src/third_party/WebKit/Source/core/inspector/InspectorDOMDebuggerAgent.cpp

   1 /*
   2  * Copyright (C) 2011 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "core/inspector/InspectorDOMDebuggerAgent.h"
  33
  34 #include "core/InspectorFrontend.h"
  35 #include "core/events/Event.h"
  36 #include "core/inspector/InspectorDOMAgent.h"
  37 #include "core/inspector/InspectorState.h"
  38 #include "core/inspector/InstrumentingAgents.h"
  39 #include "platform/JSONValues.h"
  40
  41 namespace {
  42
  43 enum DOMBreakpointType {
  44     SubtreeModified = 0,
  45     AttributeModified,
  46     NodeRemoved,
  47     DOMBreakpointTypesCount
  48 };
  49
  50 static const char listenerEventCategoryType[] = "listener:";
  51 static const char instrumentationEventCategoryType[] = "instrumentation:";
  52
  53 const uint32_t inheritableDOMBreakpointTypesMask = (1 << SubtreeModified);
  54 const int domBreakpointDerivedTypeShift = 16;
  55
  56 }
  57
  58 namespace blink {
  59
  60 static const char requestAnimationFrameEventName[] = "requestAnimationFrame";
  61 static const char cancelAnimationFrameEventName[] = "cancelAnimationFrame";
  62 static const char animationFrameFiredEventName[] = "animationFrameFired";
  63 static const char setTimerEventName[] = "setTimer";
  64 static const char clearTimerEventName[] = "clearTimer";
  65 static const char timerFiredEventName[] = "timerFired";
  66 static const char newPromiseEventName[] = "newPromise";
  67 static const char promiseResolvedEventName[] = "promiseResolved";
  68 static const char promiseRejectedEventName[] = "promiseRejected";
  69 static const char windowCloseEventName[] = "close";
  70 static const char customElementCallbackName[] = "customElementCallback";
  71 static const char webglErrorFiredEventName[] = "webglErrorFired";
  72 static const char webglWarningFiredEventName[] = "webglWarningFired";
  73 static const char webglErrorNameProperty[] = "webglErrorName";
  74
  75 namespace DOMDebuggerAgentState {
  76 static const char eventListenerBreakpoints[] = "eventListenerBreakpoints";
  77 static const char eventTargetAny[] = "*";
  78 static const char pauseOnAllXHRs[] = "pauseOnAllXHRs";
  79 static const char xhrBreakpoints[] = "xhrBreakpoints";
  80 }
  81
  82 PassOwnPtrWillBeRawPtr<InspectorDOMDebuggerAgent> InspectorDOMDebuggerAgent::create(InspectorDOMAgent* domAgent, InspectorDebuggerAgent* debuggerAgent)
  83 {
  84     return adoptPtrWillBeNoop(new InspectorDOMDebuggerAgent(domAgent, debuggerAgent));
  85 }
  86
  87 InspectorDOMDebuggerAgent::InspectorDOMDebuggerAgent(InspectorDOMAgent* domAgent, InspectorDebuggerAgent* debuggerAgent)
  88     : InspectorBaseAgent<InspectorDOMDebuggerAgent>("DOMDebugger")
  89     , m_domAgent(domAgent)
  90     , m_debuggerAgent(debuggerAgent)
  91     , m_pauseInNextEventListener(false)
  92 {
  93     m_debuggerAgent->setListener(this);
  94     m_domAgent->setListener(this);
  95 }
  96
  97 InspectorDOMDebuggerAgent::~InspectorDOMDebuggerAgent()
  98 {
  99 #if !ENABLE(OILPAN)
 100     ASSERT(!m_debuggerAgent);
 101     ASSERT(!m_instrumentingAgents->inspectorDOMDebuggerAgent());
 102 #endif
 103 }
 104
 105 void InspectorDOMDebuggerAgent::trace(Visitor* visitor)
 106 {
 107     visitor->trace(m_domAgent);
 108     visitor->trace(m_debuggerAgent);
 109 #if ENABLE(OILPAN)
 110     visitor->trace(m_domBreakpoints);
 111 #endif
 112     InspectorBaseAgent::trace(visitor);
 113 }
 114
 115 // Browser debugger agent enabled only when JS debugger is enabled.
 116 void InspectorDOMDebuggerAgent::debuggerWasEnabled()
 117 {
 118     if (m_domAgent->enabled() && m_debuggerAgent->enabled())
 119         m_instrumentingAgents->setInspectorDOMDebuggerAgent(this);
 120 }
 121
 122 void InspectorDOMDebuggerAgent::debuggerWasDisabled()
 123 {
 124     disable();
 125 }
 126
 127 void InspectorDOMDebuggerAgent::domAgentWasEnabled()
 128 {
 129     if (m_domAgent->enabled() && m_debuggerAgent->enabled())
 130         m_instrumentingAgents->setInspectorDOMDebuggerAgent(this);
 131 }
 132
 133 void InspectorDOMDebuggerAgent::domAgentWasDisabled()
 134 {
 135     disable();
 136 }
 137
 138 void InspectorDOMDebuggerAgent::stepInto()
 139 {
 140     m_pauseInNextEventListener = true;
 141 }
 142
 143 void InspectorDOMDebuggerAgent::didPause()
 144 {
 145     m_pauseInNextEventListener = false;
 146 }
 147
 148 void InspectorDOMDebuggerAgent::didProcessTask()
 149 {
 150     if (!m_pauseInNextEventListener)
 151         return;
 152     if (m_debuggerAgent && m_debuggerAgent->runningNestedMessageLoop())
 153         return;
 154     m_pauseInNextEventListener = false;
 155 }
 156
 157 void InspectorDOMDebuggerAgent::disable()
 158 {
 159     m_instrumentingAgents->setInspectorDOMDebuggerAgent(0);
 160     clear();
 161 }
 162
 163 void InspectorDOMDebuggerAgent::clearFrontend()
 164 {
 165     disable();
 166 }
 167
 168 void InspectorDOMDebuggerAgent::discardAgent()
 169 {
 170     m_debuggerAgent->setListener(0);
 171     m_debuggerAgent = nullptr;
 172 }
 173
 174 void InspectorDOMDebuggerAgent::setEventListenerBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 175 {
 176     setBreakpoint(error, String(listenerEventCategoryType) + eventName, targetName);
 177 }
 178
 179 void InspectorDOMDebuggerAgent::setInstrumentationBreakpoint(ErrorString* error, const String& eventName)
 180 {
 181     setBreakpoint(error, String(instrumentationEventCategoryType) + eventName, 0);
 182 }
 183
 184 static PassRefPtr<JSONObject> ensurePropertyObject(JSONObject* object, const String& propertyName)
 185 {
 186     JSONObject::iterator it = object->find(propertyName);
 187     if (it != object->end())
 188         return it->value->asObject();
 189
 190     RefPtr<JSONObject> result = JSONObject::create();
 191     object->setObject(propertyName, result);
 192     return result.release();
 193 }
 194
 195 void InspectorDOMDebuggerAgent::setBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 196 {
 197     if (eventName.isEmpty()) {
 198         *error = "Event name is empty";
 199         return;
 200     }
 201
 202     // Backward compatibility. Some extensions expect that DOMDebuggerAgent is always enabled.
 203     // See https://stackoverflow.com/questions/25764336/chrome-extension-domdebugger-api-does-not-work-anymore
 204     if (!m_domAgent->enabled())
 205         m_domAgent->enable(error);
 206
 207     if (error->length())
 208         return;
 209
 210     RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
 211     RefPtr<JSONObject> breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints.get(), eventName);
 212     if (!targetName || targetName->isEmpty())
 213         breakpointsByTarget->setBoolean(DOMDebuggerAgentState::eventTargetAny, true);
 214     else
 215         breakpointsByTarget->setBoolean(targetName->lower(), true);
 216     m_state->setObject(DOMDebuggerAgentState::eventListenerBreakpoints, eventListenerBreakpoints.release());
 217 }
 218
 219 void InspectorDOMDebuggerAgent::removeEventListenerBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 220 {
 221     removeBreakpoint(error, String(listenerEventCategoryType) + eventName, targetName);
 222 }
 223
 224 void InspectorDOMDebuggerAgent::removeInstrumentationBreakpoint(ErrorString* error, const String& eventName)
 225 {
 226     removeBreakpoint(error, String(instrumentationEventCategoryType) + eventName, 0);
 227 }
 228
 229 void InspectorDOMDebuggerAgent::removeBreakpoint(ErrorString* error, const String& eventName, const String* targetName)
 230 {
 231     if (eventName.isEmpty()) {
 232         *error = "Event name is empty";
 233         return;
 234     }
 235
 236     RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
 237     RefPtr<JSONObject> breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints.get(), eventName);
 238     if (!targetName || targetName->isEmpty())
 239         breakpointsByTarget->remove(DOMDebuggerAgentState::eventTargetAny);
 240     else
 241         breakpointsByTarget->remove(targetName->lower());
 242     m_state->setObject(DOMDebuggerAgentState::eventListenerBreakpoints, eventListenerBreakpoints.release());
 243 }
 244
 245 void InspectorDOMDebuggerAgent::didInvalidateStyleAttr(Node* node)
 246 {
 247     if (hasBreakpoint(node, AttributeModified)) {
 248         RefPtr<JSONObject> eventData = JSONObject::create();
 249         descriptionForDOMEvent(node, AttributeModified, false, eventData.get());
 250         m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::DOM, eventData.release());
 251     }
 252 }
 253
 254 void InspectorDOMDebuggerAgent::didInsertDOMNode(Node* node)
 255 {
 256     if (m_domBreakpoints.size()) {
 257         uint32_t mask = m_domBreakpoints.get(InspectorDOMAgent::innerParentNode(node));
 258         uint32_t inheritableTypesMask = (mask | (mask >> domBreakpointDerivedTypeShift)) & inheritableDOMBreakpointTypesMask;
 259         if (inheritableTypesMask)
 260             updateSubtreeBreakpoints(node, inheritableTypesMask, true);
 261     }
 262 }
 263
 264 void InspectorDOMDebuggerAgent::didRemoveDOMNode(Node* node)
 265 {
 266     if (m_domBreakpoints.size()) {
 267         // Remove subtree breakpoints.
 268         m_domBreakpoints.remove(node);
 269         WillBeHeapVector<RawPtrWillBeMember<Node> > stack(1, InspectorDOMAgent::innerFirstChild(node));
 270         do {
 271             Node* node = stack.last();
 272             stack.removeLast();
 273             if (!node)
 274                 continue;
 275             m_domBreakpoints.remove(node);
 276             stack.append(InspectorDOMAgent::innerFirstChild(node));
 277             stack.append(InspectorDOMAgent::innerNextSibling(node));
 278         } while (!stack.isEmpty());
 279     }
 280 }
 281
 282 static int domTypeForName(ErrorString* errorString, const String& typeString)
 283 {
 284     if (typeString == "subtree-modified")
 285         return SubtreeModified;
 286     if (typeString == "attribute-modified")
 287         return AttributeModified;
 288     if (typeString == "node-removed")
 289         return NodeRemoved;
 290     *errorString = "Unknown DOM breakpoint type: " + typeString;
 291     return -1;
 292 }
 293
 294 static String domTypeName(int type)
 295 {
 296     switch (type) {
 297     case SubtreeModified: return "subtree-modified";
 298     case AttributeModified: return "attribute-modified";
 299     case NodeRemoved: return "node-removed";
 300     default: break;
 301     }
 302     return "";
 303 }
 304
 305 void InspectorDOMDebuggerAgent::setDOMBreakpoint(ErrorString* errorString, int nodeId, const String& typeString)
 306 {
 307     Node* node = m_domAgent->assertNode(errorString, nodeId);
 308     if (!node)
 309         return;
 310
 311     int type = domTypeForName(errorString, typeString);
 312     if (type == -1)
 313         return;
 314
 315     uint32_t rootBit = 1 << type;
 316     m_domBreakpoints.set(node, m_domBreakpoints.get(node) | rootBit);
 317     if (rootBit & inheritableDOMBreakpointTypesMask) {
 318         for (Node* child = InspectorDOMAgent::innerFirstChild(node); child; child = InspectorDOMAgent::innerNextSibling(child))
 319             updateSubtreeBreakpoints(child, rootBit, true);
 320     }
 321 }
 322
 323 void InspectorDOMDebuggerAgent::removeDOMBreakpoint(ErrorString* errorString, int nodeId, const String& typeString)
 324 {
 325     Node* node = m_domAgent->assertNode(errorString, nodeId);
 326     if (!node)
 327         return;
 328     int type = domTypeForName(errorString, typeString);
 329     if (type == -1)
 330         return;
 331
 332     uint32_t rootBit = 1 << type;
 333     uint32_t mask = m_domBreakpoints.get(node) & ~rootBit;
 334     if (mask)
 335         m_domBreakpoints.set(node, mask);
 336     else
 337         m_domBreakpoints.remove(node);
 338
 339     if ((rootBit & inheritableDOMBreakpointTypesMask) && !(mask & (rootBit << domBreakpointDerivedTypeShift))) {
 340         for (Node* child = InspectorDOMAgent::innerFirstChild(node); child; child = InspectorDOMAgent::innerNextSibling(child))
 341             updateSubtreeBreakpoints(child, rootBit, false);
 342     }
 343 }
 344
 345 void InspectorDOMDebuggerAgent::willInsertDOMNode(Node* parent)
 346 {
 347     if (hasBreakpoint(parent, SubtreeModified)) {
 348         RefPtr<JSONObject> eventData = JSONObject::create();
 349         descriptionForDOMEvent(parent, SubtreeModified, true, eventData.get());
 350         m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::DOM, eventData.release());
 351     }
 352 }
 353
 354 void InspectorDOMDebuggerAgent::willRemoveDOMNode(Node* node)
 355 {
 356     Node* parentNode = InspectorDOMAgent::innerParentNode(node);
 357     if (hasBreakpoint(node, NodeRemoved)) {
 358         RefPtr<JSONObject> eventData = JSONObject::create();
 359         descriptionForDOMEvent(node, NodeRemoved, false, eventData.get());
 360         m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::DOM, eventData.release());
 361     } else if (parentNode && hasBreakpoint(parentNode, SubtreeModified)) {
 362         RefPtr<JSONObject> eventData = JSONObject::create();
 363         descriptionForDOMEvent(node, SubtreeModified, false, eventData.get());
 364         m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::DOM, eventData.release());
 365     }
 366     didRemoveDOMNode(node);
 367 }
 368
 369 void InspectorDOMDebuggerAgent::willModifyDOMAttr(Element* element, const AtomicString&, const AtomicString&)
 370 {
 371     if (hasBreakpoint(element, AttributeModified)) {
 372         RefPtr<JSONObject> eventData = JSONObject::create();
 373         descriptionForDOMEvent(element, AttributeModified, false, eventData.get());
 374         m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::DOM, eventData.release());
 375     }
 376 }
 377
 378 void InspectorDOMDebuggerAgent::descriptionForDOMEvent(Node* target, int breakpointType, bool insertion, JSONObject* description)
 379 {
 380     ASSERT(hasBreakpoint(target, breakpointType));
 381
 382     Node* breakpointOwner = target;
 383     if ((1 << breakpointType) & inheritableDOMBreakpointTypesMask) {
 384         // For inheritable breakpoint types, target node isn't always the same as the node that owns a breakpoint.
 385         // Target node may be unknown to frontend, so we need to push it first.
 386         RefPtr<TypeBuilder::Runtime::RemoteObject> targetNodeObject = m_domAgent->resolveNode(target, InspectorDebuggerAgent::backtraceObjectGroup);
 387         description->setValue("targetNode", targetNodeObject);
 388
 389         // Find breakpoint owner node.
 390         if (!insertion)
 391             breakpointOwner = InspectorDOMAgent::innerParentNode(target);
 392         ASSERT(breakpointOwner);
 393         while (!(m_domBreakpoints.get(breakpointOwner) & (1 << breakpointType))) {
 394             Node* parentNode = InspectorDOMAgent::innerParentNode(breakpointOwner);
 395             if (!parentNode)
 396                 break;
 397             breakpointOwner = parentNode;
 398         }
 399
 400         if (breakpointType == SubtreeModified)
 401             description->setBoolean("insertion", insertion);
 402     }
 403
 404     int breakpointOwnerNodeId = m_domAgent->boundNodeId(breakpointOwner);
 405     ASSERT(breakpointOwnerNodeId);
 406     description->setNumber("nodeId", breakpointOwnerNodeId);
 407     description->setString("type", domTypeName(breakpointType));
 408 }
 409
 410 bool InspectorDOMDebuggerAgent::hasBreakpoint(Node* node, int type)
 411 {
 412     uint32_t rootBit = 1 << type;
 413     uint32_t derivedBit = rootBit << domBreakpointDerivedTypeShift;
 414     return m_domBreakpoints.get(node) & (rootBit | derivedBit);
 415 }
 416
 417 void InspectorDOMDebuggerAgent::updateSubtreeBreakpoints(Node* node, uint32_t rootMask, bool set)
 418 {
 419     uint32_t oldMask = m_domBreakpoints.get(node);
 420     uint32_t derivedMask = rootMask << domBreakpointDerivedTypeShift;
 421     uint32_t newMask = set ? oldMask | derivedMask : oldMask & ~derivedMask;
 422     if (newMask)
 423         m_domBreakpoints.set(node, newMask);
 424     else
 425         m_domBreakpoints.remove(node);
 426
 427     uint32_t newRootMask = rootMask & ~newMask;
 428     if (!newRootMask)
 429         return;
 430
 431     for (Node* child = InspectorDOMAgent::innerFirstChild(node); child; child = InspectorDOMAgent::innerNextSibling(child))
 432         updateSubtreeBreakpoints(child, newRootMask, set);
 433 }
 434
 435 void InspectorDOMDebuggerAgent::pauseOnNativeEventIfNeeded(PassRefPtr<JSONObject> eventData, bool synchronous)
 436 {
 437     if (!eventData)
 438         return;
 439     if (synchronous)
 440         m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::EventListener, eventData);
 441     else
 442         m_debuggerAgent->schedulePauseOnNextStatement(InspectorFrontend::Debugger::Reason::EventListener, eventData);
 443 }
 444
 445 PassRefPtr<JSONObject> InspectorDOMDebuggerAgent::preparePauseOnNativeEventData(const String& eventName, const String* targetName)
 446 {
 447     String fullEventName = (targetName ? listenerEventCategoryType : instrumentationEventCategoryType) + eventName;
 448     if (m_pauseInNextEventListener) {
 449         m_pauseInNextEventListener = false;
 450     } else {
 451         RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
 452         JSONObject::iterator it = eventListenerBreakpoints->find(fullEventName);
 453         if (it == eventListenerBreakpoints->end())
 454             return nullptr;
 455         bool match = false;
 456         RefPtr<JSONObject> breakpointsByTarget = it->value->asObject();
 457         breakpointsByTarget->getBoolean(DOMDebuggerAgentState::eventTargetAny, &match);
 458         if (!match && targetName)
 459             breakpointsByTarget->getBoolean(targetName->lower(), &match);
 460         if (!match)
 461             return nullptr;
 462     }
 463
 464     RefPtr<JSONObject> eventData = JSONObject::create();
 465     eventData->setString("eventName", fullEventName);
 466     if (targetName)
 467         eventData->setString("targetName", *targetName);
 468     return eventData.release();
 469 }
 470
 471 void InspectorDOMDebuggerAgent::didInstallTimer(ExecutionContext*, int, int, bool)
 472 {
 473     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(setTimerEventName, 0), true);
 474 }
 475
 476 void InspectorDOMDebuggerAgent::didRemoveTimer(ExecutionContext*, int)
 477 {
 478     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(clearTimerEventName, 0), true);
 479 }
 480
 481 void InspectorDOMDebuggerAgent::willFireTimer(ExecutionContext*, int)
 482 {
 483     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(timerFiredEventName, 0), false);
 484 }
 485
 486 bool InspectorDOMDebuggerAgent::canPauseOnPromiseEvent()
 487 {
 488     if (m_pauseInNextEventListener)
 489         return true;
 490     RefPtr<JSONObject> eventListenerBreakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
 491     JSONObject::iterator end = eventListenerBreakpoints->end();
 492     return eventListenerBreakpoints->find(String(instrumentationEventCategoryType) + newPromiseEventName) != end
 493         || eventListenerBreakpoints->find(String(instrumentationEventCategoryType) + promiseResolvedEventName) != end
 494         || eventListenerBreakpoints->find(String(instrumentationEventCategoryType) + promiseRejectedEventName) != end;
 495 }
 496
 497 void InspectorDOMDebuggerAgent::didCreatePromise()
 498 {
 499     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(newPromiseEventName, 0), true);
 500 }
 501
 502 void InspectorDOMDebuggerAgent::didResolvePromise()
 503 {
 504     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(promiseResolvedEventName, 0), true);
 505 }
 506
 507 void InspectorDOMDebuggerAgent::didRejectPromise()
 508 {
 509     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(promiseRejectedEventName, 0), true);
 510 }
 511
 512 void InspectorDOMDebuggerAgent::didRequestAnimationFrame(Document*, int)
 513 {
 514     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(requestAnimationFrameEventName, 0), true);
 515 }
 516
 517 void InspectorDOMDebuggerAgent::didCancelAnimationFrame(Document*, int)
 518 {
 519     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(cancelAnimationFrameEventName, 0), true);
 520 }
 521
 522 void InspectorDOMDebuggerAgent::willFireAnimationFrame(Document*, int)
 523 {
 524     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(animationFrameFiredEventName, 0), false);
 525 }
 526
 527 void InspectorDOMDebuggerAgent::willHandleEvent(EventTarget* target, Event* event, EventListener*, bool)
 528 {
 529     Node* node = target->toNode();
 530     String targetName = node ? node->nodeName() : target->interfaceName();
 531     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(event->type(), &targetName), false);
 532 }
 533
 534 void InspectorDOMDebuggerAgent::willCloseWindow()
 535 {
 536     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(windowCloseEventName, 0), true);
 537 }
 538
 539 void InspectorDOMDebuggerAgent::willExecuteCustomElementCallback(Element*)
 540 {
 541     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(customElementCallbackName, 0), false);
 542 }
 543
 544 void InspectorDOMDebuggerAgent::didFireWebGLError(const String& errorName)
 545 {
 546     RefPtr<JSONObject> eventData = preparePauseOnNativeEventData(webglErrorFiredEventName, 0);
 547     if (!eventData)
 548         return;
 549     if (!errorName.isEmpty())
 550         eventData->setString(webglErrorNameProperty, errorName);
 551     pauseOnNativeEventIfNeeded(eventData.release(), m_debuggerAgent->canBreakProgram());
 552 }
 553
 554 void InspectorDOMDebuggerAgent::didFireWebGLWarning()
 555 {
 556     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(webglWarningFiredEventName, 0), m_debuggerAgent->canBreakProgram());
 557 }
 558
 559 void InspectorDOMDebuggerAgent::didFireWebGLErrorOrWarning(const String& message)
 560 {
 561     if (message.findIgnoringCase("error") != WTF::kNotFound)
 562         didFireWebGLError(String());
 563     else
 564         didFireWebGLWarning();
 565 }
 566
 567 void InspectorDOMDebuggerAgent::setXHRBreakpoint(ErrorString*, const String& url)
 568 {
 569     if (url.isEmpty()) {
 570         m_state->setBoolean(DOMDebuggerAgentState::pauseOnAllXHRs, true);
 571         return;
 572     }
 573
 574     RefPtr<JSONObject> xhrBreakpoints = m_state->getObject(DOMDebuggerAgentState::xhrBreakpoints);
 575     xhrBreakpoints->setBoolean(url, true);
 576     m_state->setObject(DOMDebuggerAgentState::xhrBreakpoints, xhrBreakpoints.release());
 577 }
 578
 579 void InspectorDOMDebuggerAgent::removeXHRBreakpoint(ErrorString*, const String& url)
 580 {
 581     if (url.isEmpty()) {
 582         m_state->setBoolean(DOMDebuggerAgentState::pauseOnAllXHRs, false);
 583         return;
 584     }
 585
 586     RefPtr<JSONObject> xhrBreakpoints = m_state->getObject(DOMDebuggerAgentState::xhrBreakpoints);
 587     xhrBreakpoints->remove(url);
 588     m_state->setObject(DOMDebuggerAgentState::xhrBreakpoints, xhrBreakpoints.release());
 589 }
 590
 591 void InspectorDOMDebuggerAgent::willSendXMLHttpRequest(const String& url)
 592 {
 593     String breakpointURL;
 594     if (m_state->getBoolean(DOMDebuggerAgentState::pauseOnAllXHRs))
 595         breakpointURL = "";
 596     else {
 597         RefPtr<JSONObject> xhrBreakpoints = m_state->getObject(DOMDebuggerAgentState::xhrBreakpoints);
 598         for (JSONObject::iterator it = xhrBreakpoints->begin(); it != xhrBreakpoints->end(); ++it) {
 599             if (url.contains(it->key)) {
 600                 breakpointURL = it->key;
 601                 break;
 602             }
 603         }
 604     }
 605
 606     if (breakpointURL.isNull())
 607         return;
 608
 609     RefPtr<JSONObject> eventData = JSONObject::create();
 610     eventData->setString("breakpointURL", breakpointURL);
 611     eventData->setString("url", url);
 612     m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::XHR, eventData.release());
 613 }
 614
 615 void InspectorDOMDebuggerAgent::clear()
 616 {
 617     m_domBreakpoints.clear();
 618     m_pauseInNextEventListener = false;
 619 }
 620
 621 } // namespace blink
 622