Rename renderer() to layoutObject().

Source/core/page/TouchAdjustment.cpp

 /*
  * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 88 matching lines @@
             return true;
     }
     return false;
 }
 
 bool nodeIsZoomTarget(Node* node)
 {
     if (node->isTextNode() || node->isShadowRoot())
         return false;
 
-    ASSERT(node->renderer());
-    return node->renderer()->isBox();
+    ASSERT(node->layoutObject());
+    return node->layoutObject()->isBox();
 }
 
 bool providesContextMenuItems(Node* node)
 {
     // This function tries to match the nodes that receive special context-menu items in
     // ContextMenuController::populate(), and should be kept uptodate with those.
-    ASSERT(node->renderer() || node->isShadowRoot());
-    if (!node->renderer())
+    ASSERT(node->layoutObject() || node->isShadowRoot());
+    if (!node->layoutObject())
         return false;
     if (node->isContentEditable())
         return true;
     if (node->isLink())
         return true;
-    if (node->renderer()->isImage())
+    if (node->layoutObject()->isImage())
         return true;
-    if (node->renderer()->isMedia())
+    if (node->layoutObject()->isMedia())
         return true;
-    if (node->renderer()->canBeSelectionLeaf()) {
+    if (node->layoutObject()->canBeSelectionLeaf()) {
         // If the context menu gesture will trigger a selection all selectable nodes are valid targets.
-        if (node->renderer()->frame()->editor().behavior().shouldSelectOnContextualMenuClick())
+        if (node->layoutObject()->frame()->editor().behavior().shouldSelectOnContextualMenuClick())
             return true;
         // Only the selected part of the renderer is a valid target, but this will be corrected in
         // appendContextSubtargetsForNode.
-        if (node->renderer()->selectionState() != LayoutObject::SelectionNone)
+        if (node->layoutObject()->selectionState() != LayoutObject::SelectionNone)
             return true;
     }
     return false;
 }
 
 static inline void appendQuadsToSubtargetList(Vector<FloatQuad>& quads, Node* node, SubtargetGeometryList& subtargets)
 {
     Vector<FloatQuad>::const_iterator it = quads.begin();
     const Vector<FloatQuad>::const_iterator end = quads.end();
     for (; it != end; ++it)
         subtargets.append(SubtargetGeometry(node, *it));
 }
 
 static inline void appendBasicSubtargetsForNode(Node* node, SubtargetGeometryList& subtargets)
 {
     // Node guaranteed to have renderer due to check in node filter.
-    ASSERT(node->renderer());
+    ASSERT(node->layoutObject());
 
     Vector<FloatQuad> quads;
-    node->renderer()->absoluteQuads(quads);
+    node->layoutObject()->absoluteQuads(quads);
 
     appendQuadsToSubtargetList(quads, node, subtargets);
 }
 
 static inline void appendContextSubtargetsForNode(Node* node, SubtargetGeometryList& subtargets)
 {
     // This is a variant of appendBasicSubtargetsForNode that adds special subtargets for
     // selected or auto-selectable parts of text nodes.
-    ASSERT(node->renderer());
+    ASSERT(node->layoutObject());
 
     if (!node->isTextNode())
         return appendBasicSubtargetsForNode(node, subtargets);
 
     Text* textNode = toText(node);
-    LayoutText* textRenderer = textNode->renderer();
+    LayoutText* textRenderer = textNode->layoutObject();
 
     if (textRenderer->frame()->editor().behavior().shouldSelectOnContextualMenuClick()) {
         // Make subtargets out of every word.
         String textValue = textNode->data();
         TextBreakIterator* wordIterator = wordBreakIterator(textValue, 0, textValue.length());
         int lastOffset = wordIterator->first();
         if (lastOffset == -1)
             return;
         int offset;
         while ((offset = wordIterator->next()) != -1) {
@@ skipping 30 matching lines @@
             return;
         }
         Vector<FloatQuad> quads;
         textRenderer->absoluteQuadsForRange(quads, startPos, endPos);
         appendQuadsToSubtargetList(quads, textNode, subtargets);
     }
 }
 
 static inline void appendZoomableSubtargets(Node* node, SubtargetGeometryList& subtargets)
 {
-    LayoutBox* renderer = toLayoutBox(node->renderer());
+    LayoutBox* renderer = toLayoutBox(node->layoutObject());
     ASSERT(renderer);
 
     Vector<FloatQuad> quads;
     FloatRect borderBoxRect = renderer->borderBoxRect();
     FloatRect contentBoxRect = renderer->contentBoxRect();
     quads.append(renderer->localToAbsoluteQuad(borderBoxRect));
     if (borderBoxRect != contentBoxRect)
         quads.append(renderer->localToAbsoluteQuad(contentBoxRect));
     // FIXME: For LayoutBlocks, add column boxes and content boxes cleared for floats.
 
@@ skipping 276 matching lines @@
 
 bool findBestZoomableArea(Node*& targetNode, IntRect& targetArea, const IntPoint& touchHotspot, const IntRect& touchArea, const WillBeHeapVector<RefPtrWillBeMember<Node>>& nodes)
 {
     IntPoint targetPoint;
     TouchAdjustment::SubtargetGeometryList subtargets;
     TouchAdjustment::compileZoomableSubtargets(nodes, subtargets);
     return TouchAdjustment::findNodeWithLowestDistanceMetric(targetNode, targetPoint, targetArea, touchHotspot, touchArea, subtargets, TouchAdjustment::zoomableIntersectionQuotient);
 }
 
 } // namespace blink