Support Promises instrumentation on backend.

Source/bindings/v8/custom/V8PromiseCustom.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 27 matching lines @@
 #include "bindings/v8/ScriptFunctionCall.h"
 #include "bindings/v8/ScriptState.h"
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/V8PerIsolateData.h"
 #include "bindings/v8/V8ScriptRunner.h"
 #include "bindings/v8/WrapperTypeInfo.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/UseCounter.h"
-#include "core/inspector/InspectorInstrumentation.h"
+#include "core/inspector/InspectorPromiseInstrumentation.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/Task.h"
 #include "wtf/Deque.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PassOwnPtr.h"
 
 namespace WebCore {
 
 namespace {
@@ skipping 319 matching lines @@
 {
     while (!m_derivedStack.isEmpty()) {
         v8::HandleScope handleScope(isolate);
         OwnPtr<Derived> derived = m_derivedStack.takeLast();
         updateDerived(derived->promise(isolate), derived->onFulfilled(isolate), derived->onRejected(isolate), derived->originator(isolate), isolate);
     }
 }
 
 void PromisePropagator::setValue(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
-    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
-    ASSERT(V8PromiseCustom::getState(internal) != V8PromiseCustom::Fulfilled && V8PromiseCustom::getState(internal) != V8PromiseCustom::Rejected);
-    V8PromiseCustom::setState(internal, V8PromiseCustom::Fulfilled, value, isolate);
+    ASSERT(getState(V8PromiseCustom::getInternal(promise)) != V8PromiseCustom::Fulfilled && getState(V8PromiseCustom::getInternal(promise)) != V8PromiseCustom::Rejected);
+    V8PromiseCustom::setState(promise, V8PromiseCustom::Fulfilled, value, isolate);
     propagateToDerived(promise, isolate);
 }
 
 void PromisePropagator::setReason(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> reason, v8::Isolate* isolate)
 {
-    v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
-    ASSERT(V8PromiseCustom::getState(internal) != V8PromiseCustom::Fulfilled && V8PromiseCustom::getState(internal) != V8PromiseCustom::Rejected);
-    V8PromiseCustom::setState(internal, V8PromiseCustom::Rejected, reason, isolate);
+    ASSERT(getState(V8PromiseCustom::getInternal(promise)) != V8PromiseCustom::Fulfilled && getState(V8PromiseCustom::getInternal(promise)) != V8PromiseCustom::Rejected);
+    V8PromiseCustom::setState(promise, V8PromiseCustom::Rejected, reason, isolate);
     propagateToDerived(promise, isolate);
 }
 
 void PromisePropagator::propagateToDerived(v8::Handle<v8::Object> promise, v8::Isolate* isolate)
 {
     v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
     ASSERT(V8PromiseCustom::getState(internal) == V8PromiseCustom::Fulfilled || V8PromiseCustom::getState(internal) == V8PromiseCustom::Rejected);
     v8::Local<v8::Array> fulfillCallbacks = internal->GetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex).As<v8::Array>();
     v8::Local<v8::Array> rejectCallbacks = internal->GetInternalField(V8PromiseCustom::InternalRejectCallbackIndex).As<v8::Array>();
     v8::Local<v8::Array> derivedPromises = internal->GetInternalField(V8PromiseCustom::InternalDerivedPromiseIndex).As<v8::Array>();
@@ skipping 60 matching lines @@
 
 void PromisePropagator::updateDerivedFromPromise(v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> promise, v8::Isolate* isolate)
 {
     v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
     V8PromiseCustom::PromiseState state = V8PromiseCustom::getState(internal);
     if (state == V8PromiseCustom::Fulfilled || state == V8PromiseCustom::Rejected) {
         updateDerived(derivedPromise, onFulfilled, onRejected, promise, isolate);
     } else {
         addToDerived(internal, derivedPromise, onFulfilled, onRejected, isolate);
     }
+    InspectorInstrumentation::didUpdatePromiseParent(currentExecutionContext(isolate), derivedPromise, promise);
 }
 
 } // namespace
 
 void V8Promise::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8SetReturnValue(info, v8::Local<v8::Value>());
     v8::Isolate* isolate = info.GetIsolate();
     ExecutionContext* executionContext = callingExecutionContext(isolate);
     UseCounter::count(executionContext, UseCounter::PromiseConstructor);
@@ skipping 145 matching lines @@
 
 //
 // -- V8PromiseCustom --
 v8::Local<v8::Object> V8PromiseCustom::createPromise(v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     v8::Local<v8::ObjectTemplate> internalTemplate = internalObjectTemplate(isolate);
     v8::Local<v8::Object> internal = internalTemplate->NewInstance();
     v8::Local<v8::Object> promise = V8DOMWrapper::createWrapper(creationContext, &V8Promise::wrapperTypeInfo, 0, isolate);
 
     clearDerived(internal, isolate);
-    setState(internal, Pending, v8::Undefined(isolate), isolate);
+    promise->SetInternalField(v8DOMWrapperObjectIndex, internal);
 
-    promise->SetInternalField(v8DOMWrapperObjectIndex, internal);
+    InspectorInstrumentation::didCreatePromise(currentExecutionContext(isolate), promise);
+
+    setState(promise, Pending, v8::Undefined(isolate), isolate);
     return promise;
 }
 
 v8::Local<v8::Object> V8PromiseCustom::getInternal(v8::Handle<v8::Object> promise)
 {
     v8::Local<v8::Value> value = promise->GetInternalField(v8DOMWrapperObjectIndex);
     return value.As<v8::Object>();
 }
 
 V8PromiseCustom::PromiseState V8PromiseCustom::getState(v8::Handle<v8::Object> internal)
 {
     v8::Handle<v8::Value> value = internal->GetInternalField(V8PromiseCustom::InternalStateIndex);
     uint32_t number = toInt32(value);
     ASSERT(number == Pending || number == Fulfilled || number == Rejected || number == Following);
     return static_cast<PromiseState>(number);
 }
 
-void V8PromiseCustom::setState(v8::Handle<v8::Object> internal, PromiseState state, v8::Handle<v8::Value> value, v8::Isolate* isolate)
+void V8PromiseCustom::setState(v8::Handle<v8::Object> promise, PromiseState state, v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     ASSERT(!value.IsEmpty());
     ASSERT(state == Pending || state == Fulfilled || state == Rejected || state == Following);
+    v8::Local<v8::Object> internal = getInternal(promise);
     internal->SetInternalField(InternalStateIndex, v8::Integer::New(isolate, state));
     internal->SetInternalField(InternalResultIndex, value);
+    InspectorInstrumentation::didUpdatePromiseState(currentExecutionContext(isolate), promise, state, value);
 }
 
 bool V8PromiseCustom::isPromise(v8::Handle<v8::Value> maybePromise, v8::Isolate* isolate)
 {
     WrapperWorldType currentWorldType = worldType(isolate);
     return V8Promise::domTemplate(isolate, currentWorldType)->HasInstance(maybePromise);
 }
 
 v8::Local<v8::Object> V8PromiseCustom::toPromise(v8::Handle<v8::Value> maybePromise, v8::Isolate* isolate)
 {
@@ skipping 18 matching lines @@
 
     if (isPromise(result, isolate)) {
         v8::Local<v8::Object> valuePromise = result.As<v8::Object>();
         v8::Local<v8::Object> valueInternal = getInternal(valuePromise);
         PromiseState valueState = getState(valueInternal);
         if (promise->SameValue(valuePromise)) {
             v8::Local<v8::Value> reason = V8ThrowException::createTypeError("Resolve a promise with itself", isolate);
             setReason(promise, reason, isolate);
         } else if (valueState == Following) {
             v8::Local<v8::Object> valuePromiseFollowing = valueInternal->GetInternalField(InternalResultIndex).As<v8::Object>();
-            setState(internal, Following, valuePromiseFollowing, isolate);
+            setState(promise, Following, valuePromiseFollowing, isolate);
             addToDerived(getInternal(valuePromiseFollowing), promise, v8::Handle<v8::Function>(), v8::Handle<v8::Function>(), isolate);
         } else if (valueState == Fulfilled) {
             setValue(promise, valueInternal->GetInternalField(InternalResultIndex), isolate);
         } else if (valueState == Rejected) {
             setReason(promise, valueInternal->GetInternalField(InternalResultIndex), isolate);
         } else {
             ASSERT(valueState == Pending);
-            setState(internal, Following, valuePromise, isolate);
+            setState(promise, Following, valuePromise, isolate);
             addToDerived(valueInternal, promise, v8::Handle<v8::Function>(), v8::Handle<v8::Function>(), isolate);
         }
     } else {
         setValue(promise, result, isolate);
     }
 }
 
 void V8PromiseCustom::reject(v8::Handle<v8::Object> promise, v8::Handle<v8::Value> reason, v8::Isolate* isolate)
 {
     v8::Local<v8::Object> internal = getInternal(promise);
@@ skipping 86 matching lines @@
 
 void V8PromiseCustom::callHandler(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> handler, v8::Handle<v8::Value> argument, PromiseState originatorState, v8::Isolate* isolate)
 {
     ASSERT(originatorState == Fulfilled || originatorState == Rejected);
     ExecutionContext* executionContext = currentExecutionContext(isolate);
     ASSERT(executionContext && executionContext->isContextThread());
     executionContext->postTask(adoptPtr(new CallHandlerTask(promise, handler, argument, originatorState, isolate, executionContext)));
 }
 
 } // namespace WebCore