DevTools: introduce protocol::Value, baseline for hierarchical data in remote debugging protocol.

third_party/WebKit/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 21 matching lines @@
 
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "bindings/core/v8/V8EventTarget.h"
 #include "core/dom/Element.h"
 #include "core/dom/Node.h"
 #include "core/events/Event.h"
 #include "core/events/EventTarget.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/inspector/InspectorDOMAgent.h"
 #include "core/inspector/InstrumentingAgents.h"
-#include "platform/JSONValues.h"
+#include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/public/V8DebuggerAgent.h"
 #include "platform/v8_inspector/public/V8EventListenerInfo.h"
 #include "platform/v8_inspector/public/V8RuntimeAgent.h"
 
 namespace {
 
 enum DOMBreakpointType {
     SubtreeModified = 0,
     AttributeModified,
     NodeRemoved,
@@ skipping 119 matching lines @@
 void InspectorDOMDebuggerAgent::setEventListenerBreakpoint(ErrorString* error, const String& eventName, const Maybe<String>& targetName)
 {
     setBreakpoint(error, String(listenerEventCategoryType) + eventName, targetName.fromMaybe(String()));
 }
 
 void InspectorDOMDebuggerAgent::setInstrumentationBreakpoint(ErrorString* error, const String& eventName)
 {
     setBreakpoint(error, String(instrumentationEventCategoryType) + eventName, String());
 }
 
-static PassRefPtr<JSONObject> ensurePropertyObject(PassRefPtr<JSONObject> object, const String& propertyName)
+static PassRefPtr<protocol::DictionaryValue> ensurePropertyObject(PassRefPtr<protocol::DictionaryValue> object, const String& propertyName)
 {
-    JSONObject::iterator it = object->find(propertyName);
+    protocol::DictionaryValue::iterator it = object->find(propertyName);
     if (it != object->end())
-        return JSONObject::cast(it->value);
+        return protocol::DictionaryValue::cast(it->value);
 
-    RefPtr<JSONObject> result = JSONObject::create();
+    RefPtr<protocol::DictionaryValue> result = protocol::DictionaryValue::create();
     object->setObject(propertyName, result);
     return result.release();
 }
 
-PassRefPtr<JSONObject> InspectorDOMDebuggerAgent::eventListenerBreakpoints()
+PassRefPtr<protocol::DictionaryValue> InspectorDOMDebuggerAgent::eventListenerBreakpoints()
 {
-    RefPtr<JSONObject> breakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
+    RefPtr<protocol::DictionaryValue> breakpoints = m_state->getObject(DOMDebuggerAgentState::eventListenerBreakpoints);
     if (!breakpoints) {
-        breakpoints = JSONObject::create();
+        breakpoints = protocol::DictionaryValue::create();
         m_state->setObject(DOMDebuggerAgentState::eventListenerBreakpoints, breakpoints);
     }
     return breakpoints;
 }
 
-PassRefPtr<JSONObject> InspectorDOMDebuggerAgent::xhrBreakpoints()
+PassRefPtr<protocol::DictionaryValue> InspectorDOMDebuggerAgent::xhrBreakpoints()
 {
-    RefPtr<JSONObject> breakpoints = m_state->getObject(DOMDebuggerAgentState::xhrBreakpoints);
+    RefPtr<protocol::DictionaryValue> breakpoints = m_state->getObject(DOMDebuggerAgentState::xhrBreakpoints);
     if (!breakpoints) {
-        breakpoints = JSONObject::create();
+        breakpoints = protocol::DictionaryValue::create();
         m_state->setObject(DOMDebuggerAgentState::xhrBreakpoints, breakpoints);
     }
     return breakpoints;
 }
 
 void InspectorDOMDebuggerAgent::setBreakpoint(ErrorString* error, const String& eventName, const String& targetName)
 {
     if (eventName.isEmpty()) {
         *error = "Event name is empty";
         return;
     }
 
-    RefPtr<JSONObject> breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints(), eventName);
+    RefPtr<protocol::DictionaryValue> breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints(), eventName);
     if (targetName.isEmpty())
         breakpointsByTarget->setBoolean(DOMDebuggerAgentState::eventTargetAny, true);
     else
         breakpointsByTarget->setBoolean(targetName.lower(), true);
     didAddBreakpoint();
 }
 
 void InspectorDOMDebuggerAgent::removeEventListenerBreakpoint(ErrorString* error, const String& eventName, const Maybe<String>& targetName)
 {
     removeBreakpoint(error, String(listenerEventCategoryType) + eventName, targetName.fromMaybe(String()));
 }
 
 void InspectorDOMDebuggerAgent::removeInstrumentationBreakpoint(ErrorString* error, const String& eventName)
 {
     removeBreakpoint(error, String(instrumentationEventCategoryType) + eventName, String());
 }
 
 void InspectorDOMDebuggerAgent::removeBreakpoint(ErrorString* error, const String& eventName, const String& targetName)
 {
     if (eventName.isEmpty()) {
         *error = "Event name is empty";
         return;
     }
 
-    RefPtr<JSONObject> breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints(), eventName);
+    RefPtr<protocol::DictionaryValue> breakpointsByTarget = ensurePropertyObject(eventListenerBreakpoints(), eventName);
     if (targetName.isEmpty())
         breakpointsByTarget->remove(DOMDebuggerAgentState::eventTargetAny);
     else
         breakpointsByTarget->remove(targetName.lower());
     didRemoveBreakpoint();
 }
 
 void InspectorDOMDebuggerAgent::didInvalidateStyleAttr(Node* node)
 {
     if (hasBreakpoint(node, AttributeModified)) {
-        RefPtr<JSONObject> eventData = JSONObject::create();
+        RefPtr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
         descriptionForDOMEvent(node, AttributeModified, false, eventData.get());
         m_debuggerAgent->breakProgram(protocol::Debugger::Paused::ReasonEnum::DOM, eventData.release());
     }
 }
 
 void InspectorDOMDebuggerAgent::didInsertDOMNode(Node* node)
 {
     if (m_domBreakpoints.size()) {
         uint32_t mask = m_domBreakpoints.get(InspectorDOMAgent::innerParentNode(node));
         uint32_t inheritableTypesMask = (mask | (mask >> domBreakpointDerivedTypeShift)) & inheritableDOMBreakpointTypesMask;
@@ skipping 149 matching lines @@
     if (!objectGroupId.isEmpty()) {
         value->setHandler(m_runtimeAgent->wrapObject(context, function, objectGroupId));
         value->setOriginalHandler(m_runtimeAgent->wrapObject(context, info.handler, objectGroupId));
     }
     return value.release();
 }
 
 void InspectorDOMDebuggerAgent::willInsertDOMNode(Node* parent)
 {
     if (hasBreakpoint(parent, SubtreeModified)) {
-        RefPtr<JSONObject> eventData = JSONObject::create();
+        RefPtr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
         descriptionForDOMEvent(parent, SubtreeModified, true, eventData.get());
         m_debuggerAgent->breakProgram(protocol::Debugger::Paused::ReasonEnum::DOM, eventData.release());
     }
 }
 
 void InspectorDOMDebuggerAgent::willRemoveDOMNode(Node* node)
 {
     Node* parentNode = InspectorDOMAgent::innerParentNode(node);
     if (hasBreakpoint(node, NodeRemoved)) {
-        RefPtr<JSONObject> eventData = JSONObject::create();
+        RefPtr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
         descriptionForDOMEvent(node, NodeRemoved, false, eventData.get());
         m_debuggerAgent->breakProgram(protocol::Debugger::Paused::ReasonEnum::DOM, eventData.release());
     } else if (parentNode && hasBreakpoint(parentNode, SubtreeModified)) {
-        RefPtr<JSONObject> eventData = JSONObject::create();
+        RefPtr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
         descriptionForDOMEvent(node, SubtreeModified, false, eventData.get());
         m_debuggerAgent->breakProgram(protocol::Debugger::Paused::ReasonEnum::DOM, eventData.release());
     }
     didRemoveDOMNode(node);
 }
 
 void InspectorDOMDebuggerAgent::willModifyDOMAttr(Element* element, const AtomicString&, const AtomicString&)
 {
     if (hasBreakpoint(element, AttributeModified)) {
-        RefPtr<JSONObject> eventData = JSONObject::create();
+        RefPtr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
         descriptionForDOMEvent(element, AttributeModified, false, eventData.get());
         m_debuggerAgent->breakProgram(protocol::Debugger::Paused::ReasonEnum::DOM, eventData.release());
     }
 }
 
 void InspectorDOMDebuggerAgent::willSetInnerHTML()
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(setInnerHTMLEventName, 0), true);
 }
 
-void InspectorDOMDebuggerAgent::descriptionForDOMEvent(Node* target, int breakpointType, bool insertion, JSONObject* description)
+void InspectorDOMDebuggerAgent::descriptionForDOMEvent(Node* target, int breakpointType, bool insertion, protocol::DictionaryValue* description)
 {
     ASSERT(hasBreakpoint(target, breakpointType));
 
     Node* breakpointOwner = target;
     if ((1 << breakpointType) & inheritableDOMBreakpointTypesMask) {
         // For inheritable breakpoint types, target node isn't always the same as the node that owns a breakpoint.
         // Target node may be unknown to frontend, so we need to push it first.
         OwnPtr<protocol::Runtime::RemoteObject> targetNodeObject = m_domAgent->resolveNode(target, V8DebuggerAgent::backtraceObjectGroup);
         description->setValue("targetNode", targetNodeObject->serialize());
 
@@ skipping 38 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> eventData, bool synchronous)
+void InspectorDOMDebuggerAgent::pauseOnNativeEventIfNeeded(PassRefPtr<protocol::DictionaryValue> eventData, bool synchronous)
 {
     if (!eventData)
         return;
     if (!m_debuggerAgent->enabled())
         return;
     if (synchronous)
         m_debuggerAgent->breakProgram(protocol::Debugger::Paused::ReasonEnum::EventListener, eventData);
     else
         m_debuggerAgent->schedulePauseOnNextStatement(protocol::Debugger::Paused::ReasonEnum::EventListener, eventData);
 }
 
-PassRefPtr<JSONObject> InspectorDOMDebuggerAgent::preparePauseOnNativeEventData(const String& eventName, const String* targetName)
+PassRefPtr<protocol::DictionaryValue> InspectorDOMDebuggerAgent::preparePauseOnNativeEventData(const String& eventName, const String* targetName)
 {
     String fullEventName = (targetName ? listenerEventCategoryType : instrumentationEventCategoryType) + eventName;
-    RefPtr<JSONObject> breakpoints = eventListenerBreakpoints();
-    JSONObject::iterator it = breakpoints->find(fullEventName);
+    RefPtr<protocol::DictionaryValue> breakpoints = eventListenerBreakpoints();
+    protocol::DictionaryValue::iterator it = breakpoints->find(fullEventName);
     if (it == breakpoints->end())
         return nullptr;
     bool match = false;
-    RefPtr<JSONObject> breakpointsByTarget = JSONObject::cast(it->value);
+    RefPtr<protocol::DictionaryValue> breakpointsByTarget = protocol::DictionaryValue::cast(it->value);
     breakpointsByTarget->getBoolean(DOMDebuggerAgentState::eventTargetAny, &match);
     if (!match && targetName)
         breakpointsByTarget->getBoolean(targetName->lower(), &match);
     if (!match)
         return nullptr;
 
-    RefPtr<JSONObject> eventData = JSONObject::create();
+    RefPtr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::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);
 }
@@ skipping 45 matching lines @@
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(scriptFirstStatementEventName, 0), false);
 }
 
 void InspectorDOMDebuggerAgent::willCloseWindow()
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(windowCloseEventName, 0), true);
 }
 
 void InspectorDOMDebuggerAgent::didFireWebGLError(const String& errorName)
 {
-    RefPtr<JSONObject> eventData = preparePauseOnNativeEventData(webglErrorFiredEventName, 0);
+    RefPtr<protocol::DictionaryValue> eventData = preparePauseOnNativeEventData(webglErrorFiredEventName, 0);
     if (!eventData)
         return;
     if (!errorName.isEmpty())
         eventData->setString(webglErrorNameProperty, errorName);
     pauseOnNativeEventIfNeeded(eventData.release(), m_debuggerAgent->canBreakProgram());
 }
 
 void InspectorDOMDebuggerAgent::didFireWebGLWarning()
 {
     pauseOnNativeEventIfNeeded(preparePauseOnNativeEventData(webglWarningFiredEventName, 0), m_debuggerAgent->canBreakProgram());
@@ skipping 37 matching lines @@
                 break;
             }
         }
     }
 
     if (breakpointURL.isNull())
         return;
     if (!m_debuggerAgent->enabled())
         return;
 
-    RefPtr<JSONObject> eventData = JSONObject::create();
+    RefPtr<protocol::DictionaryValue> eventData = protocol::DictionaryValue::create();
     eventData->setString("breakpointURL", breakpointURL);
     eventData->setString("url", url);
     m_debuggerAgent->breakProgram(protocol::Debugger::Paused::ReasonEnum::XHR, eventData.release());
 }
 
 void InspectorDOMDebuggerAgent::didAddBreakpoint()
 {
     if (m_state->booleanProperty(DOMDebuggerAgentState::enabled, false))
         return;
     setEnabled(true);
 }
 
-static bool isEmpty(PassRefPtr<JSONObject> object)
+static bool isEmpty(PassRefPtr<protocol::DictionaryValue> object)
 {
     return object->begin() == object->end();
 }
 
 void InspectorDOMDebuggerAgent::didRemoveBreakpoint()
 {
     if (!m_domBreakpoints.isEmpty())
         return;
     if (!isEmpty(eventListenerBreakpoints()))
         return;
@@ skipping 14 matching lines @@
         m_instrumentingAgents->setInspectorDOMDebuggerAgent(nullptr);
     }
 }
 
 void InspectorDOMDebuggerAgent::didCommitLoadForLocalFrame(LocalFrame*)
 {
     m_domBreakpoints.clear();
 }
 
 } // namespace blink