Audited and renamed uses of methods and variables named RootView

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 92 matching lines @@
     {
         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)));
+        return m_view.contentsToRootFrame(roundedIntPoint(m_renderer.localToAbsolute(rendererPoint)));
     }
 
 private:
     FrameView& m_view;
     LayoutObject& m_renderer;
     const ShapeOutsideInfo& m_shapeOutsideInfo;
 };
 
 class InspectorOverlayChromeClient final: public EmptyChromeClient {
 public:
@@ skipping 105 matching lines @@
         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)
+static void contentsQuadToRootFrame(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())));
+    quad.setP1(view->contentsToRootFrame(roundedIntPoint(quad.p1())));
+    quad.setP2(view->contentsToRootFrame(roundedIntPoint(quad.p2())));
+    quad.setP3(view->contentsToRootFrame(roundedIntPoint(quad.p3())));
+    quad.setP4(view->contentsToRootFrame(roundedIntPoint(quad.p4())));
 }
 
 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;
 
@@ skipping 32 matching lines @@
         // Ignore marginTop and marginBottom for inlines.
         marginBox = LayoutRect(borderBox.x() - renderInline->marginLeft(), borderBox.y(),
             borderBox.width() + renderInline->marginWidth(), borderBox.height());
     }
 
     *content = renderer->localToAbsoluteQuad(FloatRect(contentBox));
     *padding = renderer->localToAbsoluteQuad(FloatRect(paddingBox));
     *border = renderer->localToAbsoluteQuad(FloatRect(borderBox));
     *margin = renderer->localToAbsoluteQuad(FloatRect(marginBox));
 
-    contentsQuadToScreen(containingView, *content);
-    contentsQuadToScreen(containingView, *padding);
-    contentsQuadToScreen(containingView, *border);
-    contentsQuadToScreen(containingView, *margin);
+    contentsQuadToRootFrame(containingView, *content);
+    contentsQuadToRootFrame(containingView, *padding);
+    contentsQuadToRootFrame(containingView, *border);
+    contentsQuadToRootFrame(containingView, *margin);
 
     return true;
 }
 
 static void buildNodeHighlight(Node& node, const HighlightConfig& highlightConfig, Highlight* highlight)
 {
     LayoutObject* renderer = node.renderer();
     if (!renderer)
         return;
 
     highlight->setDataFromConfig(highlightConfig);
 
     // LayoutSVGRoot 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();
         for (size_t i = 0; i < quads.size(); ++i) {
             if (containingView)
-                contentsQuadToScreen(containingView, quads[i]);
+                contentsQuadToRootFrame(containingView, quads[i]);
             highlight->appendQuad(quads[i], highlightConfig.content, highlightConfig.contentOutline);
         }
         return;
     }
 
     FloatQuad content, padding, border, margin;
     if (!buildNodeQuads(renderer, &content, &padding, &border, &margin))
         return;
     highlight->appendQuad(content, highlightConfig.content, highlightConfig.contentOutline);
     highlight->appendQuad(padding, highlightConfig.padding);
@@ skipping 266 matching lines @@
         return nullptr;
 
     FrameView* containingView = node->document().view();
     RenderBox* renderBox = toRenderBox(renderer);
     const ShapeOutsideInfo* shapeOutsideInfo = renderBox->shapeOutsideInfo();
 
     shapeOutsideInfo->computedShape().buildDisplayPaths(*paths);
 
     LayoutRect shapeBounds = shapeOutsideInfo->computedShapePhysicalBoundingBox();
     *bounds = renderBox->localToAbsoluteQuad(FloatRect(shapeBounds));
-    contentsQuadToScreen(containingView, *bounds);
+    contentsQuadToRootFrame(containingView, *bounds);
 
     return shapeOutsideInfo;
 }
 
 static void appendPathsForShapeOutside(Highlight& highlight, const HighlightConfig& config, Node* node)
 {
     Shape::DisplayPaths paths;
     FloatQuad boundsQuad;
 
     const ShapeOutsideInfo* shapeOutsideInfo = shapeOutsideInfoForNode(node, &paths, &boundsQuad);
@@ skipping 204 matching lines @@
 {
     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()));
+    IntRect boundingBox = pixelSnappedIntRect(view->contentsToRootFrame(renderer->absoluteBoundingBoxRect()));
     LayoutBoxModelObject* modelObject = renderer->isBoxModelObject() ? toLayoutBoxModelObject(renderer) : nullptr;
 
     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());
 
@@ skipping 45 matching lines @@
     hideHighlight();
 }
 
 void InspectorOverlay::startedRecordingProfile()
 {
     if (!m_activeProfilerCount++)
         freePage();
 }
 
 } // namespace blink