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

Source/core/editing/InsertParagraphSeparatorCommand.cpp

 /*
  * Copyright (C) 2005, 2006 Apple Computer, 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 157 matching lines @@
     // FIXME: The parentAnchoredEquivalent conversion needs to be moved into enclosingBlock.
     RefPtrWillBeRawPtr<Element> startBlock = enclosingBlock(insertionPosition.parentAnchoredEquivalent().containerNode());
     Node* listChildNode = enclosingListChild(insertionPosition.parentAnchoredEquivalent().containerNode());
     RefPtrWillBeRawPtr<HTMLElement> listChild = listChildNode && listChildNode->isHTMLElement() ? toHTMLElement(listChildNode) : 0;
     Position canonicalPos = VisiblePosition(insertionPosition).deepEquivalent();
     if (!startBlock
         || !startBlock->nonShadowBoundaryParentNode()
         || isTableCell(startBlock.get())
         || isHTMLFormElement(*startBlock)
         // FIXME: If the node is hidden, we don't have a canonical position so we will do the wrong thing for tables and <hr>. https://bugs.webkit.org/show_bug.cgi?id=40342
-        || (!canonicalPos.isNull() && isRenderedTableElement(canonicalPos.deprecatedNode()))
-        || (!canonicalPos.isNull() && isHTMLHRElement(*canonicalPos.deprecatedNode()))) {
+        || (!canonicalPos.isNull() && isRenderedTableElement(canonicalPos.anchorNode()))
+        || (!canonicalPos.isNull() && isHTMLHRElement(*canonicalPos.anchorNode()))) {
         applyCommandToComposite(InsertLineBreakCommand::create(document()));
         return;
     }
 
     // Use the leftmost candidate.
     insertionPosition = insertionPosition.upstream();
     if (!insertionPosition.isCandidate())
         insertionPosition = insertionPosition.downstream();
 
     // Adjust the insertion position after the delete
@@ skipping 55 matching lines @@
                 Element* siblingElement = startBlock.get();
                 if (isHTMLDivElement(*blockToInsert))
                     siblingElement = highestVisuallyEquivalentDivBelowRoot(startBlock.get());
                 insertNodeAfter(blockToInsert, siblingElement);
             }
         }
 
         // Recreate the same structure in the new paragraph.
 
         WillBeHeapVector<RefPtrWillBeMember<Element>> ancestors;
-        getAncestorsInsideBlock(positionOutsideTabSpan(insertionPosition).deprecatedNode(), startBlock.get(), ancestors);
+        getAncestorsInsideBlock(positionOutsideTabSpan(insertionPosition).anchorNode(), startBlock.get(), ancestors);
         RefPtrWillBeRawPtr<Element> parent = cloneHierarchyUnderNewBlock(ancestors, blockToInsert);
 
         appendBlockPlaceholder(parent);
 
         setEndingSelection(VisibleSelection(firstPositionInNode(parent.get()), DOWNSTREAM, endingSelection().isDirectional()));
         return;
     }
 
 
     //---------------------------------------------------------------------
     // Handle case when position is in the first visible position in its block, and
     // similar case where previous position is in another, presumeably nested, block.
     if (isFirstInBlock || !inSameBlock(visiblePos, visiblePos.previous())) {
         Node* refNode = nullptr;
         insertionPosition = positionOutsideTabSpan(insertionPosition);
 
         if (isFirstInBlock && !nestNewBlock) {
             if (listChild && listChild != startBlock) {
                 RefPtrWillBeRawPtr<Element> listChildToInsert = listChild->cloneElementWithoutChildren();
                 appendNode(blockToInsert, listChildToInsert.get());
                 insertNodeBefore(listChildToInsert.get(), listChild);
             } else {
                 refNode = startBlock.get();
             }
         } else if (isFirstInBlock && nestNewBlock) {
             // startBlock should always have children, otherwise isLastInBlock would be true and it's handled above.
             ASSERT(startBlock->hasChildren());
             refNode = startBlock->firstChild();
-        }
-        else if (insertionPosition.deprecatedNode() == startBlock && nestNewBlock) {
+        } else if (insertionPosition.anchorNode() == startBlock && nestNewBlock) {
             refNode = NodeTraversal::childAt(*startBlock, insertionPosition.deprecatedEditingOffset());
             ASSERT(refNode); // must be true or we'd be in the end of block case
-        } else
-            refNode = insertionPosition.deprecatedNode();
+        } else {
+            refNode = insertionPosition.anchorNode();
+        }
 
         // find ending selection position easily before inserting the paragraph
         insertionPosition = insertionPosition.downstream();
 
         if (refNode)
             insertNodeBefore(blockToInsert, refNode);
 
         // Recreate the same structure in the new paragraph.
 
         WillBeHeapVector<RefPtrWillBeMember<Element>> ancestors;
-        getAncestorsInsideBlock(positionAvoidingSpecialElementBoundary(positionOutsideTabSpan(insertionPosition)).deprecatedNode(), startBlock.get(), ancestors);
+        getAncestorsInsideBlock(positionAvoidingSpecialElementBoundary(positionOutsideTabSpan(insertionPosition)).anchorNode(), startBlock.get(), ancestors);
 
         appendBlockPlaceholder(cloneHierarchyUnderNewBlock(ancestors, blockToInsert));
 
         // In this case, we need to set the new ending selection.
         setEndingSelection(VisibleSelection(insertionPosition, DOWNSTREAM, endingSelection().isDirectional()));
         return;
     }
 
     //---------------------------------------------------------------------
     // Handle the (more complicated) general case,
@@ skipping 18 matching lines @@
     // style of the upstream position.
     insertionPosition = insertionPosition.downstream();
 
     // At this point, the insertionPosition's node could be a container, and we want to make sure we include
     // all of the correct nodes when building the ancestor list.  So this needs to be the deepest representation of the position
     // before we walk the DOM tree.
     insertionPosition = positionOutsideTabSpan(VisiblePosition(insertionPosition).deepEquivalent());
 
     // If the returned position lies either at the end or at the start of an element that is ignored by editing
     // we should move to its upstream or downstream position.
-    if (editingIgnoresContent(insertionPosition.deprecatedNode())) {
+    if (editingIgnoresContent(insertionPosition.anchorNode())) {
         if (insertionPosition.atLastEditingPositionForNode())
             insertionPosition = insertionPosition.downstream();
         else if (insertionPosition.atFirstEditingPositionForNode())
             insertionPosition = insertionPosition.upstream();
     }
 
     // Make sure we do not cause a rendered space to become unrendered.
     // FIXME: We need the affinity for pos, but pos.downstream() does not give it
     Position leadingWhitespace = leadingWhitespacePosition(insertionPosition, VP_DEFAULT_AFFINITY);
     // FIXME: leadingWhitespacePosition is returning the position before preserved newlines for positions
     // after the preserved newline, causing the newline to be turned into a nbsp.
-    if (leadingWhitespace.isNotNull() && leadingWhitespace.deprecatedNode()->isTextNode()) {
-        Text* textNode = toText(leadingWhitespace.deprecatedNode());
+    if (leadingWhitespace.isNotNull() && leadingWhitespace.anchorNode()->isTextNode()) {
+        Text* textNode = toText(leadingWhitespace.anchorNode());
         ASSERT(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace());
         replaceTextInNodePreservingMarkers(textNode, leadingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
     }
 
     // Split at pos if in the middle of a text node.
     Position positionAfterSplit;
     if (insertionPosition.anchorType() == PositionAnchorType::OffsetInAnchor && insertionPosition.containerNode()->isTextNode()) {
         RefPtrWillBeRawPtr<Text> textNode = toText(insertionPosition.containerNode());
         bool atEnd = static_cast<unsigned>(insertionPosition.offsetInContainerNode()) >= textNode->length();
         if (insertionPosition.deprecatedEditingOffset() > 0 && !atEnd) {
@@ skipping 49 matching lines @@
         moveRemainingSiblingsToNewParent(n, blockToInsert.get(), blockToInsert);
     }
 
     // Handle whitespace that occurs after the split
     if (positionAfterSplit.isNotNull()) {
         document().updateLayoutIgnorePendingStylesheets();
         if (!positionAfterSplit.isRenderedCharacter()) {
             // Clear out all whitespace and insert one non-breaking space
             ASSERT(!positionAfterSplit.containerNode()->layoutObject() || positionAfterSplit.containerNode()->layoutObject()->style()->collapseWhiteSpace());
             deleteInsignificantTextDownstream(positionAfterSplit);
-            if (positionAfterSplit.deprecatedNode()->isTextNode())
+            if (positionAfterSplit.anchorNode()->isTextNode())
                 insertTextIntoNode(toText(positionAfterSplit.containerNode()), 0, nonBreakingSpaceString());
         }
     }
 
     setEndingSelection(VisibleSelection(firstPositionInNode(blockToInsert.get()), DOWNSTREAM, endingSelection().isDirectional()));
     applyStyleAfterInsertion(startBlock.get());
 }
 
 DEFINE_TRACE(InsertParagraphSeparatorCommand)
 {
     visitor->trace(m_style);
     CompositeEditCommand::trace(visitor);
 }
 
 
 } // namespace blink