Move rendering/RenderObject to layout/LayoutObject.

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 186 matching lines @@
 
 TextIterator::~TextIterator()
 {
 }
 
 bool TextIterator::isInsideReplacedElement() const
 {
     if (atEnd() || length() != 1 || !m_node)
         return false;
 
-    RenderObject* renderer = m_node->renderer();
+    LayoutObject* renderer = m_node->renderer();
     return renderer && renderer->isReplaced();
 }
 
 void TextIterator::advance()
 {
     if (m_shouldStop)
         return;
 
     ASSERT(!m_node || !m_node->document().needsRenderTreeUpdate());
 
@@ skipping 35 matching lines @@
         // if the range ends at offset 0 of an element, represent the
         // position, but not the content, of that element e.g. if the
         // node is a blockflow element, emit a newline that
         // precedes the element
         if (m_node == m_endContainer && !m_endOffset) {
             representNodeOffsetZero();
             m_node = nullptr;
             return;
         }
 
-        RenderObject* renderer = m_node->renderer();
+        LayoutObject* renderer = m_node->renderer();
         if (!renderer) {
             if (m_node->isShadowRoot()) {
                 // A shadow root doesn't have a renderer, but we want to visit children anyway.
                 m_iterationProgress = m_iterationProgress < HandledNode ? HandledNode : m_iterationProgress;
             } else {
                 m_iterationProgress = HandledChildren;
             }
         } else {
             // Enter author shadow roots, from youngest, if any and if necessary.
             if (m_iterationProgress < HandledAuthorShadowRoots) {
@@ skipping 343 matching lines @@
 {
     m_handledFirstLetter = true;
 
     if (!renderer->isRemainingTextRenderer())
         return;
 
     FirstLetterPseudoElement* firstLetterElement = renderer->firstLetterPseudoElement();
     if (!firstLetterElement)
         return;
 
-    RenderObject* pseudoRenderer = firstLetterElement->renderer();
+    LayoutObject* pseudoRenderer = firstLetterElement->renderer();
     if (pseudoRenderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
         return;
 
-    RenderObject* firstLetter = pseudoRenderer->slowFirstChild();
+    LayoutObject* firstLetter = pseudoRenderer->slowFirstChild();
     ASSERT(firstLetter);
 
     m_remainingTextBox = m_textBox;
     m_textBox = toRenderText(firstLetter)->firstTextBox();
     m_sortedTextBoxes.clear();
     m_firstLetterText = toRenderText(firstLetter);
 }
 
 bool TextIterator::supportsAltText(Node* m_node)
 {
     if (!m_node->isHTMLElement())
         return false;
     HTMLElement& element = toHTMLElement(*m_node);
 
     // FIXME: Add isSVGImageElement.
     if (isHTMLImageElement(element))
         return true;
     if (isHTMLInputElement(toHTMLElement(*m_node)) && toHTMLInputElement(*m_node).isImage())
         return true;
     return false;
 }
 
 bool TextIterator::handleReplacedElement()
 {
     if (m_fullyClippedStack.top())
         return false;
 
-    RenderObject* renderer = m_node->renderer();
+    LayoutObject* renderer = m_node->renderer();
     if (renderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
         return false;
 
     if (m_emitsObjectReplacementCharacter) {
         emitCharacter(objectReplacementCharacter, m_node->parentNode(), m_node, 0, 1);
         return true;
     }
 
     if (m_lastTextNodeEndedWithCollapsedSpace) {
         emitCharacter(space, m_lastTextNode->parentNode(), m_lastTextNode, 1, 1);
@@ skipping 42 matching lines @@
         return true;
 
     if (!renderer->isTextFragment())
         return false;
 
     RenderTextFragment* fragment = toRenderTextFragment(renderer);
     if (!fragment->isRemainingTextRenderer())
         return false;
 
     ASSERT(fragment->firstLetterPseudoElement());
-    RenderObject* pseudoElementRenderer = fragment->firstLetterPseudoElement()->renderer();
+    LayoutObject* pseudoElementRenderer = fragment->firstLetterPseudoElement()->renderer();
     return pseudoElementRenderer && pseudoElementRenderer->style()->visibility() == VISIBLE;
 }
 
 bool TextIterator::shouldEmitTabBeforeNode(Node* node)
 {
-    RenderObject* r = node->renderer();
+    LayoutObject* r = node->renderer();
 
     // Table cells are delimited by tabs.
     if (!r || !isTableCell(node))
         return false;
 
     // Want a tab before every cell other than the first one
     LayoutTableCell* rc = toLayoutTableCell(r);
     LayoutTable* t = rc->table();
     return t && (t->cellBefore(rc) || t->cellAbove(rc));
 }
 
 bool TextIterator::shouldEmitNewlineForNode(Node* node, bool emitsOriginalText)
 {
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
 
     if (renderer ? !renderer->isBR() : !isHTMLBRElement(node))
         return false;
     return emitsOriginalText || !(node->isInShadowTree() && isHTMLInputElement(*node->shadowHost()));
 }
 
 static bool shouldEmitNewlinesBeforeAndAfterNode(Node& node)
 {
     // Block flow (versus inline flow) is represented by having
     // a newline both before and after the element.
-    RenderObject* r = node.renderer();
+    LayoutObject* r = node.renderer();
     if (!r) {
         return (node.hasTagName(blockquoteTag)
             || node.hasTagName(ddTag)
             || node.hasTagName(divTag)
             || node.hasTagName(dlTag)
             || node.hasTagName(dtTag)
             || node.hasTagName(h1Tag)
             || node.hasTagName(h2Tag)
             || node.hasTagName(h3Tag)
             || node.hasTagName(h4Tag)
@@ skipping 51 matching lines @@
 {
     return shouldEmitNewlinesBeforeAndAfterNode(node);
 }
 
 static bool shouldEmitExtraNewlineForNode(Node* node)
 {
     // When there is a significant collapsed bottom margin, emit an extra
     // newline for a more realistic result. We end up getting the right
     // result even without margin collapsing. For example: <div><p>text</p></div>
     // will work right even if both the <div> and the <p> have bottom margins.
-    RenderObject* r = node->renderer();
+    LayoutObject* r = node->renderer();
     if (!r || !r->isBox())
         return false;
 
     // NOTE: We only do this for a select set of nodes, and fwiw WinIE appears
     // not to do this at all
     if (node->hasTagName(h1Tag)
         || node->hasTagName(h2Tag)
         || node->hasTagName(h3Tag)
         || node->hasTagName(h4Tag)
         || node->hasTagName(h5Tag)
@@ skipping 342 matching lines @@
     return createPlainText(it);
 }
 
 String plainText(const Position& start, const Position& end, TextIteratorBehaviorFlags behavior)
 {
     TextIterator it(start, end, behavior);
     return createPlainText(it);
 }
 
 }