Remove DevTools instrumentation of Blink promises.

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 26 matching lines @@
 #include "bindings/v8/ScriptState.h"
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/V8HiddenValue.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/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"
 #include <v8.h>
 
 #define TONATIVE_VOID_EMPTY(type, var, value)    \
     type var;                                      \
@@ skipping 143 matching lines @@
 
 // Set a |promise|'s state and result that correspond to the state.
 // |promise| must be a Promise instance.
 void setStateForPromise(v8::Handle<v8::Object> promise, V8PromiseCustom::PromiseState state, v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     ASSERT(!value.IsEmpty());
     ASSERT(state == V8PromiseCustom::Pending || state == V8PromiseCustom::Fulfilled || state == V8PromiseCustom::Rejected || state == V8PromiseCustom::Following);
     v8::Local<v8::Object> internal = V8PromiseCustom::getInternal(promise);
     internal->SetInternalField(V8PromiseCustom::InternalStateIndex, v8::Integer::New(isolate, state));
     internal->SetInternalField(V8PromiseCustom::InternalResultIndex, value);
-    ExecutionContext* context = currentExecutionContext(isolate);
-    if (InspectorInstrumentation::isPromiseTrackerEnabled(context))
-        InspectorInstrumentation::didUpdatePromiseState(context, ScriptObject(ScriptState::current(isolate), promise), state, ScriptValue(ScriptState::current(isolate), value));
 }
 
-class TaskPerformScopeForInstrumentation {
-public:
-    TaskPerformScopeForInstrumentation(ExecutionContext* context, ExecutionContextTask* task)
-        : m_cookie(InspectorInstrumentation::willPerformPromiseTask(context, task))
-    {
-    }
-
-    ~TaskPerformScopeForInstrumentation()
-    {
-        InspectorInstrumentation::didPerformPromiseTask(m_cookie);
-    }
-
-private:
-    InspectorInstrumentationCookie m_cookie;
-};
-
 class CallHandlerTask FINAL : public ExecutionContextTask {
 public:
     CallHandlerTask(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> handler, v8::Handle<v8::Value> argument, V8PromiseCustom::PromiseState originatorState, v8::Isolate* isolate, ExecutionContext* context)
         : m_promise(isolate, promise)
         , m_handler(isolate, handler)
         , m_argument(isolate, argument)
         , m_scriptState(ScriptState::current(isolate))
     {
         ASSERT(!m_promise.isEmpty());
         ASSERT(!m_handler.isEmpty());
         ASSERT(!m_argument.isEmpty());
-        InspectorInstrumentation::didPostPromiseTask(context, this, originatorState == V8PromiseCustom::Fulfilled);
     }
     virtual ~CallHandlerTask() { }
 
     virtual void performTask(ExecutionContext*) OVERRIDE;
 
 private:
     ScopedPersistent<v8::Object> m_promise;
     ScopedPersistent<v8::Function> m_handler;
     ScopedPersistent<v8::Value> m_argument;
     RefPtr<ScriptState> m_scriptState;
 };
 
 void CallHandlerTask::performTask(ExecutionContext* context)
 {
-    TaskPerformScopeForInstrumentation performTaskScope(context, this);
-
     ASSERT(context);
     if (context->activeDOMObjectsAreStopped())
         return;
 
     ScriptState::Scope scope(m_scriptState.get());
     v8::Isolate* isolate = m_scriptState->isolate();
     v8::Handle<v8::Value> info[] = { m_argument.newLocal(isolate) };
     v8::TryCatch trycatch;
     v8::Local<v8::Value> value = V8ScriptRunner::callFunction(m_handler.newLocal(isolate), context, v8::Undefined(isolate), WTF_ARRAY_LENGTH(info), info, isolate);
     if (value.IsEmpty()) {
         V8PromiseCustom::reject(m_promise.newLocal(isolate), trycatch.Exception(), isolate);
     } else {
         V8PromiseCustom::resolve(m_promise.newLocal(isolate), value, isolate);
     }
 }
 
 class UpdateDerivedTask FINAL : public ExecutionContextTask {
 public:
     UpdateDerivedTask(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Handle<v8::Object> originatorValueObject, v8::Isolate* isolate, ExecutionContext* context)
         : m_promise(isolate, promise)
         , m_onFulfilled(isolate, onFulfilled)
         , m_onRejected(isolate, onRejected)
         , m_originatorValueObject(isolate, originatorValueObject)
         , m_scriptState(ScriptState::current(isolate))
     {
         ASSERT(!m_promise.isEmpty());
         ASSERT(!m_originatorValueObject.isEmpty());
-        InspectorInstrumentation::didPostPromiseTask(context, this, true);
     }
     virtual ~UpdateDerivedTask() { }
 
     virtual void performTask(ExecutionContext*) OVERRIDE;
 
 private:
     ScopedPersistent<v8::Object> m_promise;
     ScopedPersistent<v8::Function> m_onFulfilled;
     ScopedPersistent<v8::Function> m_onRejected;
     ScopedPersistent<v8::Object> m_originatorValueObject;
     RefPtr<ScriptState> m_scriptState;
 };
 
 void UpdateDerivedTask::performTask(ExecutionContext* context)
 {
-    TaskPerformScopeForInstrumentation performTaskScope(context, this);
-
     ASSERT(context);
     if (context->activeDOMObjectsAreStopped())
         return;
 
     ScriptState::Scope scope(m_scriptState.get());
     v8::Isolate* isolate = m_scriptState->isolate();
     v8::Local<v8::Object> originatorValueObject = m_originatorValueObject.newLocal(isolate);
     v8::Local<v8::Value> coercedAlready = V8HiddenValue::getHiddenValue(isolate, originatorValueObject, V8HiddenValue::thenableHiddenPromise(isolate));
     if (!coercedAlready.IsEmpty() && coercedAlready->IsObject()) {
         ASSERT(V8PromiseCustom::isPromise(coercedAlready.As<v8::Object>(), isolate));
@@ skipping 180 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);
     }
-    ExecutionContext* context = currentExecutionContext(isolate);
-    if (InspectorInstrumentation::isPromiseTrackerEnabled(context)) {
-        ScriptState* scriptState = ScriptState::current(isolate);
-        InspectorInstrumentation::didUpdatePromiseParent(context, ScriptObject(scriptState, derivedPromise), ScriptObject(scriptState, 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 151 matching lines @@
 {
     v8::Local<v8::ObjectTemplate> internalTemplate = internalObjectTemplate(isolate);
     v8::Local<v8::Object> internal = internalTemplate->NewInstance();
     if (internal.IsEmpty())
         return v8::Local<v8::Object>();
     v8::Local<v8::Object> promise = V8DOMWrapper::createWrapper(creationContext, &V8Promise::wrapperTypeInfo, 0, isolate);
 
     clearDerived(internal, isolate);
     promise->SetInternalField(v8DOMWrapperObjectIndex, internal);
 
-    ExecutionContext* context = currentExecutionContext(isolate);
-    if (InspectorInstrumentation::isPromiseTrackerEnabled(context))
-        InspectorInstrumentation::didCreatePromise(context, ScriptObject(ScriptState::current(isolate), promise));
-
     setStateForPromise(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>();
 }
 
@@ skipping 158 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