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

third_party/WebKit/Source/core/inspector/InspectorHighlight.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/inspector/InspectorHighlight.h"
 
 #include "core/dom/ClientRect.h"
 #include "core/dom/PseudoElement.h"
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/shapes/ShapeOutsideInfo.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "platform/graphics/Path.h"
 
 namespace blink {
 
 namespace {
 
 class PathBuilder {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(PathBuilder);
 public:
-    PathBuilder() : m_path(JSONArray::create()) { }
+    PathBuilder() : m_path(protocol::ListValue::create()) { }
     virtual ~PathBuilder() { }
 
-    PassRefPtr<JSONArray> path() const { return m_path; }
+    PassRefPtr<protocol::ListValue> path() const { return m_path; }
 
     void appendPath(const Path& path)
     {
         path.apply(this, &PathBuilder::appendPathElement);
     }
 
 protected:
     virtual FloatPoint translatePoint(const FloatPoint& point) { return point; }
 
 private:
     static void appendPathElement(void* pathBuilder, const PathElement* pathElement)
     {
         static_cast<PathBuilder*>(pathBuilder)->appendPathElement(pathElement);
     }
 
     void appendPathElement(const PathElement*);
     void appendPathCommandAndPoints(const char* command, const FloatPoint points[], size_t length);
 
-    RefPtr<JSONArray> m_path;
+    RefPtr<protocol::ListValue> m_path;
 };
 
 void PathBuilder::appendPathCommandAndPoints(const char* command, const FloatPoint points[], size_t length)
 {
-    m_path->pushString(command);
+    m_path->pushValue(protocol::StringValue::create(command));
     for (size_t i = 0; i < length; i++) {
         FloatPoint point = translatePoint(points[i]);
-        m_path->pushNumber(point.x());
-        m_path->pushNumber(point.y());
+        m_path->pushValue(protocol::FundamentalValue::create(point.x()));
+        m_path->pushValue(protocol::FundamentalValue::create(point.y()));
     }
 }
 
 void PathBuilder::appendPathElement(const PathElement* pathElement)
 {
     switch (pathElement->type) {
     // The points member will contain 1 value.
     case PathElementMoveToPoint:
         appendPathCommandAndPoints("M", pathElement->points, 1);
         break;
@@ skipping 16 matching lines @@
     }
 }
 
 class ShapePathBuilder : public PathBuilder {
 public:
     ShapePathBuilder(FrameView& view, LayoutObject& layoutObject, const ShapeOutsideInfo& shapeOutsideInfo)
         : m_view(&view)
         , m_layoutObject(layoutObject)
         , m_shapeOutsideInfo(shapeOutsideInfo) { }
 
-    static RefPtr<JSONArray> buildPath(FrameView& view, LayoutObject& layoutObject, const ShapeOutsideInfo& shapeOutsideInfo, const Path& path)
+    static RefPtr<protocol::ListValue> buildPath(FrameView& view, LayoutObject& layoutObject, const ShapeOutsideInfo& shapeOutsideInfo, const Path& path)
     {
         ShapePathBuilder builder(view, layoutObject, shapeOutsideInfo);
         builder.appendPath(path);
         return builder.path();
     }
 
 protected:
     virtual FloatPoint translatePoint(const FloatPoint& point)
     {
         FloatPoint layoutObjectPoint = m_shapeOutsideInfo.shapeToLayoutObjectPoint(point);
@@ skipping 52 matching lines @@
 
     shapeOutsideInfo->computedShape().buildDisplayPaths(*paths);
 
     LayoutRect shapeBounds = shapeOutsideInfo->computedShapePhysicalBoundingBox();
     *bounds = layoutBox->localToAbsoluteQuad(FloatRect(shapeBounds));
     contentsQuadToViewport(containingView, *bounds);
 
     return shapeOutsideInfo;
 }
 
-PassRefPtr<JSONObject> buildElementInfo(Element* element)
+PassRefPtr<protocol::DictionaryValue> buildElementInfo(Element* element)
 {
-    RefPtr<JSONObject> elementInfo = JSONObject::create();
+    RefPtr<protocol::DictionaryValue> elementInfo = protocol::DictionaryValue::create();
     Element* realElement = element;
     PseudoElement* pseudoElement = nullptr;
     if (element->isPseudoElement()) {
         pseudoElement = toPseudoElement(element);
         realElement = element->parentOrShadowHostElement();
     }
     bool isXHTML = realElement->document().isXHTMLDocument();
     elementInfo->setString("tagName", isXHTML ? realElement->nodeName() : realElement->nodeName().lower());
     elementInfo->setString("idValue", realElement->getIdAttribute());
     StringBuilder classNames;
@@ skipping 28 matching lines @@
     ClientRect* boundingBox = element->getBoundingClientRect();
     elementInfo->setString("nodeWidth", String::number(boundingBox->width()));
     elementInfo->setString("nodeHeight", String::number(boundingBox->height()));
 
     return elementInfo;
 }
 
 } // namespace
 
 InspectorHighlight::InspectorHighlight()
-    : m_highlightPaths(JSONArray::create())
+    : m_highlightPaths(protocol::ListValue::create())
     , m_showRulers(false)
     , m_showExtensionLines(false)
     , m_displayAsMaterial(false)
 {
 }
 
 InspectorHighlightConfig::InspectorHighlightConfig()
     : showInfo(false)
     , showRulers(false)
     , showExtensionLines(false)
     , displayAsMaterial(false)
 {
 }
 
 InspectorHighlight::InspectorHighlight(Node* node, const InspectorHighlightConfig& highlightConfig, bool appendElementInfo)
-    : m_highlightPaths(JSONArray::create())
+    : m_highlightPaths(protocol::ListValue::create())
     , m_showRulers(highlightConfig.showRulers)
     , m_showExtensionLines(highlightConfig.showExtensionLines)
     , m_displayAsMaterial(highlightConfig.displayAsMaterial)
 {
     appendPathsForShapeOutside(node, highlightConfig);
     appendNodeHighlight(node, highlightConfig);
     if (appendElementInfo && node->isElementNode())
         m_elementInfo = buildElementInfo(toElement(node));
 }
 
 InspectorHighlight::~InspectorHighlight()
 {
 }
 
 void InspectorHighlight::appendQuad(const FloatQuad& quad, const Color& fillColor, const Color& outlineColor, const String& name)
 {
     Path path = quadToPath(quad);
     PathBuilder builder;
     builder.appendPath(path);
     appendPath(builder.path(), fillColor, outlineColor, name);
 }
 
-void InspectorHighlight::appendPath(PassRefPtr<JSONArray> path, const Color& fillColor, const Color& outlineColor, const String& name)
+void InspectorHighlight::appendPath(PassRefPtr<protocol::ListValue> path, const Color& fillColor, const Color& outlineColor, const String& name)
 {
-    RefPtr<JSONObject> object = JSONObject::create();
+    RefPtr<protocol::DictionaryValue> object = protocol::DictionaryValue::create();
     object->setValue("path", path);
     object->setString("fillColor", fillColor.serialized());
     if (outlineColor != Color::transparent)
         object->setString("outlineColor", outlineColor.serialized());
     if (!name.isEmpty())
         object->setString("name", name);
-    m_highlightPaths->pushObject(object.release());
+    m_highlightPaths->pushValue(object.release());
 }
 
 void InspectorHighlight::appendEventTargetQuads(Node* eventTargetNode, const InspectorHighlightConfig& highlightConfig)
 {
     if (eventTargetNode->layoutObject()) {
         FloatQuad border, unused;
         if (buildNodeQuads(eventTargetNode, &unused, &unused, &border, &unused))
             appendQuad(border, highlightConfig.eventTarget);
     }
 }
@@ skipping 38 matching lines @@
 
     FloatQuad content, padding, border, margin;
     if (!buildNodeQuads(node, &content, &padding, &border, &margin))
         return;
     appendQuad(content, highlightConfig.content, highlightConfig.contentOutline, "content");
     appendQuad(padding, highlightConfig.padding, Color::transparent, "padding");
     appendQuad(border, highlightConfig.border, Color::transparent, "border");
     appendQuad(margin, highlightConfig.margin, Color::transparent, "margin");
 }
 
-PassRefPtr<JSONObject> InspectorHighlight::asJSONObject() const
+PassRefPtr<protocol::DictionaryValue> InspectorHighlight::asProtocolValue() const
 {
-    RefPtr<JSONObject> object = JSONObject::create();
+    RefPtr<protocol::DictionaryValue> object = protocol::DictionaryValue::create();
     object->setArray("paths", m_highlightPaths);
     object->setBoolean("showRulers", m_showRulers);
     object->setBoolean("showExtensionLines", m_showExtensionLines);
     if (m_elementInfo)
         object->setObject("elementInfo", m_elementInfo);
     object->setBoolean("displayAsMaterial", m_displayAsMaterial);
     return object.release();
 }
 
 // static
@@ skipping 18 matching lines @@
         .setMargin(buildArrayForQuad(margin))
         .setWidth(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetWidth(), modelObject) : boundingBox.width())
         .setHeight(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetHeight(), modelObject) : boundingBox.height()).build();
 
     Shape::DisplayPaths paths;
     FloatQuad boundsQuad;
     protocol::ErrorSupport errors;
     if (const ShapeOutsideInfo* shapeOutsideInfo = shapeOutsideInfoForNode(node, &paths, &boundsQuad)) {
         (*model)->setShapeOutside(protocol::DOM::ShapeOutsideInfo::create()
             .setBounds(buildArrayForQuad(boundsQuad))
-            .setShape(protocol::Array<RefPtr<JSONValue>>::parse(ShapePathBuilder::buildPath(*view, *layoutObject, *shapeOutsideInfo, paths.shape), &errors))
-            .setMarginShape(protocol::Array<RefPtr<JSONValue>>::parse(ShapePathBuilder::buildPath(*view, *layoutObject, *shapeOutsideInfo, paths.marginShape), &errors))
+            .setShape(protocol::Array<RefPtr<protocol::Value>>::parse(ShapePathBuilder::buildPath(*view, *layoutObject, *shapeOutsideInfo, paths.shape), &errors))
+            .setMarginShape(protocol::Array<RefPtr<protocol::Value>>::parse(ShapePathBuilder::buildPath(*view, *layoutObject, *shapeOutsideInfo, paths.marginShape), &errors))
             .build());
     }
 
     return true;
 }
 
 bool InspectorHighlight::buildNodeQuads(Node* node, FloatQuad* content, FloatQuad* padding, FloatQuad* border, FloatQuad* margin)
 {
     LayoutObject* layoutObject = node->layoutObject();
     if (!layoutObject)
@@ skipping 68 matching lines @@
     config.shape = Color(0, 0, 0, 0);
     config.shapeMargin = Color(128, 128, 128, 0);
     config.showInfo = true;
     config.showRulers = true;
     config.showExtensionLines = true;
     config.displayAsMaterial = false;
     return config;
 }
 
 } // namespace blink