Move rendering/RenderObject to layout/LayoutObject.

Source/core/editing/htmlediting.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 34 matching lines @@
 #include "core/editing/iterators/TextIterator.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLDivElement.h"
 #include "core/html/HTMLLIElement.h"
 #include "core/html/HTMLParagraphElement.h"
 #include "core/html/HTMLSpanElement.h"
 #include "core/html/HTMLTableCellElement.h"
 #include "core/html/HTMLUListElement.h"
+#include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTableCell.h"
-#include "core/rendering/RenderObject.h"
 #include "wtf/Assertions.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 // Atomic means that the node has no children, or has children which are ignored for the
 // purposes of editing.
@@ skipping 281 matching lines @@
 bool inSameContainingBlockFlowElement(Node* a, Node* b)
 {
     return a && b && enclosingBlockFlowElement(*a) == enclosingBlockFlowElement(*b);
 }
 
 TextDirection directionOfEnclosingBlock(const Position& position)
 {
     Element* enclosingBlockElement = enclosingBlock(position.containerNode());
     if (!enclosingBlockElement)
         return LTR;
-    RenderObject* renderer = enclosingBlockElement->renderer();
+    LayoutObject* renderer = enclosingBlockElement->renderer();
     return renderer ? renderer->style()->direction() : LTR;
 }
 
 // This method is used to create positions in the DOM. It returns the maximum valid offset
 // in a node. It returns 1 for some elements even though they do not have children, which
 // creates technically invalid DOM Positions. Be sure to call parentAnchoredEquivalent
 // on a Position before using it to create a DOM Range, or an exception will be thrown.
 int lastOffsetForEditing(const Node* node)
 {
     ASSERT(node);
@@ skipping 37 matching lines @@
         }
     }
 
     ASSERT(rebalancedString.length() == length);
 
     return rebalancedString.toString();
 }
 
 bool isTableStructureNode(const Node *node)
 {
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
     return (renderer && (renderer->isTableCell() || renderer->isTableRow() || renderer->isTableSection() || renderer->isLayoutTableCol()));
 }
 
 const String& nonBreakingSpaceString()
 {
     DEFINE_STATIC_LOCAL(String, nonBreakingSpaceString, (&noBreakSpace, 1));
     return nonBreakingSpaceString;
 }
 
 // FIXME: need to dump this
 static bool isSpecialHTMLElement(const Node& n)
 {
     if (!n.isHTMLElement())
         return false;
 
     if (n.isLink())
         return true;
 
-    RenderObject* renderer = n.renderer();
+    LayoutObject* renderer = n.renderer();
     if (!renderer)
         return false;
 
     if (renderer->style()->display() == TABLE || renderer->style()->display() == INLINE_TABLE)
         return true;
 
     if (renderer->style()->isFloating())
         return true;
 
     return false;
@@ skipping 176 matching lines @@
         n = NodeTraversal::next(*n, node);
     }
     return false;
 }
 
 Node* highestNodeToRemoveInPruning(Node* node, Node* excludeNode)
 {
     Node* previousNode = nullptr;
     Element* rootEditableElement = node ? node->rootEditableElement() : nullptr;
     for (; node; node = node->parentNode()) {
-        if (RenderObject* renderer = node->renderer()) {
+        if (LayoutObject* renderer = node->renderer()) {
             if (!renderer->canHaveChildren() || hasARenderedDescendant(node, previousNode) || rootEditableElement == node || excludeNode == node)
                 return previousNode;
         }
         previousNode = node;
     }
     return 0;
 }
 
 Element* enclosingTableCell(const Position& p)
 {
@@ skipping 102 matching lines @@
 bool isRenderedHTMLTableElement(const Node* node)
 {
     return isHTMLTableElement(*node) && node->renderer();
 }
 
 bool isRenderedTableElement(const Node* node)
 {
     if (!node || !node->isElementNode())
         return false;
 
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
     return (renderer && renderer->isTable());
 }
 
 bool isTableCell(const Node* node)
 {
     ASSERT(node);
-    RenderObject* r = node->renderer();
+    LayoutObject* r = node->renderer();
     return r ? r->isTableCell() : isHTMLTableCellElement(*node);
 }
 
 bool isEmptyTableCell(const Node* node)
 {
     // Returns true IFF the passed in node is one of:
     //   .) a table cell with no children,
     //   .) a table cell with a single BR child, and which has no other child renderers, including :before and :after renderers
     //   .) the BR child of such a table cell
 
     // Find rendered node
     while (node && !node->renderer())
         node = node->parentNode();
     if (!node)
         return false;
 
     // Make sure the rendered node is a table cell or <br>.
     // If it's a <br>, then the parent node has to be a table cell.
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
     if (renderer->isBR()) {
         renderer = renderer->parent();
         if (!renderer)
             return false;
     }
     if (!renderer->isTableCell())
         return false;
 
     // Check that the table cell contains no child renderers except for perhaps a single <br>.
-    RenderObject* childRenderer = toLayoutTableCell(renderer)->firstChild();
+    LayoutObject* childRenderer = toLayoutTableCell(renderer)->firstChild();
     if (!childRenderer)
         return true;
     if (!childRenderer->isBR())
         return false;
     return !childRenderer->nextSibling();
 }
 
 PassRefPtrWillBeRawPtr<HTMLElement> createDefaultParagraphElement(Document& document)
 {
     switch (document.frame()->editor().defaultParagraphSeparator()) {
@@ skipping 73 matching lines @@
     return createTabSpanElement(document, PassRefPtrWillBeRawPtr<Text>(nullptr));
 }
 
 PassRefPtrWillBeRawPtr<HTMLBRElement> createBlockPlaceholderElement(Document& document)
 {
     return toHTMLBRElement(document.createElement(brTag, false).get());
 }
 
 bool isNodeRendered(const Node& node)
 {
-    RenderObject* renderer = node.renderer();
+    LayoutObject* renderer = node.renderer();
     if (!renderer)
         return false;
 
     return renderer->style()->visibility() == VISIBLE;
 }
 
 // return first preceding DOM position rendered at a different location, or "this"
 static Position previousCharacterPosition(const Position& position, EAffinity affinity)
 {
     if (position.isNull())
@@ skipping 104 matching lines @@
 {
     if (!node || !node->isHTMLElement())
         return false;
 
     const HTMLElement& element = toHTMLElement(*node);
     return element.hasTagName(blockquoteTag) && element.getAttribute("type") == "cite";
 }
 
 int caretMinOffset(const Node* n)
 {
-    RenderObject* r = n->renderer();
+    LayoutObject* r = n->renderer();
     ASSERT(!n->isCharacterDataNode() || !r || r->isText()); // FIXME: This was a runtime check that seemingly couldn't fail; changed it to an assertion for now.
     return r ? r->caretMinOffset() : 0;
 }
 
 // If a node can contain candidates for VisiblePositions, return the offset of the last candidate, otherwise
 // return the number of children for container nodes and the length for unrendered text nodes.
 int caretMaxOffset(const Node* n)
 {
     // For rendered text nodes, return the last position that a caret could occupy.
     if (n->isTextNode() && n->renderer())
@@ skipping 107 matching lines @@
     if (endIsVisuallySame && comparePositions(selectedRange.startPosition(), positionInParentBeforeNode(node)) < 0)
         return true;
 
     return startIsVisuallySame && endIsVisuallySame;
 }
 
 bool isRenderedAsNonInlineTableImageOrHR(const Node* node)
 {
     if (!node)
         return false;
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
     return renderer && ((renderer->isTable() && !renderer->isInline()) || (renderer->isImage() && !renderer->isInline()) || renderer->isHR());
 }
 
 bool areIdenticalElements(const Node* first, const Node* second)
 {
     if (!first->isElementNode() || !second->isElementNode())
         return false;
 
     const Element* firstElement = toElement(first);
     const Element* secondElement = toElement(second);
@@ skipping 17 matching lines @@
         || element.hasTagName(xmpTag)
         || element.hasTagName(h1Tag)
         || element.hasTagName(h2Tag)
         || element.hasTagName(h3Tag)
         || element.hasTagName(h4Tag)
         || element.hasTagName(h5Tag);
 }
 
 bool isBlockFlowElement(const Node& node)
 {
-    RenderObject* renderer = node.renderer();
+    LayoutObject* renderer = node.renderer();
     return node.isElementNode() && renderer && renderer->isRenderBlockFlow();
 }
 
 Position adjustedSelectionStartForStyleComputation(const VisibleSelection& selection)
 {
     // This function is used by range style computations to avoid bugs like:
     // <rdar://problem/4017641> REGRESSION (Mail): you can only bold/unbold a selection starting from end of line once
     // It is important to skip certain irrelevant content at the start of the selection, so we do not wind up
     // with a spurious "mixed" style.
 
     VisiblePosition visiblePosition(selection.start());
     if (visiblePosition.isNull())
         return Position();
 
     // if the selection is a caret, just return the position, since the style
     // behind us is relevant
     if (selection.isCaret())
         return visiblePosition.deepEquivalent();
 
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
         return visiblePosition.next().deepEquivalent().downstream();
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
     return visiblePosition.deepEquivalent().downstream();
 }
 
 } // namespace blink