Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/line/RootInlineBox.cpp

 /*
  * Copyright (C) 2003, 2006, 2008 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
@@ skipping 264 matching lines @@
         // We have to compute the expansion for annotations over the previous line to see how much we should move.
         LayoutUnit lowestAllowedPosition = std::max(prevRootBox()->lineBottom(), lineTop()) - result;
         result = prevRootBox()->computeOverAnnotationAdjustment(lowestAllowedPosition);
     }
 
     return result;
 }
 
 GapRects RootInlineBox::lineSelectionGap(const RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, LayoutUnit selTop, LayoutUnit selHeight, const PaintInfo* paintInfo) const
 {
-    RenderObject::SelectionState lineState = selectionState();
+    LayoutObject::SelectionState lineState = selectionState();
 
     bool leftGap, rightGap;
     block().getSelectionGapInfo(lineState, leftGap, rightGap);
 
     GapRects result;
 
     InlineBox* firstBox = firstSelectedBox();
     InlineBox* lastBox = lastSelectedBox();
     if (leftGap) {
         result.uniteLeft(block().logicalLeftSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock,
             &firstBox->parent()->renderer(), firstBox->logicalLeft(), selTop, selHeight, paintInfo));
     }
     if (rightGap) {
         result.uniteRight(block().logicalRightSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock,
             &lastBox->parent()->renderer(), lastBox->logicalRight(), selTop, selHeight, paintInfo));
     }
 
     // When dealing with bidi text, a non-contiguous selection region is possible.
     // e.g. The logical text aaaAAAbbb (capitals denote RTL text and non-capitals LTR) is layed out
     // visually as 3 text runs |aaa|bbb|AAA| if we select 4 characters from the start of the text the
     // selection will look like (underline denotes selection):
     // |aaa|bbb|AAA|
     //  ___       _
     // We can see that the |bbb| run is not part of the selection while the runs around it are.
     if (firstBox && firstBox != lastBox) {
         // Now fill in any gaps on the line that occurred between two selected elements.
         LayoutUnit lastLogicalLeft = firstBox->logicalRight();
-        bool isPreviousBoxSelected = firstBox->selectionState() != RenderObject::SelectionNone;
+        bool isPreviousBoxSelected = firstBox->selectionState() != LayoutObject::SelectionNone;
         for (InlineBox* box = firstBox->nextLeafChild(); box; box = box->nextLeafChild()) {
-            if (box->selectionState() != RenderObject::SelectionNone) {
+            if (box->selectionState() != LayoutObject::SelectionNone) {
                 LayoutRect logicalRect(lastLogicalLeft, selTop, box->logicalLeft() - lastLogicalLeft, selHeight);
                 logicalRect.move(renderer().isHorizontalWritingMode() ? offsetFromRootBlock : LayoutSize(offsetFromRootBlock.height(), offsetFromRootBlock.width()));
                 LayoutRect gapRect = rootBlock->logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);
                 if (isPreviousBoxSelected && gapRect.width() > 0 && gapRect.height() > 0) {
                     if (paintInfo && box->parent()->renderer().style()->visibility() == VISIBLE)
                         paintInfo->context->fillRect(gapRect, box->parent()->renderer().selectionBackgroundColor());
                     // VisibleSelection may be non-contiguous, see comment above.
                     result.uniteCenter(gapRect);
                 }
                 lastLogicalLeft = box->logicalRight();
             }
             if (box == lastBox)
                 break;
-            isPreviousBoxSelected = box->selectionState() != RenderObject::SelectionNone;
+            isPreviousBoxSelected = box->selectionState() != LayoutObject::SelectionNone;
         }
     }
 
     return result;
 }
 
-RenderObject::SelectionState RootInlineBox::selectionState() const
+LayoutObject::SelectionState RootInlineBox::selectionState() const
 {
     // Walk over all of the selected boxes.
-    RenderObject::SelectionState state = RenderObject::SelectionNone;
+    LayoutObject::SelectionState state = LayoutObject::SelectionNone;
     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
-        RenderObject::SelectionState boxState = box->selectionState();
-        if ((boxState == RenderObject::SelectionStart && state == RenderObject::SelectionEnd)
-            || (boxState == RenderObject::SelectionEnd && state == RenderObject::SelectionStart)) {
-            state = RenderObject::SelectionBoth;
-        } else if (state == RenderObject::SelectionNone || ((boxState == RenderObject::SelectionStart || boxState == RenderObject::SelectionEnd) && (state == RenderObject::SelectionNone || state == RenderObject::SelectionInside))) {
+        LayoutObject::SelectionState boxState = box->selectionState();
+        if ((boxState == LayoutObject::SelectionStart && state == LayoutObject::SelectionEnd)
+            || (boxState == LayoutObject::SelectionEnd && state == LayoutObject::SelectionStart)) {
+            state = LayoutObject::SelectionBoth;
+        } else if (state == LayoutObject::SelectionNone || ((boxState == LayoutObject::SelectionStart || boxState == LayoutObject::SelectionEnd) && (state == LayoutObject::SelectionNone || state == LayoutObject::SelectionInside))) {
             state = boxState;
-        } else if (boxState == RenderObject::SelectionNone && state == RenderObject::SelectionStart) {
+        } else if (boxState == LayoutObject::SelectionNone && state == LayoutObject::SelectionStart) {
             // We are past the end of the selection.
-            state = RenderObject::SelectionBoth;
+            state = LayoutObject::SelectionBoth;
         }
-        if (state == RenderObject::SelectionBoth)
+        if (state == LayoutObject::SelectionBoth)
             break;
     }
 
     return state;
 }
 
 InlineBox* RootInlineBox::firstSelectedBox() const
 {
     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
-        if (box->selectionState() != RenderObject::SelectionNone)
+        if (box->selectionState() != LayoutObject::SelectionNone)
             return box;
     }
 
     return 0;
 }
 
 InlineBox* RootInlineBox::lastSelectedBox() const
 {
     for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) {
-        if (box->selectionState() != RenderObject::SelectionNone)
+        if (box->selectionState() != LayoutObject::SelectionNone)
             return box;
     }
 
     return 0;
 }
 
 LayoutUnit RootInlineBox::selectionTop() const
 {
     LayoutUnit selectionTop = m_lineTop;
 
@@ skipping 16 matching lines @@
             return selectionTop;
     }
 
     return prevBottom;
 }
 
 LayoutUnit RootInlineBox::selectionTopAdjustedForPrecedingBlock() const
 {
     LayoutUnit top = selectionTop();
 
-    RenderObject::SelectionState blockSelectionState = root().block().selectionState();
-    if (blockSelectionState != RenderObject::SelectionInside && blockSelectionState != RenderObject::SelectionEnd)
+    LayoutObject::SelectionState blockSelectionState = root().block().selectionState();
+    if (blockSelectionState != LayoutObject::SelectionInside && blockSelectionState != LayoutObject::SelectionEnd)
         return top;
 
     LayoutSize offsetToBlockBefore;
     if (RenderBlock* block = root().block().blockBeforeWithinSelectionRoot(offsetToBlockBefore)) {
         if (block->isRenderBlockFlow()) {
             if (RootInlineBox* lastLine = toRenderBlockFlow(block)->lastRootBox()) {
-                RenderObject::SelectionState lastLineSelectionState = lastLine->selectionState();
-                if (lastLineSelectionState != RenderObject::SelectionInside && lastLineSelectionState != RenderObject::SelectionStart)
+                LayoutObject::SelectionState lastLineSelectionState = lastLine->selectionState();
+                if (lastLineSelectionState != LayoutObject::SelectionInside && lastLineSelectionState != LayoutObject::SelectionStart)
                     return top;
 
                 LayoutUnit lastLineSelectionBottom = lastLine->selectionBottom() + offsetToBlockBefore.height();
                 top = std::max(top, lastLineSelectionBottom);
             }
         }
     }
 
     return top;
 }
@@ skipping 85 matching lines @@
     }
 
     return closestLeaf ? closestLeaf : lastLeaf;
 }
 
 BidiStatus RootInlineBox::lineBreakBidiStatus() const
 {
     return BidiStatus(static_cast<WTF::Unicode::Direction>(m_lineBreakBidiStatusEor), static_cast<WTF::Unicode::Direction>(m_lineBreakBidiStatusLastStrong), static_cast<WTF::Unicode::Direction>(m_lineBreakBidiStatusLast), m_lineBreakContext);
 }
 
-void RootInlineBox::setLineBreakInfo(RenderObject* obj, unsigned breakPos, const BidiStatus& status)
+void RootInlineBox::setLineBreakInfo(LayoutObject* obj, unsigned breakPos, const BidiStatus& status)
 {
-    // When setting lineBreakObj, the RenderObject must not be a RenderInline
+    // When setting lineBreakObj, the LayoutObject must not be a RenderInline
     // with no line boxes, otherwise all sorts of invariants are broken later.
-    // This has security implications because if the RenderObject does not
+    // This has security implications because if the LayoutObject does not
     // point to at least one line box, then that RenderInline can be deleted
     // later without resetting the lineBreakObj, leading to use-after-free.
     ASSERT_WITH_SECURITY_IMPLICATION(!obj || obj->isText() || !(obj->isRenderInline() && obj->isBox() && !toRenderBox(obj)->inlineBoxWrapper()));
 
     m_lineBreakObj = obj;
     m_lineBreakPos = breakPos;
     m_lineBreakBidiStatusEor = status.eor;
     m_lineBreakBidiStatusLastStrong = status.lastStrong;
     m_lineBreakBidiStatusLast = status.last;
     m_lineBreakContext = status.context;
 }
 
 EllipsisBox* RootInlineBox::ellipsisBox() const
 {
     if (!hasEllipsisBox())
         return 0;
     return gEllipsisBoxMap->get(this);
 }
 
-void RootInlineBox::removeLineBoxFromRenderObject()
+void RootInlineBox::removeLineBoxFromLayoutObject()
 {
     block().lineBoxes()->removeLineBox(this);
 }
 
-void RootInlineBox::extractLineBoxFromRenderObject()
+void RootInlineBox::extractLineBoxFromLayoutObject()
 {
     block().lineBoxes()->extractLineBox(this);
 }
 
-void RootInlineBox::attachLineBoxToRenderObject()
+void RootInlineBox::attachLineBoxToLayoutObject()
 {
     block().lineBoxes()->attachLineBox(this);
 }
 
 LayoutRect RootInlineBox::paddedLayoutOverflowRect(LayoutUnit endPadding) const
 {
     LayoutRect lineLayoutOverflow = layoutOverflowRect(lineTop(), lineBottom());
     if (!endPadding)
         return lineLayoutOverflow;
 
@@ skipping 144 matching lines @@
         LayoutUnit verticalPosition = verticalPositionCache.get(renderer, baselineType());
         if (verticalPosition != PositionUndefined)
             return verticalPosition;
     }
 
     LayoutUnit verticalPosition = 0;
     EVerticalAlign verticalAlign = renderer->style()->verticalAlign();
     if (verticalAlign == TOP || verticalAlign == BOTTOM)
         return 0;
 
-    RenderObject* parent = renderer->parent();
+    LayoutObject* parent = renderer->parent();
     if (parent->isRenderInline() && parent->style()->verticalAlign() != TOP && parent->style()->verticalAlign() != BOTTOM)
         verticalPosition = box->parent()->logicalTop();
 
     if (verticalAlign != BASELINE) {
         const Font& font = parent->style(firstLine)->font();
         const FontMetrics& fontMetrics = font.fontMetrics();
         int fontSize = font.fontDescription().computedPixelSize();
 
         LineDirectionMode lineDirection = parent->isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
 
@@ skipping 117 matching lines @@
 }
 
 #ifndef NDEBUG
 const char* RootInlineBox::boxName() const
 {
     return "RootInlineBox";
 }
 #endif
 
 } // namespace blink