[CodeHealth] Use PositionStrategy<Strategy> instead of using ::PositionType

Source/core/dom/Position.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 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 63 matching lines @@
             continue;
         if (!node->hasEditableStyle())
             continue;
         if ((layoutObject->isBox() && toLayoutBox(layoutObject)->inlineBoxWrapper()) || (layoutObject->isText() && toLayoutText(layoutObject)->firstTextBox()))
             return node;
     }
     return 0;
 }
 
 template <typename Strategy>
-const TreeScope* PositionAlgorithm<Strategy>::commonAncestorTreeScope(const PositionType& a, const PositionType& b)
+const TreeScope* PositionAlgorithm<Strategy>::commonAncestorTreeScope(const PositionAlgorithm<Strategy>& a, const PositionAlgorithm<Strategy>& b)
 {
     if (!a.containerNode() || !b.containerNode())
         return nullptr;
     return a.containerNode()->treeScope().commonAncestorTreeScope(b.containerNode()->treeScope());
 }
 
 template <typename Strategy>
 PositionAlgorithm<Strategy>::PositionAlgorithm(PassRefPtrWillBeRawPtr<Node> anchorNode, LegacyEditingOffset offset)
     : m_anchorNode(anchorNode)
     , m_offset(offset.value())
@@ skipping 128 matching lines @@
 int PositionAlgorithm<Strategy>::offsetForPositionAfterAnchor() const
 {
     ASSERT(m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren);
     ASSERT(!m_isLegacyEditingPosition);
     return Strategy::lastOffsetForEditing(m_anchorNode.get());
 }
 
 // Neighbor-anchored positions are invalid DOM positions, so they need to be
 // fixed up before handing them off to the Range object.
 template <typename Strategy>
-typename Strategy::PositionType PositionAlgorithm<Strategy>::parentAnchoredEquivalent() const
+typename PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::parentAnchoredEquivalent() const

[yosin_UTC9, 2015/06/26 08:39:24]

We don't need to have |typename|.
Apply this comment rest of file.

[yoichio, 2015/06/29 06:00:33]

Done.

 {
     if (!m_anchorNode)
-        return PositionType();
+        return PositionAlgorithm<Strategy>();
 
     // FIXME: This should only be necessary for legacy positions, but is also needed for positions before and after Tables
     if (m_offset <= 0 && (m_anchorType != PositionIsAfterAnchor && m_anchorType != PositionIsAfterChildren)) {
         if (Strategy::parent(*m_anchorNode) && (Strategy::editingIgnoresContent(m_anchorNode.get()) || isRenderedHTMLTableElement(m_anchorNode.get())))
             return inParentBeforeNode(*m_anchorNode);
-        return PositionType(m_anchorNode.get(), 0, PositionIsOffsetInAnchor);
+        return PositionAlgorithm<Strategy>(m_anchorNode.get(), 0, PositionIsOffsetInAnchor);
     }
     if (!m_anchorNode->offsetInCharacters()
         && (m_anchorType == PositionIsAfterAnchor || m_anchorType == PositionIsAfterChildren || static_cast<unsigned>(m_offset) == m_anchorNode->countChildren())
         && (Strategy::editingIgnoresContent(m_anchorNode.get()) || isRenderedHTMLTableElement(m_anchorNode.get()))
         && containerNode()) {
         return inParentAfterNode(*m_anchorNode);
     }
 
-    return PositionType(containerNode(), computeOffsetInContainerNode(), PositionIsOffsetInAnchor);
+    return PositionAlgorithm<Strategy>(containerNode(), computeOffsetInContainerNode(), PositionIsOffsetInAnchor);
 }
 
 template <typename Strategy>
-typename Strategy::PositionType PositionAlgorithm<Strategy>::toOffsetInAnchor() const
+typename PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::toOffsetInAnchor() const
 {
     if (isNull())
-        return PositionType();
+        return PositionAlgorithm<Strategy>();
 
-    return PositionType(containerNode(), computeOffsetInContainerNode(), PositionIsOffsetInAnchor);
+    return PositionAlgorithm<Strategy>(containerNode(), computeOffsetInContainerNode(), PositionIsOffsetInAnchor);
 }
 
 template <typename Strategy>
 Node* PositionAlgorithm<Strategy>::computeNodeBeforePosition() const
 {
     if (!m_anchorNode)
         return 0;
     switch (anchorType()) {
     case PositionIsBeforeChildren:
         return 0;
@@ skipping 68 matching lines @@
     if (m_anchorType != PositionIsOffsetInAnchor)
         return toOffsetInAnchor().nodeAsRangePastLastNode();
     if (m_anchorNode->offsetInCharacters())
         return Strategy::nextSkippingChildren(*m_anchorNode);
     if (Node* child = Strategy::childAt(*m_anchorNode, m_offset))
         return child;
     return Strategy::nextSkippingChildren(*m_anchorNode);
 }
 
 template <typename Strategy>
-Node* PositionAlgorithm<Strategy>::commonAncestorContainer(const PositionType& other) const
+Node* PositionAlgorithm<Strategy>::commonAncestorContainer(const PositionAlgorithm<Strategy>& other) const
 {
     return Strategy::commonAncestor(*containerNode(), *other.containerNode());
 }
 
 template <typename Strategy>
 typename PositionAlgorithm<Strategy>::AnchorType PositionAlgorithm<Strategy>::anchorTypeForLegacyEditingPosition(Node* anchorNode, int offset)
 {
     if (anchorNode && Strategy::editingIgnoresContent(anchorNode)) {
         if (offset == 0)
             return PositionIsBeforeAnchor;
@@ skipping 28 matching lines @@
     ASSERT(positionB.isNotNull());
 
     Node* containerA = positionA.containerNode();
     Node* containerB = positionB.containerNode();
     int offsetA = positionA.computeOffsetInContainerNode();
     int offsetB = positionB.computeOffsetInContainerNode();
     return EditingInComposedTreeStrategy::comparePositions(containerA, offsetA, containerB, offsetB);
 }
 
 template <typename Strategy>
-int PositionAlgorithm<Strategy>::compareTo(const PositionType& other) const
+int PositionAlgorithm<Strategy>::compareTo(const PositionAlgorithm<Strategy>& other) const
 {
     return comparePositions(*this, other);
 }
 
 template <typename Strategy>
-typename Strategy::PositionType PositionAlgorithm<Strategy>::previous(PositionMoveType moveType) const
+typename PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::previous(PositionMoveType moveType) const
 {
     Node* node = deprecatedNode();
     if (!node)
-        return PositionType(*this);
+        return PositionAlgorithm<Strategy>(*this);
 
     int offset = deprecatedEditingOffset();
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(offset >= 0);
 
     if (offset > 0) {
         if (Node* child = Strategy::childAt(*node, offset - 1))
             return lastPositionInOrAfterNode(child);
 
         // There are two reasons child might be 0:
         //   1) The node is node like a text node that is not an element, and therefore has no children.
         //      Going backward one character at a time is correct.
         //   2) The old offset was a bogus offset like (<br>, 1), and there is no child.
         //      Going from 1 to 0 is correct.
         switch (moveType) {
         case CodePoint:
             return createLegacyEditingPosition(node, offset - 1);
         case Character:
             return createLegacyEditingPosition(node, uncheckedPreviousOffset(node, offset));
         case BackwardDeletion:
             return createLegacyEditingPosition(node, uncheckedPreviousOffsetForBackwardDeletion(node, offset));
         }
     }
 
     if (ContainerNode* parent = Strategy::parent(*node))
         return createLegacyEditingPosition(parent, node->nodeIndex());
-    return PositionType(*this);
+    return PositionAlgorithm<Strategy>(*this);
 }
 
 template <typename Strategy>
-typename Strategy::PositionType PositionAlgorithm<Strategy>::next(PositionMoveType moveType) const
+typename PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::next(PositionMoveType moveType) const
 {
     ASSERT(moveType != BackwardDeletion);
 
     Node* node = deprecatedNode();
     if (!node)
-        return PositionType(*this);
+        return PositionAlgorithm<Strategy>(*this);
 
     int offset = deprecatedEditingOffset();
     // FIXME: Negative offsets shouldn't be allowed. We should catch this earlier.
     ASSERT(offset >= 0);
 
     if (Node* child = Strategy::childAt(*node, offset))
         return firstPositionInOrBeforeNode(child);
 
     if (!Strategy::hasChildren(*node) && offset < lastOffsetForEditing(node)) {
         // There are two reasons child might be 0:
         //   1) The node is node like a text node that is not an element, and therefore has no children.
         //      Going forward one character at a time is correct.
         //   2) The new offset is a bogus offset like (<br>, 1), and there is no child.
         //      Going from 0 to 1 is correct.
         return createLegacyEditingPosition(node, (moveType == Character) ? uncheckedNextOffset(node, offset) : offset + 1);
     }
 
     if (ContainerNode* parent = Strategy::parent(*node))
         return createLegacyEditingPosition(parent, node->nodeIndex() + 1);
-    return PositionType(*this);
+    return PositionAlgorithm<Strategy>(*this);
 }
 
 template <typename Strategy>
 int PositionAlgorithm<Strategy>::uncheckedPreviousOffset(const Node* n, int current)
 {
     return n->layoutObject() ? n->layoutObject()->previousOffset(current) : current - 1;
 }
 
 template <typename Strategy>
 int PositionAlgorithm<Strategy>::uncheckedPreviousOffsetForBackwardDeletion(const Node* n, int current)
@@ skipping 41 matching lines @@
 // A position is considered at editing boundary if one of the following is true:
 // 1. It is the first position in the node and the next visually equivalent position
 //    is non editable.
 // 2. It is the last position in the node and the previous visually equivalent position
 //    is non editable.
 // 3. It is an editable position and both the next and previous visually equivalent
 //    positions are both non editable.
 template <typename Strategy>
 bool PositionAlgorithm<Strategy>::atEditingBoundary() const
 {
-    PositionType nextPosition = downstream(CanCrossEditingBoundary);
+    PositionAlgorithm<Strategy> nextPosition = downstream(CanCrossEditingBoundary);
     if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.deprecatedNode()->hasEditableStyle())
         return true;
 
-    PositionType prevPosition = upstream(CanCrossEditingBoundary);
+    PositionAlgorithm<Strategy> prevPosition = upstream(CanCrossEditingBoundary);
     if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->hasEditableStyle())
         return true;
 
     return nextPosition.isNotNull() && !nextPosition.deprecatedNode()->hasEditableStyle()
         && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->hasEditableStyle();
 }
 
 template <typename Strategy>
 static ContainerNode* nonShadowBoundaryParentNode(Node* node)
 {
@@ skipping 108 matching lines @@
     return pos.atStartOfNode();
 }
 
 // This function and downstream() are used for moving back and forth between visually equivalent candidates.
 // For example, for the text node "foo     bar" where whitespace is collapsible, there are two candidates
 // that map to the VisiblePosition between 'b' and the space.  This function will return the left candidate
 // and downstream() will return the right one.
 // Also, upstream() will return [boundary, 0] for any of the positions from [boundary, 0] to the first candidate
 // in boundary, where endsOfNodeAreVisuallyDistinctPositions(boundary) is true.
 template <typename Strategy>
-typename Strategy::PositionType PositionAlgorithm<Strategy>::upstream(EditingBoundaryCrossingRule rule) const
+typename PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::upstream(EditingBoundaryCrossingRule rule) const
 {
     Node* startNode = deprecatedNode();
     if (!startNode)
-        return PositionType();
+        return PositionAlgorithm<Strategy>();
 
     // iterate backward from there, looking for a qualified position
     Node* boundary = enclosingVisualBoundary<Strategy>(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
-    typename Strategy::PositionIteratorType lastVisible(m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : PositionType(*this));
+    typename Strategy::PositionIteratorType lastVisible(m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : PositionAlgorithm<Strategy>(*this));
     typename Strategy::PositionIteratorType currentPos = lastVisible;
     bool startEditable = startNode->hasEditableStyle();
     Node* lastNode = startNode;
     bool boundaryCrossed = false;
     for (; !currentPos.atStart(); currentPos.decrement()) {
         Node* currentNode = currentPos.node();
         // Don't check for an editability change if we haven't moved to a different node,
         // to avoid the expense of computing hasEditableStyle().
         if (currentNode != lastNode) {
             // Don't change editability.
@@ skipping 92 matching lines @@
 }
 
 // This function and upstream() are used for moving back and forth between visually equivalent candidates.
 // For example, for the text node "foo     bar" where whitespace is collapsible, there are two candidates
 // that map to the VisiblePosition between 'b' and the space.  This function will return the right candidate
 // and upstream() will return the left one.
 // Also, downstream() will return the last position in the last atomic node in boundary for all of the positions
 // in boundary after the last candidate, where endsOfNodeAreVisuallyDistinctPositions(boundary).
 // FIXME: This function should never be called when the line box tree is dirty. See https://bugs.webkit.org/show_bug.cgi?id=97264
 template <typename Strategy>
-typename Strategy::PositionType PositionAlgorithm<Strategy>::downstream(EditingBoundaryCrossingRule rule) const
+typename PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::downstream(EditingBoundaryCrossingRule rule) const
 {
     Node* startNode = deprecatedNode();
     if (!startNode)
-        return PositionType();
+        return PositionAlgorithm<Strategy>();
 
     // iterate forward from there, looking for a qualified position
     Node* boundary = enclosingVisualBoundary<Strategy>(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
-    typename Strategy::PositionIteratorType lastVisible(m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : PositionType(*this));
+    typename Strategy::PositionIteratorType lastVisible(m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : PositionAlgorithm<Strategy>(*this));
     typename Strategy::PositionIteratorType currentPos = lastVisible;
     bool startEditable = startNode->hasEditableStyle();
     Node* lastNode = startNode;
     bool boundaryCrossed = false;
     for (; !currentPos.atEnd(); currentPos.increment()) {
         Node* currentNode = currentPos.node();
         // Don't check for an editability change if we haven't moved to a different node,
         // to avoid the expense of computing hasEditableStyle().
         if (currentNode != lastNode) {
             // Don't change editability.
@@ skipping 241 matching lines @@
             return false;
         }
         if (m_offset >= static_cast<int>(box->start()) && m_offset < static_cast<int>(box->start() + box->len()))
             return true;
     }
 
     return false;
 }
 
 template <typename Strategy>
-bool PositionAlgorithm<Strategy>::rendersInDifferentPosition(const PositionType &pos) const
+bool PositionAlgorithm<Strategy>::rendersInDifferentPosition(const PositionAlgorithm<Strategy> &pos) const
 {
     if (isNull() || pos.isNull())
         return false;
 
     LayoutObject* layoutObject = deprecatedNode()->layoutObject();
     if (!layoutObject)
         return false;
 
     LayoutObject* posLayoutObject = pos.deprecatedNode()->layoutObject();
     if (!posLayoutObject)
@@ skipping 107 matching lines @@
                     minOffset = caretMinOffset;
                 }
             }
             if (match)
                 return match;
         }
     }
     return 0;
 }
 
-template <typename PositionType>
-PositionType downstreamIgnoringEditingBoundaries(PositionType position)
+template <typename Strategy>
+PositionAlgorithm<Strategy> downstreamIgnoringEditingBoundaries(PositionAlgorithm<Strategy> position)
 {
-    PositionType lastPosition;
+    PositionAlgorithm<Strategy> lastPosition;
     while (position != lastPosition) {
         lastPosition = position;
         position = position.downstream(CanCrossEditingBoundary);
     }
     return position;
 }
 
-template <typename PositionType>
-PositionType upstreamIgnoringEditingBoundaries(PositionType position)
+template <typename Strategy>
+PositionAlgorithm<Strategy> upstreamIgnoringEditingBoundaries(PositionAlgorithm<Strategy> position)
 {
-    PositionType lastPosition;
+    PositionAlgorithm<Strategy> lastPosition;
     while (position != lastPosition) {
         lastPosition = position;
         position = position.upstream(CanCrossEditingBoundary);
     }
     return position;
 }
 
 template <typename Strategy>
 void PositionAlgorithm<Strategy>::getInlineBoxAndOffset(EAffinity affinity, TextDirection primaryDirection, InlineBox*& inlineBox, int& caretOffset) const
 {
     caretOffset = deprecatedEditingOffset();
     LayoutObject* layoutObject = deprecatedNode()->layoutObject();
 
     if (!layoutObject->isText()) {
         inlineBox = 0;
         if (canHaveChildrenForEditing(deprecatedNode()) && 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().
-            PositionType thisPosition = PositionType(*this);
-            PositionType equivalent = downstreamIgnoringEditingBoundaries<typename Strategy::PositionType>(thisPosition);
+            PositionAlgorithm<Strategy> thisPosition = PositionAlgorithm<Strategy>(*this);
+            PositionAlgorithm<Strategy> equivalent = downstreamIgnoringEditingBoundaries(thisPosition);
             if (equivalent == thisPosition) {
                 equivalent = upstreamIgnoringEditingBoundaries(thisPosition);
-                if (equivalent == thisPosition || downstreamIgnoringEditingBoundaries<typename Strategy::PositionType>(equivalent) == thisPosition)
+                if (equivalent == thisPosition || downstreamIgnoringEditingBoundaries(equivalent) == thisPosition)
                     return;
             }
 
             equivalent.getInlineBoxAndOffset(UPSTREAM, primaryDirection, inlineBox, caretOffset);
             return;
         }
         if (layoutObject->isBox()) {
             inlineBox = toLayoutBox(layoutObject)->inlineBoxWrapper();
             if (!inlineBox || (caretOffset > inlineBox->caretMinOffset() && caretOffset < inlineBox->caretMaxOffset()))
                 return;
@@ skipping 315 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif