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

Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 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 455 matching lines @@
     Position start = createLegacyEditingPosition(boundary, 0).parentAnchoredEquivalent();
     Position end = pos.parentAnchoredEquivalent();
 
     Vector<UChar, 1024> string;
     unsigned suffixLength = 0;
 
     TrackExceptionState exceptionState;
     if (requiresContextForWordBoundary(c.characterBefore())) {
         RefPtrWillBeRawPtr<Range> forwardsScanRange(d.createRange());
         forwardsScanRange->setEndAfter(boundary, exceptionState);
-        forwardsScanRange->setStart(end.deprecatedNode(), end.deprecatedEditingOffset(), exceptionState);
+        forwardsScanRange->setStart(end.anchorNode(), end.deprecatedEditingOffset(), exceptionState);
         TextIterator forwardsIterator(forwardsScanRange->startPosition(), forwardsScanRange->endPosition());
         while (!forwardsIterator.atEnd()) {
             Vector<UChar, 1024> characters;
             forwardsIterator.text().appendTextTo(characters);
             int i = endOfFirstWordBoundaryContext(characters.data(), characters.size());
             string.append(characters.data(), i);
             suffixLength += i;
             if (static_cast<unsigned>(i) < characters.size())
                 break;
             forwardsIterator.advance();
@@ skipping 67 matching lines @@
             int length = characters.size();
             int i = startOfLastWordBoundaryContext(characters.data(), length);
             string.prepend(characters.data() + i, length - i);
             prefixLength += length - i;
             if (i > 0)
                 break;
             backwardsIterator.advance();
         }
     }
 
-    Position searchStart = createLegacyEditingPosition(start.deprecatedNode(), start.deprecatedEditingOffset());
+    Position searchStart = createLegacyEditingPosition(start.anchorNode(), start.deprecatedEditingOffset());
     RangeBoundaryPoint searchEndPoint(boundary);
     searchEndPoint.setToEndOfNode(*boundary);
     Position searchEnd = searchEndPoint.toPosition();
     TextIterator it(searchStart, searchEnd, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
     const unsigned invalidOffset = static_cast<unsigned>(-1);
     unsigned next = invalidOffset;
     bool needMoreContext = false;
     while (!it.atEnd()) {
         // Keep asking the iterator for chunks until the search function
         // returns an end value not equal to the length of the string passed to it.
@@ skipping 142 matching lines @@
     using PositionType = typename PositionWithAffinityType::PositionType;
 
     if (c.isNull())
         return PositionWithAffinityType();
 
     RootInlineBox* rootBox = RenderedPosition(c.position(), c.affinity()).rootBox();
     if (!rootBox) {
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         PositionType p = c.position();
-        if (p.deprecatedNode()->layoutObject() && p.deprecatedNode()->layoutObject()->isLayoutBlock() && !p.deprecatedEditingOffset())
+        if (p.anchorNode()->layoutObject() && p.anchorNode()->layoutObject()->isLayoutBlock() && !p.deprecatedEditingOffset())
             return c;
 
         return PositionWithAffinityType();
     }
 
     Node* startNode;
     InlineBox* startBox;
     if (mode == UseLogicalOrdering) {
         startNode = rootBox->getLogicalStartBoxWithNode(startBox);
         if (!startNode)
@@ skipping 59 matching lines @@
 static VisiblePosition endPositionForLine(const VisiblePosition& c, LineEndpointComputationMode mode)
 {
     if (c.isNull())
         return VisiblePosition();
 
     RootInlineBox* rootBox = RenderedPosition(c).rootBox();
     if (!rootBox) {
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.deprecatedNode()->layoutObject() && p.deprecatedNode()->layoutObject()->isLayoutBlock() && !p.deprecatedEditingOffset())
+        if (p.anchorNode()->layoutObject() && p.anchorNode()->layoutObject()->isLayoutBlock() && !p.deprecatedEditingOffset())
             return c;
         return VisiblePosition();
     }
 
     Node* endNode;
     InlineBox* endBox;
     if (mode == UseLogicalOrdering) {
         endNode = rootBox->getLogicalEndBoxWithNode(endBox);
         if (!endNode)
             return VisiblePosition();
@@ skipping 138 matching lines @@
 
     if (root->block().isHorizontalWritingMode())
         return LayoutPoint(lineDirectionPoint - absoluteBlockPoint.x(), root->blockDirectionPointInLine());
 
     return LayoutPoint(root->blockDirectionPointInLine(), lineDirectionPoint - absoluteBlockPoint.y());
 }
 
 VisiblePosition previousLinePosition(const VisiblePosition &visiblePosition, LayoutUnit lineDirectionPoint, EditableType editableType)
 {
     Position p = visiblePosition.deepEquivalent();
-    Node* node = p.deprecatedNode();
+    Node* node = p.anchorNode();
 
     if (!node)
         return VisiblePosition();
 
     node->document().updateLayoutIgnorePendingStylesheets();
 
     LayoutObject* layoutObject = node->layoutObject();
     if (!layoutObject)
         return VisiblePosition();
 
@@ skipping 32 matching lines @@
     // to the start of the line we're on.
     Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
     return VisiblePosition(firstPositionInNode(rootElement), DOWNSTREAM);
 }
 
 VisiblePosition nextLinePosition(const VisiblePosition &visiblePosition, LayoutUnit lineDirectionPoint, EditableType editableType)
 {
     Position p = visiblePosition.deepEquivalent();
-    Node* node = p.deprecatedNode();
+    Node* node = p.anchorNode();
 
     if (!node)
         return VisiblePosition();
 
     node->document().updateLayoutIgnorePendingStylesheets();
 
     LayoutObject* layoutObject = node->layoutObject();
     if (!layoutObject)
         return VisiblePosition();
 
@@ skipping 89 matching lines @@
 
 VisiblePosition nextSentencePosition(const VisiblePosition &c)
 {
     VisiblePosition next = nextBoundary(c, nextSentencePositionBoundary);
     return c.honorEditingBoundaryAtOrAfter(next);
 }
 
 VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     Position p = c.deepEquivalent();
-    Node* startNode = p.deprecatedNode();
+    Node* startNode = p.anchorNode();
 
     if (!startNode)
         return VisiblePosition();
 
     if (isRenderedAsNonInlineTableImageOrHR(startNode))
         return VisiblePosition(positionBeforeNode(startNode));
 
     Element* startBlock = enclosingBlock(startNode);
 
     Node* node = startNode;
@@ skipping 57 matching lines @@
 
     return VisiblePosition(Position(node, type), DOWNSTREAM);
 }
 
 VisiblePosition endOfParagraph(const VisiblePosition &c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     if (c.isNull())
         return VisiblePosition();
 
     Position p = c.deepEquivalent();
-    Node* startNode = p.deprecatedNode();
+    Node* startNode = p.anchorNode();
 
     if (isRenderedAsNonInlineTableImageOrHR(startNode))
         return VisiblePosition(positionAfterNode(startNode));
 
     Element* startBlock = enclosingBlock(startNode);
     Element* stayInsideBlock = startBlock;
 
     Node* node = startNode;
     ContainerNode* highestRoot = highestEditableRoot(p);
     int offset = p.deprecatedEditingOffset();
@@ skipping 143 matching lines @@
 VisiblePosition startOfDocument(const Node* node)
 {
     if (!node || !node->document().documentElement())
         return VisiblePosition();
 
     return VisiblePosition(firstPositionInNode(node->document().documentElement()), DOWNSTREAM);
 }
 
 VisiblePosition startOfDocument(const VisiblePosition &c)
 {
-    return startOfDocument(c.deepEquivalent().deprecatedNode());
+    return startOfDocument(c.deepEquivalent().anchorNode());
 }
 
 VisiblePosition endOfDocument(const Node* node)
 {
     if (!node || !node->document().documentElement())
         return VisiblePosition();
 
     Element* doc = node->document().documentElement();
     return VisiblePosition(lastPositionInNode(doc), DOWNSTREAM);
 }
 
 VisiblePosition endOfDocument(const VisiblePosition &c)
 {
-    return endOfDocument(c.deepEquivalent().deprecatedNode());
+    return endOfDocument(c.deepEquivalent().anchorNode());
 }
 
 bool isStartOfDocument(const VisiblePosition &p)
 {
     return p.isNotNull() && p.previous(CanCrossEditingBoundary).isNull();
 }
 
 bool isEndOfDocument(const VisiblePosition &p)
 {
     return p.isNotNull() && p.next(CanCrossEditingBoundary).isNull();
@@ skipping 59 matching lines @@
     HitTestRequest request = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::IgnoreClipping;
     HitTestResult result(request, contentsPoint);
     frame->document()->layoutView()->hitTest(result);
 
     if (Node* node = result.innerNode())
         return frame->selection().selection().visiblePositionRespectingEditingBoundary(result.localPoint(), node);
     return VisiblePosition();
 }
 
 }