Prune most of the deprecated functions from CompositeEditCommand

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

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 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 838 matching lines @@
     upstream--;
 
   int downstream = endOffset;
   while ((unsigned)downstream < text.length() && isWhitespace(text[downstream]))
     downstream++;
 
   int length = downstream - upstream;
   if (!length)
     return;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
   VisiblePosition visibleUpstreamPos =

[yosin_UTC9, 2016/10/12 02:12:06]

BTW, should we replace |VisiblePosition| to |const VisiblePositon&|?

[Xiaocheng, 2016/10/12 02:15:54]

Do you mean a global s/VisiblePosition/const VisiblePosition&/?

-      createVisiblePositionDeprecated(Position(textNode, upstream));
+      createVisiblePosition(Position(textNode, upstream));
   VisiblePosition visibleDownstreamPos =
-      createVisiblePositionDeprecated(Position(textNode, downstream));
+      createVisiblePosition(Position(textNode, downstream));
 
   String string = text.substring(upstream, length);
   // FIXME: Because of the problem mentioned at the top of this function, we
   // must also use nbsps at the start/end of the string because this function
   // doesn't get all surrounding whitespace, just the whitespace in the
   // current text node. However, if the next sibling node is a text node
   // (not empty, see http://crbug.com/632300), we should use a plain space.
   // See http://crbug.com/310149
   const bool nextSiblingIsTextNode =
       textNode->nextSibling() && textNode->nextSibling()->isTextNode() &&
       toText(textNode->nextSibling())->data().length();
   const bool shouldEmitNBSPbeforeEnd =
-      (isEndOfParagraphDeprecated(visibleDownstreamPos) ||
+      (isEndOfParagraph(visibleDownstreamPos) ||
        (unsigned)downstream == text.length()) &&
       !nextSiblingIsTextNode;
   String rebalancedString = stringWithRebalancedWhitespace(
-      string, isStartOfParagraphDeprecated(visibleUpstreamPos) || !upstream,
+      string, isStartOfParagraph(visibleUpstreamPos) || !upstream,
       shouldEmitNBSPbeforeEnd);
 
   if (string != rebalancedString)
     replaceTextInNodePreservingMarkers(textNode, upstream, length,
                                        rebalancedString);
 }
 
 void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(
     Position& position) {
   if (!isRichlyEditablePosition(position))
@@ skipping 156 matching lines @@
                           : 0;
     int endOffset = textNode == end.anchorNode()
                         ? end.computeOffsetInContainerNode()
                         : static_cast<int>(textNode->length());
     deleteInsignificantText(textNode, startOffset, endOffset);
   }
 }
 
 void CompositeEditCommand::deleteInsignificantTextDownstream(
     const Position& pos) {
+  DCHECK(!document().needsLayoutTreeUpdate());
   Position end = mostForwardCaretPosition(
-      nextPositionOf(createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY))
+      nextPositionOf(createVisiblePosition(pos, VP_DEFAULT_AFFINITY))
           .deepEquivalent());
   deleteInsignificantText(pos, end);
 }
 
 HTMLBRElement* CompositeEditCommand::appendBlockPlaceholder(
     Element* container,
     EditingState* editingState) {
   if (!container)
     return nullptr;
 
@@ skipping 74 matching lines @@
   if (editingState->isAborted())
     return nullptr;
   return paragraphElement;
 }
 
 // If the paragraph is not entirely within it's own block, create one and move
 // the paragraph into it, and return that block.  Otherwise return 0.
 HTMLElement* CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(
     const Position& pos,
     EditingState* editingState) {
+  DCHECK(!document().needsLayoutTreeUpdate());
   DCHECK(isEditablePosition(pos)) << pos;
 
   // It's strange that this function is responsible for verifying that pos has
   // not been invalidated by an earlier call to this function.  The caller,
   // applyBlockStyle, should do this.
-  VisiblePosition visiblePos =
-      createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY);
-  VisiblePosition visibleParagraphStart =
-      startOfParagraphDeprecated(visiblePos);
-  VisiblePosition visibleParagraphEnd = endOfParagraphDeprecated(visiblePos);
+  VisiblePosition visiblePos = createVisiblePosition(pos, VP_DEFAULT_AFFINITY);
+  VisiblePosition visibleParagraphStart = startOfParagraph(visiblePos);
+  VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
   VisiblePosition next = nextPositionOf(visibleParagraphEnd);
   VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
 
   Position upstreamStart =
       mostBackwardCaretPosition(visibleParagraphStart.deepEquivalent());
   Position upstreamEnd = mostBackwardCaretPosition(visibleEnd.deepEquivalent());
 
   // If there are no VisiblePositions in the same block as pos then
   // upstreamStart will be outside the paragraph
   if (comparePositions(pos, upstreamStart) < 0)
@@ skipping 35 matching lines @@
   HTMLElement* newBlock =
       insertNewDefaultParagraphElementAt(upstreamStart, editingState);
   if (editingState->isAborted())
     return nullptr;
 
   bool endWasBr =
       isHTMLBRElement(*visibleParagraphEnd.deepEquivalent().anchorNode());
 
   // Inserting default paragraph element can change visible position. We
   // should update visible positions before use them.
-  visiblePos = createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY);
-  visibleParagraphStart = startOfParagraphDeprecated(visiblePos);
-  visibleParagraphEnd = endOfParagraphDeprecated(visiblePos);
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+  visiblePos = createVisiblePosition(pos, VP_DEFAULT_AFFINITY);
+  visibleParagraphStart = startOfParagraph(visiblePos);
+  visibleParagraphEnd = endOfParagraph(visiblePos);
   moveParagraphs(visibleParagraphStart, visibleParagraphEnd,
                  VisiblePosition::firstPositionInNode(newBlock), editingState);
   if (editingState->isAborted())
     return nullptr;
 
   if (newBlock->lastChild() && isHTMLBRElement(*newBlock->lastChild()) &&
       !endWasBr) {
     removeNode(newBlock->lastChild(), editingState);
     if (editingState->isAborted())
       return nullptr;
@@ skipping 116 matching lines @@
 }
 
 // There are bugs in deletion when it removes a fully selected table/list.
 // It expands and removes the entire table/list, but will let content
 // before and after the table/list collapse onto one line.
 // Deleting a paragraph will leave a placeholder. Remove it (and prune
 // empty or unrendered parents).
 
 void CompositeEditCommand::cleanupAfterDeletion(EditingState* editingState,
                                                 VisiblePosition destination) {
-  VisiblePosition caretAfterDelete = endingSelection().visibleStartDeprecated();
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
+  VisiblePosition caretAfterDelete = endingSelection().visibleStart();
   Node* destinationNode = destination.deepEquivalent().anchorNode();
   if (caretAfterDelete.deepEquivalent() != destination.deepEquivalent() &&
-      isStartOfParagraphDeprecated(caretAfterDelete) &&
-      isEndOfParagraphDeprecated(caretAfterDelete)) {
+      isStartOfParagraph(caretAfterDelete) &&
+      isEndOfParagraph(caretAfterDelete)) {
     // Note: We want the rightmost candidate.
     Position position =
         mostForwardCaretPosition(caretAfterDelete.deepEquivalent());
     Node* node = position.anchorNode();
 
     // Bail if we'd remove an ancestor of our destination.
     if (destinationNode && destinationNode->isDescendantOf(node))
       return;
 
     // Normally deletion will leave a br as a placeholder.
@@ skipping 53 matching lines @@
       startOfParagraphToMove.deepEquivalent() ==
               endOfParagraphToMove.deepEquivalent()
           ? start
           : mostBackwardCaretPosition(endOfParagraphToMove.deepEquivalent());
   if (comparePositions(start, end) > 0)
     end = start;
 
   cloneParagraphUnderNewElement(start, end, outerNode, blockElement,
                                 editingState);
 
-  setEndingSelection(createVisibleSelectionDeprecated(start, end));
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
+  setEndingSelection(createVisibleSelection(start, end));
   deleteSelection(editingState, false, false, false);
   if (editingState->isAborted())
     return;
 
   // There are bugs in deletion when it removes a fully selected table/list.
   // It expands and removes the entire table/list, but will let content
   // before and after the table/list collapse onto one line.
 
   cleanupAfterDeletion(editingState);
   if (editingState->isAborted())
     return;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   // Add a br if pruning an empty block level element caused a collapse.  For
   // example:
   // foo^
   // <div>bar</div>
   // baz
   // Imagine moving 'bar' to ^.  'bar' will be deleted and its div pruned.  That
   // would cause 'baz' to collapse onto the line with 'foobar' unless we insert
   // a br. Must recononicalize these two VisiblePositions after the pruning
   // above.
   // TODO(yosin): We should abort when |beforeParagraph| is a orphan when
   // we have a sample.
-  beforeParagraph =
-      createVisiblePositionDeprecated(beforeParagraph.deepEquivalent());
+  beforeParagraph = createVisiblePosition(beforeParagraph.deepEquivalent());
   if (afterParagraph.isOrphan()) {
     editingState->abort();
     return;
   }
-  afterParagraph =
-      createVisiblePositionDeprecated(afterParagraph.deepEquivalent());
+  afterParagraph = createVisiblePosition(afterParagraph.deepEquivalent());
 
   if (beforeParagraph.isNotNull() &&
       !isDisplayInsideTable(beforeParagraph.deepEquivalent().anchorNode()) &&
-      ((!isEndOfParagraphDeprecated(beforeParagraph) &&
-        !isStartOfParagraphDeprecated(beforeParagraph)) ||
+      ((!isEndOfParagraph(beforeParagraph) &&
+        !isStartOfParagraph(beforeParagraph)) ||
        beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
     // FIXME: Trim text between beforeParagraph and afterParagraph if they
     // aren't equal.
     insertNodeAt(HTMLBRElement::create(document()),
                  beforeParagraph.deepEquivalent(), editingState);
   }
 }
 
+// TODO(xiaochengh): Ensure valid VisiblePositions are passed to this function.
 void CompositeEditCommand::moveParagraph(
     const VisiblePosition& startOfParagraphToMove,
     const VisiblePosition& endOfParagraphToMove,
     const VisiblePosition& destination,
     EditingState* editingState,
     ShouldPreserveSelection shouldPreserveSelection,
     ShouldPreserveStyle shouldPreserveStyle,
     Node* constrainingAncestor) {
   DCHECK(isStartOfParagraphDeprecated(startOfParagraphToMove))
       << startOfParagraphToMove;
   DCHECK(isEndOfParagraphDeprecated(endOfParagraphToMove))
       << endOfParagraphToMove;
   moveParagraphs(startOfParagraphToMove, endOfParagraphToMove, destination,
                  editingState, shouldPreserveSelection, shouldPreserveStyle,
                  constrainingAncestor);
 }
 
+// TODO(xiaochengh): Ensure valid VisiblePositions are passed to this function,
+// and do proper recalculation after mutations so that they are still valid when
+// being used.
 void CompositeEditCommand::moveParagraphs(
     const VisiblePosition& startOfParagraphToMove,
     const VisiblePosition& endOfParagraphToMove,
     const VisiblePosition& destination,
     EditingState* editingState,
     ShouldPreserveSelection shouldPreserveSelection,
     ShouldPreserveStyle shouldPreserveStyle,
     Node* constrainingAncestor) {
   if (startOfParagraphToMove.deepEquivalent() == destination.deepEquivalent() ||
       startOfParagraphToMove.isNull())
     return;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   int startIndex = -1;
   int endIndex = -1;
   int destinationIndex = -1;
   bool originalIsDirectional = endingSelection().isDirectional();
   if (shouldPreserveSelection == PreserveSelection &&
       !endingSelection().isNone()) {
-    VisiblePosition visibleStart = endingSelection().visibleStartDeprecated();
-    VisiblePosition visibleEnd = endingSelection().visibleEndDeprecated();
+    VisiblePosition visibleStart = endingSelection().visibleStart();
+    VisiblePosition visibleEnd = endingSelection().visibleEnd();
 
     bool startAfterParagraph =
         comparePositions(visibleStart, endOfParagraphToMove) > 0;
     bool endBeforeParagraph =
         comparePositions(visibleEnd, startOfParagraphToMove) < 0;
 
     if (!startAfterParagraph && !endBeforeParagraph) {
       bool startInParagraph =
           comparePositions(visibleStart, startOfParagraphToMove) >= 0;
       bool endInParagraph =
           comparePositions(visibleEnd, endOfParagraphToMove) <= 0;
 
-      // TextIterator::rangeLength requires clean layout.
-      document().updateStyleAndLayoutIgnorePendingStylesheets();
-
       startIndex = 0;
       if (startInParagraph)
         startIndex = TextIterator::rangeLength(
             startOfParagraphToMove.toParentAnchoredPosition(),
             visibleStart.toParentAnchoredPosition(), true);
 
       endIndex = 0;
       if (endInParagraph)
         endIndex = TextIterator::rangeLength(
             startOfParagraphToMove.toParentAnchoredPosition(),
@@ skipping 44 matching lines @@
     styleInEmptyParagraph =
         EditingStyle::create(startOfParagraphToMove.deepEquivalent());
     styleInEmptyParagraph->mergeTypingStyle(&document());
     // The moved paragraph should assume the block style of the destination.
     styleInEmptyParagraph->removeBlockProperties();
   }
 
   // FIXME (5098931): We should add a new insert action
   // "WebViewInsertActionMoved" and call shouldInsertFragment here.
 
-  setEndingSelection(createVisibleSelectionDeprecated(start, end));
+  DCHECK(!document().needsLayoutTreeUpdate());
+
+  setEndingSelection(createVisibleSelection(start, end));
   document()
       .frame()
       ->spellChecker()
       .clearMisspellingsAndBadGrammarForMovingParagraphs(endingSelection());
   deleteSelection(editingState, false, false, false);
   if (editingState->isAborted())
     return;
 
   DCHECK(destination.deepEquivalent().isConnected()) << destination;
   cleanupAfterDeletion(editingState, destination);
   if (editingState->isAborted())
     return;
   DCHECK(destination.deepEquivalent().isConnected()) << destination;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   // Add a br if pruning an empty block level element caused a collapse. For
   // example:
   // foo^
   // <div>bar</div>
   // baz
   // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That
   // would cause 'baz' to collapse onto the line with 'foobar' unless we insert
   // a br. Must recononicalize these two VisiblePositions after the pruning
   // above.
   VisiblePosition beforeParagraph =
-      createVisiblePositionDeprecated(beforeParagraphPosition.position());
+      createVisiblePosition(beforeParagraphPosition.position());
   VisiblePosition afterParagraph =
-      createVisiblePositionDeprecated(afterParagraphPosition.position());
+      createVisiblePosition(afterParagraphPosition.position());
   if (beforeParagraph.isNotNull() &&
-      (!isEndOfParagraphDeprecated(beforeParagraph) ||
+      (!isEndOfParagraph(beforeParagraph) ||
        beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
     // FIXME: Trim text between beforeParagraph and afterParagraph if they
     // aren't equal.
     insertNodeAt(HTMLBRElement::create(document()),
                  beforeParagraph.deepEquivalent(), editingState);
     if (editingState->isAborted())
       return;
     // Need an updateLayout here in case inserting the br has split a text node.
     document().updateStyleAndLayoutIgnorePendingStylesheets();
   }
@@ skipping 14 matching lines @@
       ReplaceSelectionCommand::SelectReplacement |
       ReplaceSelectionCommand::MovingParagraph;
   if (shouldPreserveStyle == DoNotPreserveStyle)
     options |= ReplaceSelectionCommand::MatchStyle;
   applyCommandToComposite(
       ReplaceSelectionCommand::create(document(), fragment, options),
       editingState);
   if (editingState->isAborted())
     return;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   document()
       .frame()
       ->spellChecker()
       .markMisspellingsAndBadGrammarForMovingParagraphs(endingSelection());
 
   // If the selection is in an empty paragraph, restore styles from the old
   // empty paragraph to the new empty paragraph.
   bool selectionIsEmptyParagraph =
       endingSelection().isCaret() &&
-      isStartOfParagraphDeprecated(
-          endingSelection().visibleStartDeprecated()) &&
-      isEndOfParagraphDeprecated(endingSelection().visibleStartDeprecated());
+      isStartOfParagraph(endingSelection().visibleStart()) &&
+      isEndOfParagraph(endingSelection().visibleStart());
   if (styleInEmptyParagraph && selectionIsEmptyParagraph) {
     applyStyle(styleInEmptyParagraph, editingState);
     if (editingState->isAborted())
       return;
   }
 
   if (shouldPreserveSelection == DoNotPreserveSelection || startIndex == -1)
     return;
   Element* documentElement = document().documentElement();
   if (!documentElement)
     return;
 
   // We need clean layout in order to compute plain-text ranges below.
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   // Fragment creation (using createMarkup) incorrectly uses regular spaces
   // instead of nbsps for some spaces that were rendered (11475), which causes
   // spaces to be collapsed during the move operation. This results in a call
   // to rangeFromLocationAndLength with a location past the end of the
   // document (which will return null).
   EphemeralRange startRange = PlainTextRange(destinationIndex + startIndex)
                                   .createRangeForSelection(*documentElement);
   if (startRange.isNull())
     return;
   EphemeralRange endRange = PlainTextRange(destinationIndex + endIndex)
                                 .createRangeForSelection(*documentElement);
   if (endRange.isNull())
     return;
-  setEndingSelection(createVisibleSelectionDeprecated(
+  setEndingSelection(createVisibleSelection(
       startRange.startPosition(), endRange.startPosition(),
       TextAffinity::Downstream, originalIsDirectional));
 }
 
 // FIXME: Send an appropriate shouldDeleteRange call.
 bool CompositeEditCommand::breakOutOfEmptyListItem(EditingState* editingState) {
+  DCHECK(!document().needsLayoutTreeUpdate());
   Node* emptyListItem =
-      enclosingEmptyListItem(endingSelection().visibleStartDeprecated());
+      enclosingEmptyListItem(endingSelection().visibleStart());
   if (!emptyListItem)
     return false;
 
   EditingStyle* style = EditingStyle::create(endingSelection().start());
   style->mergeTypingStyle(&document());
 
   ContainerNode* listNode = emptyListItem->parentNode();
   // FIXME: Can't we do something better when the immediate parent wasn't a list
   // node?
   if (!listNode ||
@@ skipping 72 matching lines @@
             ? emptyListItem
             : listNode,
         editingState);
     if (editingState->isAborted())
       return false;
   }
 
   appendBlockPlaceholder(newBlock, editingState);
   if (editingState->isAborted())
     return false;
-  setEndingSelection(createVisibleSelectionDeprecated(
+
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+  setEndingSelection(createVisibleSelection(
       Position::firstPositionInNode(newBlock), TextAffinity::Downstream,
       endingSelection().isDirectional()));
 
   style->prepareToApplyAt(endingSelection().start());
   if (!style->isEmpty()) {
     applyStyle(style, editingState);
     if (editingState->isAborted())
       return false;
   }
 
   return true;
 }
 
 // If the caret is in an empty quoted paragraph, and either there is nothing
 // before that paragraph, or what is before is unquoted, and the user presses
 // delete, unquote that paragraph.
 bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph(
     EditingState* editingState) {
   if (!endingSelection().isCaret())
     return false;
 
-  VisiblePosition caret = endingSelection().visibleStartDeprecated();
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
+  VisiblePosition caret = endingSelection().visibleStart();
   HTMLQuoteElement* highestBlockquote =
       toHTMLQuoteElement(highestEnclosingNodeOfType(
           caret.deepEquivalent(), &isMailHTMLBlockquoteElement));
   if (!highestBlockquote)
     return false;
 
-  if (!isStartOfParagraphDeprecated(caret) ||
-      !isEndOfParagraphDeprecated(caret))
+  if (!isStartOfParagraph(caret) || !isEndOfParagraph(caret))
     return false;
 
   VisiblePosition previous =
       previousPositionOf(caret, CannotCrossEditingBoundary);
   // Only move forward if there's nothing before the caret, or if there's
   // unquoted content before it.
   if (enclosingNodeOfType(previous.deepEquivalent(),
                           &isMailHTMLBlockquoteElement))
     return false;
 
   HTMLBRElement* br = HTMLBRElement::create(document());
   // We want to replace this quoted paragraph with an unquoted one, so insert a
   // br to hold the caret before the highest blockquote.
   insertNodeBefore(br, highestBlockquote, editingState);
   if (editingState->isAborted())
     return false;
+
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   VisiblePosition atBR = VisiblePosition::beforeNode(br);
   // If the br we inserted collapsed, for example:
   //   foo<br><blockquote>...</blockquote>
   // insert a second one.
-  if (!isStartOfParagraphDeprecated(atBR)) {
+  if (!isStartOfParagraph(atBR)) {
     insertNodeBefore(HTMLBRElement::create(document()), br, editingState);
     if (editingState->isAborted())
       return false;
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
   }
-  setEndingSelection(createVisibleSelectionDeprecated(
-      atBR, endingSelection().isDirectional()));
+  setEndingSelection(createVisibleSelection(atBR.toPositionWithAffinity(),
+                                            endingSelection().isDirectional()));
 
   // If this is an empty paragraph there must be a line break here.
   if (!lineBreakExistsAtVisiblePosition(caret))
     return false;
 
   Position caretPos(mostForwardCaretPosition(caret.deepEquivalent()));
   // A line break is either a br or a preserved newline.
   DCHECK(isHTMLBRElement(caretPos.anchorNode()) ||
          (caretPos.anchorNode()->isTextNode() &&
           caretPos.anchorNode()->layoutObject()->style()->preserveNewline()))
@@ skipping 22 matching lines @@
 // Operations use this function to avoid inserting content into an anchor when
 // at the start or the end of that anchor, as in NSTextView.
 // FIXME: This is only an approximation of NSTextViews insertion behavior, which
 // varies depending on how the caret was made.
 Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(
     const Position& original,
     EditingState* editingState) {
   if (original.isNull())
     return original;
 
-  VisiblePosition visiblePos = createVisiblePositionDeprecated(original);
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+  VisiblePosition visiblePos = createVisiblePosition(original);
   Element* enclosingAnchor = enclosingAnchorElement(original);
   Position result = original;
 
   if (!enclosingAnchor)
     return result;
 
   // Don't avoid block level anchors, because that would insert content into the
   // wrong paragraph.
   if (enclosingAnchor && !isEnclosingBlock(enclosingAnchor)) {
     VisiblePosition firstInAnchor =
@@ skipping 64 matching lines @@
     end = end->parentNode();
   if (!start->isDescendantOf(end))
     return end;
 
   Node* endNode = end;
   Node* node = nullptr;
   for (node = start; node->parentNode() != endNode; node = node->parentNode()) {
     Element* parentElement = node->parentElement();
     if (!parentElement)
       break;
+
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+
     // Do not split a node when doing so introduces an empty node.
     VisiblePosition positionInParent =
         VisiblePosition::firstPositionInNode(parentElement);
     VisiblePosition positionInNode =
-        createVisiblePositionDeprecated(firstPositionInOrBeforeNode(node));
+        createVisiblePosition(firstPositionInOrBeforeNode(node));
     if (positionInParent.deepEquivalent() != positionInNode.deepEquivalent())
       splitElement(parentElement, node);
   }
 
   return node;
 }
 
 DEFINE_TRACE(CompositeEditCommand) {
   visitor->trace(m_commands);
   visitor->trace(m_composition);
   EditCommand::trace(visitor);
 }
 
 }  // namespace blink