Rename RenderText to LayoutText

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 14 matching lines @@
  */
 
 #include "config.h"
 #include "core/editing/iterators/SimplifiedBackwardsTextIterator.h"
 
 #include "core/dom/FirstLetterPseudoElement.h"
 #include "core/editing/htmlediting.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLTextFormControlElement.h"
-#include "core/rendering/RenderTextFragment.h"
+#include "core/layout/LayoutTextFragment.h"
 
 namespace blink {
 
-static int collapsedSpaceLength(RenderText* renderer, int textEnd)
+static int collapsedSpaceLength(LayoutText* renderer, int textEnd)
 {
     const String& text = renderer->text();
     int length = text.length();
     for (int i = textEnd; i < length; ++i) {
         if (!renderer->style()->isCollapsibleWhiteSpace(text[i]))
             return i - textEnd;
     }
 
     return length - textEnd;
 }
 
 static int maxOffsetIncludingCollapsedSpaces(Node* node)
 {
     int offset = caretMaxOffset(node);
 
     if (node->renderer() && node->renderer()->isText())
-        offset += collapsedSpaceLength(toRenderText(node->renderer()), offset);
+        offset += collapsedSpaceLength(toLayoutText(node->renderer()), 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 179 matching lines @@
 
         if (m_positionNode)
             return;
     }
 }
 
 bool SimplifiedBackwardsTextIterator::handleTextNode()
 {
     int startOffset;
     int offsetInNode;
-    RenderText* renderer = handleFirstLetter(startOffset, offsetInNode);
+    LayoutText* renderer = handleFirstLetter(startOffset, offsetInNode);
     if (!renderer)
         return true;
 
     String text = renderer->text();
     if (!renderer->firstTextBox() && text.length() > 0)
         return true;
 
     m_positionEndOffset = m_offset;
     m_offset = startOffset + offsetInNode;
     m_positionNode = m_node;
     m_positionStartOffset = m_offset;
 
     ASSERT(0 <= m_positionStartOffset - offsetInNode && m_positionStartOffset - offsetInNode <= static_cast<int>(text.length()));
     ASSERT(1 <= m_positionEndOffset - offsetInNode && m_positionEndOffset - offsetInNode <= static_cast<int>(text.length()));
     ASSERT(m_positionStartOffset <= m_positionEndOffset);
 
     m_textLength = m_positionEndOffset - m_positionStartOffset;
     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;
 }
 
-RenderText* SimplifiedBackwardsTextIterator::handleFirstLetter(int& startOffset, int& offsetInNode)
+LayoutText* SimplifiedBackwardsTextIterator::handleFirstLetter(int& startOffset, int& offsetInNode)
 {
-    RenderText* renderer = toRenderText(m_node->renderer());
+    LayoutText* renderer = toLayoutText(m_node->renderer());
     startOffset = (m_node == m_startNode) ? m_startOffset : 0;
 
     if (!renderer->isTextFragment()) {
         offsetInNode = 0;
         return renderer;
     }
 
-    RenderTextFragment* fragment = toRenderTextFragment(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();
     ASSERT(pseudoElementRenderer);
     ASSERT(pseudoElementRenderer->slowFirstChild());
-    RenderText* firstLetterRenderer = toRenderText(pseudoElementRenderer->slowFirstChild());
+    LayoutText* firstLetterRenderer = toLayoutText(pseudoElementRenderer->slowFirstChild());
 
     m_offset = firstLetterRenderer->caretMaxOffset();
     m_offset += collapsedSpaceLength(firstLetterRenderer, m_offset);
 
     return firstLetterRenderer;
 }
 
 bool SimplifiedBackwardsTextIterator::handleReplacedElement()
 {
     unsigned index = m_node->nodeIndex();
@@ skipping 70 matching lines @@
 }
 
 Position SimplifiedBackwardsTextIterator::endPosition() const
 {
     if (m_positionNode)
         return createLegacyEditingPosition(m_positionNode, m_positionEndOffset);
     return createLegacyEditingPosition(m_startNode, m_startOffset);
 }
 
 } // namespace blink