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

Source/core/editing/VisiblePosition.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Portions Copyright (c) 2011 Motorola Mobility, 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
@@ skipping 431 matching lines @@
 
 template <typename PositionWithAffinityType>
 PositionWithAffinityType honorEditingBoundaryAtOrBeforeAlgorithm(const PositionWithAffinityType& pos, const typename PositionWithAffinityType::PositionType& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
 
     // Return empty position if pos is not somewhere inside the editable region containing this position
-    if (highestRoot && !pos.position().deprecatedNode()->isDescendantOf(highestRoot))
+    if (highestRoot && !pos.position().anchorNode()->isDescendantOf(highestRoot))
         return PositionWithAffinityType();
 
     // Return pos itself if the two are from the very same editable region, or both are non-editable
     // FIXME: In the non-editable case, just because the new position is non-editable doesn't mean movement
     // to it is allowed.  VisibleSelection::adjustForEditableContent has this problem too.
     if (highestEditableRoot(pos.position()) == highestRoot)
         return pos;
 
     // Return empty position if this position is non-editable, but pos is editable
     // FIXME: Move to the previous non-editable region.
@@ skipping 20 matching lines @@
 }
 
 VisiblePosition VisiblePosition::honorEditingBoundaryAtOrAfter(const VisiblePosition &pos) const
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(deepEquivalent());
 
     // Return empty position if pos is not somewhere inside the editable region containing this position
-    if (highestRoot && !pos.deepEquivalent().deprecatedNode()->isDescendantOf(highestRoot))
+    if (highestRoot && !pos.deepEquivalent().anchorNode()->isDescendantOf(highestRoot))
         return VisiblePosition();
 
     // Return pos itself if the two are from the very same editable region, or both are non-editable
     // FIXME: In the non-editable case, just because the new position is non-editable doesn't mean movement
     // to it is allowed.  VisibleSelection::adjustForEditableContent has this problem too.
     if (highestEditableRoot(pos.deepEquivalent()) == highestRoot)
         return pos;
 
     // Return empty position if this position is non-editable, but pos is editable
     // FIXME: Move to the next non-editable region.
@@ skipping 86 matching lines @@
     if (candidate.isCandidate())
         return candidate;
     candidate = position.downstream();
     if (candidate.isCandidate())
         return candidate;
 
     // When neither upstream or downstream gets us to a candidate (upstream/downstream won't leave
     // blocks or enter new ones), we search forward and backward until we find one.
     PositionType next = canonicalizeCandidate(nextCandidate(position));
     PositionType prev = canonicalizeCandidate(previousCandidate(position));
-    Node* nextNode = next.deprecatedNode();
-    Node* prevNode = prev.deprecatedNode();
+    Node* nextNode = next.anchorNode();
+    Node* prevNode = prev.anchorNode();
 
     // The new position must be in the same editable element. Enforce that first.
     // Unless the descent is from a non-editable html element to an editable body.
     if (isHTMLHtmlElement(node) && !node->hasEditableStyle() && node->document().body() && node->document().body()->hasEditableStyle())
         return next.isNotNull() ? next : prev;
 
     Element* editingRoot = editableRootForPosition(position);
 
     // If the html element is editable, descending into its body will look like a descent
     // from non-editable to editable content since rootEditableElement() always stops at the body.
-    if (isHTMLHtmlElement(editingRoot) || position.deprecatedNode()->isDocumentNode())
+    if (isHTMLHtmlElement(editingRoot) || position.anchorNode()->isDocumentNode())
         return next.isNotNull() ? next : prev;
 
     bool prevIsInSameEditableElement = prevNode && editableRootForPosition(prev) == editingRoot;
     bool nextIsInSameEditableElement = nextNode && editableRootForPosition(next) == editingRoot;
     if (prevIsInSameEditableElement && !nextIsInSameEditableElement)
         return prev;
 
     if (nextIsInSameEditableElement && !prevIsInSameEditableElement)
         return next;
 
@@ skipping 160 matching lines @@
     TrackExceptionState exceptionState;
     r->setEnd(p.containerNode(), p.offsetInContainerNode(), exceptionState);
     return !exceptionState.hadException();
 }
 
 Element* enclosingBlockFlowElement(const VisiblePosition& visiblePosition)
 {
     if (visiblePosition.isNull())
         return 0;
 
-    return enclosingBlockFlowElement(*visiblePosition.deepEquivalent().deprecatedNode());
+    return enclosingBlockFlowElement(*visiblePosition.deepEquivalent().anchorNode());
 }
 
 bool isFirstVisiblePositionInNode(const VisiblePosition& visiblePosition, const ContainerNode* node)
 {
     if (visiblePosition.isNull())
         return false;
 
     if (!visiblePosition.deepEquivalent().containerNode()->isDescendantOf(node))
         return false;
 
     VisiblePosition previous = visiblePosition.previous();
-    return previous.isNull() || !previous.deepEquivalent().deprecatedNode()->isDescendantOf(node);
+    return previous.isNull() || !previous.deepEquivalent().anchorNode()->isDescendantOf(node);
 }
 
 bool isLastVisiblePositionInNode(const VisiblePosition& visiblePosition, const ContainerNode* node)
 {
     if (visiblePosition.isNull())
         return false;
 
     if (!visiblePosition.deepEquivalent().containerNode()->isDescendantOf(node))
         return false;
 
     VisiblePosition next = visiblePosition.next();
-    return next.isNull() || !next.deepEquivalent().deprecatedNode()->isDescendantOf(node);
+    return next.isNull() || !next.deepEquivalent().anchorNode()->isDescendantOf(node);
 }
 
 DEFINE_TRACE(VisiblePosition)
 {
     visitor->trace(m_deepPosition);
 }
 
 } // namespace blink
 
 #ifndef NDEBUG
 
 void showTree(const blink::VisiblePosition* vpos)
 {
     if (vpos)
         vpos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil) VisiblePosition.\n");
 }
 
 void showTree(const blink::VisiblePosition& vpos)
 {
     vpos.showTreeForThis();
 }
 
 #endif