Introduce PositionAlgorithm<Strategy>::editingPositionOf()

Source/core/editing/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 51 matching lines @@
 template <typename Strategy>
 const TreeScope* PositionAlgorithm<Strategy>::commonAncestorTreeScope(const PositionAlgorithm<Strategy>& a, const PositionAlgorithm<Strategy>& b)
 {
     if (!a.computeContainerNode() || !b.computeContainerNode())
         return nullptr;
     return a.computeContainerNode()->treeScope().commonAncestorTreeScope(b.computeContainerNode()->treeScope());
 }
 
 
 template <typename Strategy>
-PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::createLegacyEditingPosition(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset)
+PositionAlgorithm<Strategy> PositionAlgorithm<Strategy>::editingPositionOf(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset)
 {
     if (!anchorNode || anchorNode->isTextNode())
         return PositionAlgorithm<Strategy>(anchorNode, offset);
 
     if (!Strategy::editingIgnoresContent(anchorNode.get()))
         return PositionAlgorithm<Strategy>(anchorNode, offset);
 
     if (offset == 0)
         return PositionAlgorithm<Strategy>(anchorNode, PositionAnchorType::BeforeAnchor);
 
@@ skipping 293 matching lines @@
         return firstPositionInOrBeforeNode(child);
 
     // TODO(yosin) We should use |Strategy::lastOffsetForEditing()| instead of
     // DOM tree version.
     if (!Strategy::hasChildren(*node) && offset < EditingStrategy::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);
+        return editingPositionOf(node, (moveType == Character) ? uncheckedNextOffset(node, offset) : offset + 1);
     }
 
     if (ContainerNode* parent = Strategy::parent(*node))
-        return createLegacyEditingPosition(parent, Strategy::index(*node) + 1);
+        return editingPositionOf(parent, Strategy::index(*node) + 1);
     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>
@@ skipping 168 matching lines @@
 {
     TRACE_EVENT0("blink", "Position::upstream");
 
     Node* startNode = anchorNode();
     if (!startNode)
         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.
-    PositionIteratorAlgorithm<Strategy> lastVisible(isAfterAnchor() ? createLegacyEditingPosition(m_anchorNode.get(), Strategy::caretMaxOffset(*m_anchorNode)) : PositionAlgorithm<Strategy>(*this));
+    PositionIteratorAlgorithm<Strategy> lastVisible(isAfterAnchor() ? editingPositionOf(m_anchorNode.get(), Strategy::caretMaxOffset(*m_anchorNode)) : PositionAlgorithm<Strategy>(*this));
     PositionIteratorAlgorithm<Strategy> 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 103 matching lines @@
 {
     TRACE_EVENT0("blink", "Position::downstream");
 
     Node* startNode = anchorNode();
     if (!startNode)
         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.
-    PositionIteratorAlgorithm<Strategy> lastVisible(isAfterAnchor() ? createLegacyEditingPosition(m_anchorNode.get(), Strategy::caretMaxOffset(*m_anchorNode)) : PositionAlgorithm<Strategy>(*this));
+    PositionIteratorAlgorithm<Strategy> lastVisible(isAfterAnchor() ? editingPositionOf(m_anchorNode.get(), Strategy::caretMaxOffset(*m_anchorNode)) : PositionAlgorithm<Strategy>(*this));
     PositionIteratorAlgorithm<Strategy> 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 31 matching lines @@
             break;
         }
 
         // track last visible streamer position
         if (isStreamer<Strategy>(currentPos))
             lastVisible = currentPos;
 
         // Return position before tables and nodes which have content that can be ignored.
         if (Strategy::editingIgnoresContent(currentNode) || isRenderedHTMLTableElement(currentNode)) {
             if (currentPos.offsetInLeafNode() <= layoutObject->caretMinOffset())
-                return createLegacyEditingPosition(currentNode, layoutObject->caretMinOffset());
+                return editingPositionOf(currentNode, layoutObject->caretMinOffset());
             continue;
         }
 
         // return current position if it is in laid out text
         if (layoutObject->isText() && toLayoutText(layoutObject)->firstTextBox()) {
             if (currentNode != startNode) {
                 ASSERT(currentPos.atStartOfNode());
                 return PositionAlgorithm<Strategy>(currentNode, layoutObject->caretMinOffset());
             }
 
@@ skipping 595 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif