Rename RenderText to LayoutText

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 28 matching lines @@
 #include "core/editing/iterators/CharacterIterator.h"
 #include "core/editing/iterators/WordAwareIterator.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/layout/LayoutTextControl.h"
+#include "core/layout/LayoutTextFragment.h"
 #include "core/layout/line/InlineTextBox.h"
-#include "core/rendering/RenderTextFragment.h"
 #include "platform/fonts/Font.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include <unicode/utf16.h>
 
 using namespace WTF::Unicode;
 
 namespace blink {
 
 using namespace HTMLNames;
@@ skipping 378 matching lines @@
         builder.append(string(), positionStartOffset() + position, lengthToAppend);
     }
 }
 
 bool TextIterator::handleTextNode()
 {
     if (m_fullyClippedStack.top() && !m_ignoresStyleVisibility)
         return false;
 
     Text* textNode = toText(m_node);
-    RenderText* renderer = textNode->renderer();
+    LayoutText* renderer = textNode->renderer();
 
     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;
         }
         if (!m_handledFirstLetter && renderer->isTextFragment() && !m_offset) {
-            handleTextNodeFirstLetter(toRenderTextFragment(renderer));
+            handleTextNodeFirstLetter(toLayoutTextFragment(renderer));
             if (m_firstLetterText) {
                 String firstLetter = m_firstLetterText->text();
                 emitText(textNode, m_firstLetterText, m_offset, m_offset + firstLetter.length());
                 m_firstLetterText = nullptr;
                 m_textBox = 0;
                 return false;
             }
         }
         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);
         return true;
     }
 
     if (renderer->firstTextBox())
         m_textBox = renderer->firstTextBox();
 
     bool shouldHandleFirstLetter = !m_handledFirstLetter && renderer->isTextFragment() && !m_offset;
     if (shouldHandleFirstLetter)
-        handleTextNodeFirstLetter(toRenderTextFragment(renderer));
+        handleTextNodeFirstLetter(toLayoutTextFragment(renderer));
 
     if (!renderer->firstTextBox() && str.length() > 0 && !shouldHandleFirstLetter) {
         if (renderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
             return false;
         m_lastTextNodeEndedWithCollapsedSpace = true; // entire block is collapsed space
         return true;
     }
 
     if (m_firstLetterText)
         renderer = m_firstLetterText;
 
     // Used when text boxes are out of order (Hebrew/Arabic w/ embeded LTR text)
     if (renderer->containsReversedText()) {
         m_sortedTextBoxes.clear();
         for (InlineTextBox* textBox = renderer->firstTextBox(); textBox; textBox = textBox->nextTextBox()) {
             m_sortedTextBoxes.append(textBox);
         }
         std::sort(m_sortedTextBoxes.begin(), m_sortedTextBoxes.end(), InlineTextBox::compareByStart);
         m_sortedTextBoxesPosition = 0;
         m_textBox = m_sortedTextBoxes.isEmpty() ? 0 : m_sortedTextBoxes[0];
     }
 
     handleTextBox();
     return true;
 }
 
 void TextIterator::handleTextBox()
 {
-    RenderText* renderer = m_firstLetterText ? m_firstLetterText.get() : toRenderText(m_node->renderer());
+    LayoutText* renderer = m_firstLetterText ? m_firstLetterText.get() : toLayoutText(m_node->renderer());
 
     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 76 matching lines @@
 
     if (!m_textBox && m_remainingTextBox) {
         m_textBox = m_remainingTextBox;
         m_remainingTextBox = 0;
         m_firstLetterText = nullptr;
         m_offset = 0;
         handleTextBox();
     }
 }
 
-void TextIterator::handleTextNodeFirstLetter(RenderTextFragment* renderer)
+void TextIterator::handleTextNodeFirstLetter(LayoutTextFragment* renderer)
 {
     m_handledFirstLetter = true;
 
     if (!renderer->isRemainingTextRenderer())
         return;
 
     FirstLetterPseudoElement* firstLetterElement = renderer->firstLetterPseudoElement();
     if (!firstLetterElement)
         return;
 
     LayoutObject* pseudoRenderer = firstLetterElement->renderer();
     if (pseudoRenderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
         return;
 
     LayoutObject* firstLetter = pseudoRenderer->slowFirstChild();
     ASSERT(firstLetter);
 
     m_remainingTextBox = m_textBox;
-    m_textBox = toRenderText(firstLetter)->firstTextBox();
+    m_textBox = toLayoutText(firstLetter)->firstTextBox();
     m_sortedTextBoxes.clear();
-    m_firstLetterText = toRenderText(firstLetter);
+    m_firstLetterText = toLayoutText(firstLetter);
 }
 
 bool TextIterator::supportsAltText(Node* m_node)
 {
     if (!m_node->isHTMLElement())
         return false;
     HTMLElement& element = toHTMLElement(*m_node);
 
     // FIXME: Add isSVGImageElement.
     if (isHTMLImageElement(element))
@@ skipping 51 matching lines @@
             return true;
         }
     }
 
     m_textLength = 0;
     m_lastCharacter = 0;
 
     return true;
 }
 
-bool TextIterator::hasVisibleTextNode(RenderText* renderer)
+bool TextIterator::hasVisibleTextNode(LayoutText* renderer)
 {
     if (renderer->style()->visibility() == VISIBLE)
         return true;
 
     if (!renderer->isTextFragment())
         return false;
 
-    RenderTextFragment* fragment = toRenderTextFragment(renderer);
+    LayoutTextFragment* fragment = toLayoutTextFragment(renderer);
     if (!fragment->isRemainingTextRenderer())
         return false;
 
     ASSERT(fragment->firstLetterPseudoElement());
     LayoutObject* pseudoElementRenderer = fragment->firstLetterPseudoElement()->renderer();
     return pseudoElementRenderer && pseudoElementRenderer->style()->visibility() == VISIBLE;
 }
 
 bool TextIterator::shouldEmitTabBeforeNode(Node* node)
 {
@@ skipping 277 matching lines @@
     // remember information with which to construct the TextIterator::characters() and length()
     m_singleCharacterBuffer = c;
     ASSERT(m_singleCharacterBuffer);
     m_textLength = 1;
 
     // remember some iteration state
     m_lastTextNodeEndedWithCollapsedSpace = false;
     m_lastCharacter = c;
 }
 
-void TextIterator::emitText(Node* textNode, RenderText* renderer, int textStartOffset, int textEndOffset)
+void TextIterator::emitText(Node* textNode, LayoutText* renderer, int textStartOffset, int textEndOffset)
 {
     m_text = m_emitsOriginalText ? renderer->originalText() : renderer->text();
     ASSERT(!m_text.isEmpty());
     ASSERT(0 <= textStartOffset && textStartOffset < static_cast<int>(m_text.length()));
     ASSERT(0 <= textEndOffset && textEndOffset <= static_cast<int>(m_text.length()));
     ASSERT(textStartOffset <= textEndOffset);
 
     m_positionNode = textNode;
     m_positionOffsetBaseNode = nullptr;
     m_positionStartOffset = textStartOffset;
@@ skipping 152 matching lines @@
     return createPlainText(it);
 }
 
 String plainText(const Position& start, const Position& end, TextIteratorBehaviorFlags behavior)
 {
     TextIterator it(start, end, behavior);
     return createPlainText(it);
 }
 
 }