Move rendering/RenderObject to layout/LayoutObject.

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 23 matching lines @@
 #include "bindings/core/v8/V8InspectorOverlayHost.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/Element.h"
 #include "core/dom/Node.h"
 #include "core/dom/PseudoElement.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/inspector/InspectorClient.h"
 #include "core/inspector/InspectorOverlayHost.h"
+#include "core/layout/LayoutObject.h"
 #include "core/layout/shapes/ShapeOutsideInfo.h"
 #include "core/loader/EmptyClients.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/page/Chrome.h"
 #include "core/page/EventHandler.h"
 #include "core/page/Page.h"
 #include "core/rendering/RenderBox.h"
 #include "core/rendering/RenderBoxModelObject.h"
 #include "core/rendering/RenderInline.h"
-#include "core/rendering/RenderObject.h"
 #include "core/rendering/style/RenderStyleConstants.h"
 #include "platform/JSONValues.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringBuilder.h"
 #include <v8.h>
@@ skipping 24 matching lines @@
     }
 
     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)
+    ShapePathBuilder(FrameView& view, LayoutObject& 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)
+    static PassRefPtr<TypeBuilder::Array<JSONValue>> buildPath(FrameView& view, LayoutObject& 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;
+    LayoutObject& m_renderer;
     const ShapeOutsideInfo& m_shapeOutsideInfo;
 };
 
 class InspectorOverlayChromeClient final: public EmptyChromeClient {
 public:
     InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlay* overlay)
         : m_client(client)
         , m_overlay(overlay)
     { }
 
@@ skipping 108 matching lines @@
 };
 
 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(RenderObject* renderer, FloatQuad* content, FloatQuad* padding, FloatQuad* border, FloatQuad* margin)
+static bool buildNodeQuads(LayoutObject* renderer, FloatQuad* content, FloatQuad* padding, FloatQuad* border, FloatQuad* margin)
 {
     FrameView* containingView = renderer->frameView();
     if (!containingView)
         return false;
     if (!renderer->isBox() && !renderer->isRenderInline())
         return false;
 
     LayoutRect contentBox;
     LayoutRect paddingBox;
     LayoutRect borderBox;
@@ skipping 39 matching lines @@
     contentsQuadToScreen(containingView, *content);
     contentsQuadToScreen(containingView, *padding);
     contentsQuadToScreen(containingView, *border);
     contentsQuadToScreen(containingView, *margin);
 
     return true;
 }
 
 static void buildNodeHighlight(Node& node, const HighlightConfig& highlightConfig, Highlight* highlight)
 {
-    RenderObject* renderer = node.renderer();
+    LayoutObject* 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()) {
         Vector<FloatQuad> quads;
         renderer->absoluteQuads(quads);
         FrameView* containingView = renderer->frameView();
@@ skipping 268 matching lines @@
     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();
 }
 
 static const ShapeOutsideInfo* shapeOutsideInfoForNode(Node* node, Shape::DisplayPaths* paths, FloatQuad* bounds)
 {
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
     if (!renderer || !renderer->isBox() || !toRenderBox(renderer)->shapeOutsideInfo())
         return nullptr;
 
     FrameView* containingView = node->document().view();
     RenderBox* renderBox = toRenderBox(renderer);
     const ShapeOutsideInfo* shapeOutsideInfo = renderBox->shapeOutsideInfo();
 
     shapeOutsideInfo->computedShape().buildDisplayPaths(*paths);
 
     LayoutRect shapeBounds = shapeOutsideInfo->computedShapePhysicalBoundingBox();
@@ skipping 49 matching lines @@
     }
     if (pseudoElement) {
         if (pseudoElement->pseudoId() == BEFORE)
             classNames.appendLiteral("::before");
         else if (pseudoElement->pseudoId() == AFTER)
             classNames.appendLiteral("::after");
     }
     if (!classNames.isEmpty())
         elementInfo->setString("className", classNames.toString());
 
-    RenderObject* renderer = element->renderer();
+    LayoutObject* renderer = element->renderer();
     FrameView* containingView = element->document().view();
     if (!renderer || !containingView)
         return elementInfo;
 
     // Render the getBoundingClientRect() data in the tooltip
     // to be consistent with the rulers (see http://crbug.com/262338).
     RefPtrWillBeRawPtr<ClientRect> boundingBox = element->getBoundingClientRect();
     elementInfo->setString("nodeWidth", String::number(boundingBox->width()));
     elementInfo->setString("nodeHeight", String::number(boundingBox->height()));
 
@@ skipping 137 matching lines @@
 }
 
 void InspectorOverlay::onTimer(Timer<InspectorOverlay>*)
 {
     m_drawViewSize = false;
     update();
 }
 
 bool InspectorOverlay::getBoxModel(Node* node, RefPtr<TypeBuilder::DOM::BoxModel>& model)
 {
-    RenderObject* renderer = node->renderer();
+    LayoutObject* 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) : nullptr;
@@ skipping 54 matching lines @@
     hideHighlight();
 }
 
 void InspectorOverlay::startedRecordingProfile()
 {
     if (!m_activeProfilerCount++)
         freePage();
 }
 
 } // namespace blink