1 files changed, 89 insertions, 46 deletions

diff --git a/chromium/third_party/WebKit/Source/core/inspector/InspectorDOMDebuggerAgent.cpp b/chromium/third_party/WebKit/Source/core/inspector/InspectorDOMDebuggerAgent.cpp
index 1fe691875ab..00289f5381d 100644
--- a/chromium/third_party/WebKit/Source/core/inspector/InspectorDOMDebuggerAgent.cpp
+++ b/chromium/third_party/WebKit/Source/core/inspector/InspectorDOMDebuggerAgent.cpp
@@ -31,8 +31,7 @@
 #include "config.h"
 #include "core/inspector/InspectorDOMDebuggerAgent.h"
 
-#include "InspectorFrontend.h"
-#include "core/events/Event.h"
+#include "core/InspectorFrontend.h"
 #include "core/inspector/InspectorDOMAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
@@ -63,28 +62,31 @@ static const char animationFrameFiredEventName[] = "animationFrameFired";
 static const char setTimerEventName[] = "setTimer";
 static const char clearTimerEventName[] = "clearTimer";
 static const char timerFiredEventName[] = "timerFired";
+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";
 }
 
-PassOwnPtr<InspectorDOMDebuggerAgent> InspectorDOMDebuggerAgent::create(InstrumentingAgents* instrumentingAgents, InspectorCompositeState* inspectorState, InspectorDOMAgent* domAgent, InspectorDebuggerAgent* debuggerAgent)
+PassOwnPtr<InspectorDOMDebuggerAgent> InspectorDOMDebuggerAgent::create(InspectorDOMAgent* domAgent, InspectorDebuggerAgent* debuggerAgent)
 {
-    return adoptPtr(new InspectorDOMDebuggerAgent(instrumentingAgents, inspectorState, domAgent, debuggerAgent));
+    return adoptPtr(new InspectorDOMDebuggerAgent(domAgent, debuggerAgent));
 }
 
-InspectorDOMDebuggerAgent::InspectorDOMDebuggerAgent(InstrumentingAgents* instrumentingAgents, InspectorCompositeState* inspectorState, InspectorDOMAgent* domAgent, InspectorDebuggerAgent* debuggerAgent)
-    : InspectorBaseAgent<InspectorDOMDebuggerAgent>("DOMDebugger", instrumentingAgents, inspectorState)
+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()
@@ -96,7 +98,8 @@ InspectorDOMDebuggerAgent::~InspectorDOMDebuggerAgent()
 // Browser debugger agent enabled only when JS debugger is enabled.
 void InspectorDOMDebuggerAgent::debuggerWasEnabled()
 {
-    m_instrumentingAgents->setInspectorDOMDebuggerAgent(this);
+    if (m_domAgent->enabled() && m_debuggerAgent->enabled())
+        m_instrumentingAgents->setInspectorDOMDebuggerAgent(this);
 }
 
 void InspectorDOMDebuggerAgent::debuggerWasDisabled()
@@ -104,6 +107,17 @@ void InspectorDOMDebuggerAgent::debuggerWasDisabled()
     disable();
 }
 
+void InspectorDOMDebuggerAgent::domAgentWasEnabled()
+{
+    if (m_domAgent->enabled() && m_debuggerAgent->enabled())
+        m_instrumentingAgents->setInspectorDOMDebuggerAgent(this);
+}
+
+void InspectorDOMDebuggerAgent::domAgentWasDisabled()
+{
+    disable();
+}
+
 void InspectorDOMDebuggerAgent::stepInto()
 {
     m_pauseInNextEventListener = true;
@@ -140,22 +154,28 @@ void InspectorDOMDebuggerAgent::discardAgent()
     m_debuggerAgent = 0;
 }
 
-void InspectorDOMDebuggerAgent::discardBindings()
+void InspectorDOMDebuggerAgent::setEventListenerBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 {
-    m_domBreakpoints.clear();
+    setBreakpoint(error, String(listenerEventCategoryType) + eventName, targetName);
 }
 
-void InspectorDOMDebuggerAgent::setEventListenerBreakpoint(ErrorString* error, const String& eventName)
+void InspectorDOMDebuggerAgent::setInstrumentationBreakpoint(ErrorString* error, const String& eventName)
 {
-    setBreakpoint(error, String(listenerEventCategoryType) + eventName);
+    setBreakpoint(error, String(instrumentationEventCategoryType) + eventName, 0);
 }
 
-void InspectorDOMDebuggerAgent::setInstrumentationBreakpoint(ErrorString* error, const String& eventName)
+static PassRefPtr<JSONObject> ensurePropertyObject(JSONObject* object, const String& propertyName)
 {
-    setBreakpoint(error, String(instrumentationEventCategoryType) + eventName);
+    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)
+void InspectorDOMDebuggerAgent::setBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 {
     if (eventName.isEmpty()) {
         *error = "Event name is empty";
@@ -163,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";
@@ -185,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);
+    else
+        breakpointsByTarget->remove(targetName->lower());
+    m_state->setObject(DOMDebuggerAgentState::eventListenerBreakpoints, eventListenerBreakpoints.release());
 }
 
 void InspectorDOMDebuggerAgent::didInvalidateStyleAttr(Node* node)
@@ -389,60 +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())
-            return 0;
+        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* context, int timerId, int timeout, bool singleShot)
+void InspectorDOMDebuggerAgent::didInstallTimer(ExecutionContext*, int, int, bool)
+{
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(setTimerEventName, 0), true);
+}
+
+void InspectorDOMDebuggerAgent::didRemoveTimer(ExecutionContext*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, setTimerEventName), true);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(clearTimerEventName, 0), true);
 }
 
-void InspectorDOMDebuggerAgent::didRemoveTimer(ExecutionContext* context, int timerId)
+void InspectorDOMDebuggerAgent::willFireTimer(ExecutionContext*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, clearTimerEventName), true);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(timerFiredEventName, 0), false);
 }
 
-void InspectorDOMDebuggerAgent::willFireTimer(ExecutionContext* context, int timerId)
+void InspectorDOMDebuggerAgent::didRequestAnimationFrame(Document*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, timerFiredEventName), false);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(requestAnimationFrameEventName, 0), true);
 }
 
-void InspectorDOMDebuggerAgent::didRequestAnimationFrame(Document* document, int callbackId)
+void InspectorDOMDebuggerAgent::didCancelAnimationFrame(Document*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, requestAnimationFrameEventName), true);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(cancelAnimationFrameEventName, 0), true);
 }
 
-void InspectorDOMDebuggerAgent::didCancelAnimationFrame(Document* document, int callbackId)
+void InspectorDOMDebuggerAgent::willFireAnimationFrame(Document*, int)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, cancelAnimationFrameEventName), true);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(animationFrameFiredEventName, 0), false);
 }
 
-void InspectorDOMDebuggerAgent::willFireAnimationFrame(Document* document, int callbackId)
+void InspectorDOMDebuggerAgent::willHandleEvent(EventTarget* target, Event* event, EventListener*, bool)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(false, animationFrameFiredEventName), false);
+    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(event->type(), &target->interfaceName()), false);
 }
 
-void InspectorDOMDebuggerAgent::willHandleEvent(Event* event)
+void InspectorDOMDebuggerAgent::willExecuteCustomElementCallback(Element*)
 {
-    pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(true, event->type()), 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())
@@ -452,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)
@@ -472,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)
@@ -484,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)