DevTools: Make StepInto work across script boundaries and Blink process tasks.

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 104 matching lines @@
 {
     return scriptId + ':' + String::number(lineNumber) + ':' + String::number(columnNumber) + breakpointIdSuffix(source);
 }
 
 InspectorDebuggerAgent::InspectorDebuggerAgent(InjectedScriptManager* injectedScriptManager)
     : InspectorBaseAgent<InspectorDebuggerAgent>("Debugger")
     , m_injectedScriptManager(injectedScriptManager)
     , m_frontend(0)
     , m_pausedScriptState(nullptr)
     , m_breakReason(InspectorFrontend::Debugger::Reason::Other)
+    , m_scheduledDebuggerStep(NoStep)
     , m_javaScriptPauseScheduled(false)
-    , m_debuggerStepScheduled(false)
     , m_steppingFromFramework(false)
     , m_pausingOnNativeEvent(false)
     , m_listener(nullptr)
     , m_skippedStepInCount(0)
     , m_minFrameCountForSkip(0)
     , m_skipAllPauses(false)
     , m_skipContentScripts(false)
     , m_asyncCallStackTracker(adoptPtrWillBeNoop(new AsyncCallStackTracker()))
     , m_promiseTracker(PromiseTracker::create())
 {
@@ skipping 577 matching lines @@
     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)
 {
-    if (m_javaScriptPauseScheduled || isPaused())
+    if (m_scheduledDebuggerStep == StepInto || m_javaScriptPauseScheduled || isPaused())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_pausingOnNativeEvent = true;
     scriptDebugServer().setPauseOnNextStatement(true);
 }
 
+void InspectorDebuggerAgent::schedulePauseOnNextStatementIfSteppingInto()
+{
+    if (m_scheduledDebuggerStep != StepInto || m_javaScriptPauseScheduled || isPaused())
+        return;
+    clearBreakDetails();
+    m_pausingOnNativeEvent = false;
+    m_skippedStepInCount = 0;
+    scriptDebugServer().setPauseOnNextStatement(true);
+}
+
 void InspectorDebuggerAgent::cancelPauseOnNextStatement()
 {
     if (m_javaScriptPauseScheduled || isPaused())
         return;
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     scriptDebugServer().setPauseOnNextStatement(false);
 }
 
 void InspectorDebuggerAgent::didInstallTimer(ExecutionContext* context, int timerId, int timeout, bool singleShot)
@@ skipping 212 matching lines @@
         return;
     clearBreakDetails();
     m_javaScriptPauseScheduled = true;
     scriptDebugServer().setPauseOnNextStatement(true);
 }
 
 void InspectorDebuggerAgent::resume(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
-    m_debuggerStepScheduled = false;
+    m_scheduledDebuggerStep = NoStep;
     m_steppingFromFramework = false;
     m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
     scriptDebugServer().continueProgram();
 }
 
 void InspectorDebuggerAgent::stepOver(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
-    m_debuggerStepScheduled = true;
+    m_scheduledDebuggerStep = StepOver;
     m_steppingFromFramework = isTopCallFrameInFramework();
     m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
     scriptDebugServer().stepOverStatement();
 }
 
 void InspectorDebuggerAgent::stepInto(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
-    m_debuggerStepScheduled = true;
+    m_scheduledDebuggerStep = StepInto;
     m_steppingFromFramework = isTopCallFrameInFramework();
     m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
     scriptDebugServer().stepIntoStatement();
-    if (m_listener)
-        m_listener->stepInto();
 }
 
 void InspectorDebuggerAgent::stepOut(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
-    m_debuggerStepScheduled = true;
+    m_scheduledDebuggerStep = StepOut;
     m_steppingFromFramework = isTopCallFrameInFramework();
     m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
     scriptDebugServer().stepOutOfFunction();
 }
 
 void InspectorDebuggerAgent::setPauseOnExceptions(ErrorString* errorString, const String& stringPauseState)
 {
     ScriptDebugServer::PauseOnExceptionsState pauseState;
     if (stringPauseState == "none")
         pauseState = ScriptDebugServer::DontPauseOnExceptions;
@@ skipping 222 matching lines @@
 
 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());
     }
 }
 
+void InspectorDebuggerAgent::willCallFunction(ExecutionContext*, int scriptId, const String&, int)
+{
+    // Skip unknown scripts (i.e. InjectedScript).
+    if (!m_scripts.contains(String::number(scriptId)))
+        return;
+    schedulePauseOnNextStatementIfSteppingInto();
+}
+
+void InspectorDebuggerAgent::willEvaluateScript(LocalFrame*, const String&, int)
+{
+    schedulePauseOnNextStatementIfSteppingInto();
+}
+
 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);
@@ skipping 146 matching lines @@
     if (callFrames.isEmpty())
         result = ScriptDebugListener::Continue; // Skip pauses inside V8 internal scripts and on syntax errors.
     else if (m_javaScriptPauseScheduled)
         result = ScriptDebugListener::NoSkip; // Don't skip explicit pause requests from front-end.
     else if (m_skipAllPauses)
         result = ScriptDebugListener::Continue;
     else if (!hitBreakpoints.isEmpty())
         result = ScriptDebugListener::NoSkip; // Don't skip explicit breakpoints even if set in frameworks.
     else if (!exception.isEmpty())
         result = shouldSkipExceptionPause();
-    else if (m_debuggerStepScheduled || m_pausingOnNativeEvent)
+    else if (m_scheduledDebuggerStep != NoStep || m_pausingOnNativeEvent)
         result = shouldSkipStepPause();
     else
         result = ScriptDebugListener::NoSkip;
 
     if (result != ScriptDebugListener::NoSkip)
         return result;
 
     ASSERT(scriptState && !m_pausedScriptState);
     m_pausedScriptState = scriptState;
     m_currentCallStack = callFrames;
@@ skipping 15 matching lines @@
             const String& localId = breakpointIterator->value.first;
             hitBreakpointIds->addItem(localId);
 
             BreakpointSource source = breakpointIterator->value.second;
             if (m_breakReason == InspectorFrontend::Debugger::Reason::Other && source == DebugCommandBreakpointSource)
                 m_breakReason = InspectorFrontend::Debugger::Reason::DebugCommand;
         }
     }
 
     m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData, hitBreakpointIds, currentAsyncStackTrace());
+    m_scheduledDebuggerStep = NoStep;
     m_javaScriptPauseScheduled = false;
-    m_debuggerStepScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     m_skippedStepInCount = 0;
 
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         scriptDebugServer().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
-    if (m_listener)
-        m_listener->didPause();
     return result;
 }
 
 void InspectorDebuggerAgent::didContinue()
 {
     m_pausedScriptState = nullptr;
     m_currentCallStack = ScriptValue();
     clearBreakDetails();
     m_frontend->resumed();
 }
 
 bool InspectorDebuggerAgent::canBreakProgram()
 {
     return scriptDebugServer().canBreakProgram();
 }
 
 void InspectorDebuggerAgent::breakProgram(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
 {
     if (m_skipAllPauses)
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
-    m_debuggerStepScheduled = false;
+    m_scheduledDebuggerStep = NoStep;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     scriptDebugServer().breakProgram();
 }
 
 void InspectorDebuggerAgent::clear()
 {
     m_pausedScriptState = nullptr;
     m_currentCallStack = ScriptValue();
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
     asyncCallStackTracker().clear();
     promiseTracker().clear();
     m_continueToLocationBreakpointId = String();
     clearBreakDetails();
+    m_scheduledDebuggerStep = NoStep;
     m_javaScriptPauseScheduled = false;
-    m_debuggerStepScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     ErrorString error;
     setOverlayMessage(&error, 0);
 }
 
 bool InspectorDebuggerAgent::assertPaused(ErrorString* errorString)
 {
     if (!m_pausedScriptState) {
         *errorString = "Can only perform operation while paused.";
@@ skipping 15 matching lines @@
     resolveBreakpoint(breakpointId, scriptId, breakpoint, source);
 }
 
 void InspectorDebuggerAgent::removeBreakpoint(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source)
 {
     removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
 }
 
 void InspectorDebuggerAgent::reset()
 {
+    m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
     asyncCallStackTracker().clear();
     promiseTracker().clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 void InspectorDebuggerAgent::trace(Visitor* visitor)
 {
     visitor->trace(m_injectedScriptManager);
     visitor->trace(m_listener);
     visitor->trace(m_asyncCallStackTracker);
 #if ENABLE(OILPAN)
     visitor->trace(m_promiseTracker);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink