Rename RenderText to LayoutText

Source/core/dom/FirstLetterPseudoElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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/dom/FirstLetterPseudoElement.h"
 
 #include "core/dom/Element.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutObjectInlines.h"
-#include "core/rendering/RenderText.h"
-#include "core/rendering/RenderTextFragment.h"
+#include "core/layout/LayoutText.h"
+#include "core/layout/LayoutTextFragment.h"
 #include "wtf/TemporaryChange.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/unicode/icu/UnicodeIcu.h"
 
 namespace blink {
 
 using namespace WTF;
 using namespace Unicode;
 
 // CSS 2.1 http://www.w3.org/TR/CSS21/selector.html#first-letter
@@ skipping 42 matching lines @@
         if (!isPunctuationForFirstLetter(c))
             break;
     }
     return length;
 }
 
 // Once we see any of these renderers we can stop looking for first-letter as
 // they signal the end of the first line of text.
 static bool isInvalidFirstLetterRenderer(const LayoutObject* obj)
 {
-    return (obj->isBR() || (obj->isText() && toRenderText(obj)->isWordBreak()));
+    return (obj->isBR() || (obj->isText() && toLayoutText(obj)->isWordBreak()));
 }
 
 LayoutObject* FirstLetterPseudoElement::firstLetterTextRenderer(const Element& element)
 {
     LayoutObject* parentRenderer = 0;
 
     // If we are looking at a first letter element then we need to find the
     // first letter text renderer from the parent node, and not ourselves.
     if (element.isFirstLetterPseudoElement())
         parentRenderer = element.parentOrShadowHostElement()->renderer();
     else
         parentRenderer = element.renderer();
 
     if (!parentRenderer
         || !parentRenderer->style()->hasPseudoStyle(FIRST_LETTER)
         || !parentRenderer->canHaveGeneratedChildren()
         || !(parentRenderer->isLayoutBlockFlow() || parentRenderer->isLayoutButton()))
         return nullptr;
 
     // Drill down into our children and look for our first text child.
     LayoutObject* firstLetterTextRenderer = parentRenderer->slowFirstChild();
     while (firstLetterTextRenderer) {
         // This can be called when the first letter renderer is already in the tree. We do not
         // want to consider that renderer for our text renderer so we go to the sibling (which is
-        // the RenderTextFragment for the remaining text).
+        // the LayoutTextFragment for the remaining text).
         if (firstLetterTextRenderer->style() && firstLetterTextRenderer->style()->styleType() == FIRST_LETTER) {
             firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
         } else if (firstLetterTextRenderer->isText()) {
-            // FIXME: If there is leading punctuation in a different RenderText than
+            // FIXME: If there is leading punctuation in a different LayoutText than
             // the first letter, we'll not apply the correct style to it.
-            RefPtr<StringImpl> str = toRenderText(firstLetterTextRenderer)->isTextFragment() ?
-                toRenderTextFragment(firstLetterTextRenderer)->completeText() :
-                toRenderText(firstLetterTextRenderer)->originalText();
+            RefPtr<StringImpl> str = toLayoutText(firstLetterTextRenderer)->isTextFragment() ?
+                toLayoutTextFragment(firstLetterTextRenderer)->completeText() :
+                toLayoutText(firstLetterTextRenderer)->originalText();
             if (firstLetterLength(str.get()) || isInvalidFirstLetterRenderer(firstLetterTextRenderer))
                 break;
             firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
         } else if (firstLetterTextRenderer->isListMarker()) {
             firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
         } else if (firstLetterTextRenderer->isFloatingOrOutOfFlowPositioned()) {
             if (firstLetterTextRenderer->style()->styleType() == FIRST_LETTER) {
                 firstLetterTextRenderer = firstLetterTextRenderer->slowFirstChild();
                 break;
             }
             firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
         } else if (firstLetterTextRenderer->isReplaced() || firstLetterTextRenderer->isLayoutButton()
             || firstLetterTextRenderer->isMenuList()) {
             return nullptr;
         } else if (firstLetterTextRenderer->isFlexibleBoxIncludingDeprecated() || firstLetterTextRenderer->isLayoutGrid()) {
             firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
         } else if (firstLetterTextRenderer->style()->hasPseudoStyle(FIRST_LETTER)
             && firstLetterTextRenderer->canHaveGeneratedChildren())  {
             // There is a renderer further down the tree which has FIRST_LETTER set. When that node
             // is attached we will handle setting up the first letter then.
             return nullptr;
         } else {
             firstLetterTextRenderer = firstLetterTextRenderer->slowFirstChild();
         }
     }
 
     // No first letter text to display, we're done.
-    // FIXME: This black-list of disallowed RenderText subclasses is fragile. crbug.com/422336.
-    // Should counter be on this list? What about RenderTextFragment?
+    // FIXME: This black-list of disallowed LayoutText subclasses is fragile. crbug.com/422336.
+    // Should counter be on this list? What about LayoutTextFragment?
     if (!firstLetterTextRenderer || !firstLetterTextRenderer->isText() || isInvalidFirstLetterRenderer(firstLetterTextRenderer))
         return nullptr;
 
     return firstLetterTextRenderer;
 }
 
 FirstLetterPseudoElement::FirstLetterPseudoElement(Element* parent)
     : PseudoElement(parent, FIRST_LETTER)
     , m_remainingTextRenderer(nullptr)
 {
 }
 
 FirstLetterPseudoElement::~FirstLetterPseudoElement()
 {
 }
 
 void FirstLetterPseudoElement::updateTextFragments()
 {
     String oldText =  m_remainingTextRenderer->completeText();
     ASSERT(oldText.impl());
 
     unsigned length = FirstLetterPseudoElement::firstLetterLength(oldText);
     m_remainingTextRenderer->setTextFragment(oldText.impl()->substring(length, oldText.length()), length, oldText.length() - length);
     m_remainingTextRenderer->dirtyLineBoxes();
 
     for (auto child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
-        if (!child->isText() || !toRenderText(child)->isTextFragment())
+        if (!child->isText() || !toLayoutText(child)->isTextFragment())
             continue;
-        RenderTextFragment* childFragment = toRenderTextFragment(child);
+        LayoutTextFragment* childFragment = toLayoutTextFragment(child);
         if (childFragment->firstLetterPseudoElement() != this)
             continue;
 
         childFragment->setTextFragment(oldText.impl()->substring(0, length), 0, length);
         childFragment->dirtyLineBoxes();
         break;
     }
 }
 
-void FirstLetterPseudoElement::setRemainingTextRenderer(RenderTextFragment* fragment)
+void FirstLetterPseudoElement::setRemainingTextRenderer(LayoutTextFragment* fragment)
 {
     // The text fragment we get our content from is being destroyed. We need
     // to tell our parent element to recalcStyle so we can get cleaned up
     // as well.
     if (!fragment)
         setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::PseudoClass));
 
     m_remainingTextRenderer = fragment;
 }
 
@@ skipping 38 matching lines @@
 
 void FirstLetterPseudoElement::attachFirstLetterTextRenderers()
 {
     LayoutObject* nextRenderer = FirstLetterPseudoElement::firstLetterTextRenderer(*this);
     ASSERT(nextRenderer);
     ASSERT(nextRenderer->isText());
 
     // The original string is going to be either a generated content string or a DOM node's
     // string. We want the original string before it got transformed in case first-letter has
     // no text-transform or a different text-transform applied to it.
-    String oldText = toRenderText(nextRenderer)->isTextFragment() ? toRenderTextFragment(nextRenderer)->completeText() : toRenderText(nextRenderer)->originalText();
+    String oldText = toLayoutText(nextRenderer)->isTextFragment() ? toLayoutTextFragment(nextRenderer)->completeText() : toLayoutText(nextRenderer)->originalText();
     ASSERT(oldText.impl());
 
     LayoutStyle* pseudoStyle = styleForFirstLetter(nextRenderer->parent());
     renderer()->setStyle(pseudoStyle);
 
     // FIXME: This would already have been calculated in firstLetterRenderer. Can we pass the length through?
     unsigned length = FirstLetterPseudoElement::firstLetterLength(oldText);
 
     // Construct a text fragment for the text after the first letter.
     // This text fragment might be empty.
-    RenderTextFragment* remainingText =
-        new RenderTextFragment(nextRenderer->node() ? nextRenderer->node() : &nextRenderer->document(), oldText.impl(), length, oldText.length() - length);
+    LayoutTextFragment* remainingText =
+        new LayoutTextFragment(nextRenderer->node() ? nextRenderer->node() : &nextRenderer->document(), oldText.impl(), length, oldText.length() - length);
     remainingText->setFirstLetterPseudoElement(this);
     remainingText->setIsRemainingTextRenderer(true);
     remainingText->setStyle(nextRenderer->style());
 
     if (remainingText->node())
         remainingText->node()->setRenderer(remainingText);
 
     m_remainingTextRenderer = remainingText;
 
     LayoutObject* nextSibling = renderer()->nextSibling();
     renderer()->parent()->addChild(remainingText, nextSibling);
 
     // Construct text fragment for the first letter.
-    RenderTextFragment* letter = new RenderTextFragment(&nextRenderer->document(), oldText.impl(), 0, length);
+    LayoutTextFragment* letter = new LayoutTextFragment(&nextRenderer->document(), oldText.impl(), 0, length);
     letter->setFirstLetterPseudoElement(this);
     letter->setStyle(pseudoStyle);
     renderer()->addChild(letter);
 
     nextRenderer->destroy();
 }
 
 void FirstLetterPseudoElement::didRecalcStyle(StyleRecalcChange)
 {
     if (!renderer())
@@ skipping 13 matching lines @@
 
         // We only manage the style for the generated content items.
         if (!child->isText() && !child->isQuote() && !child->isImage())
             continue;
 
         child->setPseudoStyle(renderer->style());
     }
 }
 
 } // namespace blink