DevTools: respond with error when Debugger command is sent to disabled debugger agent

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 162 matching lines @@
 }
 
 void InspectorDebuggerAgent::init()
 {
     m_promiseTracker = PromiseTracker::create(this, scriptDebugServer().isolate());
     // FIXME: make breakReason optional so that there was no need to init it with "other".
     clearBreakDetails();
     m_state->setLong(DebuggerAgentState::pauseOnExceptionsState, ScriptDebugServer::DontPauseOnExceptions);
 }
 
+bool InspectorDebuggerAgent::checkEnabled(ErrorString* errorString)
+{
+    if (enabled())
+        return true;
+    *errorString = "Debugger agent is not enabled";
+    return false;
+}
+
 void InspectorDebuggerAgent::enable()
 {
     m_instrumentingAgents->setInspectorDebuggerAgent(this);
 
     startListeningScriptDebugServer();
     // FIXME(WK44513): breakpoints activated flag should be synchronized between all front-ends
     scriptDebugServer().setBreakpointsActivated(true);
 
     m_state->setBoolean(DebuggerAgentState::debuggerEnabled, true);
     if (m_listener)
@@ skipping 82 matching lines @@
         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));
     }
 }
 
-void InspectorDebuggerAgent::setBreakpointsActive(ErrorString*, bool active)
+void InspectorDebuggerAgent::setBreakpointsActive(ErrorString* errorString, bool active)
 {
+    if (!checkEnabled(errorString))
+        return;
     scriptDebugServer().setBreakpointsActivated(active);
 }
 
 void InspectorDebuggerAgent::setSkipAllPauses(ErrorString*, bool skipped)
 {
     m_skipAllPauses = skipped;
     m_state->setBoolean(DebuggerAgentState::skipAllPauses, m_skipAllPauses);
 }
 
 bool InspectorDebuggerAgent::isPaused()
 {
     return scriptDebugServer().isPaused();
 }
 
 void InspectorDebuggerAgent::addMessageToConsole(ConsoleMessage* consoleMessage)
 {
+    ASSERT(enabled());
     if (consoleMessage->type() == AssertMessageType && scriptDebugServer().pauseOnExceptionsState() != ScriptDebugServer::DontPauseOnExceptions)
         breakProgram(InspectorFrontend::Debugger::Reason::Assert, nullptr);
 }
 
 static PassRefPtr<JSONObject> buildObjectForBreakpointCookie(const String& url, int lineNumber, int columnNumber, const String& condition, bool isRegex)
 {
     RefPtr<JSONObject> breakpointObject = JSONObject::create();
     breakpointObject->setString(DebuggerAgentState::url, url);
     breakpointObject->setNumber(DebuggerAgentState::lineNumber, lineNumber);
     breakpointObject->setNumber(DebuggerAgentState::columnNumber, columnNumber);
@@ skipping 82 matching lines @@
         return;
     }
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     actualLocation = resolveBreakpoint(breakpointId, scriptId, breakpoint, UserBreakpointSource);
     if (actualLocation)
         *outBreakpointId = breakpointId;
     else
         *errorString = "Could not resolve breakpoint";
 }
 
-void InspectorDebuggerAgent::removeBreakpoint(ErrorString*, const String& breakpointId)
+void InspectorDebuggerAgent::removeBreakpoint(ErrorString* errorString, const String& breakpointId)
 {
+    if (!checkEnabled(errorString))
+        return;
     RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     breakpointsCookie->remove(breakpointId);
     m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie);
     removeBreakpoint(breakpointId);
 }
 
 void InspectorDebuggerAgent::removeBreakpoint(const String& breakpointId)
 {
+    ASSERT(enabled());
     BreakpointIdToDebugServerBreakpointIdsMap::iterator debugServerBreakpointIdsIterator = m_breakpointIdToDebugServerBreakpointIds.find(breakpointId);
     if (debugServerBreakpointIdsIterator == m_breakpointIdToDebugServerBreakpointIds.end())
         return;
     for (size_t i = 0; i < debugServerBreakpointIdsIterator->value.size(); ++i) {
         const String& debugServerBreakpointId = debugServerBreakpointIdsIterator->value[i];
         scriptDebugServer().removeBreakpoint(debugServerBreakpointId);
         m_serverBreakpoints.remove(debugServerBreakpointId);
     }
     m_breakpointIdToDebugServerBreakpointIds.remove(debugServerBreakpointIdsIterator);
 }
 
 void InspectorDebuggerAgent::continueToLocation(ErrorString* errorString, const RefPtr<JSONObject>& location, const bool* interstateLocationOpt)
 {
+    if (!checkEnabled(errorString))
+        return;
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         scriptDebugServer().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
 
     String scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
@@ skipping 23 matching lines @@
 {
     if (!assertPaused(errorString))
         return;
     m_currentCallStack = scriptDebugServer().currentCallFrames();
     callFrames = currentCallFrames();
     asyncStackTrace = currentAsyncStackTrace();
 }
 
 bool InspectorDebuggerAgent::isCallStackEmptyOrBlackboxed()
 {
+    ASSERT(enabled());
     for (int index = 0; ; ++index) {
         RefPtrWillBeRawPtr<JavaScriptCallFrame> frame = scriptDebugServer().callFrameNoScopes(index);
         if (!frame)
             break;
         if (!isCallFrameWithUnknownScriptOrBlackboxed(frame.release()))
             return false;
     }
     return true;
 }
 
 bool InspectorDebuggerAgent::isTopCallFrameBlackboxed()
 {
+    ASSERT(enabled());
     return isCallFrameWithUnknownScriptOrBlackboxed(scriptDebugServer().callFrameNoScopes(0));
 }
 
 bool InspectorDebuggerAgent::isCallFrameWithUnknownScriptOrBlackboxed(PassRefPtrWillBeRawPtr<JavaScriptCallFrame> pFrame)
 {
     RefPtrWillBeRawPtr<JavaScriptCallFrame> frame = pFrame;
     if (!frame)
         return true;
     ScriptsMap::iterator it = m_scripts.find(String::number(frame->sourceID()));
     if (it == m_scripts.end()) {
@@ skipping 41 matching lines @@
 
     if (!m_skippedStepFrameCount)
         m_recursionLevelForStepFrame = 1;
 
     ++m_skippedStepFrameCount;
     return ScriptDebugListener::StepFrame;
 }
 
 PassRefPtr<TypeBuilder::Debugger::Location> InspectorDebuggerAgent::resolveBreakpoint(const String& breakpointId, const String& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
 {
+    ASSERT(enabled());
     ScriptsMap::iterator scriptIterator = m_scripts.find(scriptId);
     if (scriptIterator == m_scripts.end())
         return nullptr;
     Script& script = scriptIterator->value;
     if (breakpoint.lineNumber < script.startLine() || script.endLine() < breakpoint.lineNumber)
         return nullptr;
 
     int actualLineNumber;
     int actualColumnNumber;
     String debugServerBreakpointId = scriptDebugServer().setBreakpoint(scriptId, breakpoint, &actualLineNumber, &actualColumnNumber, false);
@@ skipping 19 matching lines @@
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
         results = ContentSearchUtils::searchInTextByLines(it->value.source(), query, asBool(optionalCaseSensitive), asBool(optionalIsRegex));
     else
         *error = "No script for id: " + scriptId;
 }
 
 void InspectorDebuggerAgent::setScriptSource(ErrorString* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorData, const String& scriptId, const String& newContent, const bool* const preview, RefPtr<Array<CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, RefPtr<StackTrace>& asyncStackTrace)
 {
+    if (!checkEnabled(error))
+        return;
     if (!scriptDebugServer().setScriptSource(scriptId, newContent, asBool(preview), error, errorData, &m_currentCallStack, &result))
         return;
 
     newCallFrames = currentCallFrames();
     asyncStackTrace = currentAsyncStackTrace();
 
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end())
         return;
     String url = it->value.url();
@@ skipping 15 matching lines @@
     }
 
     injectedScript.restartFrame(errorString, m_currentCallStack, callFrameId, &result);
     m_currentCallStack = scriptDebugServer().currentCallFrames();
     newCallFrames = currentCallFrames();
     asyncStackTrace = currentAsyncStackTrace();
 }
 
 void InspectorDebuggerAgent::getScriptSource(ErrorString* error, const String& scriptId, String* scriptSource)
 {
+    if (!checkEnabled(error))
+        return;
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end()) {
         *error = "No script for id: " + scriptId;
         return;
     }
 
     String url = it->value.url();
     if (!url.isEmpty() && getEditedScript(url, scriptSource))
         return;
     *scriptSource = it->value.source();
 }
 
 void InspectorDebuggerAgent::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<FunctionDetails>& details)
 {
+    if (!checkEnabled(errorString))
+        return;
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(functionId);
     if (injectedScript.isEmpty()) {
         *errorString = "Function object id is obsolete";
         return;
     }
     injectedScript.getFunctionDetails(errorString, functionId, &details);
 }
 
 void InspectorDebuggerAgent::getGeneratorObjectDetails(ErrorString* errorString, const String& objectId, RefPtr<GeneratorObjectDetails>& details)
 {
+    if (!checkEnabled(errorString))
+        return;
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(objectId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
     injectedScript.getGeneratorObjectDetails(errorString, objectId, &details);
 }
 
 void InspectorDebuggerAgent::getCollectionEntries(ErrorString* errorString, const String& objectId, RefPtr<TypeBuilder::Array<CollectionEntry> >& entries)
 {
+    if (!checkEnabled(errorString))
+        return;
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(objectId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
     injectedScript.getCollectionEntries(errorString, objectId, &entries);
 }
 
 void InspectorDebuggerAgent::schedulePauseOnNextStatement(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
 {
+    ASSERT(enabled());
     if (m_scheduledDebuggerStep == StepInto || m_javaScriptPauseScheduled || isPaused())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_pausingOnNativeEvent = true;
     m_skipNextDebuggerStepOut = false;
     scriptDebugServer().setPauseOnNextStatement(true);
 }
 
 void InspectorDebuggerAgent::schedulePauseOnNextStatementIfSteppingInto()
 {
+    ASSERT(enabled());
     if (m_scheduledDebuggerStep != StepInto || m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     scriptDebugServer().setPauseOnNextStatement(true);
 }
 
 void InspectorDebuggerAgent::didFireTimer()
@@ skipping 40 matching lines @@
     if (!parentPromise.IsEmpty() && parentPromise->IsObject())
         return;
     if (status < 0)
         m_listener->didRejectPromise();
     else if (status > 0)
         m_listener->didResolvePromise();
     else
         m_listener->didCreatePromise();
 }
 
-void InspectorDebuggerAgent::pause(ErrorString*)
+void InspectorDebuggerAgent::pause(ErrorString* errorString)
 {
+    if (!checkEnabled(errorString))
+        return;
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     clearStepIntoAsync();
     m_javaScriptPauseScheduled = true;
     m_scheduledDebuggerStep = NoStep;
     m_skippedStepFrameCount = 0;
     m_steppingFromFramework = false;
     scriptDebugServer().setPauseOnNextStatement(true);
 }
@@ skipping 54 matching lines @@
         *errorString = "Can only perform operation if async call stacks are enabled.";
         return;
     }
     clearStepIntoAsync();
     m_startingStepIntoAsync = true;
     stepInto(errorString);
 }
 
 void InspectorDebuggerAgent::setPauseOnExceptions(ErrorString* errorString, const String& stringPauseState)
 {
+    if (!checkEnabled(errorString))
+        return;
     ScriptDebugServer::PauseOnExceptionsState pauseState;
     if (stringPauseState == "none")
         pauseState = ScriptDebugServer::DontPauseOnExceptions;
     else if (stringPauseState == "all")
         pauseState = ScriptDebugServer::PauseOnAllExceptions;
     else if (stringPauseState == "uncaught")
         pauseState = ScriptDebugServer::PauseOnUncaughtExceptions;
     else {
         *errorString = "Unknown pause on exceptions mode: " + stringPauseState;
         return;
@@ skipping 41 matching lines @@
     injectedScript.evaluateOnCallFrame(errorString, m_currentCallStack, asyncCallStacks, callFrameId, expression, objectGroup ? *objectGroup : "", asBool(includeCommandLineAPI), asBool(returnByValue), asBool(generatePreview), &result, wasThrown, &exceptionDetails);
     if (asBool(doNotPauseOnExceptionsAndMuteConsole)) {
         unmuteConsole();
         if (scriptDebugServer().pauseOnExceptionsState() != previousPauseOnExceptionsState)
             scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
     }
 }
 
 void InspectorDebuggerAgent::compileScript(ErrorString* errorString, const String& expression, const String& sourceURL, bool persistScript, const int* executionContextId, TypeBuilder::OptOutput<ScriptId>* scriptId, RefPtr<ExceptionDetails>& exceptionDetails)
 {
+    if (!checkEnabled(errorString))
+        return;
     InjectedScript injectedScript = injectedScriptForEval(errorString, executionContextId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     String scriptIdValue;
     String exceptionDetailsText;
     int lineNumberValue = 0;
     int columnNumberValue = 0;
     RefPtrWillBeRawPtr<ScriptCallStack> stackTraceValue = nullptr;
     scriptDebugServer().compileScript(injectedScript.scriptState(), expression, sourceURL, persistScript, &scriptIdValue, &exceptionDetailsText, &lineNumberValue, &columnNumberValue, &stackTraceValue);
     if (!scriptIdValue && !exceptionDetailsText) {
         *errorString = "Script compilation failed";
         return;
     }
     *scriptId = scriptIdValue;
     if (!scriptIdValue.isEmpty())
         return;
 
     exceptionDetails = ExceptionDetails::create().setText(exceptionDetailsText);
     exceptionDetails->setLine(lineNumberValue);
     exceptionDetails->setColumn(columnNumberValue);
     if (stackTraceValue && stackTraceValue->size() > 0)
         exceptionDetails->setStackTrace(stackTraceValue->buildInspectorArray());
 }
 
 void InspectorDebuggerAgent::runScript(ErrorString* errorString, const ScriptId& scriptId, const int* executionContextId, const String* const objectGroup, const bool* const doNotPauseOnExceptionsAndMuteConsole, RefPtr<RemoteObject>& result, RefPtr<ExceptionDetails>& exceptionDetails)
 {
+    if (!checkEnabled(errorString))
+        return;
     InjectedScript injectedScript = injectedScriptForEval(errorString, executionContextId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
     if (asBool(doNotPauseOnExceptionsAndMuteConsole)) {
         if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
             scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
@@ skipping 22 matching lines @@
 
     if (asBool(doNotPauseOnExceptionsAndMuteConsole)) {
         unmuteConsole();
         if (scriptDebugServer().pauseOnExceptionsState() != previousPauseOnExceptionsState)
             scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
     }
 }
 
 void InspectorDebuggerAgent::setVariableValue(ErrorString* errorString, int scopeNumber, const String& variableName, const RefPtr<JSONObject>& newValue, const String* callFrameId, const String* functionObjectId)
 {
+    if (!checkEnabled(errorString))
+        return;
     InjectedScript injectedScript;
     if (callFrameId) {
         if (!isPaused() || m_currentCallStack.isEmpty()) {
             *errorString = "Attempt to access callframe when debugger is not on pause";
             return;
         }
         injectedScript = m_injectedScriptManager->injectedScriptForObjectId(*callFrameId);
         if (injectedScript.isEmpty()) {
             *errorString = "Inspected frame has gone";
             return;
         }
     } else if (functionObjectId) {
         injectedScript = m_injectedScriptManager->injectedScriptForObjectId(*functionObjectId);
         if (injectedScript.isEmpty()) {
             *errorString = "Function object id cannot be resolved";
             return;
         }
     } else {
         *errorString = "Either call frame or function object must be specified";
         return;
     }
     String newValueString = newValue->toJSONString();
 
     injectedScript.setVariableValue(errorString, m_currentCallStack, callFrameId, functionObjectId, scopeNumber, variableName, newValueString);
 }
 
 void InspectorDebuggerAgent::skipStackFrames(ErrorString* errorString, const String* pattern, const bool* skipContentScripts)
 {
+    if (!checkEnabled(errorString))
+        return;
     OwnPtr<ScriptRegexp> compiled;
     String patternValue = pattern ? *pattern : "";
     if (!patternValue.isEmpty()) {
         compiled = compileSkipCallFramePattern(patternValue);
         if (!compiled) {
             *errorString = "Invalid regular expression";
             return;
         }
     }
     m_state->setString(DebuggerAgentState::skipStackPattern, patternValue);
     m_cachedSkipStackRegExp = compiled.release();
     increaseCachedSkipStackGeneration();
     m_skipContentScripts = asBool(skipContentScripts);
     m_state->setBoolean(DebuggerAgentState::skipContentScripts, m_skipContentScripts);
 }
 
-void InspectorDebuggerAgent::setAsyncCallStackDepth(ErrorString*, int depth)
+void InspectorDebuggerAgent::setAsyncCallStackDepth(ErrorString* errorString, int depth)
 {
+    if (!checkEnabled(errorString))
+        return;
     m_state->setLong(DebuggerAgentState::asyncCallStackDepth, depth);
     internalSetAsyncCallStackDepth(depth);
 }
 
-void InspectorDebuggerAgent::enablePromiseTracker(ErrorString*, const bool* captureStacks)
+void InspectorDebuggerAgent::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));
 }
 
-void InspectorDebuggerAgent::disablePromiseTracker(ErrorString*)
+void InspectorDebuggerAgent::disablePromiseTracker(ErrorString* errorString)
 {
+    if (!checkEnabled(errorString))
+        return;
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
     promiseTracker().setEnabled(false, false);
 }
 
 void InspectorDebuggerAgent::getPromiseById(ErrorString* errorString, int promiseId, const String* objectGroup, RefPtr<RemoteObject>& promise)
 {
+    if (!checkEnabled(errorString))
+        return;
     if (!promiseTracker().isEnabled()) {
         *errorString = "Promise tracking is disabled";
         return;
     }
     ScriptValue value = promiseTracker().promiseById(promiseId);
     if (value.isEmpty()) {
         *errorString = "Promise with specified ID not found.";
         return;
     }
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(value.scriptState());
@@ skipping 515 matching lines @@
     frontend()->resumed();
 }
 
 bool InspectorDebuggerAgent::canBreakProgram()
 {
     return scriptDebugServer().canBreakProgram();
 }
 
 void InspectorDebuggerAgent::breakProgram(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
 {
+    ASSERT(enabled());
     if (m_skipAllPauses || m_pausedScriptState || isCallStackEmptyOrBlackboxed())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_scheduledDebuggerStep = NoStep;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     clearStepIntoAsync();
     scriptDebugServer().breakProgram();
 }
@@ skipping 77 matching lines @@
     visitor->trace(m_v8AsyncCallTracker);
     visitor->trace(m_promiseTracker);
     visitor->trace(m_asyncOperations);
     visitor->trace(m_currentAsyncCallChain);
     visitor->trace(m_asyncCallTrackingListeners);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink