Rename renderer() to layoutObject().

Source/core/dom/Position.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2009 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 36 matching lines @@
 #include "wtf/unicode/CharacterNames.h"
 #include <stdio.h>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static Node* nextRenderedEditable(Node* node)
 {
     for (node = node->nextLeafNode(); node; node = node->nextLeafNode()) {
-        LayoutObject* renderer = node->renderer();
+        LayoutObject* renderer = node->layoutObject();

[Julien - ping for review, 2015/03/05 16:19:16]

Ditto.

         if (!renderer)
             continue;
         if (!node->hasEditableStyle())
             continue;
         if ((renderer->isBox() && toLayoutBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toLayoutText(renderer)->firstTextBox()))
             return node;
     }
     return 0;
 }
 
 static Node* previousRenderedEditable(Node* node)
 {
     for (node = node->previousLeafNode(); node; node = node->previousLeafNode()) {
-        LayoutObject* renderer = node->renderer();
+        LayoutObject* renderer = node->layoutObject();

[Julien - ping for review, 2015/03/05 16:19:16]

Ditto (tired of repeating this so no more ditto).

         if (!renderer)
             continue;
         if (!node->hasEditableStyle())
             continue;
         if ((renderer->isBox() && toLayoutBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toLayoutText(renderer)->firstTextBox()))
             return node;
     }
     return 0;
 }
 
@@ skipping 275 matching lines @@
         return createLegacyEditingPosition(node, (moveType == Character) ? uncheckedNextOffset(node, offset) : offset + 1);
     }
 
     if (ContainerNode* parent = node->parentNode())
         return createLegacyEditingPosition(parent, node->nodeIndex() + 1);
     return *this;
 }
 
 int Position::uncheckedPreviousOffset(const Node* n, int current)
 {
-    return n->renderer() ? n->renderer()->previousOffset(current) : current - 1;
+    return n->layoutObject() ? n->layoutObject()->previousOffset(current) : current - 1;
 }
 
 int Position::uncheckedPreviousOffsetForBackwardDeletion(const Node* n, int current)
 {
-    return n->renderer() ? n->renderer()->previousOffsetForBackwardDeletion(current) : current - 1;
+    return n->layoutObject() ? n->layoutObject()->previousOffsetForBackwardDeletion(current) : current - 1;
 }
 
 int Position::uncheckedNextOffset(const Node* n, int current)
 {
-    return n->renderer() ? n->renderer()->nextOffset(current) : current + 1;
+    return n->layoutObject() ? n->layoutObject()->nextOffset(current) : current + 1;
 }
 
 bool Position::atFirstEditingPositionForNode() const
 {
     if (isNull())
         return true;
     // FIXME: Position before anchor shouldn't be considered as at the first editing position for node
     // since that position resides outside of the node.
     switch (m_anchorType) {
     case PositionIsOffsetInAnchor:
@@ skipping 68 matching lines @@
     if (isNull())
         return true;
     return !deprecatedNode()->parentNode() && m_offset >= lastOffsetForEditing(deprecatedNode());
 }
 
 int Position::renderedOffset() const
 {
     if (!deprecatedNode()->isTextNode())
         return m_offset;
 
-    if (!deprecatedNode()->renderer())
+    if (!deprecatedNode()->layoutObject())
         return m_offset;
 
     int result = 0;
-    LayoutText* textRenderer = toLayoutText(deprecatedNode()->renderer());
+    LayoutText* textRenderer = toLayoutText(deprecatedNode()->layoutObject());
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         int start = box->start();
         int end = box->start() + box->len();
         if (m_offset < start)
             return result;
         if (m_offset <= end) {
             result += m_offset - start;
             return result;
         }
         result += box->len();
     }
     return result;
 }
 
 // Whether or not [node, 0] and [node, lastOffsetForEditing(node)] are their own VisiblePositions.
 // If true, adjacent candidates are visually distinct.
 // FIXME: Disregard nodes with renderers that have no height, as we do in isCandidate.
 // FIXME: Share code with isCandidate, if possible.
 static bool endsOfNodeAreVisuallyDistinctPositions(Node* node)
 {
-    if (!node || !node->renderer())
+    if (!node || !node->layoutObject())
         return false;
 
-    if (!node->renderer()->isInline())
+    if (!node->layoutObject()->isInline())
         return true;
 
     // Don't include inline tables.
     if (isHTMLTableElement(*node))
         return false;
 
     // A Marquee elements are moving so we should assume their ends are always
     // visibily distinct.
     if (isHTMLMarqueeElement(*node))
         return true;
 
     // There is a VisiblePosition inside an empty inline-block container.
-    return node->renderer()->isReplaced() && canHaveChildrenForEditing(node) && toLayoutBox(node->renderer())->size().height() != 0 && !node->hasChildren();
+    return node->layoutObject()->isReplaced() && canHaveChildrenForEditing(node) && toLayoutBox(node->layoutObject())->size().height() != 0 && !node->hasChildren();
 }
 
 static Node* enclosingVisualBoundary(Node* node)
 {
     while (node && !endsOfNodeAreVisuallyDistinctPositions(node))
         node = node->parentNode();
 
     return node;
 }
 
@@ skipping 45 matching lines @@
             }
             lastNode = currentNode;
         }
 
         // If we've moved to a position that is visually distinct, return the last saved position. There
         // is code below that terminates early if we're *about* to move to a visually distinct position.
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
             return lastVisible;
 
         // skip position in unrendered or invisible node
-        LayoutObject* renderer = currentNode->renderer();
+        LayoutObject* renderer = currentNode->layoutObject();
         if (!renderer || renderer->style()->visibility() != VISIBLE)
             continue;
 
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer(currentPos))
@@ skipping 37 matching lines @@
 
                 // The text continues on the next line only if the last text box is not on this line and
                 // none of the boxes on this line have a larger start offset.
 
                 bool continuesOnNextLine = true;
                 InlineBox* otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->nextLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (otherBox->renderer() == textRenderer && toInlineTextBox(otherBox)->start() > textOffset))
+                    if (otherBox == lastTextBox || (otherBox->layoutObject() == textRenderer && toInlineTextBox(otherBox)->start() > textOffset))
                         continuesOnNextLine = false;
                 }
 
                 otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->prevLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (otherBox->renderer() == textRenderer && toInlineTextBox(otherBox)->start() > textOffset))
+                    if (otherBox == lastTextBox || (otherBox->layoutObject() == textRenderer && toInlineTextBox(otherBox)->start() > textOffset))
                         continuesOnNextLine = false;
                 }
 
                 if (continuesOnNextLine)
                     return currentPos;
             }
         }
     }
 
     return lastVisible;
@@ skipping 45 matching lines @@
         // Do not move to a visually distinct position.
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
             return lastVisible;
         // Do not move past a visually disinct position.
         // Note: The first position after the last in a node whose ends are visually distinct
         // positions will be [boundary->parentNode(), originalBlock->nodeIndex() + 1].
         if (boundary && boundary->parentNode() == currentNode)
             return lastVisible;
 
         // skip position in unrendered or invisible node
-        LayoutObject* renderer = currentNode->renderer();
+        LayoutObject* renderer = currentNode->layoutObject();
         if (!renderer || renderer->style()->visibility() != VISIBLE)
             continue;
 
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer(currentPos))
@@ skipping 28 matching lines @@
 
                 // The text continues on the next line only if the last text box is not on this line and
                 // none of the boxes on this line have a larger start offset.
 
                 bool continuesOnNextLine = true;
                 InlineBox* otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->nextLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (otherBox->renderer() == textRenderer && toInlineTextBox(otherBox)->start() >= textOffset))
+                    if (otherBox == lastTextBox || (otherBox->layoutObject() == textRenderer && toInlineTextBox(otherBox)->start() >= textOffset))
                         continuesOnNextLine = false;
                 }
 
                 otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->prevLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (otherBox->renderer() == textRenderer && toInlineTextBox(otherBox)->start() >= textOffset))
+                    if (otherBox == lastTextBox || (otherBox->layoutObject() == textRenderer && toInlineTextBox(otherBox)->start() >= textOffset))
                         continuesOnNextLine = false;
                 }
 
                 if (continuesOnNextLine)
                     return currentPos;
             }
         }
     }
 
     return lastVisible;
@@ skipping 12 matching lines @@
             if ((o->isText() && boundingBoxLogicalHeight(o, toLayoutText(o)->linesBoundingBox()))
                 || (o->isBox() && toLayoutBox(o)->pixelSnappedLogicalHeight())
                 || (o->isLayoutInline() && isEmptyInline(o) && boundingBoxLogicalHeight(o, toLayoutInline(o)->linesBoundingBox())))
                 return true;
         }
     return false;
 }
 
 bool Position::nodeIsUserSelectNone(Node* node)
 {
-    return node && node->renderer() && !node->renderer()->isSelectable();
+    return node && node->layoutObject() && !node->layoutObject()->isSelectable();
 }
 
 bool Position::nodeIsUserSelectAll(const Node* node)
 {
-    return RuntimeEnabledFeatures::userSelectAllEnabled() && node && node->renderer() && node->renderer()->style()->userSelect() == SELECT_ALL;
+    return RuntimeEnabledFeatures::userSelectAllEnabled() && node && node->layoutObject() && node->layoutObject()->style()->userSelect() == SELECT_ALL;
 }
 
 Node* Position::rootUserSelectAllForNode(Node* node)
 {
     if (!node || !nodeIsUserSelectAll(node))
         return 0;
     Node* parent = node->parentNode();
     if (!parent)
         return node;
 
     Node* candidateRoot = node;
     while (parent) {
-        if (!parent->renderer()) {
+        if (!parent->layoutObject()) {
             parent = parent->parentNode();
             continue;
         }
         if (!nodeIsUserSelectAll(parent))
             break;
         candidateRoot = parent;
         parent = candidateRoot->parentNode();
     }
     return candidateRoot;
 }
 
 bool Position::isCandidate() const
 {
     if (isNull())
         return false;
 
-    LayoutObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->layoutObject();
     if (!renderer)
         return false;
 
     if (renderer->style()->visibility() != VISIBLE)
         return false;
 
     if (renderer->isBR())
         // FIXME: The condition should be m_anchorType == PositionIsBeforeAnchor, but for now we still need to support legacy positions.
         return !m_offset && m_anchorType != PositionIsAfterAnchor && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
 
@@ skipping 25 matching lines @@
     }
 
     return false;
 }
 
 bool Position::inRenderedText() const
 {
     if (isNull() || !deprecatedNode()->isTextNode())
         return false;
 
-    LayoutObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->layoutObject();
     if (!renderer)
         return false;
 
     LayoutText* textRenderer = toLayoutText(renderer);
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not rendered. Return false.
             return false;
         }
         if (box->containsCaretOffset(m_offset))
             // Return false for offsets inside composed characters.
             return m_offset == 0 || m_offset == textRenderer->nextOffset(textRenderer->previousOffset(m_offset));
     }
 
     return false;
 }
 
 bool Position::isRenderedCharacter() const
 {
     if (isNull() || !deprecatedNode()->isTextNode())
         return false;
 
-    LayoutObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->layoutObject();
     if (!renderer)
         return false;
 
     LayoutText* textRenderer = toLayoutText(renderer);
     for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not rendered. Return false.
             return false;
         }
         if (m_offset >= static_cast<int>(box->start()) && m_offset < static_cast<int>(box->start() + box->len()))
             return true;
     }
 
     return false;
 }
 
 bool Position::rendersInDifferentPosition(const Position &pos) const
 {
     if (isNull() || pos.isNull())
         return false;
 
-    LayoutObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->layoutObject();
     if (!renderer)
         return false;
 
-    LayoutObject* posRenderer = pos.deprecatedNode()->renderer();
+    LayoutObject* posRenderer = pos.deprecatedNode()->layoutObject();
     if (!posRenderer)
         return false;
 
     if (renderer->style()->visibility() != VISIBLE ||
         posRenderer->style()->visibility() != VISIBLE)
         return false;
 
     if (deprecatedNode() == pos.deprecatedNode()) {
         if (isHTMLBRElement(*deprecatedNode()))
             return false;
@@ skipping 120 matching lines @@
     while (position != lastPosition) {
         lastPosition = position;
         position = position.upstream(CanCrossEditingBoundary);
     }
     return position;
 }
 
 void Position::getInlineBoxAndOffset(EAffinity affinity, TextDirection primaryDirection, InlineBox*& inlineBox, int& caretOffset) const
 {
     caretOffset = deprecatedEditingOffset();
-    LayoutObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->layoutObject();
 
     if (!renderer->isText()) {
         inlineBox = 0;
         if (canHaveChildrenForEditing(deprecatedNode()) && renderer->isLayoutBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(renderer)) {
             // Try a visually equivalent position with possibly opposite editability. This helps in case |this| is in
             // an editable block but surrounded by non-editable positions. It acts to negate the logic at the beginning
             // of LayoutObject::createVisiblePosition().
             Position equivalent = downstreamIgnoringEditingBoundaries(*this);
             if (equivalent == *this) {
                 equivalent = upstreamIgnoringEditingBoundaries(*this);
@@ skipping 135 matching lines @@
                 inlineBox = tertiaryBox;
             }
             caretOffset = inlineBox->caretRightmostOffset();
         }
     }
 }
 
 TextDirection Position::primaryDirection() const
 {
     TextDirection primaryDirection = LTR;
-    for (const LayoutObject* r = m_anchorNode->renderer(); r; r = r->parent()) {
+    for (const LayoutObject* r = m_anchorNode->layoutObject(); r; r = r->parent()) {
         if (r->isLayoutBlockFlow()) {
             primaryDirection = r->style()->direction();
             break;
         }
     }
 
     return primaryDirection;
 }
 
 DEFINE_TRACE(Position)
@@ skipping 74 matching lines @@
     pos.showTreeForThis();
 }
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
 }
 
 #endif