Rename renderer() to layoutObject().

Source/core/editing/htmlediting.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 297 matching lines @@
 
     if (editablePosition.deprecatedNode() && editablePosition.deprecatedNode() != highestRoot && !editablePosition.deprecatedNode()->isDescendantOf(highestRoot))
         return Position();
     return editablePosition;
 }
 
 // FIXME: The method name, comment, and code say three different things here!
 // Whether or not content before and after this node will collapse onto the same line as it.
 bool isBlock(const Node* node)
 {
-    return node && node->renderer() && !node->renderer()->isInline() && !node->renderer()->isRubyText();
+    return node && node->layoutObject() && !node->layoutObject()->isInline() && !node->layoutObject()->isRubyText();
 }
 
 bool isInline(const Node* node)
 {
-    return node && node->renderer() && node->renderer()->isInline();
+    return node && node->layoutObject() && node->layoutObject()->isInline();
 }
 
 // FIXME: Deploy this in all of the places where enclosingBlockFlow/enclosingBlockFlowOrTableElement are used.
 // FIXME: Pass a position to this function. The enclosing block of [table, x] for example, should be the
 // block that contains the table and not the table, and this function should be the only one responsible for
 // knowing about these kinds of special cases.
 Element* enclosingBlock(Node* node, EditingBoundaryCrossingRule rule)
 {
     Node* enclosingNode = enclosingNodeOfType(firstPositionInOrBeforeNode(node), isBlock, rule);
     return enclosingNode && enclosingNode->isElementNode() ? toElement(enclosingNode) : 0;
@@ skipping 14 matching lines @@
 bool inSameContainingBlockFlowElement(Node* a, Node* b)
 {
     return a && b && enclosingBlockFlowElement(*a) == enclosingBlockFlowElement(*b);
 }
 
 TextDirection directionOfEnclosingBlock(const Position& position)
 {
     Element* enclosingBlockElement = enclosingBlock(position.containerNode());
     if (!enclosingBlockElement)
         return LTR;
-    LayoutObject* renderer = enclosingBlockElement->renderer();
+    LayoutObject* renderer = enclosingBlockElement->layoutObject();
     return renderer ? renderer->style()->direction() : LTR;
 }
 
 // This method is used to create positions in the DOM. It returns the maximum valid offset
 // in a node. It returns 1 for some elements even though they do not have children, which
 // creates technically invalid DOM Positions. Be sure to call parentAnchoredEquivalent
 // on a Position before using it to create a DOM Range, or an exception will be thrown.
 int lastOffsetForEditing(const Node* node)
 {
     ASSERT(node);
@@ skipping 37 matching lines @@
         }
     }
 
     ASSERT(rebalancedString.length() == length);
 
     return rebalancedString.toString();
 }
 
 bool isTableStructureNode(const Node *node)
 {
-    LayoutObject* renderer = node->renderer();
+    LayoutObject* renderer = node->layoutObject();
     return (renderer && (renderer->isTableCell() || renderer->isTableRow() || renderer->isTableSection() || renderer->isLayoutTableCol()));
 }
 
 const String& nonBreakingSpaceString()
 {
     DEFINE_STATIC_LOCAL(String, nonBreakingSpaceString, (&noBreakSpace, 1));
     return nonBreakingSpaceString;
 }
 
 // FIXME: need to dump this
 static bool isSpecialHTMLElement(const Node& n)
 {
     if (!n.isHTMLElement())
         return false;
 
     if (n.isLink())
         return true;
 
-    LayoutObject* renderer = n.renderer();
+    LayoutObject* renderer = n.layoutObject();
     if (!renderer)
         return false;
 
     if (renderer->style()->display() == TABLE || renderer->style()->display() == INLINE_TABLE)
         return true;
 
     if (renderer->style()->isFloating())
         return true;
 
     return false;
@@ skipping 97 matching lines @@
     return VisiblePosition(positionInParentAfterNode(node));
 }
 
 bool isHTMLListElement(Node* n)
 {
     return (n && (isHTMLUListElement(*n) || isHTMLOListElement(*n) || isHTMLDListElement(*n)));
 }
 
 bool isListItem(const Node* n)
 {
-    return n && n->renderer() && n->renderer()->isListItem();
+    return n && n->layoutObject() && n->layoutObject()->isListItem();
 }
 
 Element* enclosingElementWithTag(const Position& p, const QualifiedName& tagName)
 {
     if (p.isNull())
         return 0;
 
     ContainerNode* root = highestEditableRoot(p);
     Element* ancestor = p.deprecatedNode()->isElementNode() ? toElement(p.deprecatedNode()) : p.deprecatedNode()->parentElement();
     for (; ancestor; ancestor = ancestor->parentElement()) {
@@ skipping 46 matching lines @@
     return highest;
 }
 
 static bool hasARenderedDescendant(Node* node, Node* excludedNode)
 {
     for (Node* n = node->firstChild(); n;) {
         if (n == excludedNode) {
             n = NodeTraversal::nextSkippingChildren(*n, node);
             continue;
         }
-        if (n->renderer())
+        if (n->layoutObject())
             return true;
         n = NodeTraversal::next(*n, node);
     }
     return false;
 }
 
 Node* highestNodeToRemoveInPruning(Node* node, Node* excludeNode)
 {
     Node* previousNode = nullptr;
     Element* rootEditableElement = node ? node->rootEditableElement() : nullptr;
     for (; node; node = node->parentNode()) {
-        if (LayoutObject* renderer = node->renderer()) {
+        if (LayoutObject* renderer = node->layoutObject()) {
             if (!renderer->canHaveChildren() || hasARenderedDescendant(node, previousNode) || rootEditableElement == node || excludeNode == node)
                 return previousNode;
         }
         previousNode = node;
     }
     return 0;
 }
 
 Element* enclosingTableCell(const Position& p)
 {
@@ skipping 94 matching lines @@
 
     return firstList->hasTagName(secondList->tagQName()) // make sure the list types match (ol vs. ul)
     && firstList->hasEditableStyle() && secondList->hasEditableStyle() // both lists are editable
     && firstList->rootEditableElement() == secondList->rootEditableElement() // don't cross editing boundaries
     && isVisiblyAdjacent(positionInParentAfterNode(*firstList), positionInParentBeforeNode(*secondList));
     // Make sure there is no visible content between this li and the previous list
 }
 
 bool isRenderedHTMLTableElement(const Node* node)
 {
-    return isHTMLTableElement(*node) && node->renderer();
+    return isHTMLTableElement(*node) && node->layoutObject();
 }
 
 bool isRenderedTableElement(const Node* node)
 {
     if (!node || !node->isElementNode())
         return false;
 
-    LayoutObject* renderer = node->renderer();
+    LayoutObject* renderer = node->layoutObject();
     return (renderer && renderer->isTable());
 }
 
 bool isTableCell(const Node* node)
 {
     ASSERT(node);
-    LayoutObject* r = node->renderer();
+    LayoutObject* r = node->layoutObject();
     return r ? r->isTableCell() : isHTMLTableCellElement(*node);
 }
 
 bool isEmptyTableCell(const Node* node)
 {
     // Returns true IFF the passed in node is one of:
     //   .) a table cell with no children,
     //   .) a table cell with a single BR child, and which has no other child renderers, including :before and :after renderers
     //   .) the BR child of such a table cell
 
     // Find rendered node
-    while (node && !node->renderer())
+    while (node && !node->layoutObject())
         node = node->parentNode();
     if (!node)
         return false;
 
     // Make sure the rendered node is a table cell or <br>.
     // If it's a <br>, then the parent node has to be a table cell.
-    LayoutObject* renderer = node->renderer();
+    LayoutObject* renderer = node->layoutObject();
     if (renderer->isBR()) {
         renderer = renderer->parent();
         if (!renderer)
             return false;
     }
     if (!renderer->isTableCell())
         return false;
 
     // Check that the table cell contains no child renderers except for perhaps a single <br>.
     LayoutObject* childRenderer = toLayoutTableCell(renderer)->firstChild();
@@ skipping 83 matching lines @@
     return createTabSpanElement(document, PassRefPtrWillBeRawPtr<Text>(nullptr));
 }
 
 PassRefPtrWillBeRawPtr<HTMLBRElement> createBlockPlaceholderElement(Document& document)
 {
     return toHTMLBRElement(document.createElement(brTag, false).get());
 }
 
 bool isNodeRendered(const Node& node)
 {
-    LayoutObject* renderer = node.renderer();
+    LayoutObject* renderer = node.layoutObject();
     if (!renderer)
         return false;
 
     return renderer->style()->visibility() == VISIBLE;
 }
 
 // return first preceding DOM position rendered at a different location, or "this"
 static Position previousCharacterPosition(const Position& position, EAffinity affinity)
 {
     if (position.isNull())
@@ skipping 104 matching lines @@
 {
     if (!node || !node->isHTMLElement())
         return false;
 
     const HTMLElement& element = toHTMLElement(*node);
     return element.hasTagName(blockquoteTag) && element.getAttribute("type") == "cite";
 }
 
 int caretMinOffset(const Node* n)
 {
-    LayoutObject* r = n->renderer();
+    LayoutObject* r = n->layoutObject();
     ASSERT(!n->isCharacterDataNode() || !r || r->isText()); // FIXME: This was a runtime check that seemingly couldn't fail; changed it to an assertion for now.
     return r ? r->caretMinOffset() : 0;
 }
 
 // If a node can contain candidates for VisiblePositions, return the offset of the last candidate, otherwise
 // return the number of children for container nodes and the length for unrendered text nodes.
 int caretMaxOffset(const Node* n)
 {
     // For rendered text nodes, return the last position that a caret could occupy.
-    if (n->isTextNode() && n->renderer())
-        return n->renderer()->caretMaxOffset();
+    if (n->isTextNode() && n->layoutObject())
+        return n->layoutObject()->caretMaxOffset();
     // For containers return the number of children. For others do the same as above.
     return lastOffsetForEditing(n);
 }
 
 bool lineBreakExistsAtVisiblePosition(const VisiblePosition& visiblePosition)
 {
     return lineBreakExistsAtPosition(visiblePosition.deepEquivalent().downstream());
 }
 
 bool lineBreakExistsAtPosition(const Position& position)
 {
     if (position.isNull())
         return false;
 
     if (isHTMLBRElement(*position.anchorNode()) && position.atFirstEditingPositionForNode())
         return true;
 
-    if (!position.anchorNode()->renderer())
+    if (!position.anchorNode()->layoutObject())
         return false;
 
-    if (!position.anchorNode()->isTextNode() || !position.anchorNode()->renderer()->style()->preserveNewline())
+    if (!position.anchorNode()->isTextNode() || !position.anchorNode()->layoutObject()->style()->preserveNewline())
         return false;
 
     Text* textNode = toText(position.anchorNode());
     unsigned offset = position.offsetInContainerNode();
     return offset < textNode->length() && textNode->data()[offset] == '\n';
 }
 
 // Modifies selections that have an end point at the edge of a table
 // that contains the other endpoint so that they don't confuse
 // code that iterates over selected paragraphs.
@@ skipping 75 matching lines @@
     if (endIsVisuallySame && comparePositions(selectedRange.startPosition(), positionInParentBeforeNode(node)) < 0)
         return true;
 
     return startIsVisuallySame && endIsVisuallySame;
 }
 
 bool isRenderedAsNonInlineTableImageOrHR(const Node* node)
 {
     if (!node)
         return false;
-    LayoutObject* renderer = node->renderer();
+    LayoutObject* renderer = node->layoutObject();
     return renderer && ((renderer->isTable() && !renderer->isInline()) || (renderer->isImage() && !renderer->isInline()) || renderer->isHR());
 }
 
 bool areIdenticalElements(const Node* first, const Node* second)
 {
     if (!first->isElementNode() || !second->isElementNode())
         return false;
 
     const Element* firstElement = toElement(first);
     const Element* secondElement = toElement(second);
@@ skipping 17 matching lines @@
         || element.hasTagName(xmpTag)
         || element.hasTagName(h1Tag)
         || element.hasTagName(h2Tag)
         || element.hasTagName(h3Tag)
         || element.hasTagName(h4Tag)
         || element.hasTagName(h5Tag);
 }
 
 bool isBlockFlowElement(const Node& node)
 {
-    LayoutObject* renderer = node.renderer();
+    LayoutObject* renderer = node.layoutObject();
     return node.isElementNode() && renderer && renderer->isLayoutBlockFlow();
 }
 
 Position adjustedSelectionStartForStyleComputation(const VisibleSelection& selection)
 {
     // This function is used by range style computations to avoid bugs like:
     // <rdar://problem/4017641> REGRESSION (Mail): you can only bold/unbold a selection starting from end of line once
     // It is important to skip certain irrelevant content at the start of the selection, so we do not wind up
     // with a spurious "mixed" style.
 
     VisiblePosition visiblePosition(selection.start());
     if (visiblePosition.isNull())
         return Position();
 
     // if the selection is a caret, just return the position, since the style
     // behind us is relevant
     if (selection.isCaret())
         return visiblePosition.deepEquivalent();
 
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
         return visiblePosition.next().deepEquivalent().downstream();
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
     return visiblePosition.deepEquivalent().downstream();
 }
 
 } // namespace blink