Rename renderer() to layoutObject().

Source/core/editing/iterators/TextIterator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * 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 185 matching lines @@
 
 TextIterator::~TextIterator()
 {
 }
 
 bool TextIterator::isInsideReplacedElement() const
 {
     if (atEnd() || length() != 1 || !m_node)
         return false;
 
-    LayoutObject* renderer = m_node->renderer();
+    LayoutObject* renderer = m_node->layoutObject();
     return renderer && renderer->isReplaced();
 }
 
 void TextIterator::advance()
 {
     if (m_shouldStop)
         return;
 
     ASSERT(!m_node || !m_node->document().needsRenderTreeUpdate());
 
@@ skipping 35 matching lines @@
         // if the range ends at offset 0 of an element, represent the
         // position, but not the content, of that element e.g. if the
         // node is a blockflow element, emit a newline that
         // precedes the element
         if (m_node == m_endContainer && !m_endOffset) {
             representNodeOffsetZero();
             m_node = nullptr;
             return;
         }
 
-        LayoutObject* renderer = m_node->renderer();
+        LayoutObject* renderer = m_node->layoutObject();
         if (!renderer) {
             if (m_node->isShadowRoot()) {
                 // A shadow root doesn't have a renderer, but we want to visit children anyway.
                 m_iterationProgress = m_iterationProgress < HandledNode ? HandledNode : m_iterationProgress;
             } else {
                 m_iterationProgress = HandledChildren;
             }
         } else {
             // Enter author shadow roots, from youngest, if any and if necessary.
             if (m_iterationProgress < HandledOpenShadowRoots) {
@@ skipping 56 matching lines @@
         if (!next) {
             // 2. If we've already iterated children or they are not available, go to the next sibling node.
             next = m_node->nextSibling();
             if (!next) {
                 // 3. If we are at the last child, go up the node tree until we find a next sibling.
                 bool pastEnd = NodeTraversal::next(*m_node) == m_pastEndNode;
                 ContainerNode* parentNode = m_node->parentNode();
                 while (!next && parentNode) {
                     if ((pastEnd && parentNode == m_endContainer) || m_endContainer->isDescendantOf(parentNode))
                         return;
-                    bool haveRenderer = m_node->renderer();
+                    bool haveRenderer = m_node->layoutObject();
                     m_node = parentNode;
                     m_fullyClippedStack.pop();
                     parentNode = m_node->parentNode();
                     if (haveRenderer)
                         exitNode();
                     if (m_positionNode) {
                         m_iterationProgress = HandledChildren;
                         return;
                     }
                     next = m_node->nextSibling();
@@ skipping 89 matching lines @@
         builder.append(string(), positionStartOffset() + position, lengthToAppend);
     }
 }
 
 bool TextIterator::handleTextNode()
 {
     if (m_fullyClippedStack.top() && !m_ignoresStyleVisibility)
         return false;
 
     Text* textNode = toText(m_node);
-    LayoutText* renderer = textNode->renderer();
+    LayoutText* renderer = textNode->layoutObject();
 
     m_lastTextNode = textNode;
     String str = renderer->text();
 
     // handle pre-formatted text
     if (!renderer->style()->collapseWhiteSpace()) {
         int runStart = m_offset;
         if (m_lastTextNodeEndedWithCollapsedSpace && hasVisibleTextNode(renderer)) {
             emitCharacter(space, textNode, 0, runStart, runStart);
             return false;
@@ skipping 10 matching lines @@
         }
         if (renderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
             return false;
         int strLength = str.length();
         int end = (textNode == m_endContainer) ? m_endOffset : INT_MAX;
         int runEnd = std::min(strLength, end);
 
         if (runStart >= runEnd)
             return true;
 
-        emitText(textNode, textNode->renderer(), runStart, runEnd);
+        emitText(textNode, textNode->layoutObject(), runStart, runEnd);
         return true;
     }
 
     if (renderer->firstTextBox())
         m_textBox = renderer->firstTextBox();
 
     bool shouldHandleFirstLetter = !m_handledFirstLetter && renderer->isTextFragment() && !m_offset;
     if (shouldHandleFirstLetter)
         handleTextNodeFirstLetter(toLayoutTextFragment(renderer));
 
@@ skipping 17 matching lines @@
         m_sortedTextBoxesPosition = 0;
         m_textBox = m_sortedTextBoxes.isEmpty() ? 0 : m_sortedTextBoxes[0];
     }
 
     handleTextBox();
     return true;
 }
 
 void TextIterator::handleTextBox()
 {
-    LayoutText* renderer = m_firstLetterText ? m_firstLetterText.get() : toLayoutText(m_node->renderer());
+    LayoutText* renderer = m_firstLetterText ? m_firstLetterText.get() : toLayoutText(m_node->layoutObject());
 
     if (renderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility) {
         m_textBox = 0;
     } else {
         String str = renderer->text();
         unsigned start = m_offset;
         unsigned end = (m_node == m_endContainer) ? static_cast<unsigned>(m_endOffset) : INT_MAX;
         while (m_textBox) {
             unsigned textBoxStart = m_textBox->start();
             unsigned runStart = std::max(textBoxStart, start);
@@ skipping 23 matching lines @@
                     nextTextBox = m_sortedTextBoxes[m_sortedTextBoxesPosition + 1];
             } else {
                 nextTextBox = m_textBox->nextTextBox();
             }
 
             // FIXME: Based on the outcome of crbug.com/446502 it's possible we can
             //   remove this block. The reason we new it now is because BIDI and
             //   FirstLetter seem to have different ideas of where things can split.
             //   FirstLetter takes the punctuation + first letter, and BIDI will
             //   split out the punctuation and possibly reorder it.
-            if (nextTextBox && nextTextBox->renderer() != renderer) {
+            if (nextTextBox && nextTextBox->layoutObject() != renderer) {
                 m_textBox = 0;
                 return;
             }
-            ASSERT(!nextTextBox || nextTextBox->renderer() == renderer);
+            ASSERT(!nextTextBox || nextTextBox->layoutObject() == renderer);
 
             if (runStart < runEnd) {
                 // Handle either a single newline character (which becomes a space),
                 // or a run of characters that does not include a newline.
                 // This effectively translates newlines to spaces without copying the text.
                 if (str[runStart] == '\n') {
                     emitCharacter(space, m_node, 0, runStart, runStart + 1);
                     m_offset = runStart + 1;
                 } else {
                     size_t subrunEnd = str.find('\n', runStart);
@@ skipping 39 matching lines @@
 {
     m_handledFirstLetter = true;
 
     if (!renderer->isRemainingTextRenderer())
         return;
 
     FirstLetterPseudoElement* firstLetterElement = renderer->firstLetterPseudoElement();
     if (!firstLetterElement)
         return;
 
-    LayoutObject* pseudoRenderer = firstLetterElement->renderer();
+    LayoutObject* pseudoRenderer = firstLetterElement->layoutObject();
     if (pseudoRenderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
         return;
 
     LayoutObject* firstLetter = pseudoRenderer->slowFirstChild();
     ASSERT(firstLetter);
 
     m_remainingTextBox = m_textBox;
     m_textBox = toLayoutText(firstLetter)->firstTextBox();
     m_sortedTextBoxes.clear();
     m_firstLetterText = toLayoutText(firstLetter);
@@ skipping 11 matching lines @@
     if (isHTMLInputElement(toHTMLElement(*m_node)) && toHTMLInputElement(*m_node).isImage())
         return true;
     return false;
 }
 
 bool TextIterator::handleReplacedElement()
 {
     if (m_fullyClippedStack.top())
         return false;
 
-    LayoutObject* renderer = m_node->renderer();
+    LayoutObject* renderer = m_node->layoutObject();
     if (renderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
         return false;
 
     if (m_emitsObjectReplacementCharacter) {
         emitCharacter(objectReplacementCharacter, m_node->parentNode(), m_node, 0, 1);
         return true;
     }
 
     if (m_lastTextNodeEndedWithCollapsedSpace) {
         emitCharacter(space, m_lastTextNode->parentNode(), m_lastTextNode, 1, 1);
@@ skipping 42 matching lines @@
         return true;
 
     if (!renderer->isTextFragment())
         return false;
 
     LayoutTextFragment* fragment = toLayoutTextFragment(renderer);
     if (!fragment->isRemainingTextRenderer())
         return false;
 
     ASSERT(fragment->firstLetterPseudoElement());
-    LayoutObject* pseudoElementRenderer = fragment->firstLetterPseudoElement()->renderer();
+    LayoutObject* pseudoElementRenderer = fragment->firstLetterPseudoElement()->layoutObject();
     return pseudoElementRenderer && pseudoElementRenderer->style()->visibility() == VISIBLE;
 }
 
 bool TextIterator::shouldEmitTabBeforeNode(Node* node)
 {
-    LayoutObject* r = node->renderer();
+    LayoutObject* r = node->layoutObject();
 
     // Table cells are delimited by tabs.
     if (!r || !isTableCell(node))
         return false;
 
     // Want a tab before every cell other than the first one
     LayoutTableCell* rc = toLayoutTableCell(r);
     LayoutTable* t = rc->table();
     return t && (t->cellBefore(rc) || t->cellAbove(rc));
 }
 
 bool TextIterator::shouldEmitNewlineForNode(Node* node, bool emitsOriginalText)
 {
-    LayoutObject* renderer = node->renderer();
+    LayoutObject* renderer = node->layoutObject();
 
     if (renderer ? !renderer->isBR() : !isHTMLBRElement(node))
         return false;
     return emitsOriginalText || !(node->isInShadowTree() && isHTMLInputElement(*node->shadowHost()));
 }
 
 static bool shouldEmitNewlinesBeforeAndAfterNode(Node& node)
 {
     // Block flow (versus inline flow) is represented by having
     // a newline both before and after the element.
-    LayoutObject* r = node.renderer();
+    LayoutObject* r = node.layoutObject();
     if (!r) {
         return (node.hasTagName(blockquoteTag)
             || node.hasTagName(ddTag)
             || node.hasTagName(divTag)
             || node.hasTagName(dlTag)
             || node.hasTagName(dtTag)
             || node.hasTagName(h1Tag)
             || node.hasTagName(h2Tag)
             || node.hasTagName(h3Tag)
             || node.hasTagName(h4Tag)
@@ skipping 34 matching lines @@
 bool TextIterator::shouldEmitNewlineAfterNode(Node& node)
 {
     // FIXME: It should be better but slower to create a VisiblePosition here.
     if (!shouldEmitNewlinesBeforeAndAfterNode(node))
         return false;
     // Check if this is the very last renderer in the document.
     // If so, then we should not emit a newline.
     Node* next = &node;
     do {
         next = NodeTraversal::nextSkippingChildren(*next);
-        if (next && next->renderer())
+        if (next && next->layoutObject())
             return true;
     } while (next);
     return false;
 }
 
 bool TextIterator::shouldEmitNewlineBeforeNode(Node& node)
 {
     return shouldEmitNewlinesBeforeAndAfterNode(node);
 }
 
 static bool shouldEmitExtraNewlineForNode(Node* node)
 {
     // When there is a significant collapsed bottom margin, emit an extra
     // newline for a more realistic result. We end up getting the right
     // result even without margin collapsing. For example: <div><p>text</p></div>
     // will work right even if both the <div> and the <p> have bottom margins.
-    LayoutObject* r = node->renderer();
+    LayoutObject* r = node->layoutObject();
     if (!r || !r->isBox())
         return false;
 
     // NOTE: We only do this for a select set of nodes, and fwiw WinIE appears
     // not to do this at all
     if (node->hasTagName(h1Tag)
         || node->hasTagName(h2Tag)
         || node->hasTagName(h3Tag)
         || node->hasTagName(h4Tag)
         || node->hasTagName(h5Tag)
@@ skipping 48 matching lines @@
     // emit after a preceding block. We chose not to emit (m_hasEmitted is false),
     // so don't second guess that now.
     // NOTE: Is this really correct when m_node is not a leftmost descendant? Probably
     // immaterial since we likely would have already emitted something by now.
     if (!m_startOffset)
         return false;
 
     // If this node is unrendered or invisible the VisiblePosition checks below won't have much meaning.
     // Additionally, if the range we are iterating over contains huge sections of unrendered content,
     // we would create VisiblePositions on every call to this function without this check.
-    if (!m_node->renderer() || m_node->renderer()->style()->visibility() != VISIBLE
-        || (m_node->renderer()->isLayoutBlockFlow() && !toLayoutBlock(m_node->renderer())->size().height() && !isHTMLBodyElement(*m_node)))
+    if (!m_node->layoutObject() || m_node->layoutObject()->style()->visibility() != VISIBLE
+        || (m_node->layoutObject()->isLayoutBlockFlow() && !toLayoutBlock(m_node->layoutObject())->size().height() && !isHTMLBodyElement(*m_node)))
         return false;
 
     // The startPos.isNotNull() check is needed because the start could be before the body,
     // and in that case we'll get null. We don't want to put in newlines at the start in that case.
     // The currPos.isNotNull() check is needed because positions in non-HTML content
     // (like SVG) do not have visible positions, and we don't want to emit for them either.
     VisiblePosition startPos = VisiblePosition(Position(m_startContainer, m_startOffset, Position::PositionIsOffsetInAnchor), DOWNSTREAM);
     VisiblePosition currPos = VisiblePosition(positionBeforeNode(m_node), DOWNSTREAM);
     return startPos.isNotNull() && currPos.isNotNull() && !inSameLine(startPos, currPos);
 }
 
 bool TextIterator::shouldEmitSpaceBeforeAndAfterNode(Node* node)
 {
-    return isRenderedTableElement(node) && (node->renderer()->isInline() || m_emitsCharactersBetweenAllVisiblePositions);
+    return isRenderedTableElement(node) && (node->layoutObject()->isInline() || m_emitsCharactersBetweenAllVisiblePositions);
 }
 
 void TextIterator::representNodeOffsetZero()
 {
     // Emit a character to show the positioning of m_node.
 
     // When we haven't been emitting any characters, shouldRepresentNodeOffsetZero() can
     // create VisiblePositions, which is expensive. So, we perform the inexpensive checks
     // on m_node to see if it necessitates emitting a character first and will early return
     // before encountering shouldRepresentNodeOffsetZero()s worse case behavior.
     if (shouldEmitTabBeforeNode(m_node)) {
         if (shouldRepresentNodeOffsetZero())
             emitCharacter('\t', m_node->parentNode(), m_node, 0, 0);
     } else if (shouldEmitNewlineBeforeNode(*m_node)) {
         if (shouldRepresentNodeOffsetZero())
             emitCharacter('\n', m_node->parentNode(), m_node, 0, 0);
     } else if (shouldEmitSpaceBeforeAndAfterNode(m_node)) {
         if (shouldRepresentNodeOffsetZero())
             emitCharacter(space, m_node->parentNode(), m_node, 0, 0);
     }
 }
 
 bool TextIterator::handleNonTextNode()
 {
     if (shouldEmitNewlineForNode(m_node, m_emitsOriginalText))
         emitCharacter('\n', m_node->parentNode(), m_node, 0, 1);
-    else if (m_emitsCharactersBetweenAllVisiblePositions && m_node->renderer() && m_node->renderer()->isHR())
+    else if (m_emitsCharactersBetweenAllVisiblePositions && m_node->layoutObject() && m_node->layoutObject()->isHR())
         emitCharacter(space, m_node->parentNode(), m_node, 0, 1);
     else
         representNodeOffsetZero();
 
     return true;
 }
 
 void TextIterator::flushPositionOffsets() const
 {
     if (!m_positionOffsetBaseNode)
@@ skipping 231 matching lines @@
     return createPlainText(it);
 }
 
 String plainText(const Position& start, const Position& end, TextIteratorBehaviorFlags behavior)
 {
     TextIterator it(start, end, behavior);
     return createPlainText(it);
 }
 
 }