Rename renderer() to 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 285 matching lines @@
     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();
+    LayoutObject* renderer = node.layoutObject();
     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();
@@ skipping 267 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)
 {
-    LayoutObject* renderer = node->renderer();
+    LayoutObject* renderer = node->layoutObject();
     if (!renderer || !renderer->isBox() || !toLayoutBox(renderer)->shapeOutsideInfo())
         return nullptr;
 
     FrameView* containingView = node->document().view();
     LayoutBox* layoutBox = toLayoutBox(renderer);
     const ShapeOutsideInfo* shapeOutsideInfo = layoutBox->shapeOutsideInfo();
 
     shapeOutsideInfo->computedShape().buildDisplayPaths(*paths);
 
     LayoutRect shapeBounds = shapeOutsideInfo->computedShapePhysicalBoundingBox();
@@ skipping 10 matching lines @@
 
     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);
+    highlight.appendPath(ShapePathBuilder::buildPath(*node->document().view(), *node->layoutObject(), *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);
+        highlight.appendPath(ShapePathBuilder::buildPath(*node->document().view(), *node->layoutObject(), *shapeOutsideInfo, paths.marginShape), config.shapeMargin, Color::transparent);
 }
 
 PassRefPtr<JSONObject> buildElementInfo(Element* element)
 {
     RefPtr<JSONObject> elementInfo = JSONObject::create();
     Element* realElement = element;
     PseudoElement* pseudoElement = nullptr;
     if (element->isPseudoElement()) {
         pseudoElement = toPseudoElement(element);
         realElement = element->parentOrShadowHostElement();
@@ skipping 16 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());
 
-    LayoutObject* renderer = element->renderer();
+    LayoutObject* renderer = element->layoutObject();
     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()));
 
     return elementInfo;
 }
 
 void InspectorOverlay::drawNodeHighlight()
 {
     if (!m_highlightNode)
         return;
 
     Highlight highlight;
     appendPathsForShapeOutside(highlight, m_nodeHighlightConfig, m_highlightNode.get());
     buildNodeHighlight(*m_highlightNode, m_nodeHighlightConfig, &highlight);
 
-    if (m_eventTargetNode && m_eventTargetNode->renderer()) {
+    if (m_eventTargetNode && m_eventTargetNode->layoutObject()) {
         FloatQuad border, unused;
-        if (buildNodeQuads(m_eventTargetNode->renderer(), &unused, &unused, &border, &unused))
+        if (buildNodeQuads(m_eventTargetNode->layoutObject(), &unused, &unused, &border, &unused))
             highlight.appendQuad(border, m_nodeHighlightConfig.eventTarget);
     }
 
-    if (m_highlightNode->isElementNode() && !m_omitTooltip && m_nodeHighlightConfig.showInfo && m_highlightNode->renderer() && m_highlightNode->document().frame())
+    if (m_highlightNode->isElementNode() && !m_omitTooltip && m_nodeHighlightConfig.showInfo && m_highlightNode->layoutObject() && m_highlightNode->document().frame())
         highlight.setElementInfo(buildElementInfo(toElement(m_highlightNode.get())));
 
     evaluateInOverlay("drawHighlight", highlight.asJSONObject());
 }
 
 void InspectorOverlay::drawQuadHighlight()
 {
     if (!m_highlightQuad)
         return;
 
@@ skipping 108 matching lines @@
 }
 
 void InspectorOverlay::onTimer(Timer<InspectorOverlay>*)
 {
     m_drawViewSize = false;
     update();
 }
 
 bool InspectorOverlay::getBoxModel(Node* node, RefPtr<TypeBuilder::DOM::BoxModel>& model)
 {
-    LayoutObject* renderer = node->renderer();
+    LayoutObject* renderer = node->layoutObject();
     FrameView* view = node->document().view();
     if (!renderer || !view)
         return false;
 
     FloatQuad content, padding, border, margin;
-    if (!buildNodeQuads(node->renderer(), &content, &padding, &border, &margin))
+    if (!buildNodeQuads(node->layoutObject(), &content, &padding, &border, &margin))
         return false;
 
     IntRect boundingBox = 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))
@@ skipping 48 matching lines @@
     hideHighlight();
 }
 
 void InspectorOverlay::startedRecordingProfile()
 {
     if (!m_activeProfilerCount++)
         freePage();
 }
 
 } // namespace blink