Rename renderer() to layoutObject().

Source/core/editing/iterators/SimplifiedBackwardsTextIterator.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 34 matching lines @@
             return i - textEnd;
     }
 
     return length - textEnd;
 }
 
 static int maxOffsetIncludingCollapsedSpaces(Node* node)
 {
     int offset = caretMaxOffset(node);
 
-    if (node->renderer() && node->renderer()->isText())
-        offset += collapsedSpaceLength(toLayoutText(node->renderer()), offset);
+    if (node->layoutObject() && node->layoutObject()->isText())
+        offset += collapsedSpaceLength(toLayoutText(node->layoutObject()), offset);
 
     return offset;
 }
 
 SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator(const Range* r, TextIteratorBehaviorFlags behavior)
     : m_node(nullptr)
     , m_offset(0)
     , m_handledNode(false)
     , m_handledChildren(false)
     , m_startNode(nullptr)
@@ skipping 111 matching lines @@
         m_shouldStop = true;
         return;
     }
 
     m_positionNode = nullptr;
     m_textLength = 0;
 
     while (m_node && !m_havePassedStartNode) {
         // Don't handle node if we start iterating at [node, 0].
         if (!m_handledNode && !(m_node == m_endNode && !m_endOffset)) {
-            LayoutObject* renderer = m_node->renderer();
+            LayoutObject* renderer = m_node->layoutObject();
             if (renderer && renderer->isText() && m_node->nodeType() == Node::TEXT_NODE) {
                 // FIXME: What about CDATA_SECTION_NODE?
                 if (renderer->style()->visibility() == VISIBLE && m_offset > 0)
                     m_handledNode = handleTextNode();
             } else if (renderer && (renderer->isLayoutPart() || TextIterator::supportsAltText(m_node))) {
                 if (renderer->style()->visibility() == VISIBLE && m_offset > 0)
                     m_handledNode = handleReplacedElement();
             } else {
                 m_handledNode = handleNonTextNode();
             }
@@ skipping 75 matching lines @@
     m_textOffset = m_positionStartOffset - offsetInNode;
     m_textContainer = text;
     m_singleCharacterBuffer = 0;
     RELEASE_ASSERT(static_cast<unsigned>(m_textOffset + m_textLength) <= text.length());
 
     return !m_shouldHandleFirstLetter;
 }
 
 LayoutText* SimplifiedBackwardsTextIterator::handleFirstLetter(int& startOffset, int& offsetInNode)
 {
-    LayoutText* renderer = toLayoutText(m_node->renderer());
+    LayoutText* renderer = toLayoutText(m_node->layoutObject());
     startOffset = (m_node == m_startNode) ? m_startOffset : 0;
 
     if (!renderer->isTextFragment()) {
         offsetInNode = 0;
         return renderer;
     }
 
     LayoutTextFragment* fragment = toLayoutTextFragment(renderer);
     int offsetAfterFirstLetter = fragment->start();
     if (startOffset >= offsetAfterFirstLetter) {
         ASSERT(!m_shouldHandleFirstLetter);
         offsetInNode = offsetAfterFirstLetter;
         return renderer;
     }
 
     if (!m_shouldHandleFirstLetter && offsetAfterFirstLetter < m_offset) {
         m_shouldHandleFirstLetter = true;
         offsetInNode = offsetAfterFirstLetter;
         return renderer;
     }
 
     m_shouldHandleFirstLetter = false;
     offsetInNode = 0;
 
     ASSERT(fragment->isRemainingTextRenderer());
     ASSERT(fragment->firstLetterPseudoElement());
 
-    LayoutObject* pseudoElementRenderer = fragment->firstLetterPseudoElement()->renderer();
+    LayoutObject* pseudoElementRenderer = fragment->firstLetterPseudoElement()->layoutObject();
     ASSERT(pseudoElementRenderer);
     ASSERT(pseudoElementRenderer->slowFirstChild());
     LayoutText* firstLetterRenderer = toLayoutText(pseudoElementRenderer->slowFirstChild());
 
     m_offset = firstLetterRenderer->caretMaxOffset();
     m_offset += collapsedSpaceLength(firstLetterRenderer, m_offset);
 
     return firstLetterRenderer;
 }
 
@@ skipping 73 matching lines @@
 }
 
 Position SimplifiedBackwardsTextIterator::endPosition() const
 {
     if (m_positionNode)
         return createLegacyEditingPosition(m_positionNode, m_positionEndOffset);
     return createLegacyEditingPosition(m_startNode, m_startOffset);
 }
 
 } // namespace blink