1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/core/streams/promise_handler.h"
#include "third_party/blink/renderer/platform/wtf/assertions.h"
namespace blink {
namespace {
void NoopFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>&) {}
// Creating a new v8::Promise::Resolver to create a new promise can fail. If
// JavaScript will no longer execute, then we can safely return the original
// promise. Otherwise we have no choice but to crash.
v8::Local<v8::Promise> AttemptToReturnDummyPromise(
v8::Local<v8::Context> context,
v8::Local<v8::Promise> original_promise) {
v8::Local<v8::Promise::Resolver> resolver;
if (!v8::Promise::Resolver::New(context).ToLocal(&resolver)) {
if (!context->GetIsolate()->IsExecutionTerminating()) {
// It's not safe to leak |original_promise| unless we have a guarantee
// that no further JavaScript will run.
LOG(FATAL) << "Cannot recover from failure to create a new "
"v8::Promise::Resolver object (OOM?)";
}
// We are probably in the process of worker termination.
return original_promise;
}
return resolver->GetPromise();
}
} // namespace
PromiseHandler::PromiseHandler(ScriptState* script_state)
: PromiseHandlerBase(script_state) {}
void PromiseHandler::CallRaw(const v8::FunctionCallbackInfo<v8::Value>& args) {
DCHECK_EQ(args.Length(), 1);
CallWithLocal(args[0]);
}
PromiseHandlerWithValue::PromiseHandlerWithValue(ScriptState* script_state)
: PromiseHandlerBase(script_state) {}
void PromiseHandlerWithValue::CallRaw(
const v8::FunctionCallbackInfo<v8::Value>& args) {
DCHECK_EQ(args.Length(), 1);
auto ret = CallWithLocal(args[0]);
args.GetReturnValue().Set(ret);
}
v8::Local<v8::Promise> StreamThenPromise(v8::Local<v8::Context> context,
v8::Local<v8::Promise> promise,
PromiseHandlerBase* on_fulfilled,
PromiseHandlerBase* on_rejected) {
v8::MaybeLocal<v8::Promise> result_maybe;
if (!on_fulfilled) {
DCHECK(on_rejected);
// v8::Promise::Catch is not safe as it calls promise.then() which can be
// tampered with by JavaScript. v8::Promise::Then won't accept an undefined
// value for on_fulfilled, it has to be a function. So we pass a no-op
// function, which gives us approximately the semantics we need.
// TODO(ricea): Add a safe variant of v8::Promise::Catch to V8.
v8::Local<v8::Function> noop;
if (!v8::Function::New(context, NoopFunctionCallback).ToLocal(&noop)) {
DVLOG(3) << "Assuming that the failure of v8::Function::New() is caused "
<< "by shutdown and ignoring it";
return AttemptToReturnDummyPromise(context, promise);
}
result_maybe =
promise->Then(context, noop, on_rejected->BindToV8Function());
} else if (on_rejected) {
result_maybe = promise->Then(context, on_fulfilled->BindToV8Function(),
on_rejected->BindToV8Function());
} else {
result_maybe = promise->Then(context, on_fulfilled->BindToV8Function());
}
v8::Local<v8::Promise> result;
if (!result_maybe.ToLocal(&result)) {
DVLOG(3)
<< "assuming that failure of promise->Then() is caused by shutdown and"
"ignoring it";
result = AttemptToReturnDummyPromise(context, promise);
}
return result;
}
} // namespace blink
|
