Move computeInlineBoxPosition() out from PositionAlgorithm template class

This patch moves |computeInlineBoxPosition()| out from |PositionAlgorithm|
template class to reduce |InlineBox| dependency in |PositionAlgorithm| class
and simplify |PositionAlgorithm| class for improving code health.

Following patch will move |computeInlineBoxPosition()| to "VisibleUnits.cpp".

BUG=518738
TEST=n/a; no behavior changes

Review URL: https://codereview.chromium.org/1295893006

git-svn-id: svn://svn.chromium.org/blink/trunk@200906 bbb929c8-8fbe-4397-9dbb-9b2b20218538

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

@@ -619,9 +619,19 @@ bool inRenderedText(const PositionInComposedTree& position)
 }
 
 template <typename Strategy>
-InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(TextAffinity affinity) const
+static InlineBoxPosition computeInlineBoxPositionAlgorithm(const PositionAlgorithm<Strategy>& position, TextAffinity affinity)
 {
-    return computeInlineBoxPosition(affinity, primaryDirectionOf(*anchorNode()));
+    return computeInlineBoxPositionAlgorithm<Strategy>(position, affinity, primaryDirectionOf(*position.anchorNode()));
+}
+
+InlineBoxPosition computeInlineBoxPosition(const Position& position, TextAffinity affinity)
+{
+    return computeInlineBoxPositionAlgorithm<EditingStrategy>(position, affinity);
+}
+
+InlineBoxPosition computeInlineBoxPosition(const PositionInComposedTree& position, TextAffinity affinity)
+{
+    return computeInlineBoxPositionAlgorithm<EditingInComposedTreeStrategy>(position, affinity);
 }
 
 static bool isNonTextLeafChild(LayoutObject* object)
@@ -683,28 +693,28 @@ PositionAlgorithm<Strategy> upstreamIgnoringEditingBoundaries(PositionAlgorithm<
 }
 
 template <typename Strategy>
-InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(TextAffinity affinity, TextDirection primaryDirection) const
+static InlineBoxPosition computeInlineBoxPositionAlgorithm(const PositionAlgorithm<Strategy>& position, TextAffinity affinity, TextDirection primaryDirection)
 {
     InlineBox* inlineBox = nullptr;
-    int caretOffset = computeEditingOffset();
-    LayoutObject* layoutObject = m_anchorNode->isShadowRoot() ? toShadowRoot(m_anchorNode)->host()->layoutObject() : m_anchorNode->layoutObject();
+    int caretOffset = position.computeEditingOffset();
+    Node* const anchorNode = position.anchorNode();
+    LayoutObject* layoutObject = anchorNode->isShadowRoot() ? toShadowRoot(anchorNode)->host()->layoutObject() : anchorNode->layoutObject();
 
     if (!layoutObject->isText()) {
         inlineBox = 0;
-        if (canHaveChildrenForEditing(anchorNode()) && layoutObject->isLayoutBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(layoutObject)) {
+        if (canHaveChildrenForEditing(anchorNode) && layoutObject->isLayoutBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(layoutObject)) {
             // Try a visually equivalent position with possibly opposite
             // editability. This helps in case |this| is in an editable block
             // but surrounded by non-editable positions. It acts to negate the
             // logic at the beginning of LayoutObject::createVisiblePosition().
-            PositionAlgorithm<Strategy> thisPosition = PositionAlgorithm<Strategy>(*this);
-            PositionAlgorithm<Strategy> equivalent = downstreamIgnoringEditingBoundaries(thisPosition);
-            if (equivalent == thisPosition) {
-                equivalent = upstreamIgnoringEditingBoundaries(thisPosition);
-                if (equivalent == thisPosition || downstreamIgnoringEditingBoundaries(equivalent) == thisPosition)
+            PositionAlgorithm<Strategy> equivalent = downstreamIgnoringEditingBoundaries(position);
+            if (equivalent == position) {
+                equivalent = upstreamIgnoringEditingBoundaries(position);
+                if (equivalent == position || downstreamIgnoringEditingBoundaries(equivalent) == position)
                     return InlineBoxPosition(inlineBox, caretOffset);
             }
 
-            return equivalent.computeInlineBoxPosition(TextAffinity::Upstream, primaryDirection);
+            return computeInlineBoxPosition(equivalent, TextAffinity::Upstream, primaryDirection);
         }
         if (layoutObject->isBox()) {
             inlineBox = toLayoutBox(layoutObject)->inlineBoxWrapper();
@@ -848,6 +858,16 @@ InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(TextAffi
     return InlineBoxPosition(inlineBox, inlineBox->caretRightmostOffset());
 }
 
+InlineBoxPosition computeInlineBoxPosition(const Position& position, TextAffinity affinity, TextDirection primaryDirection)
+{
+    return computeInlineBoxPositionAlgorithm<EditingStrategy>(position, affinity, primaryDirection);
+}
+
+InlineBoxPosition computeInlineBoxPosition(const PositionInComposedTree& position, TextAffinity affinity, TextDirection primaryDirection)
+{
+    return computeInlineBoxPositionAlgorithm<EditingInComposedTreeStrategy>(position, affinity, primaryDirection);
+}
+
 template <typename Strategy>
 void PositionAlgorithm<Strategy>::debugPosition(const char* msg) const
 {

third_party/WebKit/Source/core/editing/Position.h

@@ -189,9 +189,6 @@ public:
 
     bool isCandidate() const;
 
-    InlineBoxPosition computeInlineBoxPosition(TextAffinity) const;
-    InlineBoxPosition computeInlineBoxPosition(TextAffinity, TextDirection primaryDirection) const;
-
     static PositionAlgorithm<Strategy> beforeNode(Node* anchorNode);
     static PositionAlgorithm<Strategy> afterNode(Node* anchorNode);
     static PositionAlgorithm<Strategy> inParentBeforeNode(const Node& anchorNode);
@@ -433,6 +430,17 @@ inline PositionInComposedTree fromPositionInDOMTree<EditingInComposedTreeStrateg
     return toPositionInComposedTree(position);
 }
 
+// TODO(yosin) |isRenderedCharacter()| should be removed, and we should use
+// |VisiblePosition::characterAfter()| and |VisiblePosition::characterBefore()|.
+// TODO(yosin) We should move |isRenderedCharacter()| to "VisibleUnits.cpp",
+// since it is used only in "editing/commands/"
+CORE_EXPORT bool isRenderedCharacter(const Position&);
+// TODO(yosin) We should move |computeInlineBoxPosition()| to "VisibleUnits.cpp"
+CORE_EXPORT InlineBoxPosition computeInlineBoxPosition(const Position&, TextAffinity);
+CORE_EXPORT InlineBoxPosition computeInlineBoxPosition(const Position&, TextAffinity, TextDirection primaryDirection);
+CORE_EXPORT InlineBoxPosition computeInlineBoxPosition(const PositionInComposedTree&, TextAffinity);
+CORE_EXPORT InlineBoxPosition computeInlineBoxPosition(const PositionInComposedTree&, TextAffinity, TextDirection primaryDirection);
+
 // TODO(yosin) We should move |inRenderedText()| to "VisibleUnits.h" for
 // reduce dependency of |LayoutObject| in |Position| class.
 CORE_EXPORT bool inRenderedText(const Position&);

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

@@ -92,7 +92,7 @@ RenderedPosition::RenderedPosition(const Position& position, TextAffinity affini
 {
     if (position.isNull())
         return;
-    InlineBoxPosition boxPosition = position.computeInlineBoxPosition(affinity);
+    InlineBoxPosition boxPosition = computeInlineBoxPosition(position, affinity);
     m_inlineBox = boxPosition.inlineBox;
     m_offset = boxPosition.offsetInBox;
     if (m_inlineBox)

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

@@ -124,7 +124,7 @@ Position VisiblePosition::leftVisuallyDistinctCandidate() const
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
 
     while (true) {
-        InlineBoxPosition boxPosition = p.computeInlineBoxPosition(m_affinity, primaryDirection);
+        InlineBoxPosition boxPosition = computeInlineBoxPosition(p, m_affinity, primaryDirection);
         InlineBox* box = boxPosition.inlineBox;
         int offset = boxPosition.offsetInBox;
         if (!box)
@@ -161,7 +161,7 @@ Position VisiblePosition::leftVisuallyDistinctCandidate() const
                     if (positionOnLeft.isNull())
                         return Position();
 
-                    InlineBox* boxOnLeft = positionOnLeft.computeInlineBoxPosition(m_affinity, primaryDirection).inlineBox;
+                    InlineBox* boxOnLeft = computeInlineBoxPosition(positionOnLeft, m_affinity, primaryDirection).inlineBox;
                     if (boxOnLeft && boxOnLeft->root() == box->root())
                         return Position();
                     return positionOnLeft;
@@ -283,7 +283,7 @@ Position VisiblePosition::rightVisuallyDistinctCandidate() const
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
 
     while (true) {
-        InlineBoxPosition boxPosition = p.computeInlineBoxPosition(m_affinity, primaryDirection);
+        InlineBoxPosition boxPosition = computeInlineBoxPosition(p, m_affinity, primaryDirection);
         InlineBox* box = boxPosition.inlineBox;
         int offset = boxPosition.offsetInBox;
         if (!box)
@@ -320,7 +320,7 @@ Position VisiblePosition::rightVisuallyDistinctCandidate() const
                     if (positionOnRight.isNull())
                         return Position();
 
-                    InlineBox* boxOnRight = positionOnRight.computeInlineBoxPosition(m_affinity, primaryDirection).inlineBox;
+                    InlineBox* boxOnRight = computeInlineBoxPosition(positionOnRight, m_affinity, primaryDirection).inlineBox;
                     if (boxOnRight && boxOnRight->root() == box->root())
                         return Position();
                     return positionOnRight;

third_party/WebKit/Source/core/editing/VisiblePosition.h

@@ -142,7 +142,7 @@ private:
 // with |Position| version.
 inline InlineBoxPosition computeInlineBoxPosition(const VisiblePosition& position)
 {
-    return position.deepEquivalent().computeInlineBoxPosition(position.affinity());
+    return computeInlineBoxPosition(position.deepEquivalent(), position.affinity());
 }
 
 EphemeralRange makeRange(const VisiblePosition&, const VisiblePosition&);

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

@@ -377,7 +377,7 @@ static VisiblePosition visualWordPosition(const VisiblePosition& visiblePosition
         if (adjacentCharacterPosition.deepEquivalent() == current.deepEquivalent() || adjacentCharacterPosition.isNull())
             return VisiblePosition();
 
-        InlineBoxPosition boxPosition = adjacentCharacterPosition.deepEquivalent().computeInlineBoxPosition(TextAffinity::Upstream);
+        InlineBoxPosition boxPosition = computeInlineBoxPosition(adjacentCharacterPosition.deepEquivalent(), TextAffinity::Upstream);
         InlineBox* box = boxPosition.inlineBox;
         int offsetInBox = boxPosition.offsetInBox;
 
@@ -1444,7 +1444,7 @@ LayoutRect localCaretRectOfPosition(const PositionWithAffinity& position, Layout
     if (!layoutObject)
         return LayoutRect();
 
-    InlineBoxPosition boxPosition = position.position().computeInlineBoxPosition(position.affinity());
+    InlineBoxPosition boxPosition = computeInlineBoxPosition(position.position(), position.affinity());
 
     if (boxPosition.inlineBox)
         layoutObject = &boxPosition.inlineBox->layoutObject();
@@ -1592,8 +1592,8 @@ bool rendersInDifferentPosition(const Position& position1, const Position& posit
     if (layoutObject == posLayoutObject && renderedOffset1 == renderedOffset2)
         return false;
 
-    InlineBoxPosition boxPosition1 = position1.computeInlineBoxPosition(TextAffinity::Downstream);
-    InlineBoxPosition boxPosition2 = position2.computeInlineBoxPosition(TextAffinity::Downstream);
+    InlineBoxPosition boxPosition1 = computeInlineBoxPosition(position1, TextAffinity::Downstream);
+    InlineBoxPosition boxPosition2 = computeInlineBoxPosition(position2, TextAffinity::Downstream);
 
     WTF_LOG(Editing, "layoutObject1:   %p [%p]\n", layoutObject, boxPosition1.inlineBox);
     WTF_LOG(Editing, "renderedOffset1: %d\n", renderedOffset1);