Oilpan: Prepare moving AsyncCallStackTracker to Oilpan

Source/core/inspector/InspectorDebuggerAgent.cpp

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 105 matching lines @@
     , m_injectedScriptManager(injectedScriptManager)
     , m_frontend(0)
     , m_pausedScriptState(nullptr)
     , m_javaScriptPauseScheduled(false)
     , m_debuggerStepScheduled(false)
     , m_steppingFromFramework(false)
     , m_pausingOnNativeEvent(false)
     , m_listener(nullptr)
     , m_skippedStepInCount(0)
     , m_skipAllPauses(false)
+    , m_asyncCallStackTracker(adoptPtrWillBeNoop(new AsyncCallStackTracker()))
 {
 }
 
 InspectorDebuggerAgent::~InspectorDebuggerAgent()
 {
 #if !ENABLE(OILPAN)
     ASSERT(!m_instrumentingAgents->inspectorDebuggerAgent());
 #endif
 }
 
@@ skipping 77 matching lines @@
         enable();
         long pauseState = m_state->getLong(DebuggerAgentState::pauseOnExceptionsState);
         String error;
         setPauseOnExceptionsImpl(&error, pauseState);
         m_cachedSkipStackRegExp = compileSkipCallFramePattern(m_state->getString(DebuggerAgentState::skipStackPattern));
         m_skipAllPauses = m_state->getBoolean(DebuggerAgentState::skipAllPauses);
         if (m_skipAllPauses && m_state->getBoolean(DebuggerAgentState::skipAllPausesExpiresOnReload)) {
             m_skipAllPauses = false;
             m_state->setBoolean(DebuggerAgentState::skipAllPauses, false);
         }
-        m_asyncCallStackTracker.setAsyncCallStackDepth(m_state->getLong(DebuggerAgentState::asyncCallStackDepth));
+        asyncCallStackTracker().setAsyncCallStackDepth(m_state->getLong(DebuggerAgentState::asyncCallStackDepth));
     }
 }
 
 void InspectorDebuggerAgent::setFrontend(InspectorFrontend* frontend)
 {
     m_frontend = frontend->debugger();
 }
 
 void InspectorDebuggerAgent::clearFrontend()
 {
@@ skipping 471 matching lines @@
 {
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     scriptDebugServer().setPauseOnNextStatement(false);
 }
 
 void InspectorDebuggerAgent::didInstallTimer(ExecutionContext* context, int timerId, int timeout, bool singleShot)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didInstallTimer(context, timerId, singleShot, scriptDebugServer().currentCallFramesForAsyncStack());
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didInstallTimer(context, timerId, singleShot, scriptDebugServer().currentCallFramesForAsyncStack());
 }
 
 void InspectorDebuggerAgent::didRemoveTimer(ExecutionContext* context, int timerId)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didRemoveTimer(context, timerId);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didRemoveTimer(context, timerId);
 }
 
 bool InspectorDebuggerAgent::willFireTimer(ExecutionContext* context, int timerId)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.willFireTimer(context, timerId);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willFireTimer(context, timerId);
     return true;
 }
 
 void InspectorDebuggerAgent::didFireTimer()
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didFireAsyncCall();
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
     cancelPauseOnNextStatement();
 }
 
 void InspectorDebuggerAgent::didRequestAnimationFrame(Document* document, int callbackId)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didRequestAnimationFrame(document, callbackId, scriptDebugServer().currentCallFramesForAsyncStack());
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didRequestAnimationFrame(document, callbackId, scriptDebugServer().currentCallFramesForAsyncStack());
 }
 
 void InspectorDebuggerAgent::didCancelAnimationFrame(Document* document, int callbackId)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didCancelAnimationFrame(document, callbackId);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didCancelAnimationFrame(document, callbackId);
 }
 
 bool InspectorDebuggerAgent::willFireAnimationFrame(Document* document, int callbackId)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.willFireAnimationFrame(document, callbackId);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willFireAnimationFrame(document, callbackId);
     return true;
 }
 
 void InspectorDebuggerAgent::didFireAnimationFrame()
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didFireAsyncCall();
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
 }
 
 void InspectorDebuggerAgent::didEnqueueEvent(EventTarget* eventTarget, Event* event)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didEnqueueEvent(eventTarget, event, scriptDebugServer().currentCallFramesForAsyncStack());
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didEnqueueEvent(eventTarget, event, scriptDebugServer().currentCallFramesForAsyncStack());
 }
 
 void InspectorDebuggerAgent::didRemoveEvent(EventTarget* eventTarget, Event* event)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didRemoveEvent(eventTarget, event);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didRemoveEvent(eventTarget, event);
 }
 
 void InspectorDebuggerAgent::willHandleEvent(EventTarget* eventTarget, Event* event, EventListener* listener, bool useCapture)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.willHandleEvent(eventTarget, event, listener, useCapture);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willHandleEvent(eventTarget, event, listener, useCapture);
 }
 
 void InspectorDebuggerAgent::didHandleEvent()
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didFireAsyncCall();
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
     cancelPauseOnNextStatement();
 }
 
 void InspectorDebuggerAgent::willLoadXHR(XMLHttpRequest* xhr, ThreadableLoaderClient*, const AtomicString&, const KURL&, bool async, FormData*, const HTTPHeaderMap&, bool)
 {
-    if (m_asyncCallStackTracker.isEnabled() && async)
-        m_asyncCallStackTracker.willLoadXHR(xhr, scriptDebugServer().currentCallFramesForAsyncStack());
+    if (asyncCallStackTracker().isEnabled() && async)
+        asyncCallStackTracker().willLoadXHR(xhr, scriptDebugServer().currentCallFramesForAsyncStack());
 }
 
 void InspectorDebuggerAgent::didDispatchXHRLoadendEvent(XMLHttpRequest* xhr)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didLoadXHR(xhr);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didLoadXHR(xhr);
 }
 
 void InspectorDebuggerAgent::didEnqueueMutationRecord(ExecutionContext* context, MutationObserver* observer)
 {
-    if (m_asyncCallStackTracker.isEnabled() && !m_asyncCallStackTracker.hasEnqueuedMutationRecord(context, observer))
-        m_asyncCallStackTracker.didEnqueueMutationRecord(context, observer, scriptDebugServer().currentCallFramesForAsyncStack());
+    if (asyncCallStackTracker().isEnabled() && !asyncCallStackTracker().hasEnqueuedMutationRecord(context, observer))
+        asyncCallStackTracker().didEnqueueMutationRecord(context, observer, scriptDebugServer().currentCallFramesForAsyncStack());
 }
 
 void InspectorDebuggerAgent::didClearAllMutationRecords(ExecutionContext* context, MutationObserver* observer)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didClearAllMutationRecords(context, observer);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didClearAllMutationRecords(context, observer);
 }
 
 void InspectorDebuggerAgent::willDeliverMutationRecords(ExecutionContext* context, MutationObserver* observer)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.willDeliverMutationRecords(context, observer);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willDeliverMutationRecords(context, observer);
 }
 
 void InspectorDebuggerAgent::didDeliverMutationRecords()
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didFireAsyncCall();
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
 }
 
 void InspectorDebuggerAgent::didPostExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task)
 {
-    if (m_asyncCallStackTracker.isEnabled() && !task->taskNameForInstrumentation().isEmpty())
-        m_asyncCallStackTracker.didPostExecutionContextTask(context, task, scriptDebugServer().currentCallFramesForAsyncStack());
+    if (asyncCallStackTracker().isEnabled() && !task->taskNameForInstrumentation().isEmpty())
+        asyncCallStackTracker().didPostExecutionContextTask(context, task, scriptDebugServer().currentCallFramesForAsyncStack());
 }
 
 void InspectorDebuggerAgent::didKillAllExecutionContextTasks(ExecutionContext* context)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didKillAllExecutionContextTasks(context);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didKillAllExecutionContextTasks(context);
 }
 
 void InspectorDebuggerAgent::willPerformExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.willPerformExecutionContextTask(context, task);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().willPerformExecutionContextTask(context, task);
 }
 
 void InspectorDebuggerAgent::didPerformExecutionContextTask()
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didFireAsyncCall();
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
 }
 
 int InspectorDebuggerAgent::traceAsyncOperationStarting(ExecutionContext* context, const String& operationName, int prevOperationId)
 {
-    if (!m_asyncCallStackTracker.isEnabled())
+    if (!asyncCallStackTracker().isEnabled())
         return 0;
     if (prevOperationId)
-        m_asyncCallStackTracker.traceAsyncOperationCompleted(context, prevOperationId);
-    return m_asyncCallStackTracker.traceAsyncOperationStarting(context, operationName, scriptDebugServer().currentCallFramesForAsyncStack());
+        asyncCallStackTracker().traceAsyncOperationCompleted(context, prevOperationId);
+    return asyncCallStackTracker().traceAsyncOperationStarting(context, operationName, scriptDebugServer().currentCallFramesForAsyncStack());
 }
 
 void InspectorDebuggerAgent::traceAsyncOperationCompleted(ExecutionContext* context, int operationId)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.traceAsyncOperationCompleted(context, operationId);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().traceAsyncOperationCompleted(context, operationId);
 }
 
 void InspectorDebuggerAgent::traceAsyncOperationCompletedCallbackStarting(ExecutionContext* context, int operationId)
 {
-    if (!m_asyncCallStackTracker.isEnabled())
+    if (!asyncCallStackTracker().isEnabled())
         return;
-    m_asyncCallStackTracker.traceAsyncCallbackStarting(context, operationId);
-    m_asyncCallStackTracker.traceAsyncOperationCompleted(context, operationId);
+    asyncCallStackTracker().traceAsyncCallbackStarting(context, operationId);
+    asyncCallStackTracker().traceAsyncOperationCompleted(context, operationId);
 }
 
 void InspectorDebuggerAgent::traceAsyncCallbackStarting(ExecutionContext* context, int operationId)
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.traceAsyncCallbackStarting(context, operationId);
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().traceAsyncCallbackStarting(context, operationId);
 }
 
 void InspectorDebuggerAgent::traceAsyncCallbackCompleted()
 {
-    if (m_asyncCallStackTracker.isEnabled())
-        m_asyncCallStackTracker.didFireAsyncCall();
+    if (asyncCallStackTracker().isEnabled())
+        asyncCallStackTracker().didFireAsyncCall();
 }
 
 void InspectorDebuggerAgent::didReceiveV8AsyncTaskEvent(ExecutionContext* context, const String& eventType, const String& eventName, int id)
 {
-    if (!m_asyncCallStackTracker.isEnabled())
+    if (!asyncCallStackTracker().isEnabled())
         return;
     if (eventType == v8AsyncTaskEventEnqueue)
-        m_asyncCallStackTracker.didEnqueueV8AsyncTask(context, eventName, id, scriptDebugServer().currentCallFramesForAsyncStack());
+        asyncCallStackTracker().didEnqueueV8AsyncTask(context, eventName, id, scriptDebugServer().currentCallFramesForAsyncStack());
     else if (eventType == v8AsyncTaskEventWillHandle)
-        m_asyncCallStackTracker.willHandleV8AsyncTask(context, eventName, id);
+        asyncCallStackTracker().willHandleV8AsyncTask(context, eventName, id);
     else if (eventType == v8AsyncTaskEventDidHandle)
-        m_asyncCallStackTracker.didFireAsyncCall();
+        asyncCallStackTracker().didFireAsyncCall();
     else
         ASSERT_NOT_REACHED();
 }
 
 void InspectorDebuggerAgent::pause(ErrorString*)
 {
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     m_javaScriptPauseScheduled = true;
@@ skipping 80 matching lines @@
     }
 
     ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
     if (asBool(doNotPauseOnExceptionsAndMuteConsole)) {
         if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
             scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
         muteConsole();
     }
 
     Vector<ScriptValue> asyncCallStacks;
-    const AsyncCallStackTracker::AsyncCallChain* asyncChain = m_asyncCallStackTracker.isEnabled() ? m_asyncCallStackTracker.currentAsyncCallChain() : 0;
+    const AsyncCallStackTracker::AsyncCallChain* asyncChain = asyncCallStackTracker().isEnabled() ? asyncCallStackTracker().currentAsyncCallChain() : 0;
     if (asyncChain) {
         const AsyncCallStackTracker::AsyncCallStackVector& callStacks = asyncChain->callStacks();
         asyncCallStacks.resize(callStacks.size());
         AsyncCallStackTracker::AsyncCallStackVector::const_iterator it = callStacks.begin();
         for (size_t i = 0; it != callStacks.end(); ++it, ++i)
             asyncCallStacks[i] = (*it)->callFrames();
     }
 
     injectedScript.evaluateOnCallFrame(errorString, m_currentCallStack, asyncCallStacks, callFrameId, expression, objectGroup ? *objectGroup : "", asBool(includeCommandLineAPI), asBool(returnByValue), asBool(generatePreview), &result, wasThrown, &exceptionDetails);
     // V8 doesn't generate afterCompile event when it's in debugger therefore there is no content of evaluated scripts on frontend
@@ skipping 121 matching lines @@
             return;
         }
     }
     m_state->setString(DebuggerAgentState::skipStackPattern, patternValue);
     m_cachedSkipStackRegExp = compiled.release();
 }
 
 void InspectorDebuggerAgent::setAsyncCallStackDepth(ErrorString*, int depth)
 {
     m_state->setLong(DebuggerAgentState::asyncCallStackDepth, depth);
-    m_asyncCallStackTracker.setAsyncCallStackDepth(depth);
+    asyncCallStackTracker().setAsyncCallStackDepth(depth);
 }
 
 void InspectorDebuggerAgent::scriptExecutionBlockedByCSP(const String& directiveText)
 {
     if (scriptDebugServer().pauseOnExceptionsState() != ScriptDebugServer::DontPauseOnExceptions) {
         RefPtr<JSONObject> directive = JSONObject::create();
         directive->setString("directiveText", directiveText);
         breakProgram(InspectorFrontend::Debugger::Reason::CSPViolation, directive.release());
     }
 }
 
 PassRefPtr<Array<CallFrame> > InspectorDebuggerAgent::currentCallFrames()
 {
     if (!m_pausedScriptState || m_currentCallStack.isEmpty())
         return Array<CallFrame>::create();
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
     if (injectedScript.isEmpty()) {
         ASSERT_NOT_REACHED();
         return Array<CallFrame>::create();
     }
     return injectedScript.wrapCallFrames(m_currentCallStack, 0);
 }
 
 PassRefPtr<StackTrace> InspectorDebuggerAgent::currentAsyncStackTrace()
 {
-    if (!m_pausedScriptState || !m_asyncCallStackTracker.isEnabled())
+    if (!m_pausedScriptState || !asyncCallStackTracker().isEnabled())
         return nullptr;
-    const AsyncCallStackTracker::AsyncCallChain* chain = m_asyncCallStackTracker.currentAsyncCallChain();
+    const AsyncCallStackTracker::AsyncCallChain* chain = asyncCallStackTracker().currentAsyncCallChain();
     if (!chain)
         return nullptr;
     const AsyncCallStackTracker::AsyncCallStackVector& callStacks = chain->callStacks();
     if (callStacks.isEmpty())
         return nullptr;
     RefPtr<StackTrace> result;
     int asyncOrdinal = callStacks.size();
     for (AsyncCallStackTracker::AsyncCallStackVector::const_reverse_iterator it = callStacks.rbegin(); it != callStacks.rend(); ++it, --asyncOrdinal) {
         ScriptValue callFrames = (*it)->callFrames();
         ScriptState* scriptState = callFrames.scriptState();
@@ skipping 23 matching lines @@
         // FIXME(WK62725): Debugger line/column are 0-based, while console ones are 1-based.
         int line = callFrame->line() + 1;
         int column = callFrame->column() + 1;
         frames.append(ScriptCallFrame(callFrame->functionName(), scriptId, callFrame->scriptName(), line, column));
     }
     return ScriptCallStack::create(frames);
 }
 
 PassRefPtrWillBeRawPtr<ScriptAsyncCallStack> InspectorDebuggerAgent::currentAsyncStackTraceForConsole()
 {
-    if (!m_asyncCallStackTracker.isEnabled())
+    if (!asyncCallStackTracker().isEnabled())
         return nullptr;
-    const AsyncCallStackTracker::AsyncCallChain* chain = m_asyncCallStackTracker.currentAsyncCallChain();
+    const AsyncCallStackTracker::AsyncCallChain* chain = asyncCallStackTracker().currentAsyncCallChain();
     if (!chain)
         return nullptr;
     const AsyncCallStackTracker::AsyncCallStackVector& callStacks = chain->callStacks();
     if (callStacks.isEmpty())
         return nullptr;
     RefPtrWillBeRawPtr<ScriptAsyncCallStack> result = nullptr;
     for (AsyncCallStackTracker::AsyncCallStackVector::const_reverse_iterator it = callStacks.rbegin(); it != callStacks.rend(); ++it) {
         RefPtrWillBeRawPtr<JavaScriptCallFrame> callFrame = ScriptDebugServer::toJavaScriptCallFrameUnsafe((*it)->callFrames());
         if (!callFrame)
             break;
@@ skipping 169 matching lines @@
     m_pausingOnNativeEvent = false;
     scriptDebugServer().breakProgram();
 }
 
 void InspectorDebuggerAgent::clear()
 {
     m_pausedScriptState = nullptr;
     m_currentCallStack = ScriptValue();
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
-    m_asyncCallStackTracker.clear();
+    asyncCallStackTracker().clear();
     m_continueToLocationBreakpointId = String();
     clearBreakDetails();
     m_javaScriptPauseScheduled = false;
     m_debuggerStepScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     ErrorString error;
     setOverlayMessage(&error, 0);
 }
 
@@ skipping 21 matching lines @@
 
 void InspectorDebuggerAgent::removeBreakpoint(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source)
 {
     removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
 }
 
 void InspectorDebuggerAgent::reset()
 {
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
-    m_asyncCallStackTracker.clear();
+    asyncCallStackTracker().clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 void InspectorDebuggerAgent::trace(Visitor* visitor)
 {
     visitor->trace(m_injectedScriptManager);
     visitor->trace(m_listener);
+    visitor->trace(m_asyncCallStackTracker);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink