Prune deprecated functions from DeleteSelectionCommand

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

 /*
  * Copyright (C) 2005 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 94 matching lines @@
       m_sanitizeMarkup(sanitizeMarkup),
       m_inputType(inputType),
       m_selectionToDelete(selection),
       m_startBlock(nullptr),
       m_endBlock(nullptr),
       m_typingStyle(nullptr),
       m_deleteIntoBlockquoteStyle(nullptr) {}
 
 void DeleteSelectionCommand::initializeStartEnd(Position& start,
                                                 Position& end) {
+  DCHECK(!document().needsLayoutTreeUpdate());
+  DocumentLifecycle::DisallowTransitionScope disallowTransition(
+      document().lifecycle());
+
   HTMLElement* startSpecialContainer = nullptr;
   HTMLElement* endSpecialContainer = nullptr;
 
   start = m_selectionToDelete.start();
   end = m_selectionToDelete.end();
 
   // For HRs, we'll get a position at (HR,1) when hitting delete from the
   // beginning of the previous line, or (HR,0) when forward deleting, but in
   // these cases, we want to delete it, so manually expand the selection
   if (isHTMLHRElement(*start.anchorNode()))
@@ skipping 11 matching lines @@
     endSpecialContainer = 0;
 
     Position s =
         positionBeforeContainingSpecialElement(start, &startSpecialContainer);
     Position e =
         positionAfterContainingSpecialElement(end, &endSpecialContainer);
 
     if (!startSpecialContainer && !endSpecialContainer)
       break;
 
-    if (createVisiblePositionDeprecated(start).deepEquivalent() !=
-            m_selectionToDelete.visibleStartDeprecated().deepEquivalent() ||
-        createVisiblePositionDeprecated(end).deepEquivalent() !=
-            m_selectionToDelete.visibleEndDeprecated().deepEquivalent())
+    if (createVisiblePosition(start).deepEquivalent() !=
+            m_selectionToDelete.visibleStart().deepEquivalent() ||
+        createVisiblePosition(end).deepEquivalent() !=
+            m_selectionToDelete.visibleEnd().deepEquivalent())
       break;
 
     // If we're going to expand to include the startSpecialContainer, it must be
     // fully selected.
     if (startSpecialContainer && !endSpecialContainer &&
         comparePositions(Position::inParentAfterNode(*startSpecialContainer),
                          end) > -1)
       break;
 
     // If we're going to expand to include the endSpecialContainer, it must be
@@ skipping 18 matching lines @@
     } else {
       start = s;
       end = e;
     }
   }
 }
 
 void DeleteSelectionCommand::setStartingSelectionOnSmartDelete(
     const Position& start,
     const Position& end) {
+  DCHECK(!document().needsLayoutTreeUpdate());
+  DocumentLifecycle::DisallowTransitionScope disallowTransition(
+      document().lifecycle());
+
   bool isBaseFirst = startingSelection().isBaseFirst();
-  VisiblePosition newBase =
-      createVisiblePositionDeprecated(isBaseFirst ? start : end);
-  VisiblePosition newExtent =
-      createVisiblePositionDeprecated(isBaseFirst ? end : start);
-  setStartingSelection(createVisibleSelectionDeprecated(
+  VisiblePosition newBase = createVisiblePosition(isBaseFirst ? start : end);
+  VisiblePosition newExtent = createVisiblePosition(isBaseFirst ? end : start);
+  setStartingSelection(createVisibleSelection(
       newBase, newExtent, startingSelection().isDirectional()));
 }
 
 void DeleteSelectionCommand::initializePositionData(
     EditingState* editingState) {
+  DCHECK(!document().needsLayoutTreeUpdate());
+  DocumentLifecycle::DisallowTransitionScope disallowTransition(
+      document().lifecycle());
+
   Position start, end;
   initializeStartEnd(start, end);
   DCHECK(start.isNotNull());
   DCHECK(end.isNotNull());
   if (!isEditablePosition(start)) {
     editingState->abort();
     return;
   }
   if (!isEditablePosition(end)) {
     Node* highestRoot = highestEditableRoot(start);
@@ skipping 24 matching lines @@
                                       CanCrossEditingBoundary);
   // FIXME: This isn't right.  A borderless table with two rows and a single
   // column would appear as two paragraphs.
   if (endCell && endCell != startCell)
     m_mergeBlocksAfterDelete = false;
 
   // Usually the start and the end of the selection to delete are pulled
   // together as a result of the deletion. Sometimes they aren't (like when no
   // merge is requested), so we must choose one position to hold the caret
   // and receive the placeholder after deletion.
-  VisiblePosition visibleEnd = createVisiblePositionDeprecated(m_downstreamEnd);
-  if (m_mergeBlocksAfterDelete && !isEndOfParagraphDeprecated(visibleEnd))
+  VisiblePosition visibleEnd = createVisiblePosition(m_downstreamEnd);
+  if (m_mergeBlocksAfterDelete && !isEndOfParagraph(visibleEnd))
     m_endingPosition = m_downstreamEnd;
   else
     m_endingPosition = m_downstreamStart;
 
   // We don't want to merge into a block if it will mean changing the quote
   // level of content after deleting selections that contain a whole number
   // paragraphs plus a line break, since it is unclear to most users that such a
   // selection actually ends at the start of the next paragraph. This matches
   // TextEdit behavior for indented paragraphs.
   // Only apply this rule if the endingSelection is a range selection.  If it is
   // a caret, then other operations have created the selection we're deleting
   // (like the process of creating a selection to delete during a backspace),
   // and the user isn't in the situation described above.
   if (numEnclosingMailBlockquotes(start) != numEnclosingMailBlockquotes(end) &&
-      isStartOfParagraphDeprecated(visibleEnd) &&
-      isStartOfParagraph(createVisiblePositionDeprecated(start)) &&
+      isStartOfParagraph(visibleEnd) &&
+      isStartOfParagraph(createVisiblePosition(start)) &&
       endingSelection().isRange()) {
     m_mergeBlocksAfterDelete = false;
     m_pruneStartBlockIfNecessary = true;
   }
 
   // Handle leading and trailing whitespace, as well as smart delete adjustments
   // to the selection
   m_leadingWhitespace = leadingWhitespacePosition(
       m_upstreamStart, m_selectionToDelete.affinity());
   m_trailingWhitespace =
       trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);
 
   if (m_smartDelete) {
     // skip smart delete if the selection to delete already starts or ends with
     // whitespace
-    Position pos = createVisiblePositionDeprecated(
-                       m_upstreamStart, m_selectionToDelete.affinity())
-                       .deepEquivalent();
+    Position pos =
+        createVisiblePosition(m_upstreamStart, m_selectionToDelete.affinity())
+            .deepEquivalent();
     bool skipSmartDelete =
         trailingWhitespacePosition(pos, VP_DEFAULT_AFFINITY,
                                    ConsiderNonCollapsibleWhitespace)
             .isNotNull();
     if (!skipSmartDelete)
       skipSmartDelete =
           leadingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY,
                                     ConsiderNonCollapsibleWhitespace)
               .isNotNull();
 
     // extend selection upstream if there is whitespace there
     bool hasLeadingWhitespaceBeforeAdjustment =
         leadingWhitespacePosition(m_upstreamStart,
                                   m_selectionToDelete.affinity(),
                                   ConsiderNonCollapsibleWhitespace)
             .isNotNull();
     if (!skipSmartDelete && hasLeadingWhitespaceBeforeAdjustment) {
-      VisiblePosition visiblePos =
-          previousPositionOf(createVisiblePositionDeprecated(
-              m_upstreamStart, VP_DEFAULT_AFFINITY));
+      VisiblePosition visiblePos = previousPositionOf(
+          createVisiblePosition(m_upstreamStart, VP_DEFAULT_AFFINITY));
       pos = visiblePos.deepEquivalent();
       // Expand out one character upstream for smart delete and recalculate
       // positions based on this change.
       m_upstreamStart = mostBackwardCaretPosition(pos);
       m_downstreamStart = mostForwardCaretPosition(pos);
       m_leadingWhitespace =
           leadingWhitespacePosition(m_upstreamStart, visiblePos.affinity());
 
       setStartingSelectionOnSmartDelete(m_upstreamStart, m_upstreamEnd);
     }
 
     // trailing whitespace is only considered for smart delete if there is no
     // leading whitespace, as in the case where you double-click the first word
     // of a paragraph.
     if (!skipSmartDelete && !hasLeadingWhitespaceBeforeAdjustment &&
         trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY,
                                    ConsiderNonCollapsibleWhitespace)
             .isNotNull()) {
       // Expand out one character downstream for smart delete and recalculate
       // positions based on this change.
-      pos = nextPositionOf(createVisiblePositionDeprecated(m_downstreamEnd,
-                                                           VP_DEFAULT_AFFINITY))
+      pos = nextPositionOf(
+                createVisiblePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY))
                 .deepEquivalent();
       m_upstreamEnd = mostBackwardCaretPosition(pos);
       m_downstreamEnd = mostForwardCaretPosition(pos);
       m_trailingWhitespace =
           trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);
 
       setStartingSelectionOnSmartDelete(m_downstreamStart, m_downstreamEnd);
     }
   }
 
@@ skipping 441 matching lines @@
     return;
 
   // FIXME: The deletion algorithm shouldn't let this happen.
   if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)
     return;
 
   // There's nothing to merge.
   if (m_upstreamStart == m_downstreamEnd)
     return;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   VisiblePosition startOfParagraphToMove =
-      createVisiblePositionDeprecated(m_downstreamEnd);
-  VisiblePosition mergeDestination =
-      createVisiblePositionDeprecated(m_upstreamStart);
+      createVisiblePosition(m_downstreamEnd);
+  VisiblePosition mergeDestination = createVisiblePosition(m_upstreamStart);
 
   // m_downstreamEnd's block has been emptied out by deletion.  There is no
   // content inside of it to move, so just remove it.
   Element* endBlock = enclosingBlock(m_downstreamEnd.anchorNode());
   if (!endBlock ||
       !endBlock->contains(
           startOfParagraphToMove.deepEquivalent().anchorNode()) ||
       !startOfParagraphToMove.deepEquivalent().anchorNode()) {
     removeNode(enclosingBlock(m_downstreamEnd.anchorNode()), editingState);
     return;
@@ skipping 18 matching lines @@
     document().updateStyleAndLayoutIgnorePendingStylesheets();
     mergeDestination = createVisiblePosition(m_upstreamStart);
     startOfParagraphToMove =
         createVisiblePosition(storedStartOfParagraphToMove);
   }
 
   if (mergeDestination.deepEquivalent() ==
       startOfParagraphToMove.deepEquivalent())
     return;
 
-  VisiblePosition endOfParagraphToMove = endOfParagraphDeprecated(
-      startOfParagraphToMove, CanSkipOverEditingBoundary);
+  VisiblePosition endOfParagraphToMove =
+      endOfParagraph(startOfParagraphToMove, CanSkipOverEditingBoundary);
 
   if (mergeDestination.deepEquivalent() ==
       endOfParagraphToMove.deepEquivalent())
     return;
 
   // If the merge destination and source to be moved are both list items of
   // different lists, merge them into single list.
   Node* listItemInFirstParagraph =
       enclosingNodeOfType(m_upstreamStart, isListItem);
   Node* listItemInSecondParagraph =
       enclosingNodeOfType(m_downstreamEnd, isListItem);
   if (listItemInFirstParagraph && listItemInSecondParagraph &&
       listItemInFirstParagraph->parentElement() !=
           listItemInSecondParagraph->parentElement() &&
       canMergeLists(listItemInFirstParagraph->parentElement(),
                     listItemInSecondParagraph->parentElement())) {
     mergeIdenticalElements(listItemInFirstParagraph->parentElement(),
                            listItemInSecondParagraph->parentElement(),
                            editingState);
     if (editingState->isAborted())
       return;
     m_endingPosition = mergeDestination.deepEquivalent();
     return;
   }
 
   // The rule for merging into an empty block is: only do so if its farther to
   // the right.
   // FIXME: Consider RTL.
-  if (!m_startsAtEmptyLine && isStartOfParagraphDeprecated(mergeDestination) &&
+  if (!m_startsAtEmptyLine && isStartOfParagraph(mergeDestination) &&
       absoluteCaretBoundsOf(startOfParagraphToMove).x() >
           absoluteCaretBoundsOf(mergeDestination).x()) {
     if (isHTMLBRElement(
             *mostForwardCaretPosition(mergeDestination.deepEquivalent())
                  .anchorNode())) {
       removeNodeAndPruneAncestors(
           mostForwardCaretPosition(mergeDestination.deepEquivalent())
               .anchorNode(),
           editingState);
       if (editingState->isAborted())
         return;
       m_endingPosition = startOfParagraphToMove.deepEquivalent();
       return;
     }
   }
 
   // Block images, tables and horizontal rules cannot be made inline with
   // content at mergeDestination.  If there is any
   // (!isStartOfParagraphDeprecated(mergeDestination)), don't merge, just move
   // the caret to just before the selection we deleted. See
   // https://bugs.webkit.org/show_bug.cgi?id=25439
   if (isRenderedAsNonInlineTableImageOrHR(
           startOfParagraphToMove.deepEquivalent().anchorNode()) &&
-      !isStartOfParagraphDeprecated(mergeDestination)) {
+      !isStartOfParagraph(mergeDestination)) {
     m_endingPosition = m_upstreamStart;
     return;
   }
 
   // moveParagraphs will insert placeholders if it removes blocks that would
   // require their use, don't let block removals that it does cause the
   // insertion of *another* placeholder.
   bool needPlaceholder = m_needPlaceholder;
   bool paragraphToMergeIsEmpty = startOfParagraphToMove.deepEquivalent() ==
                                  endOfParagraphToMove.deepEquivalent();
@@ skipping 133 matching lines @@
 
   if (!m_selectionToDelete.isNonOrphanedRange() ||
       !m_selectionToDelete.isContentEditable())
     return;
 
   RelocatablePosition relocatableReferencePosition(m_referenceMovePosition);
 
   // save this to later make the selection with
   TextAffinity affinity = m_selectionToDelete.affinity();
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   Position downstreamEnd = mostForwardCaretPosition(m_selectionToDelete.end());
   bool rootWillStayOpenWithoutPlaceholder =
       downstreamEnd.computeContainerNode() ==
           rootEditableElement(*downstreamEnd.computeContainerNode()) ||
       (downstreamEnd.computeContainerNode()->isTextNode() &&
        downstreamEnd.computeContainerNode()->parentNode() ==
            rootEditableElement(*downstreamEnd.computeContainerNode()));
-  bool lineBreakAtEndOfSelectionToDelete = lineBreakExistsAtVisiblePosition(
-      m_selectionToDelete.visibleEndDeprecated());
-  m_needPlaceholder =
-      !rootWillStayOpenWithoutPlaceholder &&
-      isStartOfParagraphDeprecated(m_selectionToDelete.visibleStartDeprecated(),
-                                   CanCrossEditingBoundary) &&
-      isEndOfParagraphDeprecated(m_selectionToDelete.visibleEndDeprecated(),
-                                 CanCrossEditingBoundary) &&
-      !lineBreakAtEndOfSelectionToDelete;
+  bool lineBreakAtEndOfSelectionToDelete =
+      lineBreakExistsAtVisiblePosition(m_selectionToDelete.visibleEnd());
+  m_needPlaceholder = !rootWillStayOpenWithoutPlaceholder &&
+                      isStartOfParagraph(m_selectionToDelete.visibleStart(),
+                                         CanCrossEditingBoundary) &&
+                      isEndOfParagraph(m_selectionToDelete.visibleEnd(),
+                                       CanCrossEditingBoundary) &&
+                      !lineBreakAtEndOfSelectionToDelete;
   if (m_needPlaceholder) {
     // Don't need a placeholder when deleting a selection that starts just
     // before a table and ends inside it (we do need placeholders to hold
     // open empty cells, but that's handled elsewhere).
-    if (Element* table = tableElementJustAfter(
-            m_selectionToDelete.visibleStartDeprecated())) {
+    if (Element* table =
+            tableElementJustAfter(m_selectionToDelete.visibleStart())) {
       if (m_selectionToDelete.end().anchorNode()->isDescendantOf(table))
         m_needPlaceholder = false;
     }
   }
 
   // set up our state
   initializePositionData(editingState);
   if (editingState->isAborted())
     return;
 
   bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(
-      previousPositionOf(createVisiblePositionDeprecated(m_upstreamStart)));
+      previousPositionOf(createVisiblePosition(m_upstreamStart)));
 
   // Delete any text that may hinder our ability to fixup whitespace after the
   // delete
   deleteInsignificantTextDownstream(m_trailingWhitespace);
 
   saveTypingStyleState();
 
   // deleting just a BR is handled specially, at least because we do not
   // want to replace it with a placeholder BR!
   bool brResult = handleSpecialCaseBRDelete(editingState);
   if (editingState->isAborted())
     return;
   if (brResult) {
     calculateTypingStyleAfterDelete();
-    setEndingSelection(createVisibleSelectionDeprecated(
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+    setEndingSelection(createVisibleSelection(
         m_endingPosition, affinity, endingSelection().isDirectional()));
     clearTransientState();
     rebalanceWhitespace();
     return;
   }
 
   handleGeneralDelete(editingState);
   if (editingState->isAborted())
     return;
 
   fixupWhitespace();
 
   mergeParagraphs(editingState);
   if (editingState->isAborted())
     return;
 
   removePreviouslySelectedEmptyTableRows(editingState);
   if (editingState->isAborted())
     return;
 
   if (!m_needPlaceholder && rootWillStayOpenWithoutPlaceholder) {
-    VisiblePosition visualEnding =
-        createVisiblePositionDeprecated(m_endingPosition);
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+    VisiblePosition visualEnding = createVisiblePosition(m_endingPosition);
     bool hasPlaceholder =
         lineBreakExistsAtVisiblePosition(visualEnding) &&
         nextPositionOf(visualEnding, CannotCrossEditingBoundary).isNull();
     m_needPlaceholder = hasPlaceholder && lineBreakBeforeStart &&
                         !lineBreakAtEndOfSelectionToDelete;
   }
 
   HTMLBRElement* placeholder =
       m_needPlaceholder ? HTMLBRElement::create(document()) : nullptr;
 
   if (placeholder) {
     if (m_sanitizeMarkup) {
       removeRedundantBlocks(editingState);
       if (editingState->isAborted())
         return;
     }
     // handleGeneralDelete cause DOM mutation events so |m_endingPosition|
     // can be out of document.
     if (m_endingPosition.isConnected()) {
       insertNodeAt(placeholder, m_endingPosition, editingState);
       if (editingState->isAborted())
         return;
     }
   }
 
   rebalanceWhitespaceAt(m_endingPosition);
 
   calculateTypingStyleAfterDelete();
 
-  setEndingSelection(createVisibleSelectionDeprecated(
-      m_endingPosition, affinity, endingSelection().isDirectional()));
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
+  setEndingSelection(createVisibleSelection(m_endingPosition, affinity,
+                                            endingSelection().isDirectional()));
 
   if (relocatableReferencePosition.position().isNull()) {
     clearTransientState();
     return;
   }
 
   // This deletion command is part of a move operation, we need to cleanup after
   // deletion.
   m_referenceMovePosition = relocatableReferencePosition.position();
   // If the node for the destination has been removed as a result of the
   // deletion, set the destination to the ending point after the deletion.
   // Fixes: <rdar://problem/3910425> REGRESSION (Mail): Crash in
   // ReplaceSelectionCommand; selection is empty, leading to null deref
   if (!m_referenceMovePosition.isConnected())
     m_referenceMovePosition = endingSelection().start();
 
   // Move selection shouldn't left empty <li> block.
-  cleanupAfterDeletion(
-      editingState, createVisiblePositionDeprecated(m_referenceMovePosition));
+  cleanupAfterDeletion(editingState,
+                       createVisiblePosition(m_referenceMovePosition));
   if (editingState->isAborted())
     return;
 
   clearTransientState();
 }
 
 InputEvent::InputType DeleteSelectionCommand::inputType() const {
   // |DeleteSelectionCommand| could be used with Cut, Menu Bar deletion and
   // |TypingCommand|.
   // 1. Cut and Menu Bar deletion should rely on correct |m_inputType|.
@@ skipping 26 matching lines @@
   visitor->trace(m_deleteIntoBlockquoteStyle);
   visitor->trace(m_startRoot);
   visitor->trace(m_endRoot);
   visitor->trace(m_startTableRow);
   visitor->trace(m_endTableRow);
   visitor->trace(m_temporaryPlaceholder);
   CompositeEditCommand::trace(visitor);
 }
 
 }  // namespace blink