[DevTools] Remove promise inspector experiment

third_party/WebKit/Source/platform/v8_inspector/V8DebuggerAgentImpl.cpp

 // Copyright 2015 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 "platform/v8_inspector/V8DebuggerAgentImpl.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/IgnoreExceptionsScope.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
 #include "platform/v8_inspector/InjectedScriptManager.h"
 #include "platform/v8_inspector/JavaScriptCallFrame.h"
-#include "platform/v8_inspector/PromiseTracker.h"
 #include "platform/v8_inspector/RemoteObjectId.h"
 #include "platform/v8_inspector/ScriptBreakpoint.h"
 #include "platform/v8_inspector/V8AsyncCallTracker.h"
 #include "platform/v8_inspector/V8Regex.h"
 #include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8ContentSearchUtil.h"
 #include "platform/v8_inspector/public/V8Debugger.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 #include "platform/v8_inspector/public/V8ToProtocolValue.h"
 
 using blink::protocol::Array;
 using blink::protocol::Maybe;
 using blink::protocol::Debugger::AsyncOperation;
 using blink::protocol::Debugger::BreakpointId;
 using blink::protocol::Debugger::CallFrame;
 using blink::protocol::Debugger::CollectionEntry;
 using blink::protocol::Runtime::ExceptionDetails;
 using blink::protocol::Debugger::FunctionDetails;
 using blink::protocol::Debugger::GeneratorObjectDetails;
-using blink::protocol::Debugger::PromiseDetails;
 using blink::protocol::Runtime::ScriptId;
 using blink::protocol::Runtime::StackTrace;
 using blink::protocol::Runtime::RemoteObject;
 
 namespace blink {
 
 namespace DebuggerAgentState {
 static const char javaScriptBreakpoints[] = "javaScriptBreakopints";
 static const char pauseOnExceptionsState[] = "pauseOnExceptionsState";
 static const char asyncCallStackDepth[] = "asyncCallStackDepth";
-static const char promiseTrackerEnabled[] = "promiseTrackerEnabled";
-static const char promiseTrackerCaptureStacks[] = "promiseTrackerCaptureStacks";
 
 // Breakpoint properties.
 static const char url[] = "url";
 static const char isRegex[] = "isRegex";
 static const char lineNumber[] = "lineNumber";
 static const char columnNumber[] = "columnNumber";
 static const char condition[] = "condition";
 static const char skipAllPauses[] = "skipAllPauses";
 
 } // namespace DebuggerAgentState;
@@ skipping 130 matching lines @@
     , m_nestedAsyncCallCount(0)
     , m_currentAsyncOperationId(unknownAsyncOperationId)
     , m_pendingTraceAsyncOperationCompleted(false)
     , m_startingStepIntoAsync(false)
 {
     ASSERT(contextGroupId);
     m_injectedScriptManager->injectedScriptHost()->setDebuggerAgent(this);
 
     // FIXME: remove once InjectedScriptManager moves to v8.
     m_v8AsyncCallTracker = V8AsyncCallTracker::create(this);
-    m_promiseTracker = PromiseTracker::create(this, m_isolate);
     clearBreakDetails();
 }
 
 V8DebuggerAgentImpl::~V8DebuggerAgentImpl()
 {
 }
 
 bool V8DebuggerAgentImpl::checkEnabled(ErrorString* errorString)
 {
     if (enabled())
@@ skipping 28 matching lines @@
 }
 
 void V8DebuggerAgentImpl::disable(ErrorString*)
 {
     if (!enabled())
         return;
 
     m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, protocol::DictionaryValue::create());
     m_state->setNumber(DebuggerAgentState::pauseOnExceptionsState, V8DebuggerImpl::DontPauseOnExceptions);
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, 0);
-    m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
-    m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, false);
 
     debugger().removeDebuggerAgent(m_contextGroupId);
     m_pausedContext.Reset();
     m_currentCallStack.clear();
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     internalSetAsyncCallStackDepth(0);
-    m_promiseTracker->setEnabled(false, false);
     m_continueToLocationBreakpointId = String16();
     clearBreakDetails();
     m_scheduledDebuggerStep = NoStep;
     m_skipNextDebuggerStepOut = false;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     m_asyncOperationNotifications.clear();
@@ skipping 34 matching lines @@
 
     int pauseState = V8DebuggerImpl::DontPauseOnExceptions;
     m_state->getNumber(DebuggerAgentState::pauseOnExceptionsState, &pauseState);
     setPauseOnExceptionsImpl(&error, pauseState);
 
     m_skipAllPauses = m_state->booleanProperty(DebuggerAgentState::skipAllPauses, false);
 
     int asyncCallStackDepth = 0;
     m_state->getNumber(DebuggerAgentState::asyncCallStackDepth, &asyncCallStackDepth);
     internalSetAsyncCallStackDepth(asyncCallStackDepth);
-
-    m_promiseTracker->setEnabled(m_state->booleanProperty(DebuggerAgentState::promiseTrackerEnabled, false), m_state->booleanProperty(DebuggerAgentState::promiseTrackerCaptureStacks, false));
 }
 
 void V8DebuggerAgentImpl::setBreakpointsActive(ErrorString* errorString, bool active)
 {
     if (!checkEnabled(errorString))
         return;
     debugger().setBreakpointsActivated(active);
 }
 
 void V8DebuggerAgentImpl::setSkipAllPauses(ErrorString*, bool skipped)
@@ skipping 540 matching lines @@
 {
     return trackingAsyncCalls();
 }
 
 void V8DebuggerAgentImpl::didReceiveV8AsyncTaskEvent(v8::Local<v8::Context> context, const String16& eventType, const String16& eventName, int id)
 {
     ASSERT(trackingAsyncCalls());
     m_v8AsyncCallTracker->didReceiveV8AsyncTaskEvent(context, eventType, eventName, id);
 }
 
-bool V8DebuggerAgentImpl::v8PromiseEventsEnabled() const
-{
-    return m_promiseTracker->isEnabled();
-}
-
-void V8DebuggerAgentImpl::didReceiveV8PromiseEvent(v8::Local<v8::Context> context, v8::Local<v8::Object> promise, v8::Local<v8::Value> parentPromise, int status)
-{
-    ASSERT(m_promiseTracker->isEnabled());
-    m_promiseTracker->didReceiveV8PromiseEvent(context, promise, parentPromise, status);
-}
-
 void V8DebuggerAgentImpl::pause(ErrorString* errorString)
 {
     if (!checkEnabled(errorString))
         return;
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     clearStepIntoAsync();
     m_javaScriptPauseScheduled = true;
     m_scheduledDebuggerStep = NoStep;
@@ skipping 191 matching lines @@
 }
 
 void V8DebuggerAgentImpl::setAsyncCallStackDepth(ErrorString* errorString, int depth)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, depth);
     internalSetAsyncCallStackDepth(depth);
 }
 
-void V8DebuggerAgentImpl::enablePromiseTracker(ErrorString* errorString,
-    const Maybe<bool>& captureStacks)
-{
-    if (!checkEnabled(errorString))
-        return;
-    m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, true);
-    m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, captureStacks.fromMaybe(false));
-    m_promiseTracker->setEnabled(true, captureStacks.fromMaybe(false));
-}
-
-void V8DebuggerAgentImpl::disablePromiseTracker(ErrorString* errorString)
-{
-    if (!checkEnabled(errorString))
-        return;
-    m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
-    m_promiseTracker->setEnabled(false, false);
-}
-
-void V8DebuggerAgentImpl::getPromiseById(ErrorString* errorString, int promiseId, const Maybe<String16>& objectGroup, OwnPtr<RemoteObject>* promise)
-{
-    if (!checkEnabled(errorString))
-        return;
-    if (!m_promiseTracker->isEnabled()) {
-        *errorString = "Promise tracking is disabled";
-        return;
-    }
-    v8::HandleScope handles(m_isolate);
-    v8::Local<v8::Object> value = m_promiseTracker->promiseById(promiseId);
-    if (value.IsEmpty()) {
-        *errorString = "Promise with specified ID not found.";
-        return;
-    }
-    InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(value->CreationContext());
-    *promise = injectedScript->wrapObject(errorString, value, objectGroup.fromMaybe(""));
-}
-
-void V8DebuggerAgentImpl::didUpdatePromise(const String16& eventType, PassOwnPtr<protocol::Debugger::PromiseDetails> promise)
-{
-    if (m_frontend)
-        m_frontend->promiseUpdated(eventType, promise);
-}
-
 int V8DebuggerAgentImpl::traceAsyncOperationStarting(const String16& description)
 {
     v8::HandleScope scope(m_isolate);
     OwnPtr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(this, V8StackTrace::maxCallStackSizeToCapture, description);
 
     do {
         ++m_lastAsyncOperationId;
         if (m_lastAsyncOperationId <= 0)
             m_lastAsyncOperationId = 1;
     } while (m_asyncOperations.contains(m_lastAsyncOperationId));
@@ skipping 546 matching lines @@
 
 void V8DebuggerAgentImpl::reset()
 {
     if (!enabled())
         return;
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
-    m_promiseTracker->clear();
 }
 
 } // namespace blink