DevTools: highlight page regions as paths, not quads

Source/core/inspector/InspectorOverlay.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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 46 matching lines @@
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
 #include "wtf/text/StringBuilder.h"
 #include <v8.h>
 
 namespace blink {
 
 namespace {
 
-struct PathApplyInfo {
-    FrameView* view;
-    TypeBuilder::Array<JSONValue>* array;
-    RenderObject* renderer;
-    const ShapeOutsideInfo* shapeOutsideInfo;
+class PathBuilder {
+    WTF_MAKE_NONCOPYABLE(PathBuilder);
+public:
+    PathBuilder() : m_path(TypeBuilder::Array<JSONValue>::create()) { }
+    virtual ~PathBuilder() { }
+
+    PassRefPtr<TypeBuilder::Array<JSONValue> > 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<TypeBuilder::Array<JSONValue> > m_path;
+};
+
+class ShapePathBuilder : public PathBuilder {
+public:
+    ShapePathBuilder(FrameView& view, RenderObject& renderer, const ShapeOutsideInfo& shapeOutsideInfo)
+        : m_view(view)
+        , m_renderer(renderer)
+        , m_shapeOutsideInfo(shapeOutsideInfo) { }
+
+    static PassRefPtr<TypeBuilder::Array<JSONValue> > buildPath(FrameView& view, RenderObject& renderer, const ShapeOutsideInfo& shapeOutsideInfo, const Path& path)
+    {
+        ShapePathBuilder builder(view, renderer, shapeOutsideInfo);
+        builder.appendPath(path);
+        return builder.path();
+    }
+
+protected:
+    virtual FloatPoint translatePoint(const FloatPoint& point)
+    {
+        FloatPoint rendererPoint = m_shapeOutsideInfo.shapeToRendererPoint(point);
+        return m_view.contentsToRootView(roundedIntPoint(m_renderer.localToAbsolute(rendererPoint)));
+    }
+
+private:
+    FrameView& m_view;
+    RenderObject& m_renderer;
+    const ShapeOutsideInfo& m_shapeOutsideInfo;
 };
 
 class InspectorOverlayChromeClient FINAL: public EmptyChromeClient {
 public:
     InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlay* overlay)
         : m_client(client)
         , m_overlay(overlay)
     { }
 
     virtual void setCursor(const Cursor& cursor) OVERRIDE
@@ skipping 14 matching lines @@
     virtual void invalidateContentsForSlowScroll(const IntRect&) OVERRIDE
     {
         m_overlay->invalidate();
     }
 
 private:
     ChromeClient& m_client;
     InspectorOverlay* m_overlay;
 };
 
-Path quadToPath(const FloatQuad& quad)
+static Path quadToPath(const FloatQuad& quad)
 {
     Path quadPath;
     quadPath.moveTo(quad.p1());
     quadPath.addLineTo(quad.p2());
     quadPath.addLineTo(quad.p3());
     quadPath.addLineTo(quad.p4());
     quadPath.closeSubpath();
     return quadPath;
 }
 
@@ skipping 14 matching lines @@
         context->strokePath(quadPath);
 
         context->restore();
     }
 
     // Now do the fill
     context->setFillColor(fillColor);
     context->fillPath(quadPath);
 }
 
+class Highlight {
+public:
+    Highlight()
+        : m_showRulers(false)
+        , m_showExtensionLines(false)
+        , m_highlightPaths(JSONArray::create())
+    { }
+
+    void setDataFromConfig(const HighlightConfig& highlightConfig)
+    {
+        m_showRulers = highlightConfig.showRulers;
+        m_showExtensionLines = highlightConfig.showExtensionLines;
+    }
+
+    void setElementInfo(PassRefPtr<JSONObject> elementInfo)
+    {
+        m_elementInfo = elementInfo;
+    }
+
+    void appendQuad(const FloatQuad& quad, const Color& fillColor, const Color& outlineColor = Color::transparent)
+    {
+        Path path = quadToPath(quad);
+        PathBuilder builder;
+        builder.appendPath(path);
+        appendPath(builder.path(), fillColor, outlineColor);
+    }
+
+    void appendPath(PassRefPtr<JSONArrayBase> path, const Color& fillColor, const Color& outlineColor)
+    {
+        RefPtr<JSONObject> object = JSONObject::create();
+        object->setValue("path", path);
+        object->setString("fillColor", fillColor.serialized());
+        if (outlineColor != Color::transparent)
+            object->setString("outlineColor", outlineColor.serialized());
+        m_highlightPaths->pushObject(object.release());
+    }
+
+    PassRefPtr<JSONObject> asJSONObject() const
+    {
+        RefPtr<JSONObject> object = JSONObject::create();
+        object->setArray("paths", m_highlightPaths);
+        object->setBoolean("showRulers", m_showRulers);
+        object->setBoolean("showExtensionLines", m_showExtensionLines);
+        if (m_elementInfo)
+            object->setObject("elementInfo", m_elementInfo);
+        return object.release();
+    }
+
+private:
+    bool m_showRulers;
+    bool m_showExtensionLines;
+    RefPtr<JSONObject> m_elementInfo;
+    RefPtr<JSONArray> m_highlightPaths;
+};
+
 static void contentsQuadToScreen(const FrameView* view, FloatQuad& quad)
 {
     quad.setP1(view->contentsToRootView(roundedIntPoint(quad.p1())));
     quad.setP2(view->contentsToRootView(roundedIntPoint(quad.p2())));
     quad.setP3(view->contentsToRootView(roundedIntPoint(quad.p3())));
     quad.setP4(view->contentsToRootView(roundedIntPoint(quad.p4())));
 }
 
-static bool buildNodeQuads(Node* node, Vector<FloatQuad>& quads)
+static bool buildNodeQuads(RenderObject* renderer, FloatQuad* content, FloatQuad* padding, FloatQuad* border, FloatQuad* margin)
 {
-    RenderObject* renderer = node->renderer();
-    LocalFrame* containingFrame = node->document().frame();
-
-    if (!renderer || !containingFrame)
+    FrameView* containingView = renderer->frameView();
+    if (!containingView)
         return false;
-
-    FrameView* containingView = containingFrame->view();
-
-    // RenderSVGRoot should be highlighted through the isBox() code path, all other SVG elements should just dump their absoluteQuads().
-    if (renderer->node() && renderer->node()->isSVGElement() && !renderer->isSVGRoot()) {
-        renderer->absoluteQuads(quads);
-        for (size_t i = 0; i < quads.size(); ++i)
-            contentsQuadToScreen(containingView, quads[i]);
-        return false;
-    }
-
     if (!renderer->isBox() && !renderer->isRenderInline())
         return false;
 
     LayoutRect contentBox;
     LayoutRect paddingBox;
     LayoutRect borderBox;
     LayoutRect marginBox;
 
     if (renderer->isBox()) {
         RenderBox* renderBox = toRenderBox(renderer);
@@ skipping 16 matching lines @@
         borderBox = renderInline->linesBoundingBox();
         paddingBox = LayoutRect(borderBox.x() + renderInline->borderLeft(), borderBox.y() + renderInline->borderTop(),
             borderBox.width() - renderInline->borderLeft() - renderInline->borderRight(), borderBox.height() - renderInline->borderTop() - renderInline->borderBottom());
         contentBox = LayoutRect(paddingBox.x() + renderInline->paddingLeft(), paddingBox.y() + renderInline->paddingTop(),
             paddingBox.width() - renderInline->paddingLeft() - renderInline->paddingRight(), paddingBox.height() - renderInline->paddingTop() - renderInline->paddingBottom());
         // Ignore marginTop and marginBottom for inlines.
         marginBox = LayoutRect(borderBox.x() - renderInline->marginLeft(), borderBox.y(),
             borderBox.width() + renderInline->marginWidth(), borderBox.height());
     }
 
-    FloatQuad absContentQuad = renderer->localToAbsoluteQuad(FloatRect(contentBox));
-    FloatQuad absPaddingQuad = renderer->localToAbsoluteQuad(FloatRect(paddingBox));
-    FloatQuad absBorderQuad = renderer->localToAbsoluteQuad(FloatRect(borderBox));
-    FloatQuad absMarginQuad = renderer->localToAbsoluteQuad(FloatRect(marginBox));
+    *content = renderer->localToAbsoluteQuad(FloatRect(contentBox));
+    *padding = renderer->localToAbsoluteQuad(FloatRect(paddingBox));
+    *border = renderer->localToAbsoluteQuad(FloatRect(borderBox));
+    *margin = renderer->localToAbsoluteQuad(FloatRect(marginBox));
 
-    contentsQuadToScreen(containingView, absContentQuad);
-    contentsQuadToScreen(containingView, absPaddingQuad);
-    contentsQuadToScreen(containingView, absBorderQuad);
-    contentsQuadToScreen(containingView, absMarginQuad);
-
-    quads.append(absMarginQuad);
-    quads.append(absBorderQuad);
-    quads.append(absPaddingQuad);
-    quads.append(absContentQuad);
+    contentsQuadToScreen(containingView, *content);
+    contentsQuadToScreen(containingView, *padding);
+    contentsQuadToScreen(containingView, *border);
+    contentsQuadToScreen(containingView, *margin);
 
     return true;
 }
 
-static void buildNodeHighlight(Node* node, const HighlightConfig& highlightConfig, Highlight* highlight)
+static void buildNodeHighlight(Node& node, const HighlightConfig& highlightConfig, Highlight* highlight)
 {
-    RenderObject* renderer = node->renderer();
-    LocalFrame* containingFrame = node->document().frame();
-
-    if (!renderer || !containingFrame)
+    RenderObject* renderer = node.renderer();
+    if (!renderer)
         return;
 
     highlight->setDataFromConfig(highlightConfig);
 
     // RenderSVGRoot should be highlighted through the isBox() code path, all other SVG elements should just dump their absoluteQuads().
-    if (renderer->node() && renderer->node()->isSVGElement() && !renderer->isSVGRoot())
-        highlight->type = HighlightTypeRects;
-    else if (renderer->isBox() || renderer->isRenderInline())
-        highlight->type = HighlightTypeNode;
-    buildNodeQuads(node, highlight->quads);
-}
+    if (renderer->node() && renderer->node()->isSVGElement() && !renderer->isSVGRoot()) {
+        Vector<FloatQuad> quads;
+        renderer->absoluteQuads(quads);
+        for (size_t i = 0; i < quads.size(); ++i)
+            highlight->appendQuad(quads[i], highlightConfig.content, highlightConfig.contentOutline);
+        return;
+    }
 
-static void buildQuadHighlight(Page* page, const FloatQuad& quad, const HighlightConfig& highlightConfig, Highlight *highlight)
-{
-    if (!page)
+    FloatQuad content, padding, border, margin;
+    if (!buildNodeQuads(renderer, &content, &padding, &border, &margin))
         return;
-    highlight->setDataFromConfig(highlightConfig);
-    highlight->type = HighlightTypeRects;
-    highlight->quads.append(quad);
+    highlight->appendQuad(content, highlightConfig.content, highlightConfig.contentOutline);
+    highlight->appendQuad(padding, highlightConfig.padding);
+    highlight->appendQuad(border, highlightConfig.border);
+    highlight->appendQuad(margin, highlightConfig.margin);
 }
 
 } // anonymous namespace
 
 InspectorOverlay::InspectorOverlay(Page* page, InspectorClient* client)
     : m_page(page)
     , m_client(client)
     , m_inspectModeEnabled(false)
     , m_overlayHost(InspectorOverlayHost::create())
     , m_drawViewSize(false)
@@ skipping 176 matching lines @@
     m_timer.stop();
     m_highlightNode.clear();
     m_eventTargetNode.clear();
     m_highlightQuad.clear();
     m_pausedInDebuggerMessage = String();
     m_drawViewSize = false;
     m_drawViewSizeWithGrid = false;
     update();
 }
 
-static PassRefPtr<JSONObject> buildObjectForPoint(const FloatPoint& point)
-{
-    RefPtr<JSONObject> object = JSONObject::create();
-    object->setNumber("x", point.x());
-    object->setNumber("y", point.y());
-    return object.release();
-}
-
-static PassRefPtr<JSONArray> buildArrayForQuad(const FloatQuad& quad)
-{
-    RefPtr<JSONArray> array = JSONArray::create();
-    array->pushObject(buildObjectForPoint(quad.p1()));
-    array->pushObject(buildObjectForPoint(quad.p2()));
-    array->pushObject(buildObjectForPoint(quad.p3()));
-    array->pushObject(buildObjectForPoint(quad.p4()));
-    return array.release();
-}
-
-static PassRefPtr<JSONObject> buildObjectForHighlight(const Highlight& highlight)
-{
-    RefPtr<JSONObject> object = JSONObject::create();
-    RefPtr<JSONArray> array = JSONArray::create();
-    for (size_t i = 0; i < highlight.quads.size(); ++i)
-        array->pushArray(buildArrayForQuad(highlight.quads[i]));
-    object->setArray("quads", array.release());
-    object->setBoolean("showRulers", highlight.showRulers);
-    object->setBoolean("showExtensionLines", highlight.showExtensionLines);
-    object->setString("contentColor", highlight.contentColor.serialized());
-    object->setString("contentOutlineColor", highlight.contentOutlineColor.serialized());
-    object->setString("paddingColor", highlight.paddingColor.serialized());
-    object->setString("borderColor", highlight.borderColor.serialized());
-    object->setString("marginColor", highlight.marginColor.serialized());
-    object->setString("eventTargetColor", highlight.eventTargetColor.serialized());
-    return object.release();
-}
-
 static PassRefPtr<JSONObject> buildObjectForSize(const IntSize& size)
 {
     RefPtr<JSONObject> result = JSONObject::create();
     result->setNumber("width", size.width());
     result->setNumber("height", size.height());
     return result.release();
 }
 
-// CSS shapes
-static void appendPathCommandAndPoints(PathApplyInfo* info, const String& command, const FloatPoint points[], unsigned length)
+void PathBuilder::appendPathCommandAndPoints(const char* command, const FloatPoint points[], size_t length)
 {
-    FloatPoint point;
-    info->array->addItem(JSONString::create(command));
-    for (unsigned i = 0; i < length; i++) {
-        point = info->shapeOutsideInfo->shapeToRendererPoint(points[i]);
-        point = info->view->contentsToRootView(roundedIntPoint(info->renderer->localToAbsolute(point)));
-        info->array->addItem(JSONBasicValue::create(point.x()));
-        info->array->addItem(JSONBasicValue::create(point.y()));
+    m_path->addItem(JSONString::create(command));
+    for (size_t i = 0; i < length; i++) {
+        FloatPoint point = translatePoint(points[i]);
+        m_path->addItem(JSONBasicValue::create(point.x()));
+        m_path->addItem(JSONBasicValue::create(point.y()));
     }
 }
 
-static void appendPathSegment(void* info, const PathElement* pathElement)
+void PathBuilder::appendPathElement(const PathElement* pathElement)
 {
-    PathApplyInfo* pathApplyInfo = static_cast<PathApplyInfo*>(info);
-    FloatPoint point;
     switch (pathElement->type) {
     // The points member will contain 1 value.
     case PathElementMoveToPoint:
-        appendPathCommandAndPoints(pathApplyInfo, "M", pathElement->points, 1);
+        appendPathCommandAndPoints("M", pathElement->points, 1);
         break;
     // The points member will contain 1 value.
     case PathElementAddLineToPoint:
-        appendPathCommandAndPoints(pathApplyInfo, "L", pathElement->points, 1);
+        appendPathCommandAndPoints("L", pathElement->points, 1);
         break;
     // The points member will contain 3 values.
     case PathElementAddCurveToPoint:
-        appendPathCommandAndPoints(pathApplyInfo, "C", pathElement->points, 3);
+        appendPathCommandAndPoints("C", pathElement->points, 3);
         break;
     // The points member will contain 2 values.
     case PathElementAddQuadCurveToPoint:
-        appendPathCommandAndPoints(pathApplyInfo, "Q", pathElement->points, 2);
+        appendPathCommandAndPoints("Q", pathElement->points, 2);
         break;
     // The points member will contain no values.
     case PathElementCloseSubpath:
-        appendPathCommandAndPoints(pathApplyInfo, "Z", 0, 0);
+        appendPathCommandAndPoints("Z", 0, 0);
         break;
     }
 }
 
-static RefPtr<TypeBuilder::Array<double> > buildArrayForQuadTypeBuilder(const FloatQuad& quad)
+static RefPtr<TypeBuilder::Array<double> > buildArrayForQuad(const FloatQuad& quad)
 {
     RefPtr<TypeBuilder::Array<double> > array = TypeBuilder::Array<double>::create();
     array->addItem(quad.p1().x());
     array->addItem(quad.p1().y());
     array->addItem(quad.p2().x());
     array->addItem(quad.p2().y());
     array->addItem(quad.p3().x());
     array->addItem(quad.p3().y());
     array->addItem(quad.p4().x());
     array->addItem(quad.p4().y());
     return array.release();
 }
 
-PassRefPtr<TypeBuilder::DOM::ShapeOutsideInfo> InspectorOverlay::buildObjectForShapeOutside(Node* node)
+static const ShapeOutsideInfo* shapeOutsideInfoForNode(Node* node, Shape::DisplayPaths* paths, FloatQuad* bounds)
 {
     RenderObject* renderer = node->renderer();
     if (!renderer || !renderer->isBox() || !toRenderBox(renderer)->shapeOutsideInfo())
-        return nullptr;
+        return 0;
 
-    LocalFrame* containingFrame = node->document().frame();
+    FrameView* containingView = node->document().view();
     RenderBox* renderBox = toRenderBox(renderer);
     const ShapeOutsideInfo* shapeOutsideInfo = renderBox->shapeOutsideInfo();
 
+    shapeOutsideInfo->computedShape().buildDisplayPaths(*paths);
+
     LayoutRect shapeBounds = shapeOutsideInfo->computedShapePhysicalBoundingBox();
-    FloatQuad shapeQuad = renderBox->localToAbsoluteQuad(FloatRect(shapeBounds));
-    FrameView* containingView = containingFrame->view();
-    contentsQuadToScreen(containingView, shapeQuad);
+    *bounds = renderBox->localToAbsoluteQuad(FloatRect(shapeBounds));
+    contentsQuadToScreen(containingView, *bounds);
 
-    Shape::DisplayPaths paths;
-    shapeOutsideInfo->computedShape().buildDisplayPaths(paths);
-    RefPtr<TypeBuilder::Array<JSONValue> > shapePath = TypeBuilder::Array<JSONValue>::create();
-    RefPtr<TypeBuilder::Array<JSONValue> > marginShapePath = TypeBuilder::Array<JSONValue>::create();
-
-    if (paths.shape.length()) {
-        PathApplyInfo info;
-        info.view = containingView;
-        info.array = shapePath.get();
-        info.renderer = renderBox;
-        info.shapeOutsideInfo = shapeOutsideInfo;
-        paths.shape.apply(&info, &appendPathSegment);
-
-        if (paths.marginShape.length()) {
-            info.array = marginShapePath.get();
-            paths.marginShape.apply(&info, &appendPathSegment);
-        }
-    }
-    RefPtr<TypeBuilder::DOM::ShapeOutsideInfo> shapeTypeBuilder = TypeBuilder::DOM::ShapeOutsideInfo::create()
-        .setBounds(buildArrayForQuadTypeBuilder(shapeQuad))
-        .setShape(shapePath)
-        .setMarginShape(marginShapePath);
-
-    return shapeTypeBuilder.release();
+    return shapeOutsideInfo;
 }
 
-static void setElementInfo(RefPtr<JSONObject>& highlightObject, RefPtr<JSONObject>& shapeObject, Node* node)
+static void appendPathsForShapeOutside(Highlight& highlight, const HighlightConfig& config, Node* node)
+{
+    Shape::DisplayPaths paths;
+    FloatQuad boundsQuad;
+
+    const ShapeOutsideInfo* shapeOutsideInfo = shapeOutsideInfoForNode(node, &paths, &boundsQuad);
+    if (!shapeOutsideInfo)
+        return;
+
+    if (!paths.shape.length()) {
+        highlight.appendQuad(boundsQuad, config.shape);
+        return;
+    }
+
+    highlight.appendPath(ShapePathBuilder::buildPath(*node->document().view(), *node->renderer(), *shapeOutsideInfo, paths.shape), config.shape, Color::transparent);
+    if (paths.marginShape.length())
+        highlight.appendPath(ShapePathBuilder::buildPath(*node->document().view(), *node->renderer(), *shapeOutsideInfo, paths.marginShape), config.shapeMargin, Color::transparent);
+}
+
+PassRefPtr<JSONObject> buildElementInfo(Element* element)
 {
     RefPtr<JSONObject> elementInfo = JSONObject::create();
-    Element* element = toElement(node);
     Element* realElement = element;
     PseudoElement* pseudoElement = 0;
     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 11 matching lines @@
     }
     if (pseudoElement) {
         if (pseudoElement->pseudoId() == BEFORE)
             classNames.append("::before");
         else if (pseudoElement->pseudoId() == AFTER)
             classNames.append("::after");
     }
     if (!classNames.isEmpty())
         elementInfo->setString("className", classNames.toString());
 
-    RenderObject* renderer = node->renderer();
-    LocalFrame* containingFrame = node->document().frame();
-    FrameView* containingView = containingFrame->view();
+    RenderObject* renderer = element->renderer();
+    FrameView* containingView = element->document().view();
+    if (!renderer || !containingView)
+        return elementInfo;
+
     IntRect boundingBox = pixelSnappedIntRect(containingView->contentsToRootView(renderer->absoluteBoundingBoxRect()));
     RenderBoxModelObject* modelObject = renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : 0;
     elementInfo->setString("nodeWidth", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetWidth(), modelObject) : boundingBox.width()));
     elementInfo->setString("nodeHeight", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetHeight(), modelObject) : boundingBox.height()));
-    if (renderer->isBox() && shapeObject)
-        elementInfo->setObject("shapeOutsideInfo", shapeObject.release());
-    highlightObject->setObject("elementInfo", elementInfo.release());
+
+    return elementInfo;
 }
 
 void InspectorOverlay::drawNodeHighlight()
 {
     if (!m_highlightNode)
         return;
 
     Highlight highlight;
-    buildNodeHighlight(m_highlightNode.get(), m_nodeHighlightConfig, &highlight);
-    if (m_eventTargetNode) {
-        Highlight eventTargetHighlight;
-        buildNodeHighlight(m_eventTargetNode.get(), m_nodeHighlightConfig, &eventTargetHighlight);
-        highlight.quads.append(eventTargetHighlight.quads[1]); // Add border from eventTargetNode to highlight.
+    appendPathsForShapeOutside(highlight, m_nodeHighlightConfig, m_highlightNode.get());
+    buildNodeHighlight(*m_highlightNode, m_nodeHighlightConfig, &highlight);
+
+    if (m_eventTargetNode && m_eventTargetNode->renderer()) {
+        FloatQuad border, unused;
+        if (buildNodeQuads(m_eventTargetNode->renderer(), &unused, &unused, &border, &unused))
+            highlight.appendQuad(border, m_nodeHighlightConfig.eventTarget);
     }
-    RefPtr<JSONObject> highlightObject = buildObjectForHighlight(highlight);
 
-    Node* node = m_highlightNode.get();
-    RefPtr<TypeBuilder::DOM::ShapeOutsideInfo> shapeObject = buildObjectForShapeOutside(node);
-    RefPtr<JSONObject> shapeObjectJSON = shapeObject ? shapeObject->asObject() : nullptr;
-    if (node->isElementNode() && !m_omitTooltip && m_nodeHighlightConfig.showInfo && node->renderer() && node->document().frame())
-        setElementInfo(highlightObject, shapeObjectJSON, node);
-    evaluateInOverlay("drawNodeHighlight", highlightObject);
+    if (m_highlightNode->isElementNode() && !m_omitTooltip && m_nodeHighlightConfig.showInfo && m_highlightNode->renderer() && m_highlightNode->document().frame())
+        highlight.setElementInfo(buildElementInfo(toElement(m_highlightNode.get())));
+
+    evaluateInOverlay("drawHighlight", highlight.asJSONObject());
 }
 
 void InspectorOverlay::drawQuadHighlight()
 {
     if (!m_highlightQuad)
         return;
 
     Highlight highlight;
-    buildQuadHighlight(m_page, *m_highlightQuad, m_quadHighlightConfig, &highlight);
-    evaluateInOverlay("drawQuadHighlight", buildObjectForHighlight(highlight));
+    highlight.appendQuad(*m_highlightQuad, m_quadHighlightConfig.content, m_quadHighlightConfig.contentOutline);
+    evaluateInOverlay("drawHighlight", highlight.asJSONObject());
 }
 
 void InspectorOverlay::drawPausedInDebuggerMessage()
 {
     if (!m_pausedInDebuggerMessage.isNull())
         evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
 }
 
 void InspectorOverlay::drawViewSize()
 {
@@ skipping 93 matching lines @@
     command->pushValue(argument);
     toLocalFrame(overlayPage()->mainFrame())->script().executeScriptInMainWorld("dispatch(" + command->toJSONString() + ")", ScriptController::ExecuteScriptWhenScriptsDisabled);
 }
 
 void InspectorOverlay::onTimer(Timer<InspectorOverlay>*)
 {
     m_drawViewSize = false;
     update();
 }
 
-bool InspectorOverlay::getBoxModel(Node* node, Vector<FloatQuad>* quads)
+bool InspectorOverlay::getBoxModel(Node* node, RefPtr<TypeBuilder::DOM::BoxModel>& model)
 {
-    return buildNodeQuads(node, *quads);
+    RenderObject* renderer = node->renderer();
+    FrameView* view = node->document().view();
+    if (!renderer || !view)
+        return false;
+
+    FloatQuad content, padding, border, margin;
+    if (!buildNodeQuads(node->renderer(), &content, &padding, &border, &margin))
+        return false;
+
+    IntRect boundingBox = pixelSnappedIntRect(view->contentsToRootView(renderer->absoluteBoundingBoxRect()));
+    RenderBoxModelObject* modelObject = renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : 0;
+
+    model = TypeBuilder::DOM::BoxModel::create()
+        .setContent(buildArrayForQuad(content))
+        .setPadding(buildArrayForQuad(padding))
+        .setBorder(buildArrayForQuad(border))
+        .setMargin(buildArrayForQuad(margin))
+        .setWidth(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetWidth(), modelObject) : boundingBox.width())
+        .setHeight(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetHeight(), modelObject) : boundingBox.height());
+
+    Shape::DisplayPaths paths;
+    FloatQuad boundsQuad;
+    if (const ShapeOutsideInfo* shapeOutsideInfo = shapeOutsideInfoForNode(node, &paths, &boundsQuad)) {
+        RefPtr<TypeBuilder::DOM::ShapeOutsideInfo> shapeTypeBuilder = TypeBuilder::DOM::ShapeOutsideInfo::create()
+            .setBounds(buildArrayForQuad(boundsQuad))
+            .setShape(ShapePathBuilder::buildPath(*view, *renderer, *shapeOutsideInfo, paths.shape))
+            .setMarginShape(ShapePathBuilder::buildPath(*view, *renderer, *shapeOutsideInfo, paths.marginShape));
+        model->setShapeOutside(shapeTypeBuilder);
+    }
+
+    return true;
 }
 
 void InspectorOverlay::freePage()
 {
     if (m_overlayPage) {
         m_overlayPage->willBeDestroyed();
         m_overlayPage.clear();
     }
     m_overlayChromeClient.clear();
     m_timer.stop();
 
     // This will clear internal structures and issue update to the client. Safe to call last.
     hideHighlight();
 }
 
 void InspectorOverlay::startedRecordingProfile()
 {
     if (!m_activeProfilerCount++)
         freePage();
 }
 
 } // namespace blink