[CodeHealth] Use Position::anchorNode instead of deprecatedNode.

Source/core/editing/htmlediting.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 264 matching lines @@
     return node->hasEditableStyle(editableType);
 }
 
 bool isEditablePosition(const PositionInComposedTree& p, EditableType editableType, EUpdateStyle updateStyle)
 {
     return isEditablePosition(toPositionInDOMTree(p), editableType, updateStyle);
 }
 
 bool isAtUnsplittableElement(const Position& pos)
 {
-    Node* node = pos.deprecatedNode();
+    Node* node = pos.anchorNode();
     return (node == editableRootForPosition(pos) || node == enclosingNodeOfType(pos, &isTableCell));
 }
 
 
 bool isRichlyEditablePosition(const Position& p, EditableType editableType)
 {
-    Node* node = p.deprecatedNode();
+    Node* node = p.anchorNode();
     if (!node)
         return false;
 
     if (isRenderedHTMLTableElement(node))
         node = node->parentNode();
 
     return node->layoutObjectIsRichlyEditable(editableType);
 }
 
 Element* editableRootForPosition(const Position& p, EditableType editableType)
@@ skipping 109 matching lines @@
 }
 
 VisiblePosition firstEditableVisiblePositionAfterPositionInRoot(const Position& position, ContainerNode* highestRoot)
 {
     // position falls before highestRoot.
     if (comparePositions(position, firstPositionInNode(highestRoot)) == -1 && highestRoot->hasEditableStyle())
         return VisiblePosition(firstPositionInNode(highestRoot));
 
     Position editablePosition = position;
 
-    if (position.deprecatedNode()->treeScope() != highestRoot->treeScope()) {
-        Node* shadowAncestor = highestRoot->treeScope().ancestorInThisScope(editablePosition.deprecatedNode());
+    if (position.anchorNode()->treeScope() != highestRoot->treeScope()) {
+        Node* shadowAncestor = highestRoot->treeScope().ancestorInThisScope(editablePosition.anchorNode());
         if (!shadowAncestor)
             return VisiblePosition();
 
         editablePosition = positionAfterNode(shadowAncestor);
     }
 
-    while (editablePosition.deprecatedNode() && !isEditablePosition(editablePosition) && editablePosition.deprecatedNode()->isDescendantOf(highestRoot))
-        editablePosition = isAtomicNode(editablePosition.deprecatedNode()) ? positionInParentAfterNode(*editablePosition.deprecatedNode()) : nextVisuallyDistinctCandidate(editablePosition);
+    while (editablePosition.anchorNode() && !isEditablePosition(editablePosition) && editablePosition.anchorNode()->isDescendantOf(highestRoot))
+        editablePosition = isAtomicNode(editablePosition.anchorNode()) ? positionInParentAfterNode(*editablePosition.anchorNode()) : nextVisuallyDistinctCandidate(editablePosition);
 
-    if (editablePosition.deprecatedNode() && editablePosition.deprecatedNode() != highestRoot && !editablePosition.deprecatedNode()->isDescendantOf(highestRoot))
+    if (editablePosition.anchorNode() && editablePosition.anchorNode() != highestRoot && !editablePosition.anchorNode()->isDescendantOf(highestRoot))
         return VisiblePosition();
 
     return VisiblePosition(editablePosition);
 }
 
 VisiblePosition lastEditableVisiblePositionBeforePositionInRoot(const Position& position, ContainerNode* highestRoot)
 {
     return VisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
 }
 
 template <typename PositionType>
 PositionType lastEditablePositionBeforePositionInRootAlgorithm(const PositionType& position, Node* highestRoot)
 {
     // When position falls after highestRoot, the result is easy to compute.
     if (position.compareTo(PositionType::lastPositionInNode(highestRoot)) == 1)
         return PositionType::lastPositionInNode(highestRoot);
 
     PositionType editablePosition = position;
 
-    if (position.deprecatedNode()->treeScope() != highestRoot->treeScope()) {
-        Node* shadowAncestor = highestRoot->treeScope().ancestorInThisScope(editablePosition.deprecatedNode());
+    if (position.anchorNode()->treeScope() != highestRoot->treeScope()) {
+        Node* shadowAncestor = highestRoot->treeScope().ancestorInThisScope(editablePosition.anchorNode());
         if (!shadowAncestor)
             return PositionType();
 
         editablePosition = PositionType::firstPositionInOrBeforeNode(shadowAncestor);
     }
 
-    while (editablePosition.deprecatedNode() && !isEditablePosition(editablePosition) && editablePosition.deprecatedNode()->isDescendantOf(highestRoot))
-        editablePosition = isAtomicNode(editablePosition.deprecatedNode()) ? PositionType::inParentBeforeNode(*editablePosition.deprecatedNode()) : previousVisuallyDistinctCandidate(editablePosition);
+    while (editablePosition.anchorNode() && !isEditablePosition(editablePosition) && editablePosition.anchorNode()->isDescendantOf(highestRoot))
+        editablePosition = isAtomicNode(editablePosition.anchorNode()) ? PositionType::inParentBeforeNode(*editablePosition.anchorNode()) : previousVisuallyDistinctCandidate(editablePosition);
 
-    if (editablePosition.deprecatedNode() && editablePosition.deprecatedNode() != highestRoot && !editablePosition.deprecatedNode()->isDescendantOf(highestRoot))
+    if (editablePosition.anchorNode() && editablePosition.anchorNode() != highestRoot && !editablePosition.anchorNode()->isDescendantOf(highestRoot))
         return PositionType();
     return editablePosition;
 }
 
 Position lastEditablePositionBeforePositionInRoot(const Position& position, Node* highestRoot)
 {
     return lastEditablePositionBeforePositionInRootAlgorithm<Position>(position, highestRoot);
 }
 
 PositionInComposedTree lastEditablePositionBeforePositionInRoot(const PositionInComposedTree& position, Node* highestRoot)
@@ skipping 118 matching lines @@
 
     if (layoutObject->style()->isFloating())
         return true;
 
     return false;
 }
 
 static HTMLElement* firstInSpecialElement(const Position& pos)
 {
     Element* rootEditableElement = pos.containerNode()->rootEditableElement();
-    for (Node* n = pos.deprecatedNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode()) {
+    for (Node* n = pos.anchorNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode()) {
         if (isSpecialHTMLElement(*n)) {
             HTMLElement* specialElement = toHTMLElement(n);
             VisiblePosition vPos = VisiblePosition(pos, DOWNSTREAM);
             VisiblePosition firstInElement = VisiblePosition(firstPositionInOrBeforeNode(specialElement), DOWNSTREAM);
             if (isRenderedTableElement(specialElement) && vPos == firstInElement.next())
                 return specialElement;
             if (vPos == firstInElement)
                 return specialElement;
         }
     }
     return 0;
 }
 
 static HTMLElement* lastInSpecialElement(const Position& pos)
 {
     Element* rootEditableElement = pos.containerNode()->rootEditableElement();
-    for (Node* n = pos.deprecatedNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode()) {
+    for (Node* n = pos.anchorNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode()) {
         if (isSpecialHTMLElement(*n)) {
             HTMLElement* specialElement = toHTMLElement(n);
             VisiblePosition vPos = VisiblePosition(pos, DOWNSTREAM);
             VisiblePosition lastInElement = VisiblePosition(lastPositionInOrAfterNode(specialElement), DOWNSTREAM);
             if (isRenderedTableElement(specialElement) && vPos == lastInElement.previous())
                 return specialElement;
             if (vPos == lastInElement)
                 return specialElement;
         }
     }
     return 0;
 }
 
 Position positionBeforeContainingSpecialElement(const Position& pos, HTMLElement** containingSpecialElement)
 {
     HTMLElement* n = firstInSpecialElement(pos);
     if (!n)
         return pos;
     Position result = positionInParentBeforeNode(*n);
-    if (result.isNull() || result.deprecatedNode()->rootEditableElement() != pos.deprecatedNode()->rootEditableElement())
+    if (result.isNull() || result.anchorNode()->rootEditableElement() != pos.anchorNode()->rootEditableElement())
         return pos;
     if (containingSpecialElement)
         *containingSpecialElement = n;
     return result;
 }
 
 Position positionAfterContainingSpecialElement(const Position& pos, HTMLElement** containingSpecialElement)
 {
     HTMLElement* n = lastInSpecialElement(pos);
     if (!n)
         return pos;
     Position result = positionInParentAfterNode(*n);
-    if (result.isNull() || result.deprecatedNode()->rootEditableElement() != pos.deprecatedNode()->rootEditableElement())
+    if (result.isNull() || result.anchorNode()->rootEditableElement() != pos.anchorNode()->rootEditableElement())
         return pos;
     if (containingSpecialElement)
         *containingSpecialElement = n;
     return result;
 }
 
 Element* isFirstPositionAfterTable(const VisiblePosition& visiblePosition)
 {
     Position upstream(visiblePosition.deepEquivalent().upstream());
-    if (isRenderedTableElement(upstream.deprecatedNode()) && upstream.atLastEditingPositionForNode())
-        return toElement(upstream.deprecatedNode());
+    if (isRenderedTableElement(upstream.anchorNode()) && upstream.atLastEditingPositionForNode())
+        return toElement(upstream.anchorNode());
 
     return 0;
 }
 
 Element* isLastPositionBeforeTable(const VisiblePosition& visiblePosition)
 {
     Position downstream(visiblePosition.deepEquivalent().downstream());
-    if (isRenderedTableElement(downstream.deprecatedNode()) && downstream.atFirstEditingPositionForNode())
-        return toElement(downstream.deprecatedNode());
+    if (isRenderedTableElement(downstream.anchorNode()) && downstream.atFirstEditingPositionForNode())
+        return toElement(downstream.anchorNode());
 
     return 0;
 }
 
 static Node* previousNodeConsideringAtomicNodes(const Node& start)
 {
     if (start.previousSibling()) {
         Node* node = start.previousSibling();
         while (!isAtomicNode(node) && node->lastChild())
             node = node->lastChild();
@@ skipping 67 matching lines @@
 {
     return n && n->layoutObject() && n->layoutObject()->isListItem();
 }
 
 Element* enclosingElementWithTag(const Position& p, const QualifiedName& tagName)
 {
     if (p.isNull())
         return 0;
 
     ContainerNode* root = highestEditableRoot(p);
-    Element* ancestor = p.deprecatedNode()->isElementNode() ? toElement(p.deprecatedNode()) : p.deprecatedNode()->parentElement();
+    Element* ancestor = p.anchorNode()->isElementNode() ? toElement(p.anchorNode()) : p.anchorNode()->parentElement();
     for (; ancestor; ancestor = ancestor->parentElement()) {
         if (root && !ancestor->hasEditableStyle())
             continue;
         if (ancestor->hasTagName(tagName))
             return ancestor;
         if (ancestor == root)
             return 0;
     }
 
     return 0;
 }
 
 Node* enclosingNodeOfType(const Position& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule)
 {
     // FIXME: support CanSkipCrossEditingBoundary
     ASSERT(rule == CanCrossEditingBoundary || rule == CannotCrossEditingBoundary);
     if (p.isNull())
         return 0;
 
     ContainerNode* root = rule == CannotCrossEditingBoundary ? highestEditableRoot(p) : 0;
-    for (Node* n = p.deprecatedNode(); n; n = n->parentNode()) {
+    for (Node* n = p.anchorNode(); n; n = n->parentNode()) {
         // Don't return a non-editable node if the input position was editable, since
         // the callers from editing will no doubt want to perform editing inside the returned node.
         if (root && !n->hasEditableStyle())
             continue;
         if (nodeIsOfType(n))
             return n;
         if (n == root)
             return 0;
     }
 
@@ skipping 47 matching lines @@
 Element* enclosingTableCell(const Position& p)
 {
     return toElement(enclosingNodeOfType(p, isTableCell));
 }
 
 Element* enclosingAnchorElement(const Position& p)
 {
     if (p.isNull())
         return 0;
 
-    for (Element* ancestor = ElementTraversal::firstAncestorOrSelf(*p.deprecatedNode()); ancestor; ancestor = ElementTraversal::firstAncestor(*ancestor)) {
+    for (Element* ancestor = ElementTraversal::firstAncestorOrSelf(*p.anchorNode()); ancestor; ancestor = ElementTraversal::firstAncestor(*ancestor)) {
         if (ancestor->isLink())
             return ancestor;
     }
     return 0;
 }
 
 HTMLElement* enclosingList(Node* node)
 {
     if (!node)
         return 0;
@@ skipping 26 matching lines @@
             return 0;
     }
 
     return 0;
 }
 
 // FIXME: This method should not need to call isStartOfParagraph/isEndOfParagraph
 Node* enclosingEmptyListItem(const VisiblePosition& visiblePos)
 {
     // Check that position is on a line by itself inside a list item
-    Node* listChildNode = enclosingListChild(visiblePos.deepEquivalent().deprecatedNode());
+    Node* listChildNode = enclosingListChild(visiblePos.deepEquivalent().anchorNode());
     if (!listChildNode || !isStartOfParagraph(visiblePos) || !isEndOfParagraph(visiblePos))
         return 0;
 
     VisiblePosition firstInListChild(firstPositionInOrBeforeNode(listChildNode));
     VisiblePosition lastInListChild(lastPositionInOrAfterNode(listChildNode));
 
     if (firstInListChild != visiblePos || lastInListChild != visiblePos)
         return 0;
 
     return listChildNode;
@@ skipping 243 matching lines @@
     bool isSpace = option == ConsiderNonCollapsibleWhitespace ? (isSpaceOrNewline(characterAfterVisiblePosition) || characterAfterVisiblePosition == noBreakSpaceCharacter) : isCollapsibleWhitespace(characterAfterVisiblePosition);
     // The space must not be in another paragraph and it must be editable.
     if (isSpace && !isEndOfParagraph(visiblePosition) && visiblePosition.next(CannotCrossEditingBoundary).isNotNull())
         return position;
     return Position();
 }
 
 unsigned numEnclosingMailBlockquotes(const Position& p)
 {
     unsigned num = 0;
-    for (Node* n = p.deprecatedNode(); n; n = n->parentNode())
+    for (Node* n = p.anchorNode(); n; n = n->parentNode())
         if (isMailHTMLBlockquoteElement(n))
             num++;
 
     return num;
 }
 
 void updatePositionForNodeRemoval(Position& position, Node& node)
 {
     if (position.isNull())
         return;
@@ skipping 81 matching lines @@
 {
     VisibleSelection newSelection(original);
     VisiblePosition startOfSelection(newSelection.visibleStart());
     VisiblePosition endOfSelection(newSelection.visibleEnd());
 
     // If the end of the selection to modify is just after a table, and
     // if the start of the selection is inside that table, then the last paragraph
     // that we'll want modify is the last one inside the table, not the table itself
     // (a table is itself a paragraph).
     if (Element* table = isFirstPositionAfterTable(endOfSelection))
-        if (startOfSelection.deepEquivalent().deprecatedNode()->isDescendantOf(table))
+        if (startOfSelection.deepEquivalent().anchorNode()->isDescendantOf(table))
             newSelection = VisibleSelection(startOfSelection, endOfSelection.previous(CannotCrossEditingBoundary));
 
     // If the start of the selection to modify is just before a table,
     // and if the end of the selection is inside that table, then the first paragraph
     // we'll want to modify is the first one inside the table, not the paragraph
     // containing the table itself.
     if (Element* table = isLastPositionBeforeTable(startOfSelection))
-        if (endOfSelection.deepEquivalent().deprecatedNode()->isDescendantOf(table))
+        if (endOfSelection.deepEquivalent().anchorNode()->isDescendantOf(table))
             newSelection = VisibleSelection(startOfSelection.next(CannotCrossEditingBoundary), endOfSelection);
 
     return newSelection;
 }
 
 // FIXME: indexForVisiblePosition and visiblePositionForIndex use TextIterators to convert between
 // VisiblePositions and indices. But TextIterator iteration using TextIteratorEmitsCharactersBetweenAllVisiblePositions
 // does not exactly match VisiblePosition iteration, so using them to preserve a selection during an editing
 // opertion is unreliable. TextIterator's TextIteratorEmitsCharactersBetweenAllVisiblePositions mode needs to be fixed,
 // or these functions need to be changed to iterate using actual VisiblePositions.
@@ skipping 113 matching lines @@
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
         return visiblePosition.next().deepEquivalent().downstream();
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
     return visiblePosition.deepEquivalent().downstream();
 }
 
 } // namespace blink