Lines Matching defs:promise
30 #include "src/builtins/builtins-promise.h"
90 #include "src/objects/promise-inl.h"
771 // We store the offset of the promise into the element function's
928 void CaptureAsyncStackTrace(Isolate* isolate, Handle<JSPromise> promise,
931 // Check that the {promise} is not settled.
932 if (promise->status() != Promise::kPending) return;
934 // Check that we have exactly one PromiseReaction on the {promise}.
935 if (!promise->reactions().IsPromiseReaction()) return;
937 PromiseReaction::cast(promise->reactions()), isolate);
963 promise = handle(async_function_object->promise(), isolate);
971 promise = handle(JSPromise::cast(async_generator_request->promise()),
984 // find the promise capability that's being resolved when all
990 if (!capability->promise().IsJSPromise()) return;
991 promise = handle(JSPromise::cast(capability->promise()), isolate);
1003 // find the promise capability that's being resolved when all
1009 if (!capability->promise().IsJSPromise()) return;
1010 promise = handle(JSPromise::cast(capability->promise()), isolate);
1021 // find the promise capability that's being resolved when any of
1026 if (!capability->promise().IsJSPromise()) return;
1027 promise = handle(JSPromise::cast(capability->promise()), isolate);
1033 promise =
1037 // We have some generic promise chain here, so try to
1038 // continue with the chained promise on the reaction
1039 // (only works for native promise chains).
1043 promise = Handle<JSPromise>::cast(promise_or_capability);
1047 if (!capability->promise().IsJSPromise()) return;
1048 promise = handle(JSPromise::cast(capability->promise()), isolate);
1086 Handle<JSPromise> promise(async_function_object->promise(), isolate);
1087 CaptureAsyncStackTrace(isolate, promise, builder);
1095 Handle<JSPromise> promise(
1096 JSPromise::cast(async_generator_request->promise()), isolate);
1097 CaptureAsyncStackTrace(isolate, promise, builder);
1109 Handle<JSPromise> promise =
1111 CaptureAsyncStackTrace(isolate, promise, builder);
2628 void Isolate::PushPromise(Handle<JSObject> promise) {
2630 promise_on_stack = factory()->NewPromiseOnStack(promise_on_stack, promise);
2663 Handle<JSPromise> promise) {
2664 Handle<Object> current(promise->reactions(), isolate);
2672 Handle<PromiseCapability>::cast(promise_or_capability)->promise(),
2675 promise = Handle<JSPromise>::cast(promise_or_capability);
2681 if (isolate->PromiseHasUserDefinedRejectHandler(promise)) return true;
2690 bool Isolate::PromiseHasUserDefinedRejectHandler(Handle<JSPromise> promise) {
2693 // First descend into the outermost promise and collect the stack of
2696 // If this promise was marked as being handled by a catch block
2698 if (promise->handled_hint()) return true;
2699 if (promise->status() == Promise::kPending) {
2700 promises.push(promise);
2703 JSObject::GetDataProperty(this, promise, key);
2705 promise = Handle<JSPromise>::cast(outer_promise_obj);
2709 promise = promises.top();
2710 if (PromiseHasUserDefinedRejectHandlerInternal(this, promise)) return true;
2748 // Mark the inner promise as caught in the "synchronous case" so
2758 Handle<JSObject> promise;
2762 .ToHandle(&promise)) {
2763 return promise;
4654 v8::Local<v8::Promise> promise = resolver->GetPromise();
4655 return v8::Utils::OpenHandle(*promise);
4682 v8::Local<v8::Promise> promise;
4692 this, promise,
4708 this, promise,
4715 return v8::Utils::OpenHandle(*promise);
4991 Handle<JSPromise> promise,
4995 native_context()->RunPromiseHook(type, promise, parent);
4999 RunPromiseHook(type, promise, parent);
5003 void Isolate::RunPromiseHook(PromiseHookType type, Handle<JSPromise> promise,
5007 promise_hook_(type, v8::Utils::PromiseToLocal(promise),
5011 void Isolate::OnAsyncFunctionSuspended(Handle<JSPromise> promise,
5013 DCHECK_EQ(0, promise->async_task_id());
5014 RunAllPromiseHooks(PromiseHookType::kInit, promise, parent);
5017 promise->set_async_task_id(++async_task_count_);
5019 promise->async_task_id(), false);
5023 // so pop the outer promise from the isolate's promise stack.
5028 void Isolate::OnPromiseThen(Handle<JSPromise> promise) {
5055 DCHECK_EQ(0, promise->async_task_id());
5056 promise->set_async_task_id(++async_task_count_);
5058 promise->async_task_id(),
5066 void Isolate::OnPromiseBefore(Handle<JSPromise> promise) {
5067 RunPromiseHook(PromiseHookType::kBefore, promise,
5070 if (promise->async_task_id()) {
5072 debug::kDebugWillHandle, promise->async_task_id(), false);
5075 if (debug()->is_active()) PushPromise(promise);
5078 void Isolate::OnPromiseAfter(Handle<JSPromise> promise) {
5079 RunPromiseHook(PromiseHookType::kAfter, promise,
5082 if (promise->async_task_id()) {
5084 debug::kDebugDidHandle, promise->async_task_id(), false);
5099 // (2) Empty the promise stack to avoid leaking memory.
5100 // (3) If the |current_microtask| is a promise reaction or resolve thenable
5110 // Empty the promise stack.
5120 Handle<PromiseCapability>::cast(promise_or_capability)->promise(),
5141 void Isolate::ReportPromiseReject(Handle<JSPromise> promise,
5146 v8::Utils::PromiseToLocal(promise), event, v8::Utils::ToLocal(value)));