DevTools: simplify the async instrumentation harness.

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

 // 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.
 
 #ifndef V8DebuggerAgentImpl_h
 #define V8DebuggerAgentImpl_h
 
 #include "platform/inspector_protocol/Collections.h"
 #include "platform/inspector_protocol/Dispatcher.h"
 #include "platform/inspector_protocol/Frontend.h"
 #include "platform/inspector_protocol/String16.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/public/V8DebuggerAgent.h"
 
 namespace blink {
 
 class JavaScriptCallFrame;
 class PromiseTracker;
-class V8AsyncCallTracker;
 class V8InspectorConnectionImpl;
 class V8StackTraceImpl;
 
 namespace protocol {
 class DictionaryValue;
 }
 
 using protocol::Maybe;
 
 class V8DebuggerAgentImpl : public V8DebuggerAgent {
@@ skipping 112 matching lines @@
     void breakProgramOnException(const String16& breakReason, PassOwnPtr<protocol::DictionaryValue> data) override;
     void willExecuteScript(int scriptId) override;
     void didExecuteScript() override;
 
     bool enabled() override;
     V8DebuggerImpl& debugger() override { return *m_debugger; }
 
     void setBreakpointAt(const String16& scriptId, int lineNumber, int columnNumber, BreakpointSource, const String16& condition = String16());
     void removeBreakpointAt(const String16& scriptId, int lineNumber, int columnNumber, BreakpointSource);
 
-    // Async call stacks implementation
-    int traceAsyncOperationStarting(const String16& description) override;
-    void traceAsyncCallbackStarting(int operationId) override;
-    void traceAsyncCallbackCompleted() override;
-    void traceAsyncOperationCompleted(int operationId) override;
-    bool trackingAsyncCalls() const override { return m_maxAsyncCallStackDepth; }
+    // Async call stacks implementation.
+    void asyncTaskScheduled(const String16& taskName, void* task, bool recurring) override;
+    void asyncTaskCanceled(void* task) override;
+    void asyncTaskStarted(void* task) override;
+    void asyncTaskFinished(void* task) override;
+    void allAsyncTasksCanceled() override;
 
     void reset();
 
     // Interface for V8DebuggerImpl
     SkipPauseRequest didPause(v8::Local<v8::Context>, v8::Local<v8::Value> exception, const protocol::Vector<String16>& hitBreakpoints, bool isPromiseRejection);
     void didContinue();
     void didParseSource(const V8DebuggerParsedScript&);
     bool v8AsyncTaskEventsEnabled() const;
     void didReceiveV8AsyncTaskEvent(v8::Local<v8::Context>, const String16& eventType, const String16& eventName, int id);
 
     v8::Isolate* isolate() { return m_isolate; }
     int maxAsyncCallChainDepth() { return m_maxAsyncCallStackDepth; }
     V8StackTraceImpl* currentAsyncCallChain();
 
 private:
     bool checkEnabled(ErrorString*);
     void enable();
 
     SkipPauseRequest shouldSkipExceptionPause(JavaScriptCallFrame* topCallFrame);
     SkipPauseRequest shouldSkipStepPause(JavaScriptCallFrame* topCallFrame);
 
     void schedulePauseOnNextStatementIfSteppingInto();
 
     PassOwnPtr<protocol::Array<protocol::Debugger::CallFrame>> currentCallFrames(ErrorString*);
     PassOwnPtr<protocol::Runtime::StackTrace> currentAsyncStackTrace();
 
-    void clearCurrentAsyncOperation();
-    void resetAsyncCallTracker();
-
     void changeJavaScriptRecursionLevel(int step);
 
     void setPauseOnExceptionsImpl(ErrorString*, int);
 
     PassOwnPtr<protocol::Debugger::Location> resolveBreakpoint(const String16& breakpointId, const String16& scriptId, const ScriptBreakpoint&, BreakpointSource);
     void removeBreakpoint(const String16& breakpointId);
     bool assertPaused(ErrorString*);
     void clearBreakDetails();
 
     bool isCurrentCallStackEmptyOrBlackboxed();
@@ skipping 33 matching lines @@
     bool m_skipNextDebuggerStepOut;
     bool m_javaScriptPauseScheduled;
     bool m_steppingFromFramework;
     bool m_pausingOnNativeEvent;
 
     int m_skippedStepFrameCount;
     int m_recursionLevelForStepOut;
     int m_recursionLevelForStepFrame;
     bool m_skipAllPauses;
 
-    // This field must be destroyed before the listeners set above.
-    OwnPtr<V8AsyncCallTracker> m_v8AsyncCallTracker;
-
-    using AsyncOperationIdToStackTrace = protocol::HashMap<int, OwnPtr<V8StackTraceImpl>>;
-    AsyncOperationIdToStackTrace m_asyncOperations;
-    int m_lastAsyncOperationId;
+    using AsyncTaskToStackTrace = protocol::HashMap<void*, OwnPtr<V8StackTraceImpl>>;
+    AsyncTaskToStackTrace m_asyncTaskStacks;
+    protocol::HashSet<void*> m_recurringTasks;
     int m_maxAsyncCallStackDepth;
-    OwnPtr<V8StackTraceImpl> m_currentAsyncCallChain;
-    unsigned m_nestedAsyncCallCount;
-    int m_currentAsyncOperationId;
-    bool m_pendingTraceAsyncOperationCompleted;
+#if ENABLE(ASSERT)
+    Vector<void*> m_currentTasks;
+#endif
+    Vector<OwnPtr<V8StackTraceImpl>> m_currentStacks;
     protocol::HashMap<String16, protocol::Vector<std::pair<int, int>>> m_blackboxedPositions;
 };
 
 } // namespace blink
 
 
 #endif // V8DebuggerAgentImpl_h