Rename LineLayoutPaintShim -> LineLayoutAPIShim

third_party/WebKit/Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 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 35 matching lines @@
 #include "core/frame/Settings.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTextFragment.h"
 #include "core/layout/LayoutView.h"
+#include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/api/LineLayoutItem.h"
 #include "core/layout/line/InlineIterator.h"
 #include "core/layout/line/InlineTextBox.h"
-#include "core/paint/LineLayoutPaintShim.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/Logging.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/heap/Handle.h"
 #include "platform/text/TextBoundaries.h"
 
 namespace blink {
 
 template <typename PositionType>
 static PositionType canonicalizeCandidate(const PositionType& candidate)
@@ skipping 2047 matching lines @@
     }
     Node* node = position.position().anchorNode();
 
     layoutObject = node->layoutObject();
     if (!layoutObject)
         return LayoutRect();
 
     InlineBoxPosition boxPosition = computeInlineBoxPosition(position.position(), position.affinity());
 
     if (boxPosition.inlineBox)
-        layoutObject = LineLayoutPaintShim::layoutObjectFrom(boxPosition.inlineBox->lineLayoutItem());
+        layoutObject = LineLayoutAPIShim::layoutObjectFrom(boxPosition.inlineBox->lineLayoutItem());
 
     return layoutObject->localCaretRect(boxPosition.inlineBox, boxPosition.offsetInBox);
 }
 
 LayoutRect localCaretRectOfPosition(const PositionWithAffinity& position, LayoutObject*& layoutObject)
 {
     return localCaretRectOfPositionTemplate<EditingStrategy>(position, layoutObject);
 }
 
 LayoutRect localCaretRectOfPosition(const PositionInComposedTreeWithAffinity& position, LayoutObject*& layoutObject)
@@ skipping 391 matching lines @@
 
                 // The text continues on the next line only if the last text box is not on this line and
                 // none of the boxes on this line have a larger start offset.
 
                 bool continuesOnNextLine = true;
                 InlineBox* otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->nextLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (LineLayoutPaintShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() > textOffset))
+                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() > textOffset))
                         continuesOnNextLine = false;
                 }
 
                 otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->prevLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (LineLayoutPaintShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() > textOffset))
+                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() > textOffset))
                         continuesOnNextLine = false;
                 }
 
                 if (continuesOnNextLine)
                     return currentPos.computePosition();
             }
         }
     }
     return lastVisible.deprecatedComputePosition();
 }
@@ skipping 101 matching lines @@
 
                 // The text continues on the next line only if the last text box is not on this line and
                 // none of the boxes on this line have a larger start offset.
 
                 bool continuesOnNextLine = true;
                 InlineBox* otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->nextLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (LineLayoutPaintShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() >= textOffset))
+                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() >= textOffset))
                         continuesOnNextLine = false;
                 }
 
                 otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->prevLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (LineLayoutPaintShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() >= textOffset))
+                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() >= textOffset))
                         continuesOnNextLine = false;
                 }
 
                 if (continuesOnNextLine)
                     return currentPos.computePosition();
             }
         }
     }
 
     return lastVisible.deprecatedComputePosition();
@@ skipping 387 matching lines @@
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
     const TextAffinity affinity = visiblePosition.affinity();
 
     while (true) {
         InlineBoxPosition boxPosition = computeInlineBoxPosition(p, affinity, primaryDirection);
         InlineBox* box = boxPosition.inlineBox;
         int offset = boxPosition.offsetInBox;
         if (!box)
             return primaryDirection == LTR ? nextVisuallyDistinctCandidate(deepPosition) : previousVisuallyDistinctCandidate(deepPosition);
 
-        LayoutObject* layoutObject = LineLayoutPaintShim::layoutObjectFrom(box->lineLayoutItem());
+        LayoutObject* layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
 
         while (true) {
             if ((layoutObject->isAtomicInlineLevel() || layoutObject->isBR()) && offset == box->caretLeftmostOffset())
                 return box->isLeftToRightDirection() ? nextVisuallyDistinctCandidate(deepPosition) : previousVisuallyDistinctCandidate(deepPosition);
 
             if (!layoutObject->node()) {
                 box = box->nextLeafChild();
                 if (!box)
                     return primaryDirection == LTR ? nextVisuallyDistinctCandidate(deepPosition) : previousVisuallyDistinctCandidate(deepPosition);
-                layoutObject = LineLayoutPaintShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
                 offset = box->caretLeftmostOffset();
                 continue;
             }
 
             offset = box->isLeftToRightDirection() ? layoutObject->nextOffset(offset) : layoutObject->previousOffset(offset);
 
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (offset > caretMinOffset && offset < caretMaxOffset)
                 break;
 
             if (box->isLeftToRightDirection() ? offset > caretMaxOffset : offset < caretMinOffset) {
                 // Overshot to the right.
                 InlineBox* nextBox = box->nextLeafChildIgnoringLineBreak();
                 if (!nextBox) {
                     PositionTemplate<Strategy> positionOnRight = primaryDirection == LTR ? nextVisuallyDistinctCandidate(deepPosition) : previousVisuallyDistinctCandidate(deepPosition);
                     if (positionOnRight.isNull())
                         return PositionTemplate<Strategy>();
 
                     InlineBox* boxOnRight = computeInlineBoxPosition(positionOnRight, affinity, primaryDirection).inlineBox;
                     if (boxOnRight && boxOnRight->root() == box->root())
                         return PositionTemplate<Strategy>();
                     return positionOnRight;
                 }
 
                 // Reposition at the other logical position corresponding to our
                 // edge's visual position and go for another round.
                 box = nextBox;
-                layoutObject = LineLayoutPaintShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
                 offset = nextBox->caretLeftmostOffset();
                 continue;
             }
 
             ASSERT(offset == box->caretRightmostOffset());
 
             unsigned char level = box->bidiLevel();
             InlineBox* nextBox = box->nextLeafChild();
 
             if (box->direction() == primaryDirection) {
                 if (!nextBox) {
                     InlineBox* logicalEnd = 0;
                     if (primaryDirection == LTR ? box->root().getLogicalEndBoxWithNode(logicalEnd) : box->root().getLogicalStartBoxWithNode(logicalEnd)) {
                         box = logicalEnd;
-                        layoutObject = LineLayoutPaintShim::layoutObjectFrom(box->lineLayoutItem());
+                        layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
                         offset = primaryDirection == LTR ? box->caretMaxOffset() : box->caretMinOffset();
                     }
                     break;
                 }
 
                 if (nextBox->bidiLevel() >= level)
                     break;
 
                 level = nextBox->bidiLevel();
 
                 InlineBox* prevBox = box;
                 do {
                     prevBox = prevBox->prevLeafChild();
                 } while (prevBox && prevBox->bidiLevel() > level);
 
                 // For example, abc FED 123 ^ CBA
                 if (prevBox && prevBox->bidiLevel() == level)
                     break;
 
                 // For example, abc 123 ^ CBA or 123 ^ CBA abc
                 box = nextBox;
-                layoutObject = LineLayoutPaintShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
                 offset = box->caretLeftmostOffset();
                 if (box->direction() == primaryDirection)
                     break;
                 continue;
             }
 
             while (nextBox && !nextBox->lineLayoutItem().node())
                 nextBox = nextBox->nextLeafChild();
 
             if (nextBox) {
                 box = nextBox;
-                layoutObject = LineLayoutPaintShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
                 offset = box->caretLeftmostOffset();
 
                 if (box->bidiLevel() > level) {
                     do {
                         nextBox = nextBox->nextLeafChild();
                     } while (nextBox && nextBox->bidiLevel() > level);
 
                     if (!nextBox || nextBox->bidiLevel() < level)
                         continue;
                 }
@@ skipping 10 matching lines @@
                     level = box->bidiLevel();
                     while (InlineBox* nextBox = box->nextLeafChild()) {
                         if (nextBox->bidiLevel() < level)
                             break;
                         box = nextBox;
                     }
                     if (box->bidiLevel() == level)
                         break;
                     level = box->bidiLevel();
                 }
-                layoutObject = LineLayoutPaintShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
                 offset = primaryDirection == LTR ? box->caretMaxOffset() : box->caretMinOffset();
             }
             break;
         }
 
         p = PositionTemplate<Strategy>::editingPositionOf(layoutObject->node(), offset);
 
         if ((isVisuallyEquivalentCandidate(p) && mostForwardCaretPosition(p) != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
             return p;
 
@@ skipping 109 matching lines @@
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInComposedTree previousPositionOf(const VisiblePositionInComposedTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink