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

Source/core/inspector/InspectorDOMDebuggerAgent.cpp

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 49 matching lines @@
 static const char requestAnimationFrameEventName[] = "requestAnimationFrame";
 static const char cancelAnimationFrameEventName[] = "cancelAnimationFrame";
 static const char animationFrameFiredEventName[] = "animationFrameFired";
 static const char setTimerEventName[] = "setTimer";
 static const char clearTimerEventName[] = "clearTimer";
 static const char timerFiredEventName[] = "timerFired";
 static const char newPromiseEventName[] = "newPromise";
 static const char promiseResolvedEventName[] = "promiseResolved";
 static const char promiseRejectedEventName[] = "promiseRejected";
 static const char windowCloseEventName[] = "close";
-static const char customElementCallbackName[] = "customElementCallback";
 static const char webglErrorFiredEventName[] = "webglErrorFired";
 static const char webglWarningFiredEventName[] = "webglWarningFired";
 static const char webglErrorNameProperty[] = "webglErrorName";
 
 namespace DOMDebuggerAgentState {
 static const char eventListenerBreakpoints[] = "eventListenerBreakpoints";
 static const char eventTargetAny[] = "*";
 static const char pauseOnAllXHRs[] = "pauseOnAllXHRs";
 static const char xhrBreakpoints[] = "xhrBreakpoints";
 }
 
 PassOwnPtrWillBeRawPtr<InspectorDOMDebuggerAgent> InspectorDOMDebuggerAgent::create(InspectorDOMAgent* domAgent, InspectorDebuggerAgent* debuggerAgent)
 {
     return adoptPtrWillBeNoop(new InspectorDOMDebuggerAgent(domAgent, debuggerAgent));
 }
 
 InspectorDOMDebuggerAgent::InspectorDOMDebuggerAgent(InspectorDOMAgent* domAgent, InspectorDebuggerAgent* debuggerAgent)
     : InspectorBaseAgent<InspectorDOMDebuggerAgent>("DOMDebugger")
     , m_domAgent(domAgent)
     , m_debuggerAgent(debuggerAgent)
-    , m_pauseInNextEventListener(false)
 {
     m_debuggerAgent->setListener(this);
     m_domAgent->setListener(this);
 }
 
 InspectorDOMDebuggerAgent::~InspectorDOMDebuggerAgent()
 {
 #if !ENABLE(OILPAN)
     ASSERT(!m_debuggerAgent);
     ASSERT(!m_instrumentingAgents->inspectorDOMDebuggerAgent());
@@ skipping 26 matching lines @@
 {
     if (m_domAgent->enabled() && m_debuggerAgent->enabled())
         m_instrumentingAgents->setInspectorDOMDebuggerAgent(this);
 }
 
 void InspectorDOMDebuggerAgent::domAgentWasDisabled()
 {
     disable();
 }
 
-void InspectorDOMDebuggerAgent::stepInto()
-{
-    m_pauseInNextEventListener = true;
-}
-
-void InspectorDOMDebuggerAgent::didPause()
-{
-    m_pauseInNextEventListener = false;
-}
-
-void InspectorDOMDebuggerAgent::didProcessTask()
-{
-    if (!m_pauseInNextEventListener)
-        return;
-    if (m_debuggerAgent && m_debuggerAgent->runningNestedMessageLoop())
-        return;
-    m_pauseInNextEventListener = false;
-}
-
 void InspectorDOMDebuggerAgent::disable()
 {
     m_instrumentingAgents->setInspectorDOMDebuggerAgent(0);
     clear();
 }
 
 void InspectorDOMDebuggerAgent::clearFrontend()
 {
     disable();
 }
@@ skipping 258 matching lines @@
         m_domBreakpoints.remove(node);
 
     uint32_t newRootMask = rootMask & ~newMask;
     if (!newRootMask)
         return;
 
     for (Node* child = InspectorDOMAgent::innerFirstChild(node); child; child = InspectorDOMAgent::innerNextSibling(child))
         updateSubtreeBreakpoints(child, newRootMask, set);
 }
 
-void InspectorDOMDebuggerAgent::pauseOnNativeEventIfNeeded(PassRefPtr<JSONObject> prpEventData, bool synchronous)
+void InspectorDOMDebuggerAgent::pauseOnNativeEventIfNeeded(PassRefPtr<JSONObject> eventData, bool synchronous)
 {
-    if (!prpEventData)
+    if (!eventData)
         return;
-    RefPtr<JSONObject> eventData = prpEventData;
-    InspectorFrontend::Debugger::Reason::Enum breakReason = InspectorFrontend::Debugger::Reason::EventListener;
-    if (m_pauseInNextEventListener) {
-        m_pauseInNextEventListener = false;
-        breakReason = InspectorFrontend::Debugger::Reason::Other;
-        eventData = nullptr;
-    }
     if (synchronous)
-        m_debuggerAgent->breakProgram(breakReason, eventData.release());
+        m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::EventListener, eventData);
     else
-        m_debuggerAgent->schedulePauseOnNextStatement(breakReason, eventData.release());
+        m_debuggerAgent->schedulePauseOnNextStatement(InspectorFrontend::Debugger::Reason::EventListener, eventData);
 }
 
 PassRefPtr<JSONObject> InspectorDOMDebuggerAgent::preparePauseOnNativeEventData(const String& eventName, const String* targetName)
 {
     String fullEventName = (targetName ? listenerEventCategoryType : instrumentationEventCategoryType) + eventName;
-    if (!m_pauseInNextEventListener) {
-        RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
-        JSONObject::iterator it = eventListenerBreakpoints->find(fullEventName);
-        if (it == eventListenerBreakpoints->end())
-            return nullptr;
-        bool match = false;
-        RefPtr<JSONObject> breakpointsByTarget = it->value->asObject();
-        breakpointsByTarget->getBoolean(DOMDebuggerAgentState::eventTargetAny, &match);
-        if (!match && targetName)
-            breakpointsByTarget->getBoolean(targetName->lower(), &match);
-        if (!match)
-            return nullptr;
-    }
+    RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
+    JSONObject::iterator it = eventListenerBreakpoints->find(fullEventName);
+    if (it == eventListenerBreakpoints->end())
+        return nullptr;
+    bool match = false;
+    RefPtr<JSONObject> breakpointsByTarget = it->value->asObject();
+    breakpointsByTarget->getBoolean(DOMDebuggerAgentState::eventTargetAny, &match);
+    if (!match && targetName)
+        breakpointsByTarget->getBoolean(targetName->lower(), &match);
+    if (!match)
+        return nullptr;
 
     RefPtr<JSONObject> eventData = JSONObject::create();
     eventData->setString("eventName", fullEventName);
     if (targetName)
         eventData->setString("targetName", *targetName);
     return eventData.release();
 }
 
 void InspectorDOMDebuggerAgent::didInstallTimer(ExecutionContext*, int, int, bool)
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(setTimerEventName, 0), true);
 }
 
 void InspectorDOMDebuggerAgent::didRemoveTimer(ExecutionContext*, int)
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(clearTimerEventName, 0), true);
 }
 
 void InspectorDOMDebuggerAgent::willFireTimer(ExecutionContext*, int)
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(timerFiredEventName, 0), false);
 }
 
 bool InspectorDOMDebuggerAgent::canPauseOnPromiseEvent()
 {
-    if (m_pauseInNextEventListener)
-        return true;
     RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
     JSONObject::iterator end = eventListenerBreakpoints->end();
     return eventListenerBreakpoints->find(String(instrumentationEventCategoryType) + newPromiseEventName) != end
         || eventListenerBreakpoints->find(String(instrumentationEventCategoryType) + promiseResolvedEventName) != end
         || eventListenerBreakpoints->find(String(instrumentationEventCategoryType) + promiseRejectedEventName) != end;
 }
 
 void InspectorDOMDebuggerAgent::didCreatePromise()
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(newPromiseEventName, 0), true);
@@ skipping 29 matching lines @@
     Node* node = target->toNode();
     String targetName = node ? node->nodeName() : target->interfaceName();
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(event->type(), &targetName), false);
 }
 
 void InspectorDOMDebuggerAgent::willCloseWindow()
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(windowCloseEventName, 0), true);
 }
 
-void InspectorDOMDebuggerAgent::willExecuteCustomElementCallback(Element*)
-{
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(customElementCallbackName, 0), false);
-}
-
 void InspectorDOMDebuggerAgent::didFireWebGLError(const String& errorName)
 {
     RefPtr<JSONObject> eventData = preparePauseOnNativeEventData(webglErrorFiredEventName, 0);
     if (!eventData)
         return;
     if (!errorName.isEmpty())
         eventData->setString(webglErrorNameProperty, errorName);
     pauseOnNativeEventIfNeeded(eventData.release(), m_debuggerAgent->canBreakProgram());
 }
 
@@ skipping 54 matching lines @@
 
     RefPtr<JSONObject> eventData = JSONObject::create();
     eventData->setString("breakpointURL", breakpointURL);
     eventData->setString("url", url);
     m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::XHR, eventData.release());
 }
 
 void InspectorDOMDebuggerAgent::clear()
 {
     m_domBreakpoints.clear();
-    m_pauseInNextEventListener = false;
 }
 
 } // namespace blink
-