Prune deprecated functions from ReplaceSelectionCommand

third_party/WebKit/Source/core/editing/commands/ReplaceSelectionCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010, 2011 Google 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 136 matching lines @@
        pos = nextPosition) {
     if (lineBreakExistsAtPosition(pos))
       break;
 
     if (pos.computeContainerNode()->nonShadowBoundaryParentNode())
       nextPosition = Position::inParentAfterNode(*pos.computeContainerNode());
 
     if (nextPosition == pos ||
         enclosingBlock(nextPosition.computeContainerNode()) !=
             enclosingBlockElement ||
-        createVisiblePositionDeprecated(pos).deepEquivalent() !=
-            createVisiblePositionDeprecated(nextPosition).deepEquivalent())
+        createVisiblePosition(pos).deepEquivalent() !=
+            createVisiblePosition(nextPosition).deepEquivalent())
       break;
   }
   return pos;
 }
 
 ReplacementFragment::ReplacementFragment(Document* document,
                                          DocumentFragment* fragment,
                                          const VisibleSelection& selection)
     : m_document(document),
       m_fragment(fragment),
@@ skipping 296 matching lines @@
     return false;
 
   // When we have matching quote levels, its ok to merge more frequently.
   // For a successful merge, we still need to make sure that the inserted
   // content starts with the beginning of a paragraph. And we should only merge
   // here if the selection start was inside a mail blockquote. This prevents
   // against removing a blockquote from newly pasted quoted content that was
   // pasted into an unquoted position. If that unquoted position happens to be
   // right after another blockquote, we don't want to merge and risk stripping a
   // valid block (and newline) from the pasted content.
-  if (isStartOfParagraphDeprecated(startOfInsertedContent) &&
+  if (isStartOfParagraph(startOfInsertedContent) &&
       selectionStartWasInsideMailBlockquote &&
       hasMatchingQuoteLevel(prev, positionAtEndOfInsertedContent()))
     return true;
 
   return !selectionStartWasStartOfParagraph &&
          !fragmentHasInterchangeNewlineAtStart &&
-         isStartOfParagraphDeprecated(startOfInsertedContent) &&
+         isStartOfParagraph(startOfInsertedContent) &&
          !isHTMLBRElement(
              *startOfInsertedContent.deepEquivalent().anchorNode()) &&
          shouldMerge(startOfInsertedContent, prev);
 }
 
 bool ReplaceSelectionCommand::shouldMergeEnd(
     bool selectionEndWasEndOfParagraph) {
   VisiblePosition endOfInsertedContent(positionAtEndOfInsertedContent());
   VisiblePosition next =
       nextPositionOf(endOfInsertedContent, CannotCrossEditingBoundary);
   if (next.isNull())
     return false;
 
   return !selectionEndWasEndOfParagraph &&
-         isEndOfParagraphDeprecated(endOfInsertedContent) &&
+         isEndOfParagraph(endOfInsertedContent) &&
          !isHTMLBRElement(
              *endOfInsertedContent.deepEquivalent().anchorNode()) &&
          shouldMerge(endOfInsertedContent, next);
 }
 
 static bool isMailPasteAsQuotationHTMLBlockQuoteElement(const Node* node) {
   if (!node || !node->isHTMLElement())
     return false;
   const HTMLElement& element = toHTMLElement(*node);
   if (!element.hasTagName(blockquoteTag) ||
@@ skipping 240 matching lines @@
   }
 }
 
 void ReplaceSelectionCommand::moveElementOutOfAncestor(
     Element* element,
     Element* ancestor,
     EditingState* editingState) {
   if (!hasEditableStyle(*ancestor->parentNode()))
     return;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
   VisiblePosition positionAtEndOfNode =
-      createVisiblePositionDeprecated(lastPositionInOrAfterNode(element));
+      createVisiblePosition(lastPositionInOrAfterNode(element));
   VisiblePosition lastPositionInParagraph =
       VisiblePosition::lastPositionInNode(ancestor);
   if (positionAtEndOfNode.deepEquivalent() ==
       lastPositionInParagraph.deepEquivalent()) {
     removeNode(element, editingState);
     if (editingState->isAborted())
       return;
     if (ancestor->nextSibling())
       insertNodeBefore(element, ancestor->nextSibling(), editingState);
     else
@@ skipping 40 matching lines @@
   if (firstNodeInserted && firstNodeInserted->isTextNode() &&
       !nodeHasVisibleLayoutText(toText(*firstNodeInserted))) {
     insertedNodes.willRemoveNode(*firstNodeInserted);
     // Removing a Text node won't dispatch synchronous events.
     removeNode(firstNodeInserted, ASSERT_NO_EDITING_ABORT);
   }
 }
 
 VisiblePosition ReplaceSelectionCommand::positionAtEndOfInsertedContent()
     const {
+  // TODO(xiaochengh): Hoist the call and change it into a DCHECK.
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
   // TODO(yosin): We should set |m_endOfInsertedContent| not in SELECT
   // element, since contents of SELECT elements, e.g. OPTION, OPTGROUP, are
   // not editable, or SELECT element is an atomic on editing.
   HTMLSelectElement* enclosingSelect = toHTMLSelectElement(
       enclosingElementWithTag(m_endOfInsertedContent, selectTag));
   if (enclosingSelect)
-    return createVisiblePositionDeprecated(
-        lastPositionInOrAfterNode(enclosingSelect));
+    return createVisiblePosition(lastPositionInOrAfterNode(enclosingSelect));
   if (m_endOfInsertedContent.isOrphan())
     return VisiblePosition();
-  return createVisiblePositionDeprecated(m_endOfInsertedContent);
+  return createVisiblePosition(m_endOfInsertedContent);
 }
 
 VisiblePosition ReplaceSelectionCommand::positionAtStartOfInsertedContent()
     const {
+  // TODO(xiaochengh): Hoist the call and change it into a DCHECK.
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
   if (m_startOfInsertedContent.isOrphan())
     return VisiblePosition();
-  return createVisiblePositionDeprecated(m_startOfInsertedContent);
+  return createVisiblePosition(m_startOfInsertedContent);
 }
 
 static void removeHeadContents(ReplacementFragment& fragment) {
   Node* next = nullptr;
   for (Node* node = fragment.firstChild(); node; node = next) {
     if (isHTMLBaseElement(*node) || isHTMLLinkElement(*node) ||
         isHTMLMetaElement(*node) || isHTMLTitleElement(*node)) {
       next = NodeTraversal::nextSkippingChildren(*node);
       fragment.removeNode(node);
     } else {
@@ skipping 150 matching lines @@
   if (m_movingParagraph) {
     NOTREACHED();
     return;
   }
 
   // Merging two paragraphs will destroy the moved one's block styles.  Always
   // move the end of inserted forward to preserve the block style of the
   // paragraph already in the document, unless the paragraph to move would
   // include the what was the start of the selection that was pasted into, so
   // that we preserve that paragraph's block styles.
-  bool mergeForward = !(
-      inSameParagraphDeprecated(startOfInsertedContent, endOfInsertedContent) &&
-      !isStartOfParagraphDeprecated(startOfInsertedContent));
+  bool mergeForward =
+      !(inSameParagraph(startOfInsertedContent, endOfInsertedContent) &&
+        !isStartOfParagraph(startOfInsertedContent));
 
   VisiblePosition destination = mergeForward
                                     ? nextPositionOf(endOfInsertedContent)
                                     : endOfInsertedContent;
+  // TODO(xiaochengh): Stop storing VisiblePositions through mutations.
   VisiblePosition startOfParagraphToMove =
-      mergeForward ? startOfParagraphDeprecated(endOfInsertedContent)
+      mergeForward ? startOfParagraph(endOfInsertedContent)
                    : nextPositionOf(endOfInsertedContent);
 
   // Merging forward could result in deleting the destination anchor node.
   // To avoid this, we add a placeholder node before the start of the paragraph.
-  if (endOfParagraphDeprecated(startOfParagraphToMove).deepEquivalent() ==
+  if (endOfParagraph(startOfParagraphToMove).deepEquivalent() ==
       destination.deepEquivalent()) {
     HTMLBRElement* placeholder = HTMLBRElement::create(document());
     insertNodeBefore(placeholder,
                      startOfParagraphToMove.deepEquivalent().anchorNode(),
                      editingState);
     if (editingState->isAborted())
       return;
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
     destination = VisiblePosition::beforeNode(placeholder);
+    startOfParagraphToMove =
+        createVisiblePosition(startOfParagraphToMove.toPositionWithAffinity());
   }
 
-  moveParagraph(startOfParagraphToMove,
-                endOfParagraphDeprecated(startOfParagraphToMove), destination,
-                editingState);
+  moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove),
+                destination, editingState);
   if (editingState->isAborted())
     return;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   // Merging forward will remove m_endOfInsertedContent from the document.
   if (mergeForward) {
-    if (m_startOfInsertedContent.isOrphan())
+    if (m_startOfInsertedContent.isOrphan()) {
       m_startOfInsertedContent =
-          endingSelection().visibleStartDeprecated().deepEquivalent();
-    m_endOfInsertedContent =
-        endingSelection().visibleEndDeprecated().deepEquivalent();
+          endingSelection().visibleStart().deepEquivalent();
+    }
+    m_endOfInsertedContent = endingSelection().visibleEnd().deepEquivalent();
     // If we merged text nodes, m_endOfInsertedContent could be null. If
     // this is the case, we use m_startOfInsertedContent.
     if (m_endOfInsertedContent.isNull())
       m_endOfInsertedContent = m_startOfInsertedContent;
   }
 }
 
 static Node* enclosingInline(Node* node) {
   while (ContainerNode* parent = node->parentNode()) {
     if (isBlockFlowElement(*parent) || isHTMLBodyElement(*parent))
@@ skipping 62 matching lines @@
     return;
 
   ReplacementFragment fragment(&document(), m_documentFragment.get(),
                                selection);
   bool trivialReplaceResult = performTrivialReplace(fragment, editingState);
   if (editingState->isAborted())
     return;
   if (trivialReplaceResult)
     return;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   // We can skip matching the style if the selection is plain text.
   if ((selection.start().anchorNode()->layoutObject() &&
        selection.start().anchorNode()->layoutObject()->style()->userModify() ==
            READ_WRITE_PLAINTEXT_ONLY) &&
       (selection.end().anchorNode()->layoutObject() &&
        selection.end().anchorNode()->layoutObject()->style()->userModify() ==
            READ_WRITE_PLAINTEXT_ONLY))
     m_matchStyle = false;
 
   if (m_matchStyle) {
     m_insertionStyle = EditingStyle::create(selection.start());
     m_insertionStyle->mergeTypingStyle(&document());
   }
 
-  const VisiblePosition visibleStart = selection.visibleStartDeprecated();
-  const VisiblePosition visibleEnd = selection.visibleEndDeprecated();
+  const VisiblePosition visibleStart = selection.visibleStart();
+  const VisiblePosition visibleEnd = selection.visibleEnd();
 
-  const bool selectionEndWasEndOfParagraph =
-      isEndOfParagraphDeprecated(visibleEnd);
+  const bool selectionEndWasEndOfParagraph = isEndOfParagraph(visibleEnd);
   const bool selectionStartWasStartOfParagraph =
-      isStartOfParagraphDeprecated(visibleStart);
+      isStartOfParagraph(visibleStart);
 
   Element* enclosingBlockOfVisibleStart =
       enclosingBlock(visibleStart.deepEquivalent().anchorNode());
 
   const bool startIsInsideMailBlockquote = enclosingNodeOfType(
       selection.start(), isMailHTMLBlockquoteElement, CanCrossEditingBoundary);
   const bool selectionIsPlainText = !selection.isContentRichlyEditable();
   Element* currentRoot = selection.rootEditableElement();
 
   if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph &&
        !startIsInsideMailBlockquote) ||
       enclosingBlockOfVisibleStart == currentRoot ||
       isListItem(enclosingBlockOfVisibleStart) || selectionIsPlainText) {
     m_preventNesting = false;
   }
 
   if (selection.isRange()) {
     // When the end of the selection being pasted into is at the end of a
     // paragraph, and that selection spans multiple blocks, not merging may
     // leave an empty line.
     // When the start of the selection being pasted into is at the start of a
     // block, not merging will leave hanging block(s).
     // Merge blocks if the start of the selection was in a Mail blockquote,
     // since we handle that case specially to prevent nesting.
     bool mergeBlocksAfterDelete = startIsInsideMailBlockquote ||
-                                  isEndOfParagraphDeprecated(visibleEnd) ||
+                                  isEndOfParagraph(visibleEnd) ||
                                   isStartOfBlock(visibleStart);
     // FIXME: We should only expand to include fully selected special elements
     // if we are copying a selection and pasting it on top of itself.
     deleteSelection(editingState, false, mergeBlocksAfterDelete, false);
     if (editingState->isAborted())
       return;
     if (fragment.hasInterchangeNewlineAtStart()) {
-      VisiblePosition startAfterDelete =
-          endingSelection().visibleStartDeprecated();
-      if (isEndOfParagraphDeprecated(startAfterDelete) &&
-          !isStartOfParagraphDeprecated(startAfterDelete) &&
+      document().updateStyleAndLayoutIgnorePendingStylesheets();
+      VisiblePosition startAfterDelete = endingSelection().visibleStart();
+      if (isEndOfParagraph(startAfterDelete) &&
+          !isStartOfParagraph(startAfterDelete) &&
           !isEndOfEditableOrNonEditableContent(startAfterDelete))
         setEndingSelection(nextPositionOf(startAfterDelete));
       else
         insertParagraphSeparator(editingState);
       if (editingState->isAborted())
         return;
     }
   } else {
     DCHECK(selection.isCaret());
     if (fragment.hasInterchangeNewlineAtStart()) {
       const VisiblePosition next =
           nextPositionOf(visibleStart, CannotCrossEditingBoundary);
-      if (isEndOfParagraphDeprecated(visibleStart) &&
-          !isStartOfParagraphDeprecated(visibleStart) && next.isNotNull())
+      if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart) &&
+          next.isNotNull()) {
         setEndingSelection(next);
-      else
+      } else {
         insertParagraphSeparator(editingState);
-      if (editingState->isAborted())
-        return;
+        if (editingState->isAborted())
+          return;
+        document().updateStyleAndLayoutIgnorePendingStylesheets();
+      }
     }
     // We split the current paragraph in two to avoid nesting the blocks from
     // the fragment inside the current block.
     //
     // For example, paste
     //   <div>foo</div><div>bar</div><div>baz</div>
     // into
     //   <div>x^x</div>
     // where ^ is the caret.
     //
     // As long as the div styles are the same, visually you'd expect:
     //   <div>xbar</div><div>bar</div><div>bazx</div>
     // not
     //   <div>xbar<div>bar</div><div>bazx</div></div>
     // Don't do this if the selection started in a Mail blockquote.
     if (m_preventNesting && !startIsInsideMailBlockquote &&
-        !isEndOfParagraphDeprecated(
-            endingSelection().visibleStartDeprecated()) &&
-        !isStartOfParagraphDeprecated(
-            endingSelection().visibleStartDeprecated())) {
+        !isEndOfParagraph(endingSelection().visibleStart()) &&
+        !isStartOfParagraph(endingSelection().visibleStart())) {
       insertParagraphSeparator(editingState);
       if (editingState->isAborted())
         return;
-      setEndingSelection(
-          previousPositionOf(endingSelection().visibleStartDeprecated()));
+      document().updateStyleAndLayoutIgnorePendingStylesheets();
+      setEndingSelection(previousPositionOf(endingSelection().visibleStart()));
     }
   }
 
   Position insertionPos = endingSelection().start();
   // We don't want any of the pasted content to end up nested in a Mail
   // blockquote, so first break out of any surrounding Mail blockquotes. Unless
   // we're inserting in a table, in which case breaking the blockquote will
   // prevent the content from actually being inserted in the table.
   if (enclosingNodeOfType(insertionPos, isMailHTMLBlockquoteElement,
                           CanCrossEditingBoundary) &&
@@ skipping 11 matching lines @@
     insertionPos = Position::inParentBeforeNode(*br);
     removeNode(br, editingState);
     if (editingState->isAborted())
       return;
   }
 
   // Inserting content could cause whitespace to collapse, e.g. inserting
   // <div>foo</div> into hello^ world.
   prepareWhitespaceAtPositionForSplit(insertionPos);
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   // If the downstream node has been removed there's no point in continuing.
   if (!mostForwardCaretPosition(insertionPos).anchorNode())
     return;
 
   // NOTE: This would be an incorrect usage of downstream() if downstream() were
   // changed to mean the last position after p that maps to the same visible
   // position as p (since in the case where a br is at the end of a block and
   // collapsed away, there are positions after the br which map to the same
   // visible position as [br, 0]).
   HTMLBRElement* endBR =
       isHTMLBRElement(*mostForwardCaretPosition(insertionPos).anchorNode())
           ? toHTMLBRElement(mostForwardCaretPosition(insertionPos).anchorNode())
           : 0;
   VisiblePosition originalVisPosBeforeEndBR;
   if (endBR)
     originalVisPosBeforeEndBR =
         previousPositionOf(VisiblePosition::beforeNode(endBR));
 
   Element* enclosingBlockOfInsertionPos =
       enclosingBlock(insertionPos.anchorNode());
 
   // Adjust |enclosingBlockOfInsertionPos| to prevent nesting.
   // If the start was in a Mail blockquote, we will have already handled
   // adjusting |enclosingBlockOfInsertionPos| above.
   if (m_preventNesting && enclosingBlockOfInsertionPos &&
       enclosingBlockOfInsertionPos != currentRoot &&
       !isTableCell(enclosingBlockOfInsertionPos) &&
       !startIsInsideMailBlockquote) {
-    VisiblePosition visibleInsertionPos =
-        createVisiblePositionDeprecated(insertionPos);
+    VisiblePosition visibleInsertionPos = createVisiblePosition(insertionPos);
     if (isEndOfBlock(visibleInsertionPos) &&
         !(isStartOfBlock(visibleInsertionPos) &&
           fragment.hasInterchangeNewlineAtEnd()))
       insertionPos = Position::inParentAfterNode(*enclosingBlockOfInsertionPos);
     else if (isStartOfBlock(visibleInsertionPos))
       insertionPos =
           Position::inParentBeforeNode(*enclosingBlockOfInsertionPos);
   }
 
   // Paste at start or end of link goes outside of link.
   insertionPos =
       positionAvoidingSpecialElementBoundary(insertionPos, editingState);
   if (editingState->isAborted())
     return;
 
   // FIXME: Can this wait until after the operation has been performed?  There
   // doesn't seem to be any work performed after this that queries or uses the
   // typing style.
   if (LocalFrame* frame = document().frame())
     frame->selection().clearTypingStyle();
 
   removeHeadContents(fragment);
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   // We don't want the destination to end up inside nodes that weren't selected.
   // To avoid that, we move the position forward without changing the visible
   // position so we're still at the same visible location, but outside of
   // preceding tags.
   insertionPos = positionAvoidingPrecedingNodes(insertionPos);
 
   // Paste into run of tabs splits the tab span.
   insertionPos = positionOutsideTabSpan(insertionPos);
 
   bool handledStyleSpans =
@@ skipping 100 matching lines @@
 
   if (isRichlyEditablePosition(insertionPos))
     removeUnrenderedTextNodesAtEnds(insertedNodes);
 
   if (!handledStyleSpans) {
     handleStyleSpans(insertedNodes, editingState);
     if (editingState->isAborted())
       return;
   }
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   // Mutation events (bug 20161) may have already removed the inserted content
   if (!insertedNodes.firstNodeInserted() ||
       !insertedNodes.firstNodeInserted()->isConnected())
     return;
 
   // Scripts specified in javascript protocol may remove
   // |enclosingBlockOfInsertionPos| during insertion, e.g. <iframe
   // src="javascript:...">
   if (enclosingBlockOfInsertionPos &&
       !enclosingBlockOfInsertionPos->isConnected())
     enclosingBlockOfInsertionPos = nullptr;
 
-  VisiblePosition startOfInsertedContent = createVisiblePositionDeprecated(
+  VisiblePosition startOfInsertedContent = createVisiblePosition(
       firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted()));
 
   // We inserted before the enclosingBlockOfInsertionPos to prevent nesting, and
   // the content before the enclosingBlockOfInsertionPos wasn't in its own block
   // and didn't have a br after it, so the inserted content ended up in the same
   // paragraph.
   if (!startOfInsertedContent.isNull() && enclosingBlockOfInsertionPos &&
       insertionPos.anchorNode() == enclosingBlockOfInsertionPos->parentNode() &&
       (unsigned)insertionPos.computeEditingOffset() <
           enclosingBlockOfInsertionPos->nodeIndex() &&
-      !isStartOfParagraphDeprecated(startOfInsertedContent)) {
+      !isStartOfParagraph(startOfInsertedContent)) {
     insertNodeAt(HTMLBRElement::create(document()),
                  startOfInsertedContent.deepEquivalent(), editingState);
     if (editingState->isAborted())
       return;
   }
 
   if (endBR &&
       (plainTextFragment ||
        (shouldRemoveEndBR(endBR, originalVisPosBeforeEndBR) &&
         !(fragment.hasInterchangeNewlineAtEnd() && selectionIsPlainText)))) {
@@ skipping 36 matching lines @@
       lastPositionInOrAfterNode(insertedNodes.lastLeafInserted());
 
   // Determine whether or not we should merge the end of inserted content with
   // what's after it before we do the start merge so that the start merge
   // doesn't effect our decision.
   m_shouldMergeEnd = shouldMergeEnd(selectionEndWasEndOfParagraph);
 
   if (shouldMergeStart(selectionStartWasStartOfParagraph,
                        fragment.hasInterchangeNewlineAtStart(),
                        startIsInsideMailBlockquote)) {
+    // TODO(xiaochengh): Stop storing VisiblePositions through mutations.
     VisiblePosition startOfParagraphToMove = positionAtStartOfInsertedContent();
     VisiblePosition destination = previousPositionOf(startOfParagraphToMove);
     // We need to handle the case where we need to merge the end
     // but our destination node is inside an inline that is the last in the
     // block.
     // We insert a placeholder before the newly inserted content to avoid being
     // merged into the inline.
     Node* destinationNode = destination.deepEquivalent().anchorNode();
     if (m_shouldMergeEnd &&
         destinationNode != enclosingInline(destinationNode) &&
         enclosingInline(destinationNode)->nextSibling()) {
       insertNodeBefore(HTMLBRElement::create(document()), refNode,
                        editingState);
       if (editingState->isAborted())
         return;
     }
 
     // Merging the the first paragraph of inserted content with the content that
     // came before the selection that was pasted into would also move content
     // after the selection that was pasted into if: only one paragraph was being
     // pasted, and it was not wrapped in a block, the selection that was pasted
     // into ended at the end of a block and the next paragraph didn't start at
     // the start of a block.
     // Insert a line break just after the inserted content to separate it from
     // what comes after and prevent that from happening.
     VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
-    if (startOfParagraphDeprecated(endOfInsertedContent).deepEquivalent() ==
+    if (startOfParagraph(endOfInsertedContent).deepEquivalent() ==
         startOfParagraphToMove.deepEquivalent()) {
       insertNodeAt(HTMLBRElement::create(document()),
                    endOfInsertedContent.deepEquivalent(), editingState);
       if (editingState->isAborted())
         return;
       // Mutation events (bug 22634) triggered by inserting the <br> might have
       // removed the content we're about to move
       if (!startOfParagraphToMove.deepEquivalent().isConnected())
         return;
     }
 
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+
     // FIXME: Maintain positions for the start and end of inserted content
     // instead of keeping nodes.  The nodes are only ever used to create
     // positions where inserted content starts/ends.
     moveParagraph(startOfParagraphToMove,
-                  endOfParagraphDeprecated(startOfParagraphToMove), destination,
-                  editingState);
+                  endOfParagraph(createVisiblePosition(
+                      startOfParagraphToMove.toPositionWithAffinity())),
+                  destination, editingState);
     if (editingState->isAborted())
       return;
+
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
     m_startOfInsertedContent = mostForwardCaretPosition(
-        endingSelection().visibleStartDeprecated().deepEquivalent());
-    if (m_endOfInsertedContent.isOrphan())
+        endingSelection().visibleStart().deepEquivalent());
+    if (m_endOfInsertedContent.isOrphan()) {
       m_endOfInsertedContent = mostBackwardCaretPosition(
-          endingSelection().visibleEndDeprecated().deepEquivalent());
+          endingSelection().visibleEnd().deepEquivalent());
+    }
   }
 
   Position lastPositionToSelect;
   if (fragment.hasInterchangeNewlineAtEnd()) {
     VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
     VisiblePosition next =
         nextPositionOf(endOfInsertedContent, CannotCrossEditingBoundary);
 
     if (selectionEndWasEndOfParagraph ||
-        !isEndOfParagraphDeprecated(endOfInsertedContent) || next.isNull()) {
+        !isEndOfParagraph(endOfInsertedContent) || next.isNull()) {
       if (HTMLTextFormControlElement* textControl =
               enclosingTextFormControl(currentRoot)) {
         if (!insertedNodes.lastLeafInserted()->nextSibling()) {
           insertNodeAfter(textControl->createPlaceholderBreakElement(),
                           insertedNodes.lastLeafInserted(), editingState);
           if (editingState->isAborted())
             return;
         }
         setEndingSelection(
             VisiblePosition::afterNode(insertedNodes.lastLeafInserted()));
         // Select up to the paragraph separator that was added.
         lastPositionToSelect =
-            endingSelection().visibleStartDeprecated().deepEquivalent();
-      } else if (!isStartOfParagraphDeprecated(endOfInsertedContent)) {
+            endingSelection().visibleStart().deepEquivalent();
+      } else if (!isStartOfParagraph(endOfInsertedContent)) {
         setEndingSelection(endOfInsertedContent);
         Element* enclosingBlockElement =
             enclosingBlock(endOfInsertedContent.deepEquivalent().anchorNode());
         if (isListItem(enclosingBlockElement)) {
           HTMLLIElement* newListItem = HTMLLIElement::create(document());
           insertNodeAfter(newListItem, enclosingBlockElement, editingState);
           if (editingState->isAborted())
             return;
           setEndingSelection(VisiblePosition::firstPositionInNode(newListItem));
         } else {
           // Use a default paragraph element (a plain div) for the empty
           // paragraph, using the last paragraph block's style seems to annoy
           // users.
           insertParagraphSeparator(
               editingState, true,
               !startIsInsideMailBlockquote &&
                   highestEnclosingNodeOfType(
                       endOfInsertedContent.deepEquivalent(),
                       isMailHTMLBlockquoteElement, CannotCrossEditingBoundary,
                       insertedNodes.firstNodeInserted()->parentNode()));
           if (editingState->isAborted())
             return;
         }
 
+        document().updateStyleAndLayoutIgnorePendingStylesheets();
+
         // Select up to the paragraph separator that was added.
         lastPositionToSelect =
-            endingSelection().visibleStartDeprecated().deepEquivalent();
+            endingSelection().visibleStart().deepEquivalent();
         updateNodesInserted(lastPositionToSelect.anchorNode());
       }
     } else {
       // Select up to the beginning of the next paragraph.
       lastPositionToSelect = mostForwardCaretPosition(next.deepEquivalent());
     }
   } else {
     mergeEndIfNeeded(editingState);
     if (editingState->isAborted())
       return;
@@ skipping 26 matching lines @@
 
   VisiblePosition visiblePos = VisiblePosition::beforeNode(endBR);
 
   // Don't remove the br if nothing was inserted.
   if (previousPositionOf(visiblePos).deepEquivalent() ==
       originalVisPosBeforeEndBR.deepEquivalent())
     return false;
 
   // Remove the br if it is collapsed away and so is unnecessary.
   if (!document().inNoQuirksMode() && isEndOfBlock(visiblePos) &&
-      !isStartOfParagraphDeprecated(visiblePos))
+      !isStartOfParagraph(visiblePos))
     return true;
 
   // A br that was originally holding a line open should be displaced by
   // inserted content or turned into a line break.
   // A br that was originally acting as a line break should still be acting as a
   // line break, not as a placeholder.
-  return isStartOfParagraphDeprecated(visiblePos) &&
-         isEndOfParagraphDeprecated(visiblePos);
+  return isStartOfParagraph(visiblePos) && isEndOfParagraph(visiblePos);
 }
 
 bool ReplaceSelectionCommand::shouldPerformSmartReplace() const {
   if (!m_smartReplace)
     return false;
 
   HTMLTextFormControlElement* textControl = enclosingTextFormControl(
       positionAtStartOfInsertedContent().deepEquivalent());
   if (isHTMLInputElement(textControl) &&
       toHTMLInputElement(textControl)->type() == InputTypeNames::password)
@@ skipping 16 matching lines @@
       mostBackwardCaretPosition(endOfInsertedContent.deepEquivalent());
   Node* endNode = endUpstream.computeNodeBeforePosition();
   int endOffset =
       endNode && endNode->isTextNode() ? toText(endNode)->length() : 0;
   if (endUpstream.isOffsetInAnchor()) {
     endNode = endUpstream.computeContainerNode();
     endOffset = endUpstream.offsetInContainerNode();
   }
 
   bool needsTrailingSpace =
-      !isEndOfParagraphDeprecated(endOfInsertedContent) &&
+      !isEndOfParagraph(endOfInsertedContent) &&
       !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(
           characterAfter(endOfInsertedContent), false);
   if (needsTrailingSpace && endNode) {
     bool collapseWhiteSpace =
         !endNode->layoutObject() ||
         endNode->layoutObject()->style()->collapseWhiteSpace();
     if (endNode->isTextNode()) {
       insertTextIntoNode(toText(endNode), endOffset,
                          collapseWhiteSpace ? nonBreakingSpaceString() : " ");
       if (m_endOfInsertedContent.computeContainerNode() == endNode)
@@ skipping 18 matching lines @@
   Position startDownstream =
       mostForwardCaretPosition(startOfInsertedContent.deepEquivalent());
   Node* startNode = startDownstream.computeNodeAfterPosition();
   unsigned startOffset = 0;
   if (startDownstream.isOffsetInAnchor()) {
     startNode = startDownstream.computeContainerNode();
     startOffset = startDownstream.offsetInContainerNode();
   }
 
   bool needsLeadingSpace =
-      !isStartOfParagraphDeprecated(startOfInsertedContent) &&
+      !isStartOfParagraph(startOfInsertedContent) &&
       !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(
           characterBefore(startOfInsertedContent), true);
   if (needsLeadingSpace && startNode) {
     bool collapseWhiteSpace =
         !startNode->layoutObject() ||
         startNode->layoutObject()->style()->collapseWhiteSpace();
     if (startNode->isTextNode()) {
       insertTextIntoNode(toText(startNode), startOffset,
                          collapseWhiteSpace ? nonBreakingSpaceString() : " ");
       if (m_endOfInsertedContent.computeContainerNode() == startNode &&
@@ skipping 43 matching lines @@
       return;
   } else if (lastPositionToSelect.isNotNull()) {
     start = end = lastPositionToSelect;
   } else {
     return;
   }
 
   m_startOfInsertedRange = start;
   m_endOfInsertedRange = end;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   if (m_selectReplacement)
-    setEndingSelection(createVisibleSelectionDeprecated(
+    setEndingSelection(createVisibleSelection(
         start, end, SelDefaultAffinity, endingSelection().isDirectional()));
   else
-    setEndingSelection(createVisibleSelectionDeprecated(
+    setEndingSelection(createVisibleSelection(
         end, SelDefaultAffinity, endingSelection().isDirectional()));
 }
 
 void ReplaceSelectionCommand::mergeTextNodesAroundPosition(
     Position& position,
     Position& positionOnlyToBeUpdated,
     EditingState* editingState) {
   bool positionIsOffsetInAnchor = position.isOffsetInAnchor();
   bool positionOnlyToBeUpdatedIsOffsetInAnchor =
       positionOnlyToBeUpdated.isOffsetInAnchor();
@@ skipping 91 matching lines @@
 // list, we put the list items into the existing list.
 Node* ReplaceSelectionCommand::insertAsListItems(HTMLElement* listElement,
                                                  Element* insertionBlock,
                                                  const Position& insertPos,
                                                  InsertedNodes& insertedNodes,
                                                  EditingState* editingState) {
   while (listElement->hasOneChild() &&
          isHTMLListElement(listElement->firstChild()))
     listElement = toHTMLElement(listElement->firstChild());
 
-  bool isStart =
-      isStartOfParagraphDeprecated(createVisiblePositionDeprecated(insertPos));
-  bool isEnd =
-      isEndOfParagraphDeprecated(createVisiblePositionDeprecated(insertPos));
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+  bool isStart = isStartOfParagraph(createVisiblePosition(insertPos));
+  bool isEnd = isEndOfParagraph(createVisiblePosition(insertPos));
   bool isMiddle = !isStart && !isEnd;
   Node* lastNode = insertionBlock;
 
   // If we're in the middle of a list item, we should split it into two separate
   // list items and insert these nodes between them.
   if (isMiddle) {
     int textNodeOffset = insertPos.offsetInContainerNode();
     if (insertPos.anchorNode()->isTextNode() && textNodeOffset > 0)
       splitTextNode(toText(insertPos.anchorNode()), textNodeOffset);
     splitTreeToNode(insertPos.anchorNode(), lastNode, true);
@@ skipping 74 matching lines @@
       shouldRemoveEndBR(toHTMLBRElement(nodeAfterInsertionPos),
                         VisiblePosition::beforeNode(nodeAfterInsertionPos))) {
     removeNodeAndPruneAncestors(nodeAfterInsertionPos, editingState);
     if (editingState->isAborted())
       return false;
   }
 
   m_startOfInsertedRange = start;
   m_endOfInsertedRange = end;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
   VisibleSelection selectionAfterReplace =
-      createVisibleSelectionDeprecated(m_selectReplacement ? start : end, end);
+      createVisibleSelection(m_selectReplacement ? start : end, end);
 
   setEndingSelection(selectionAfterReplace);
 
   return true;
 }
 
 bool ReplaceSelectionCommand::isReplaceSelectionCommand() const {
   return true;
 }
 
 EphemeralRange ReplaceSelectionCommand::insertedRange() const {
   return EphemeralRange(m_startOfInsertedRange, m_endOfInsertedRange);
 }
 
 DEFINE_TRACE(ReplaceSelectionCommand) {
   visitor->trace(m_startOfInsertedContent);
   visitor->trace(m_endOfInsertedContent);
   visitor->trace(m_insertionStyle);
   visitor->trace(m_documentFragment);
   visitor->trace(m_startOfInsertedRange);
   visitor->trace(m_endOfInsertedRange);
   CompositeEditCommand::trace(visitor);
 }
 
 }  // namespace blink