DevTools: inline some private methods that called only once

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 175 matching lines @@
 {
     // debugger().addListener may result in reporting all parsed scripts to
     // the agent so it should already be in enabled state by then.
     m_state->setBoolean(DebuggerAgentState::debuggerEnabled, true);
     debugger().addListener(m_contextGroupId, this);
     // FIXME(WK44513): breakpoints activated flag should be synchronized between all front-ends
     debugger().setBreakpointsActivated(true);
     m_client->debuggerAgentEnabled();
 }
 
-void V8DebuggerAgent::disable()
-{
-    m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, JSONObject::create());
-    m_state->setLong(DebuggerAgentState::pauseOnExceptionsState, V8Debugger::DontPauseOnExceptions);
-    m_state->setString(DebuggerAgentState::skipStackPattern, "");
-    m_state->setBoolean(DebuggerAgentState::skipContentScripts, false);
-    m_state->setLong(DebuggerAgentState::asyncCallStackDepth, 0);
-    m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
-
-    debugger().removeListener(m_contextGroupId);
-    m_client->debuggerAgentDisabled();
-    clear();
-    m_skipAllPauses = false;
-}
-
 bool V8DebuggerAgent::enabled()
 {
     return m_state->getBoolean(DebuggerAgentState::debuggerEnabled);
 }
 
 void V8DebuggerAgent::enable(ErrorString*)
 {
     if (enabled())
         return;
 
     enable();
 
     ASSERT(m_frontend);
 }
 
 void V8DebuggerAgent::disable(ErrorString*)
 {
     if (!enabled())
         return;
 
-    disable();
+    m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, JSONObject::create());
+    m_state->setLong(DebuggerAgentState::pauseOnExceptionsState, V8Debugger::DontPauseOnExceptions);
+    m_state->setString(DebuggerAgentState::skipStackPattern, "");
+    m_state->setBoolean(DebuggerAgentState::skipContentScripts, false);
+    m_state->setLong(DebuggerAgentState::asyncCallStackDepth, 0);
+    m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
+    m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, false);
+
+    debugger().removeListener(m_contextGroupId);
+    m_client->debuggerAgentDisabled();
+    m_pausedScriptState = nullptr;
+    m_currentCallStack.Reset();
+    m_scripts.clear();
+    m_breakpointIdToDebuggerBreakpointIds.clear();
+    internalSetAsyncCallStackDepth(0);
+    m_promiseTracker->setEnabled(false, false);
+    m_continueToLocationBreakpointId = String();
+    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();
+    m_compiledScripts.Clear();
+    clearStepIntoAsync();
+    m_skipAllPauses = false;
     m_state->setBoolean(DebuggerAgentState::debuggerEnabled, false);
 }
 
 static PassOwnPtr<ScriptRegexp> compileSkipCallFramePattern(String patternText)
 {
     if (patternText.isEmpty())
         return nullptr;
     OwnPtr<ScriptRegexp> result = adoptPtr(new ScriptRegexp(patternText, TextCaseSensitive));
     if (!result->isValid())
         result.clear();
@@ skipping 33 matching lines @@
         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));
+        m_promiseTracker->setEnabled(m_state->getBoolean(DebuggerAgentState::promiseTrackerEnabled), m_state->getBoolean(DebuggerAgentState::promiseTrackerCaptureStacks));
     }
 }
 
 void V8DebuggerAgent::setBreakpointsActive(ErrorString* errorString, bool active)
 {
     if (!checkEnabled(errorString))
         return;
     debugger().setBreakpointsActivated(active);
 }
 
@@ skipping 445 matching lines @@
 
 void V8DebuggerAgent::didReceiveV8AsyncTaskEvent(v8::Local<v8::Context> context, const String& eventType, const String& eventName, int id)
 {
     ASSERT(trackingAsyncCalls());
     ScriptState* state = ScriptState::from(context);
     m_v8AsyncCallTracker->didReceiveV8AsyncTaskEvent(state, eventType, eventName, id);
 }
 
 bool V8DebuggerAgent::v8PromiseEventsEnabled() const
 {
-    return promiseTracker().isEnabled();
+    return m_promiseTracker->isEnabled();
 }
 
 void V8DebuggerAgent::didReceiveV8PromiseEvent(v8::Local<v8::Context> context, v8::Local<v8::Object> promise, v8::Local<v8::Value> parentPromise, int status)
 {
-    ASSERT(promiseTracker().isEnabled());
+    ASSERT(m_promiseTracker->isEnabled());
     ScriptState* scriptState = ScriptState::from(context);
-    promiseTracker().didReceiveV8PromiseEvent(scriptState, promise, parentPromise, status);
+    m_promiseTracker->didReceiveV8PromiseEvent(scriptState, promise, parentPromise, status);
 }
 
 void V8DebuggerAgent::pause(ErrorString* errorString)
 {
     if (!checkEnabled(errorString))
         return;
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     clearStepIntoAsync();
@@ skipping 313 matching lines @@
     m_state->setLong(DebuggerAgentState::asyncCallStackDepth, depth);
     internalSetAsyncCallStackDepth(depth);
 }
 
 void V8DebuggerAgent::enablePromiseTracker(ErrorString* errorString, const bool* captureStacks)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, true);
     m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, asBool(captureStacks));
-    promiseTracker().setEnabled(true, asBool(captureStacks));
+    m_promiseTracker->setEnabled(true, asBool(captureStacks));
 }
 
 void V8DebuggerAgent::disablePromiseTracker(ErrorString* errorString)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
-    promiseTracker().setEnabled(false, false);
+    m_promiseTracker->setEnabled(false, false);
 }
 
 void V8DebuggerAgent::getPromiseById(ErrorString* errorString, int promiseId, const String* objectGroup, RefPtr<RemoteObject>& promise)
 {
     if (!checkEnabled(errorString))
         return;
-    if (!promiseTracker().isEnabled()) {
+    if (!m_promiseTracker->isEnabled()) {
         *errorString = "Promise tracking is disabled";
         return;
     }
-    ScriptValue value = promiseTracker().promiseById(promiseId);
+    ScriptValue value = m_promiseTracker->promiseById(promiseId);
     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)
 {
@@ skipping 512 matching lines @@
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_scheduledDebuggerStep = NoStep;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     clearStepIntoAsync();
     debugger().breakProgram();
 }
 
-void V8DebuggerAgent::clear()
-{
-    m_pausedScriptState = nullptr;
-    m_currentCallStack.Reset();
-    m_scripts.clear();
-    m_breakpointIdToDebuggerBreakpointIds.clear();
-    internalSetAsyncCallStackDepth(0);
-    promiseTracker().clear();
-    m_continueToLocationBreakpointId = String();
-    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();
-    m_compiledScripts.Clear();
-    clearStepIntoAsync();
-}
-
 void V8DebuggerAgent::clearStepIntoAsync()
 {
     m_startingStepIntoAsync = false;
     m_pausingOnAsyncOperation = false;
     m_pausingAsyncOperations.clear();
 }
 
 bool V8DebuggerAgent::assertPaused(ErrorString* errorString)
 {
     if (!m_pausedScriptState) {
@@ skipping 20 matching lines @@
 {
     removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
 }
 
 void V8DebuggerAgent::reset()
 {
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
-    promiseTracker().clear();
+    m_promiseTracker->clear();
     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