DevTools: simplify the async instrumentation harness.

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/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::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::Runtime::ScriptId;
 using blink::protocol::Runtime::StackTrace;
 using blink::protocol::Runtime::RemoteObject;
 
+namespace {
+static const char v8AsyncTaskEventEnqueue[] = "enqueue";
+static const char v8AsyncTaskEventWillHandle[] = "willHandle";
+static const char v8AsyncTaskEventDidHandle[] = "didHandle";
+}
+
 namespace blink {
 
 namespace DebuggerAgentState {
 static const char javaScriptBreakpoints[] = "javaScriptBreakopints";
 static const char pauseOnExceptionsState[] = "pauseOnExceptionsState";
 static const char asyncCallStackDepth[] = "asyncCallStackDepth";
 
 // 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;
 
 static const int maxSkipStepFrameCount = 128;
 
 const char V8DebuggerAgent::backtraceObjectGroup[] = "backtrace";
 
-const int V8DebuggerAgent::unknownAsyncOperationId = 0;
-
 static String16 breakpointIdSuffix(V8DebuggerAgentImpl::BreakpointSource source)
 {
     switch (source) {
     case V8DebuggerAgentImpl::UserBreakpointSource:
         break;
     case V8DebuggerAgentImpl::DebugCommandBreakpointSource:
         return ":debug";
     case V8DebuggerAgentImpl::MonitorCommandBreakpointSource:
         return ":monitor";
     }
@@ skipping 81 matching lines @@
         .setLineNumber(lineNumber)
         .setColumnNumber(columnNumber).build();
 }
 
 PassOwnPtr<V8DebuggerAgent> V8DebuggerAgent::create(V8RuntimeAgent* runtimeAgent)
 {
     V8RuntimeAgentImpl* runtimeAgentImpl = static_cast<V8RuntimeAgentImpl*>(runtimeAgent);
     return adoptPtr(new V8DebuggerAgentImpl(runtimeAgentImpl->getInjectedScriptManager(), runtimeAgentImpl->debugger(), runtimeAgentImpl->contextGroupId()));
 }
 
+void V8DebuggerAgent::asyncTaskStarted(void* task)

[dgozman, 2016/04/05 01:09:49]

Remove.

+{
+}
+
+void V8DebuggerAgent::asyncTaskFinished(void* task)
+{
+}
+
 V8DebuggerAgentImpl::V8DebuggerAgentImpl(InjectedScriptManager* injectedScriptManager, V8DebuggerImpl* debugger, int contextGroupId)
     : m_injectedScriptManager(injectedScriptManager)
     , m_debugger(debugger)
     , m_contextGroupId(contextGroupId)
     , m_enabled(false)
     , m_state(nullptr)
     , m_frontend(nullptr)
     , m_isolate(debugger->isolate())
     , m_breakReason(protocol::Debugger::Paused::ReasonEnum::Other)
     , m_scheduledDebuggerStep(NoStep)
     , m_skipNextDebuggerStepOut(false)
     , m_javaScriptPauseScheduled(false)
     , m_steppingFromFramework(false)
     , m_pausingOnNativeEvent(false)
     , m_skippedStepFrameCount(0)
     , m_recursionLevelForStepOut(0)
     , m_recursionLevelForStepFrame(0)
     , m_skipAllPauses(false)
-    , m_lastAsyncOperationId(0)
     , m_maxAsyncCallStackDepth(0)
-    , m_currentAsyncCallChain(nullptr)
-    , m_nestedAsyncCallCount(0)
-    , m_currentAsyncOperationId(unknownAsyncOperationId)
-    , m_pendingTraceAsyncOperationCompleted(false)
 {
     ASSERT(contextGroupId);
     m_injectedScriptManager->injectedScriptHost()->setDebuggerAgent(this);
-
-    // FIXME: remove once InjectedScriptManager moves to v8.
-    m_v8AsyncCallTracker = V8AsyncCallTracker::create(this);
     clearBreakDetails();
 }
 
 V8DebuggerAgentImpl::~V8DebuggerAgentImpl()
 {
 }
 
 bool V8DebuggerAgentImpl::checkEnabled(ErrorString* errorString)
 {
     if (enabled())
@@ skipping 54 matching lines @@
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     m_skipAllPauses = false;
     m_enabled = false;
 }
 
 void V8DebuggerAgentImpl::internalSetAsyncCallStackDepth(int depth)
 {
     if (depth <= 0) {
         m_maxAsyncCallStackDepth = 0;
-        resetAsyncCallTracker();
+        resetAsyncCallStacks();
     } else {
         m_maxAsyncCallStackDepth = depth;
     }
-    m_v8AsyncCallTracker->asyncCallTrackingStateChanged(m_maxAsyncCallStackDepth);
 }
 
 void V8DebuggerAgentImpl::setInspectorState(protocol::DictionaryValue* state)
 {
     m_state = state;
 }
 
 void V8DebuggerAgentImpl::clearFrontend()
 {
     ErrorString error;
@@ skipping 557 matching lines @@
 {
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     debugger().setPauseOnNextStatement(false);
 }
 
 bool V8DebuggerAgentImpl::v8AsyncTaskEventsEnabled() const
 {
-    return trackingAsyncCalls();
+    return m_maxAsyncCallStackDepth;
 }
 
 void V8DebuggerAgentImpl::didReceiveV8AsyncTaskEvent(v8::Local<v8::Context> context, const String16& eventType, const String16& eventName, int id)
 {
+    ASSERT(m_maxAsyncCallStackDepth);
+    void* ptr = reinterpret_cast<void*> (id * 2 + 1);
     ASSERT(trackingAsyncCalls());
-    m_v8AsyncCallTracker->didReceiveV8AsyncTaskEvent(context, eventType, eventName, id);
+    if (eventType == v8AsyncTaskEventEnqueue)
+        scheduleAsyncTask(eventName, ptr, false);
+    else if (eventType == v8AsyncTaskEventWillHandle)
+        asyncTaskStarted(ptr);
+    else if (eventType == v8AsyncTaskEventDidHandle)
+        asyncTaskFinished(ptr);
+    else
+        ASSERT_NOT_REACHED();
 }
 
 void V8DebuggerAgentImpl::pause(ErrorString* errorString)
 {
     if (!checkEnabled(errorString))
         return;
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     m_javaScriptPauseScheduled = true;
@@ skipping 175 matching lines @@
 }
 
 void V8DebuggerAgentImpl::setAsyncCallStackDepth(ErrorString* errorString, int depth)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, depth);
     internalSetAsyncCallStackDepth(depth);
 }
 
-int V8DebuggerAgentImpl::traceAsyncOperationStarting(const String16& description)
+void V8DebuggerAgentImpl::scheduleAsyncTask(const String16& taskName, void* task, bool recurring)
 {
     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));
-
+    OwnPtr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(this, V8StackTrace::maxCallStackSizeToCapture, taskName);
     if (chain)
-        m_asyncOperations.set(m_lastAsyncOperationId, chain.release());
-
-    return m_lastAsyncOperationId;
+        m_asyncTaskStacks.set(task, chain.release());
 }
 
-void V8DebuggerAgentImpl::traceAsyncCallbackStarting(int operationId)
+void V8DebuggerAgentImpl::cancelAsyncTask(void* task)
 {
-    ASSERT(operationId > 0 || operationId == unknownAsyncOperationId);
-    V8StackTraceImpl* chain = operationId > 0 ? m_asyncOperations.get(operationId) : nullptr;
-    // FIXME: extract recursion check into a delegate.
-    bool hasRecursionLevel = m_debugger->client()->hasRecursionLevel();
-    if (chain && !hasRecursionLevel) {
-        // There can be still an old m_currentAsyncCallChain set if we start running Microtasks
-        // right after executing a JS callback but before the corresponding traceAsyncCallbackCompleted().
-        // In this case just call traceAsyncCallbackCompleted() now, and the subsequent ones will be ignored.
-        //
-        // The nested levels count may be greater than 1, for example, when events are guarded via custom
-        // traceAsync* calls, like in window.postMessage(). In this case there will be a willHandleEvent
-        // instrumentation with unknownAsyncOperationId bumping up the nested levels count.
-        if (m_currentAsyncCallChain) {
-            ASSERT(m_nestedAsyncCallCount >= 1);
-            m_nestedAsyncCallCount = 1;
-            traceAsyncCallbackCompleted();
-        }
-
-        // Current AsyncCallChain corresponds to the bottommost JS call frame.
-        ASSERT(!m_currentAsyncCallChain);
-        m_currentAsyncCallChain = chain->clone();
-        m_currentAsyncOperationId = operationId;
-        m_pendingTraceAsyncOperationCompleted = false;
-        m_nestedAsyncCallCount = 1;
-    } else {
-        if (m_currentAsyncCallChain)
-            ++m_nestedAsyncCallCount;
-    }
+    m_asyncTaskStacks.remove(task);
 }
 
-void V8DebuggerAgentImpl::traceAsyncCallbackCompleted()
+void V8DebuggerAgentImpl::cancelAllAsyncTasks()
 {
-    if (!m_nestedAsyncCallCount)
-        return;
-    ASSERT(m_currentAsyncCallChain);
-    --m_nestedAsyncCallCount;
-    if (!m_nestedAsyncCallCount)
-        clearCurrentAsyncOperation();
+    m_asyncTaskStacks.clear();
 }
 
-void V8DebuggerAgentImpl::traceAsyncOperationCompleted(int operationId)
+void V8DebuggerAgentImpl::asyncTaskStarted(void* task)
 {
-    ASSERT(operationId > 0 || operationId == unknownAsyncOperationId);
-    if (operationId > 0) {
-        if (m_currentAsyncOperationId == operationId) {
-            if (m_pendingTraceAsyncOperationCompleted) {
-                m_pendingTraceAsyncOperationCompleted = false;
-            } else {
-                // Delay traceAsyncOperationCompleted() until the last async callback (being currently executed) is done.
-                m_pendingTraceAsyncOperationCompleted = true;
-                return;
-            }
-        }
-        m_asyncOperations.remove(operationId);
-    }
+    m_currentTasks.append(task);
 }
 
-void V8DebuggerAgentImpl::clearCurrentAsyncOperation()
+void V8DebuggerAgentImpl::asyncTaskFinished(void* task)
 {
-    if (m_pendingTraceAsyncOperationCompleted && m_currentAsyncOperationId != unknownAsyncOperationId)
-        traceAsyncOperationCompleted(m_currentAsyncOperationId);
-
-    m_currentAsyncOperationId = unknownAsyncOperationId;
-    m_pendingTraceAsyncOperationCompleted = false;
-    m_nestedAsyncCallCount = 0;
-    m_currentAsyncCallChain.clear();
+    ASSERT(m_currentTasks.size() && m_currentTasks.last() == task);
+    m_currentTasks.removeLast();
+    m_asyncTaskStacks.remove(task);
 }
 
-void V8DebuggerAgentImpl::resetAsyncCallTracker()
+void V8DebuggerAgentImpl::resetAsyncCallStacks()
 {
-    clearCurrentAsyncOperation();
-    m_v8AsyncCallTracker->resetAsyncOperations();
-    m_asyncOperations.clear();
+    m_asyncTaskStacks.clear();
 }
 
 void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String16& scriptId, PassOwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
 {
     if (!m_scripts.contains(scriptId)) {
         *error = "No script with passed id.";
         return;
     }
 
     if (!inPositions->length()) {
@@ skipping 132 matching lines @@
 
     protocol::ErrorSupport errorSupport;
     OwnPtr<Array<CallFrame>> callFrames = Array<CallFrame>::parse(toProtocolValue(context, objects).get(), &errorSupport);
     if (hasInternalError(errorString, !callFrames))
         return Array<CallFrame>::create();
     return callFrames.release();
 }
 
 PassOwnPtr<StackTrace> V8DebuggerAgentImpl::currentAsyncStackTrace()
 {
-    if (m_pausedContext.IsEmpty() || !trackingAsyncCalls() || !m_currentAsyncCallChain)
+    if (m_pausedContext.IsEmpty() || !m_maxAsyncCallStackDepth || !m_currentTasks.size())
         return nullptr;
 
-    return m_currentAsyncCallChain->buildInspectorObjectForTail(this);
+    return m_asyncTaskStacks.get(m_currentTasks.last())->buildInspectorObjectForTail(this);
 }
 
 V8StackTraceImpl* V8DebuggerAgentImpl::currentAsyncCallChain()
 {
-    return trackingAsyncCalls() ? m_currentAsyncCallChain.get() : nullptr;
+    if (!m_currentTasks.size())
+        return nullptr;
+    return m_asyncTaskStacks.get(m_currentTasks.last());
 }
 
 void V8DebuggerAgentImpl::didParseSource(const V8DebuggerParsedScript& parsedScript)
 {
     V8DebuggerScript script = parsedScript.script;
 
     bool isDeprecatedSourceURL = false;
     if (!parsedScript.success)
         script.setSourceURL(V8ContentSearchUtil::findSourceURL(script.source(), false, &isDeprecatedSourceURL));
     else if (script.hasSourceURL())
@@ skipping 188 matching lines @@
 }
 
 void V8DebuggerAgentImpl::reset()
 {
     if (!enabled())
         return;
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
-    resetAsyncCallTracker();
+    resetAsyncCallStacks();
 }
 
 } // namespace blink