Move SelectionState out of LayoutObject and into Line Layout API

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 265 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 LayoutBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, LayoutUnit selTop, LayoutUnit selHeight, const PaintInfo* paintInfo) const
 {
-    LayoutObject::SelectionState lineState = selectionState();
+    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()->layoutObject(), firstBox->logicalLeft(), selTop, selHeight, paintInfo));
     }
     if (rightGap) {
         result.uniteRight(block().logicalRightSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock,
             &lastBox->parent()->layoutObject(), 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() != LayoutObject::SelectionNone;
+        bool isPreviousBoxSelected = firstBox->selectionState() != SelectionNone;
         for (InlineBox* box = firstBox->nextLeafChild(); box; box = box->nextLeafChild()) {
-            if (box->selectionState() != LayoutObject::SelectionNone) {
+            if (box->selectionState() != SelectionNone) {
                 LayoutRect logicalRect(lastLogicalLeft, selTop, box->logicalLeft() - lastLogicalLeft, selHeight);
                 logicalRect.move(layoutObject().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()->layoutObject().style()->visibility() == VISIBLE)
                         paintInfo->context->fillRect(gapRect, box->parent()->layoutObject().selectionBackgroundColor());
                     // VisibleSelection may be non-contiguous, see comment above.
                     result.uniteCenter(gapRect);
                 }
                 lastLogicalLeft = box->logicalRight();
             }
             if (box == lastBox)
                 break;
-            isPreviousBoxSelected = box->selectionState() != LayoutObject::SelectionNone;
+            isPreviousBoxSelected = box->selectionState() != SelectionNone;
         }
     }
 
     return result;
 }
 
-LayoutObject::SelectionState RootInlineBox::selectionState() const
+SelectionState RootInlineBox::selectionState() const
 {
     // Walk over all of the selected boxes.
-    LayoutObject::SelectionState state = LayoutObject::SelectionNone;
+    SelectionState state = SelectionNone;
     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
-        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))) {
+        SelectionState boxState = box->selectionState();
+        if ((boxState == SelectionStart && state == SelectionEnd)
+            || (boxState == SelectionEnd && state == SelectionStart)) {
+            state = SelectionBoth;
+        } else if (state == SelectionNone || ((boxState == SelectionStart || boxState == SelectionEnd) && (state == SelectionNone || state == SelectionInside))) {
             state = boxState;
-        } else if (boxState == LayoutObject::SelectionNone && state == LayoutObject::SelectionStart) {
+        } else if (boxState == SelectionNone && state == SelectionStart) {
             // We are past the end of the selection.
-            state = LayoutObject::SelectionBoth;
+            state = SelectionBoth;
         }
-        if (state == LayoutObject::SelectionBoth)
+        if (state == SelectionBoth)
             break;
     }
 
     return state;
 }
 
 InlineBox* RootInlineBox::firstSelectedBox() const
 {
     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
-        if (box->selectionState() != LayoutObject::SelectionNone)
+        if (box->selectionState() != SelectionNone)
             return box;
     }
 
     return nullptr;
 }
 
 InlineBox* RootInlineBox::lastSelectedBox() const
 {
     for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) {
-        if (box->selectionState() != LayoutObject::SelectionNone)
+        if (box->selectionState() != SelectionNone)
             return box;
     }
 
     return nullptr;
 }
 
 LayoutUnit RootInlineBox::selectionTop() const
 {
     LayoutUnit selectionTop = m_lineTop;
 
@@ skipping 16 matching lines @@
             return selectionTop;
     }
 
     return prevBottom;
 }
 
 LayoutUnit RootInlineBox::selectionTopAdjustedForPrecedingBlock() const
 {
     LayoutUnit top = selectionTop();
 
-    LayoutObject::SelectionState blockSelectionState = root().block().selectionState();
-    if (blockSelectionState != LayoutObject::SelectionInside && blockSelectionState != LayoutObject::SelectionEnd)
+    SelectionState blockSelectionState = root().block().selectionState();
+    if (blockSelectionState != SelectionInside && blockSelectionState != SelectionEnd)
         return top;
 
     LayoutSize offsetToBlockBefore;
     if (LayoutBlock* block = root().block().blockBeforeWithinSelectionRoot(offsetToBlockBefore)) {
         if (block->isLayoutBlockFlow()) {
             if (RootInlineBox* lastLine = toLayoutBlockFlow(block)->lastRootBox()) {
-                LayoutObject::SelectionState lastLineSelectionState = lastLine->selectionState();
-                if (lastLineSelectionState != LayoutObject::SelectionInside && lastLineSelectionState != LayoutObject::SelectionStart)
+                SelectionState lastLineSelectionState = lastLine->selectionState();
+                if (lastLineSelectionState != SelectionInside && lastLineSelectionState != SelectionStart)
                     return top;
 
                 LayoutUnit lastLineSelectionBottom = lastLine->selectionBottom() + offsetToBlockBefore.height();
                 top = std::max(top, lastLineSelectionBottom);
             }
         }
     }
 
     return top;
 }
@@ skipping 420 matching lines @@
     endBox = nullptr;
     return nullptr;
 }
 
 const char* RootInlineBox::boxName() const
 {
     return "RootInlineBox";
 }
 
 } // namespace blink