Rename RenderText to LayoutText

Source/core/layout/LayoutTextFragment.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
-#include "core/rendering/RenderTextFragment.h"
+#include "core/layout/LayoutTextFragment.h"
 
 #include "core/dom/FirstLetterPseudoElement.h"
 #include "core/dom/PseudoElement.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/Text.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutBlock.h"
 
 namespace blink {
 
-RenderTextFragment::RenderTextFragment(Node* node, StringImpl* str, int startOffset, int length)
-    : RenderText(node, str ? str->substring(startOffset, length) : PassRefPtr<StringImpl>(nullptr))
+LayoutTextFragment::LayoutTextFragment(Node* node, StringImpl* str, int startOffset, int length)
+    : LayoutText(node, str ? str->substring(startOffset, length) : PassRefPtr<StringImpl>(nullptr))
     , m_start(startOffset)
     , m_end(length)
     , m_isRemainingTextRenderer(false)
     , m_contentString(str)
     , m_firstLetterPseudoElement(nullptr)
 {
 }
 
-RenderTextFragment::RenderTextFragment(Node* node, StringImpl* str)
-    : RenderText(node, str)
+LayoutTextFragment::LayoutTextFragment(Node* node, StringImpl* str)
+    : LayoutText(node, str)
     , m_start(0)
     , m_end(str ? str->length() : 0)
     , m_isRemainingTextRenderer(false)
     , m_contentString(str)
     , m_firstLetterPseudoElement(nullptr)
 {
 }
 
-RenderTextFragment::~RenderTextFragment()
+LayoutTextFragment::~LayoutTextFragment()
 {
     ASSERT(!m_firstLetterPseudoElement);
 }
 
-void RenderTextFragment::destroy()
+void LayoutTextFragment::destroy()
 {
     if (m_isRemainingTextRenderer && m_firstLetterPseudoElement)
         m_firstLetterPseudoElement->setRemainingTextRenderer(nullptr);
     m_firstLetterPseudoElement = nullptr;
-    RenderText::destroy();
+    LayoutText::destroy();
 }
 
-PassRefPtr<StringImpl> RenderTextFragment::completeText() const
+PassRefPtr<StringImpl> LayoutTextFragment::completeText() const
 {
     Text* text = associatedTextNode();
     return text ? text->dataImpl() : contentString();
 }
 
-void RenderTextFragment::setContentString(StringImpl* str)
+void LayoutTextFragment::setContentString(StringImpl* str)
 {
     m_contentString = str;
     setText(str);
 }
 
-PassRefPtr<StringImpl> RenderTextFragment::originalText() const
+PassRefPtr<StringImpl> LayoutTextFragment::originalText() const
 {
     RefPtr<StringImpl> result = completeText();
     if (!result)
         return nullptr;
     return result->substring(start(), end());
 }
 
-void RenderTextFragment::setText(PassRefPtr<StringImpl> text, bool force)
+void LayoutTextFragment::setText(PassRefPtr<StringImpl> text, bool force)
 {
-    RenderText::setText(text, force);
+    LayoutText::setText(text, force);
 
     m_start = 0;
     m_end = textLength();
 
     // If we're the remaining text from a first letter then we have to tell the
     // first letter pseudo element to reattach itself so it can re-calculate the
     // correct first-letter settings.
     if (LayoutObject* previous = previousSibling()) {
         if (!previous->isPseudoElement() || !previous->node()->isFirstLetterPseudoElement())
             return;
 
         // Tell the first letter container node, and the first-letter node
         // that their text content changed.
         toFirstLetterPseudoElement(previous->node())->updateTextFragments();
     }
 }
 
-void RenderTextFragment::setTextFragment(PassRefPtr<StringImpl> text, unsigned start, unsigned length)
+void LayoutTextFragment::setTextFragment(PassRefPtr<StringImpl> text, unsigned start, unsigned length)
 {
-    RenderText::setText(text, false);
+    LayoutText::setText(text, false);
 
     m_start = start;
     m_end = length;
 }
 
-void RenderTextFragment::transformText()
+void LayoutTextFragment::transformText()
 {
-    // Note, we have to call RenderText::setText here because, if we use our
+    // Note, we have to call LayoutText::setText here because, if we use our
     // version we will, potentially, screw up the first-letter settings where
     // we only use portions of the string.
     if (RefPtr<StringImpl> textToTransform = originalText())
-        RenderText::setText(textToTransform.release(), true);
+        LayoutText::setText(textToTransform.release(), true);
 }
 
-UChar RenderTextFragment::previousCharacter() const
+UChar LayoutTextFragment::previousCharacter() const
 {
     if (start()) {
         StringImpl* original = completeText().get();
         if (original && start() <= original->length())
             return (*original)[start() - 1];
     }
 
-    return RenderText::previousCharacter();
+    return LayoutText::previousCharacter();
 }
 
 // If this is the renderer for a first-letter pseudoNode then we have to look
 // at the node for the remaining text to find our content.
-Text* RenderTextFragment::associatedTextNode() const
+Text* LayoutTextFragment::associatedTextNode() const
 {
     Node* node = this->firstLetterPseudoElement();
     if (m_isRemainingTextRenderer || !node) {
         // If we don't have a node, then we aren't part of a first-letter pseudo
         // element, so use the actual node. Likewise, if we have a node, but
         // we're the remainingTextRenderer for a pseudo element use the real
         // text node.
         node = this->node();
     }
 
     if (!node)
         return nullptr;
 
     if (node->isFirstLetterPseudoElement()) {
         FirstLetterPseudoElement* pseudo = toFirstLetterPseudoElement(node);
         LayoutObject* nextRenderer = FirstLetterPseudoElement::firstLetterTextRenderer(*pseudo);
         if (!nextRenderer)
             return nullptr;
         node = nextRenderer->node();
     }
     return (node && node->isTextNode()) ? toText(node) : nullptr;
 }
 
 } // namespace blink