CSS shapes support in Web Inspector

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 465 matching lines @@
 }
 
 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();
 }
 
-static void setElementInfo(RefPtr<JSONObject>& highlightObject, Node* node)
+// CSS shapes
+struct PathApplyInfo {
+    FrameView* rootView;
+    FrameView* view;
+    JSONArray* array;
+    RenderObject* renderer;
+    const ShapeOutsideInfo* shapeOutsideInfo;
+};
+
+static void appendPathCommandAndPoints(PathApplyInfo* info, const String& command, const FloatPoint points[], unsigned length)
+{
+    FloatPoint point;
+    info->array->pushString(command);
+    for (unsigned i = 0; i < length; i++) {
+        point = info->shapeOutsideInfo->shapeToRendererPoint(points[i]);
+        point = info->view->contentsToRootView(roundedIntPoint(info->renderer->localToAbsolute(point))) + info->rootView->scrollOffset();
+        info->array->pushNumber(point.x());
+        info->array->pushNumber(point.y());
+    }
+}
+
+static void appendPathSegment(void* info, 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);
+        break;
+    // The points member will contain 1 value.
+    case PathElementAddLineToPoint:
+        appendPathCommandAndPoints(pathApplyInfo, "L", pathElement->points, 1);
+        break;
+    // The points member will contain 3 values.
+    case PathElementAddCurveToPoint:
+        appendPathCommandAndPoints(pathApplyInfo, "C", pathElement->points, 3);
+        break;
+    // The points member will contain 2 values.
+    case PathElementAddQuadCurveToPoint:
+        appendPathCommandAndPoints(pathApplyInfo, "Q", pathElement->points, 2);
+        break;
+    // The points member will contain no values.
+    case PathElementCloseSubpath:
+        appendPathCommandAndPoints(pathApplyInfo, "Z", 0, 0);
+        break;
+    }
+}
+
+static PassRefPtr<JSONObject> buildObjectForShapeOutsideLocal(Node* node)
+{
+    RenderObject* renderer = node->renderer();
+    RefPtr<JSONObject> shapeObject = JSONObject::create();
+
+    if (renderer && renderer->isBox()) {
+        LocalFrame* containingFrame = node->document().frame();
+        RenderBox* renderBox = toRenderBox(renderer);
+        if (renderBox) {
+            const ShapeOutsideInfo* shapeOutsideInfo = renderBox->shapeOutsideInfo();
+            if (!shapeOutsideInfo)
+                return shapeObject.release();
+
+            LayoutRect shapeBounds = shapeOutsideInfo->computedShapePhysicalBoundingBox();
+            FloatQuad shapeQuad = renderBox->localToAbsoluteQuad(FloatRect(shapeBounds));
+            FrameView* mainView = containingFrame->page()->mainFrame()->view();
+            FrameView* containingView = containingFrame->view();
+            contentsQuadToPage(mainView, containingView, shapeQuad);
+            shapeObject->setArray("bounds", buildArrayForQuad(shapeQuad));
+
+            Shape::DisplayPaths paths;
+            shapeOutsideInfo->computedShape().buildDisplayPaths(paths);
+
+            if (paths.shape.length()) {
+                RefPtr<JSONArray> shapePath = JSONArray::create();
+                RefPtr<JSONArray> marginShapePath = JSONArray::create();
+                PathApplyInfo info;
+                info.rootView = mainView;
+                info.view = containingView;
+                info.array = shapePath.get();
+                info.renderer = renderBox;
+                info.shapeOutsideInfo = shapeOutsideInfo;
+                paths.shape.apply(&info, &appendPathSegment);
+                shapeObject->setArray("shape", shapePath.release());
+                if (paths.marginShape.length()) {
+                    info.array = marginShapePath.get();
+                    paths.marginShape.apply(&info, &appendPathSegment);
+                }
+                shapeObject->setArray("marginShape", marginShapePath.release());
+            }
+        }
+    }
+    return shapeObject.release();
+}
+
+static RefPtr<TypeBuilder::Array<JSONValue> > buildArrayForShapeOutside(PassRefPtr<JSONValue> value)
+{
+    RefPtr<TypeBuilder::Array<JSONValue> > array = TypeBuilder::Array<JSONValue>::create();
+    array->addItem(value);
+    return array.release();
+}
+
+static RefPtr<TypeBuilder::Array<double> > buildArrayForQuadTypeBuilder(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)
+{
+    // Initialize the shapeObject
+    RefPtr<TypeBuilder::DOM::ShapeOutsideInfo> shapeObject = TypeBuilder::DOM::ShapeOutsideInfo::create()

[pfeldman, 2014/05/02 07:21:54]

You don't need this, see below.

[Habib Virji, 2014/05/02 09:39:22]

Done.

+        .setBounds(buildArrayForQuadTypeBuilder(FloatQuad()))
+        .setShape(buildArrayForShapeOutside(JSONValue::null()))
+        .setMarginShape(buildArrayForShapeOutside(JSONValue::null()));
+
+    RenderObject* renderer = node->renderer();
+    if (renderer->isBox()) { // This check is necessary as shapeOutside is not mandatory part of box model:w

[pfeldman, 2014/05/02 07:21:54]

Since shapeOutside is optional, lets start with 

if (!render-isBox() || !toRenderBox(renderer)->shapeOutside())
    return 0;

[Habib Virji, 2014/05/02 09:39:22]

Done.

+
+        RenderBox* renderBox = toRenderBox(renderer);
+        if (renderBox && renderBox->shapeOutsideInfo()) {
+            RefPtr<JSONObject> value = buildObjectForShapeOutsideLocal(node);

[pfeldman, 2014/05/02 07:21:54]

Now instead of doing this, I'd suggest that you inline
buildObjectForShapeOutsideLocal here. I'll comment on its other call site below.

[Habib Virji, 2014/05/02 09:39:22]

Done.

+            if (!value)
+                return shapeObject.release();
+            shapeObject = TypeBuilder::DOM::ShapeOutsideInfo::create()
+                .setBounds(buildArrayForQuadTypeBuilder(FloatQuad()))

[pfeldman, 2014/05/02 07:21:54]

Why empty quad here?

[Habib Virji, 2014/05/02 09:39:22]

Done.

+                .setShape(buildArrayForShapeOutside(value->getArray("shape")))
+                .setMarginShape(buildArrayForShapeOutside(value->getArray("marginShape")));
+        }
+    }
+
+    return shapeObject.release();
+}
+
+static void setElementInfo(RefPtr<JSONObject>& highlightObject, RefPtr<JSONObject>& shapeObject, Node* node)
 {
     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();
@@ skipping 21 matching lines @@
     if (!classNames.isEmpty())
         elementInfo->setString("className", classNames.toString());
 
     RenderObject* renderer = node->renderer();
     LocalFrame* containingFrame = node->document().frame();
     FrameView* containingView = containingFrame->view();
     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());
 }
 
 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.
     }
     RefPtr<JSONObject> highlightObject = buildObjectForHighlight(highlight);
 
     Node* node = m_highlightNode.get();
+    RefPtr<JSONObject> shapeObject = buildObjectForShapeOutsideLocal(node);

[pfeldman, 2014/05/02 07:21:54]

RefPtr<JSONObject> shapeObject = buildObjectForShapeOutside(node)->asObject();
// Turns out it is already available.

[Habib Virji, 2014/05/02 09:39:22]

Done.

     if (node->isElementNode() && !m_omitTooltip && m_nodeHighlightConfig.showInfo && node->renderer() && node->document().frame())
-        setElementInfo(highlightObject, node);
+        setElementInfo(highlightObject, shapeObject, node);
     evaluateInOverlay("drawNodeHighlight", highlightObject);
 }
 
 void InspectorOverlay::drawQuadHighlight()
 {
     if (!m_highlightQuad)
         return;
 
     Highlight highlight;
     buildQuadHighlight(m_page, *m_highlightQuad, m_quadHighlightConfig, &highlight);
@@ skipping 125 matching lines @@
     hideHighlight();
 }
 
 void InspectorOverlay::startedRecordingProfile()
 {
     if (!m_activeProfilerCount++)
         freePage();
 }
 
 } // namespace WebCore