DevTools: Expand protocol to allow setting DOM event breakpoints on a given event target.

Source/core/inspector/InspectorDOMDebuggerAgent.cpp

Index: Source/core/inspector/InspectorDOMDebuggerAgent.cpp
diff --git a/Source/core/inspector/InspectorDOMDebuggerAgent.cpp b/Source/core/inspector/InspectorDOMDebuggerAgent.cpp
index bedc03bd1118731b97098b3c9adefeb3f952cb9a..631671f39b5ecc24b18db83ae074e48aede263f8 100644
--- a/Source/core/inspector/InspectorDOMDebuggerAgent.cpp
+++ b/Source/core/inspector/InspectorDOMDebuggerAgent.cpp
@@ -69,6 +69,7 @@ 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";
 }
@@ -153,17 +154,28 @@ void InspectorDOMDebuggerAgent::discardAgent()
     m_debuggerAgent = 0;
 }
 
-void InspectorDOMDebuggerAgent::setEventListenerBreakpoint(ErrorString* error, const String& eventName)
+void InspectorDOMDebuggerAgent::setEventListenerBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 {
-    setBreakpoint(error, String(listenerEventCategoryType) + eventName);
+    setBreakpoint(error, String(listenerEventCategoryType) + eventName, targetName);
 }
 
 void InspectorDOMDebuggerAgent::setInstrumentationBreakpoint(ErrorString* error, const String& eventName)
 {
-    setBreakpoint(error, String(instrumentationEventCategoryType) + eventName);
+    setBreakpoint(error, String(instrumentationEventCategoryType) + eventName, 0);
 }
 
-void InspectorDOMDebuggerAgent::setBreakpoint(ErrorString* error, const String& eventName)
+static PassRefPtr<JSONObject> ensurePropertyObject(JSONObject* object, const String& propertyName)
+{
+    JSONObject::iterator it = object->find(propertyName);
+    if (it != object->end())
+        return it->value->asObject();
+
+    RefPtr<JSONObject> result = JSONObject::create();
+    object->setObject(propertyName, result);
+    return result.release();
+}
+
+void InspectorDOMDebuggerAgent::setBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 {
     if (eventName.isEmpty()) {
         *error = "Event name is empty";
@@ -171,21 +183,25 @@ void InspectorDOMDebuggerAgent::setBreakpoint(ErrorString* error, const String&
     }
 
     RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
-    eventListenerBreakpoints->setBoolean(eventName, true);
-    m_state->setObject(DOMDebuggerAgentState::eventListenerBreakpoints, eventListenerBreakpoints);
+    RefPtr<JSONObject> breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints.get(), eventName);
+    if (!targetName || targetName->isEmpty())
+        breakpointsByTarget->setBoolean(DOMDebuggerAgentState::eventTargetAny, true);
+    else
+        breakpointsByTarget->setBoolean(targetName->lower(), true);
+    m_state->setObject(DOMDebuggerAgentState::eventListenerBreakpoints, eventListenerBreakpoints.release());
 }
 
-void InspectorDOMDebuggerAgent::removeEventListenerBreakpoint(ErrorString* error, const String& eventName)
+void InspectorDOMDebuggerAgent::removeEventListenerBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 {
-    removeBreakpoint(error, String(listenerEventCategoryType) + eventName);
+    removeBreakpoint(error, String(listenerEventCategoryType) + eventName, targetName);
 }
 
 void InspectorDOMDebuggerAgent::removeInstrumentationBreakpoint(ErrorString* error, const String& eventName)
 {
-    removeBreakpoint(error, String(instrumentationEventCategoryType) + eventName);
+    removeBreakpoint(error, String(instrumentationEventCategoryType) + eventName, 0);
 }
 
-void InspectorDOMDebuggerAgent::removeBreakpoint(ErrorString* error, const String& eventName)
+void InspectorDOMDebuggerAgent::removeBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 {
     if (eventName.isEmpty()) {
         *error = "Event name is empty";
@@ -193,8 +209,12 @@ void InspectorDOMDebuggerAgent::removeBreakpoint(ErrorString* error, const Strin
     }
 
     RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
-    eventListenerBreakpoints->remove(eventName);
-    m_state->setObject(DOMDebuggerAgentState::eventListenerBreakpoints, eventListenerBreakpoints);
+    RefPtr<JSONObject> breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints.get(), eventName);
+    if (!targetName || targetName->isEmpty())
+        breakpointsByTarget->remove(DOMDebuggerAgentState::eventTargetAny);

[yurys, 2014/06/10 08:49:53]

It might make sense to remove all targets if targetName is not specified. 

[aandrey, 2014/06/10 09:14:38]

I dont think so.
e.g. if we have an option to break on "load" event on all targets, and on "load"
only for XHRs.
Removing the former option (a checkbox in the UI) should not affect the latter.

+    else
+        breakpointsByTarget->remove(targetName->lower());
+    m_state->setObject(DOMDebuggerAgentState::eventListenerBreakpoints, eventListenerBreakpoints.release());
 }
 
 void InspectorDOMDebuggerAgent::didInvalidateStyleAttr(Node* node)
@@ -397,65 +417,75 @@ void InspectorDOMDebuggerAgent::pauseOnNativeEventIfNeeded(PassRefPtr<JSONObject
         m_debuggerAgent->schedulePauseOnNextStatement(InspectorFrontend::Debugger::Reason::EventListener, eventData);
 }
 
-PassRefPtr<JSONObject> InspectorDOMDebuggerAgent::preparePauseOnNativeEventData(bool isDOMEvent, const String& eventName)
+PassRefPtr<JSONObject> InspectorDOMDebuggerAgent::preparePauseOnNativeEventData(const String& eventName, const AtomicString* targetName)
 {
-    String fullEventName = (isDOMEvent ? listenerEventCategoryType : instrumentationEventCategoryType) + eventName;
-    if (m_pauseInNextEventListener)
+    String fullEventName = (targetName ? listenerEventCategoryType : instrumentationEventCategoryType) + eventName;
+    if (m_pauseInNextEventListener) {
         m_pauseInNextEventListener = false;
-    else {
+    } else {
         RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
-        if (eventListenerBreakpoints->find(fullEventName) == eventListenerBreakpoints->end())
+        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(false, setTimerEventName), true);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(setTimerEventName, 0), true);
 }
 
 void InspectorDOMDebuggerAgent::didRemoveTimer(ExecutionContext*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, clearTimerEventName), true);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(clearTimerEventName, 0), true);
 }
 
 void InspectorDOMDebuggerAgent::willFireTimer(ExecutionContext*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, timerFiredEventName), false);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(timerFiredEventName, 0), false);
 }
 
 void InspectorDOMDebuggerAgent::didRequestAnimationFrame(Document*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, requestAnimationFrameEventName), true);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(requestAnimationFrameEventName, 0), true);
 }
 
 void InspectorDOMDebuggerAgent::didCancelAnimationFrame(Document*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, cancelAnimationFrameEventName), true);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(cancelAnimationFrameEventName, 0), true);
 }
 
 void InspectorDOMDebuggerAgent::willFireAnimationFrame(Document*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, animationFrameFiredEventName), false);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(animationFrameFiredEventName, 0), false);
 }
 
-void InspectorDOMDebuggerAgent::willHandleEvent(EventTarget*, const AtomicString& eventType, EventListener*, bool)
+void InspectorDOMDebuggerAgent::willHandleEvent(EventTarget* target, const AtomicString& eventType, EventListener*, bool)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(true, eventType), false);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(eventType, &target->interfaceName()), false);
 }
 
 void InspectorDOMDebuggerAgent::willExecuteCustomElementCallback(Element*)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, customElementCallbackName), false);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(customElementCallbackName, 0), false);
 }
 
 void InspectorDOMDebuggerAgent::didFireWebGLError(const String& errorName)
 {
-    RefPtr<JSONObject> eventData = preparePauseOnNativeEventData(false, webglErrorFiredEventName);
+    RefPtr<JSONObject> eventData = preparePauseOnNativeEventData(webglErrorFiredEventName, 0);
     if (!eventData)
         return;
     if (!errorName.isEmpty())
@@ -465,7 +495,7 @@ void InspectorDOMDebuggerAgent::didFireWebGLError(const String& errorName)
 
 void InspectorDOMDebuggerAgent::didFireWebGLWarning()
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, webglWarningFiredEventName), m_debuggerAgent->canBreakProgram());
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(webglWarningFiredEventName, 0), m_debuggerAgent->canBreakProgram());
 }
 
 void InspectorDOMDebuggerAgent::didFireWebGLErrorOrWarning(const String& message)
@@ -485,7 +515,7 @@ void InspectorDOMDebuggerAgent::setXHRBreakpoint(ErrorString*, const String& url
 
     RefPtr<JSONObject> xhrBreakpoints = m_state->getObject(DOMDebuggerAgentState::xhrBreakpoints);
     xhrBreakpoints->setBoolean(url, true);
-    m_state->setObject(DOMDebuggerAgentState::xhrBreakpoints, xhrBreakpoints);
+    m_state->setObject(DOMDebuggerAgentState::xhrBreakpoints, xhrBreakpoints.release());
 }
 
 void InspectorDOMDebuggerAgent::removeXHRBreakpoint(ErrorString*, const String& url)
@@ -497,7 +527,7 @@ void InspectorDOMDebuggerAgent::removeXHRBreakpoint(ErrorString*, const String&
 
     RefPtr<JSONObject> xhrBreakpoints = m_state->getObject(DOMDebuggerAgentState::xhrBreakpoints);
     xhrBreakpoints->remove(url);
-    m_state->setObject(DOMDebuggerAgentState::xhrBreakpoints, xhrBreakpoints);
+    m_state->setObject(DOMDebuggerAgentState::xhrBreakpoints, xhrBreakpoints.release());
 }
 
 void InspectorDOMDebuggerAgent::willSendXMLHttpRequest(const String& url)