DevTools: make InspectorDebuggerAgent aggregate V8DebuggerAgent instead of inheriting

Source/core/inspector/V8DebuggerAgent.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 "config.h"
 #include "core/inspector/V8DebuggerAgent.h"
 
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptRegexp.h"
 #include "bindings/core/v8/ScriptValue.h"
@@ skipping 104 matching lines @@
     return V8JavaScriptCallFrame::unwrap(value);
 }
 
 static PassRefPtrWillBeRawPtr<ScriptCallStack> toScriptCallStack(v8::Local<v8::Object> callFrames)
 {
     RefPtr<JavaScriptCallFrame> jsCallFrame = toJavaScriptCallFrame(callFrames);
     return jsCallFrame ? toScriptCallStack(jsCallFrame.get()) : nullptr;
 }
 
 V8DebuggerAgent::V8DebuggerAgent(InjectedScriptManager* injectedScriptManager, V8Debugger* debugger, V8DebuggerAgent::Client* client, int contextGroupId)
-    : InspectorBaseAgent<V8DebuggerAgent, InspectorFrontend::Debugger>("Debugger")
-    , m_injectedScriptManager(injectedScriptManager)
+    : m_injectedScriptManager(injectedScriptManager)
     , m_debugger(debugger)
     , m_client(client)
     , m_contextGroupId(contextGroupId)
+    , m_state(nullptr)
+    , m_frontend(nullptr)
     , m_isolate(debugger->isolate())
     , m_pausedScriptState(nullptr)
     , m_breakReason(InspectorFrontend::Debugger::Reason::Other)
     , m_scheduledDebuggerStep(NoStep)
     , m_skipNextDebuggerStepOut(false)
     , m_javaScriptPauseScheduled(false)
     , m_steppingFromFramework(false)
     , m_pausingOnNativeEvent(false)
     , m_pausingOnAsyncOperation(false)
     , m_skippedStepFrameCount(0)
@@ skipping 60 matching lines @@
     return m_state->getBoolean(DebuggerAgentState::debuggerEnabled);
 }
 
 void V8DebuggerAgent::enable(ErrorString*)
 {
     if (enabled())
         return;
 
     enable();
 
-    ASSERT(frontend());
+    ASSERT(m_frontend);
 }
 
 void V8DebuggerAgent::disable(ErrorString*)
 {
     if (!enabled())
         return;
 
     disable();
     m_state->setBoolean(DebuggerAgentState::debuggerEnabled, false);
 }
@@ skipping 20 matching lines @@
     if (depth <= 0) {
         m_maxAsyncCallStackDepth = 0;
         resetAsyncCallTracker();
     } else {
         m_maxAsyncCallStackDepth = depth;
     }
     for (auto& listener: m_asyncCallTrackingListeners)
         listener->asyncCallTrackingStateChanged(m_maxAsyncCallStackDepth);
 }
 
+void V8DebuggerAgent::clearFrontend()
+{
+    ErrorString error;
+    disable(&error);
+    ASSERT(m_frontend);
+    m_frontend = nullptr;
+}
+
 void V8DebuggerAgent::restore()
 {
     if (enabled()) {
-        frontend()->globalObjectCleared();
+        m_frontend->globalObjectCleared();
         enable();
         long pauseState = m_state->getLong(DebuggerAgentState::pauseOnExceptionsState, V8Debugger::DontPauseOnExceptions);
         String error;
         setPauseOnExceptionsImpl(&error, pauseState);
         m_cachedSkipStackRegExp = compileSkipCallFramePattern(m_state->getString(DebuggerAgentState::skipStackPattern));
         increaseCachedSkipStackGeneration();
         m_skipContentScripts = m_state->getBoolean(DebuggerAgentState::skipContentScripts);
         m_skipAllPauses = m_state->getBoolean(DebuggerAgentState::skipAllPauses);
         internalSetAsyncCallStackDepth(m_state->getLong(DebuggerAgentState::asyncCallStackDepth));
         promiseTracker().setEnabled(m_state->getBoolean(DebuggerAgentState::promiseTrackerEnabled), m_state->getBoolean(DebuggerAgentState::promiseTrackerCaptureStacks));
@@ skipping 432 matching lines @@
     ASSERT(enabled());
     if (m_scheduledDebuggerStep != StepInto || m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     debugger().setPauseOnNextStatement(true);
 }
 
-void V8DebuggerAgent::didFireTimer()
-{
-    cancelPauseOnNextStatement();
-}
-
-void V8DebuggerAgent::didHandleEvent()
-{
-    cancelPauseOnNextStatement();
-}
-
 void V8DebuggerAgent::cancelPauseOnNextStatement()
 {
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     debugger().setPauseOnNextStatement(false);
 }
 
 bool V8DebuggerAgent::v8AsyncTaskEventsEnabled() const
@@ skipping 374 matching lines @@
     if (value.isEmpty()) {
         *errorString = "Promise with specified ID not found.";
         return;
     }
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(value.scriptState());
     promise = injectedScript.wrapObject(value, objectGroup ? *objectGroup : "");
 }
 
 void V8DebuggerAgent::didUpdatePromise(InspectorFrontend::Debugger::EventType::Enum eventType, PassRefPtr<TypeBuilder::Debugger::PromiseDetails> promise)
 {
-    if (frontend())
-        frontend()->promiseUpdated(eventType, promise);
+    if (m_frontend)
+        m_frontend->promiseUpdated(eventType, promise);
 }
 
 int V8DebuggerAgent::traceAsyncOperationStarting(const String& description)
 {
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> callFrames = debugger().currentCallFramesForAsyncStack();
     RefPtrWillBeRawPtr<AsyncCallChain> chain = nullptr;
     if (callFrames.IsEmpty()) {
         if (m_currentAsyncCallChain)
             chain = AsyncCallChain::create(nullptr, m_currentAsyncCallChain.get(), m_maxAsyncCallStackDepth);
@@ skipping 101 matching lines @@
         }
         m_asyncOperations.remove(operationId);
         m_asyncOperationBreakpoints.remove(operationId);
         m_pausingAsyncOperations.remove(operationId);
         shouldNotify = !m_asyncOperationNotifications.take(operationId);
     }
     if (m_startingStepIntoAsync) {
         if (!m_pausingOnAsyncOperation && m_pausingAsyncOperations.isEmpty())
             clearStepIntoAsync();
     }
-    if (frontend() && shouldNotify)
-        frontend()->asyncOperationCompleted(operationId);
+    if (m_frontend && shouldNotify)
+        m_frontend->asyncOperationCompleted(operationId);
 }
 
 void V8DebuggerAgent::flushAsyncOperationEvents(ErrorString*)
 {
-    if (!frontend())
+    if (!m_frontend)
         return;
 
     for (int operationId : m_asyncOperationNotifications) {
         RefPtrWillBeRawPtr<AsyncCallChain> chain = m_asyncOperations.get(operationId);
         ASSERT(chain);
         const AsyncCallStackVector& callStacks = chain->callStacks();
         ASSERT(!callStacks.isEmpty());
 
         RefPtr<AsyncOperation> operation;
         RefPtr<AsyncStackTrace> lastAsyncStackTrace;
@@ skipping 14 matching lines @@
                 .setCallFrames(scriptCallStack->buildInspectorArray());
             asyncStackTrace->setDescription(callStack->description());
             if (lastAsyncStackTrace)
                 lastAsyncStackTrace->setAsyncStackTrace(asyncStackTrace);
             else
                 operation->setAsyncStackTrace(asyncStackTrace);
             lastAsyncStackTrace = asyncStackTrace.release();
         }
 
         if (operation)
-            frontend()->asyncOperationStarted(operation.release());
+            m_frontend->asyncOperationStarted(operation.release());
     }
 
     m_asyncOperationNotifications.clear();
 }
 
 void V8DebuggerAgent::clearCurrentAsyncOperation()
 {
     if (m_pendingTraceAsyncOperationCompleted && m_currentAsyncOperationId != unknownAsyncOperationId)
         traceAsyncOperationCompleted(m_currentAsyncOperationId);
 
@@ skipping 37 matching lines @@
         *errorString = "Can only perform operation while tracking async call stacks.";
         return;
     }
     if (operationId <= 0) {
         *errorString = "Wrong async operation id.";
         return;
     }
     m_asyncOperationBreakpoints.remove(operationId);
 }
 
-void V8DebuggerAgent::scriptExecutionBlockedByCSP(const String& directiveText)
-{
-    if (debugger().pauseOnExceptionsState() != V8Debugger::DontPauseOnExceptions) {
-        RefPtr<JSONObject> directive = JSONObject::create();
-        directive->setString("directiveText", directiveText);
-        breakProgram(InspectorFrontend::Debugger::Reason::CSPViolation, directive.release());
-    }
-}
-
 void V8DebuggerAgent::addAsyncCallTrackingListener(AsyncCallTrackingListener* listener)
 {
     m_asyncCallTrackingListeners.add(listener);
 }
 
 void V8DebuggerAgent::removeAsyncCallTrackingListener(AsyncCallTrackingListener* listener)
 {
     ASSERT(m_asyncCallTrackingListeners.contains(listener));
     m_asyncCallTrackingListeners.remove(listener);
 }
 
-void V8DebuggerAgent::willCallFunction(ExecutionContext*, const DevToolsFunctionInfo& info)
+void V8DebuggerAgent::willCallFunction(int scriptId)
 {
     changeJavaScriptRecursionLevel(+1);
     // Fast return.
     if (m_scheduledDebuggerStep != StepInto)
         return;
     // Skip unknown scripts (e.g. InjectedScript).
-    if (!m_scripts.contains(String::number(info.scriptId())))
+    if (!m_scripts.contains(String::number(scriptId)))
         return;
     schedulePauseOnNextStatementIfSteppingInto();
 }
 
 void V8DebuggerAgent::didCallFunction()
 {
     changeJavaScriptRecursionLevel(-1);
 }
 
-void V8DebuggerAgent::willEvaluateScript(const String&, int)
+void V8DebuggerAgent::willEvaluateScript()
 {
     changeJavaScriptRecursionLevel(+1);
     schedulePauseOnNextStatementIfSteppingInto();
 }
 
 void V8DebuggerAgent::didEvaluateScript()
 {
     changeJavaScriptRecursionLevel(-1);
 }
 
@@ skipping 120 matching lines @@
     bool isInternalScript = script.isInternalScript();
     bool hasSourceURL = script.hasSourceURL();
     String scriptURL = script.sourceURL();
     String sourceMapURL = sourceMapURLForScript(script, parsedScript.compileResult);
 
     const String* sourceMapURLParam = sourceMapURL.isNull() ? nullptr : &sourceMapURL;
     const bool* isContentScriptParam = isContentScript ? &isContentScript : nullptr;
     const bool* isInternalScriptParam = isInternalScript ? &isInternalScript : nullptr;
     const bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : nullptr;
     if (!hasSyntaxError)
-        frontend()->scriptParsed(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam);
+        m_frontend->scriptParsed(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam);
     else
-        frontend()->scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam);
+        m_frontend->scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam);
 
     m_scripts.set(parsedScript.scriptId, script);
 
     if (scriptURL.isEmpty() || hasSyntaxError)
         return;
 
     RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     for (auto& cookie : *breakpointsCookie) {
         RefPtr<JSONObject> breakpointObject = cookie.value->asObject();
         bool isRegex;
         breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
         String url;
         breakpointObject->getString(DebuggerAgentState::url, &url);
         if (!matches(scriptURL, url, isRegex))
             continue;
         ScriptBreakpoint breakpoint;
         breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakpoint.lineNumber);
         breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakpoint.columnNumber);
         breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition);
         RefPtr<TypeBuilder::Debugger::Location> location = resolveBreakpoint(cookie.key, parsedScript.scriptId, breakpoint, UserBreakpointSource);
         if (location)
-            frontend()->breakpointResolved(cookie.key, location);
+            m_frontend->breakpointResolved(cookie.key, location);
     }
 }
 
 V8DebuggerListener::SkipPauseRequest V8DebuggerAgent::didPause(v8::Local<v8::Context> context, v8::Local<v8::Object> callFrames, v8::Local<v8::Value> v8exception, const Vector<String>& hitBreakpoints, bool isPromiseRejection)
 {
     ScriptState* scriptState = ScriptState::from(context);
     ScriptValue exception(scriptState, v8exception);
 
     V8DebuggerListener::SkipPauseRequest result;
     if (m_skipAllPauses)
@@ skipping 43 matching lines @@
 
             BreakpointSource source = breakpointIterator->value.second;
             if (m_breakReason == InspectorFrontend::Debugger::Reason::Other && source == DebugCommandBreakpointSource)
                 m_breakReason = InspectorFrontend::Debugger::Reason::DebugCommand;
         }
     }
 
     if (!m_asyncOperationNotifications.isEmpty())
         flushAsyncOperationEvents(nullptr);
 
-    frontend()->paused(currentCallFrames(), m_breakReason, m_breakAuxData, hitBreakpointIds, currentAsyncStackTrace());
+    m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData, hitBreakpointIds, currentAsyncStackTrace());
     m_scheduledDebuggerStep = NoStep;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     clearStepIntoAsync();
 
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
     return result;
 }
 
 void V8DebuggerAgent::didContinue()
 {
     m_pausedScriptState = nullptr;
     m_currentCallStack.Reset();
     clearBreakDetails();
-    frontend()->resumed();
+    m_frontend->resumed();
 }
 
 bool V8DebuggerAgent::canBreakProgram()
 {
     return debugger().canBreakProgram();
 }
 
 void V8DebuggerAgent::breakProgram(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
 {
     ASSERT(enabled());
@@ skipping 64 matching lines @@
     removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
 }
 
 void V8DebuggerAgent::reset()
 {
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     promiseTracker().clear();
-    if (frontend())
-        frontend()->globalObjectCleared();
-}
-
-DEFINE_TRACE(V8DebuggerAgent)
-{
-#if ENABLE(OILPAN)
-    visitor->trace(m_injectedScriptManager);
-    visitor->trace(m_v8AsyncCallTracker);
-    visitor->trace(m_promiseTracker);
-    visitor->trace(m_asyncOperations);
-    visitor->trace(m_currentAsyncCallChain);
-    visitor->trace(m_asyncCallTrackingListeners);
-#endif
-    InspectorBaseAgent::trace(visitor);
+    if (m_frontend)
+        m_frontend->globalObjectCleared();
 }
 
 PassRefPtr<TypeBuilder::Debugger::ExceptionDetails> V8DebuggerAgent::createExceptionDetails(v8::Isolate* isolate, v8::Local<v8::Message> message)
 {
     RefPtr<ExceptionDetails> exceptionDetails = ExceptionDetails::create().setText(toCoreStringWithUndefinedOrNullCheck(message->Get()));
     exceptionDetails->setLine(message->GetLineNumber());
     exceptionDetails->setColumn(message->GetStartColumn());
     v8::Local<v8::StackTrace> messageStackTrace = message->GetStackTrace();
     if (!messageStackTrace.IsEmpty() && messageStackTrace->GetFrameCount() > 0)
         exceptionDetails->setStackTrace(createScriptCallStack(isolate, messageStackTrace, messageStackTrace->GetFrameCount())->buildInspectorArray());
     return exceptionDetails.release();
 }
 
 } // namespace blink