Prune deprecated editing functions from ApplyBlockElementCommand and its subclasses

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

 /*
  * Copyright (C) 2006, 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 73 matching lines @@
 
   // We should calculate visible range in list item because inserting new
   // list element will change visibility of list item, e.g. :first-child
   // CSS selector.
   HTMLElement* newList = toHTMLElement(
       document().createElement(listElement->tagQName(), CreatedByCloneNode));
   insertNodeBefore(newList, selectedListItem, editingState);
   if (editingState->isAborted())
     return false;
 
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+
   // We should clone all the children of the list item for indenting purposes. However, in case the current
   // selection does not encompass all its children, we need to explicitally handle the same. The original
   // list item too would require proper deletion in that case.
   if (end.anchorNode() == selectedListItem ||
       end.anchorNode()->isDescendantOf(selectedListItem->lastChild())) {
-    moveParagraphWithClones(createVisiblePositionDeprecated(start),
-                            createVisiblePositionDeprecated(end), newList,
+    moveParagraphWithClones(createVisiblePosition(start),
+                            createVisiblePosition(end), newList,
                             selectedListItem, editingState);
   } else {
     moveParagraphWithClones(
-        createVisiblePositionDeprecated(start),
+        createVisiblePosition(start),
         VisiblePosition::afterNode(selectedListItem->lastChild()), newList,
         selectedListItem, editingState);
     if (editingState->isAborted())
       return false;
     removeNode(selectedListItem, editingState);
   }
   if (editingState->isAborted())
     return false;
 
   if (canMergeLists(previousList, newList)) {
@@ skipping 24 matching lines @@
     elementToSplitTo = rootEditableElementOf(start);
 
   if (!elementToSplitTo)
     return;
 
   Node* outerBlock =
       (start.computeContainerNode() == elementToSplitTo)
           ? start.computeContainerNode()
           : splitTreeToNode(start.computeContainerNode(), elementToSplitTo);
 
-  VisiblePosition startOfContents = createVisiblePositionDeprecated(start);
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
+  VisiblePosition startOfContents = createVisiblePosition(start);
   if (!targetBlockquote) {
     // Create a new blockquote and insert it as a child of the root editable element. We accomplish
     // this by splitting all parents of the current paragraph up to that point.
     targetBlockquote = createBlockElement();
     if (outerBlock == start.computeContainerNode()) {
       // When we apply indent to an empty <blockquote>, we should call insertNodeAfter().
       // See http://crbug.com/625802 for more details.
       if (outerBlock->hasTagName(blockquoteTag))
         insertNodeAfter(targetBlockquote, outerBlock, editingState);
       else
         insertNodeAt(targetBlockquote, start, editingState);
     } else
       insertNodeBefore(targetBlockquote, outerBlock, editingState);
     if (editingState->isAborted())
       return;
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
     startOfContents = VisiblePosition::inParentAfterNode(*targetBlockquote);
   }
 
-  VisiblePosition endOfContents = createVisiblePositionDeprecated(end);
+  VisiblePosition endOfContents = createVisiblePosition(end);
   if (startOfContents.isNull() || endOfContents.isNull())
     return;
   moveParagraphWithClones(startOfContents, endOfContents, targetBlockquote,
                           outerBlock, editingState);
 }
 
 void IndentOutdentCommand::outdentParagraph(EditingState* editingState) {
   VisiblePosition visibleStartOfParagraph =
-      startOfParagraphDeprecated(endingSelection().visibleStartDeprecated());
+      startOfParagraph(endingSelection().visibleStart());
   VisiblePosition visibleEndOfParagraph =
-      endOfParagraphDeprecated(visibleStartOfParagraph);
+      endOfParagraph(visibleStartOfParagraph);
 
   HTMLElement* enclosingElement = toHTMLElement(
       enclosingNodeOfType(visibleStartOfParagraph.deepEquivalent(),
                           &isHTMLListOrBlockquoteElement));
   if (!enclosingElement ||
       !hasEditableStyle(
           *enclosingElement
                ->parentNode()))  // We can't outdent if there is no place to go!
     return;
 
@@ skipping 41 matching lines @@
         if (splitPointParent->hasTagName(blockquoteTag) &&
             !splitPoint->hasTagName(blockquoteTag) &&
             hasEditableStyle(
                 *splitPointParent
                      ->parentNode()))  // We can't outdent if there is no place to go!
           splitElement(splitPointParent, splitPoint);
       }
     }
 
     document().updateStyleAndLayoutIgnorePendingStylesheets();
-    visibleStartOfParagraph = createVisiblePositionDeprecated(
-        visibleStartOfParagraph.deepEquivalent());
-    visibleEndOfParagraph =
-        createVisiblePositionDeprecated(visibleEndOfParagraph.deepEquivalent());
+    visibleStartOfParagraph =
+        createVisiblePosition(visibleStartOfParagraph.deepEquivalent());
     if (visibleStartOfParagraph.isNotNull() &&
-        !isStartOfParagraphDeprecated(visibleStartOfParagraph)) {
+        !isStartOfParagraph(visibleStartOfParagraph)) {
       insertNodeAt(HTMLBRElement::create(document()),
                    visibleStartOfParagraph.deepEquivalent(), editingState);
       if (editingState->isAborted())
         return;
     }
+
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+    visibleEndOfParagraph =
+        createVisiblePosition(visibleEndOfParagraph.deepEquivalent());
     if (visibleEndOfParagraph.isNotNull() &&
-        !isEndOfParagraphDeprecated(visibleEndOfParagraph))
+        !isEndOfParagraph(visibleEndOfParagraph))
       insertNodeAt(HTMLBRElement::create(document()),
                    visibleEndOfParagraph.deepEquivalent(), editingState);
     return;
   }
+
   Node* splitBlockquoteNode = enclosingElement;
   if (Element* enclosingBlockFlow = enclosingBlock(
           visibleStartOfParagraph.deepEquivalent().anchorNode())) {
     if (enclosingBlockFlow != enclosingElement) {
       splitBlockquoteNode =
           splitTreeToNode(enclosingBlockFlow, enclosingElement, true);
     } else {
       // We split the blockquote at where we start outdenting.
       Node* highestInlineNode = highestEnclosingNodeOfType(
           visibleStartOfParagraph.deepEquivalent(), isInline,
           CannotCrossEditingBoundary, enclosingBlockFlow);
       splitElement(enclosingElement,
                    highestInlineNode
                        ? highestInlineNode
                        : visibleStartOfParagraph.deepEquivalent().anchorNode());
     }
+
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+
+    // Re-canonicalize visible{Start,End}OfParagraph, make them valid again
+    // after DOM change.
+    // TODO(xiaochengh): We should not store a VisiblePosition and later inspect
+    // its properties when it is already invalidated.
+    visibleStartOfParagraph =
+        createVisiblePosition(visibleStartOfParagraph.toPositionWithAffinity());
+    visibleEndOfParagraph =
+        createVisiblePosition(visibleEndOfParagraph.toPositionWithAffinity());
   }
+
   VisiblePosition startOfParagraphToMove =
-      startOfParagraphDeprecated(visibleStartOfParagraph);
-  VisiblePosition endOfParagraphToMove =
-      endOfParagraphDeprecated(visibleEndOfParagraph);
+      startOfParagraph(visibleStartOfParagraph);
+  VisiblePosition endOfParagraphToMove = endOfParagraph(visibleEndOfParagraph);
   if (startOfParagraphToMove.isNull() || endOfParagraphToMove.isNull())
     return;
   HTMLBRElement* placeholder = HTMLBRElement::create(document());
   insertNodeBefore(placeholder, splitBlockquoteNode, editingState);
   if (editingState->isAborted())
     return;
+
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
   moveParagraph(startOfParagraphToMove, endOfParagraphToMove,
                 VisiblePosition::beforeNode(placeholder), editingState,
                 PreserveSelection);
 }
 
 // FIXME: We should merge this function with ApplyBlockElementCommand::formatSelection
 void IndentOutdentCommand::outdentRegion(
     const VisiblePosition& startOfSelection,
     const VisiblePosition& endOfSelection,
     EditingState* editingState) {
-  VisiblePosition endOfCurrentParagraph =
-      endOfParagraphDeprecated(startOfSelection);
-  VisiblePosition endOfLastParagraph = endOfParagraphDeprecated(endOfSelection);
+  VisiblePosition endOfCurrentParagraph = endOfParagraph(startOfSelection);
+  VisiblePosition endOfLastParagraph = endOfParagraph(endOfSelection);
 
   if (endOfCurrentParagraph.deepEquivalent() ==
       endOfLastParagraph.deepEquivalent()) {
     outdentParagraph(editingState);
     return;
   }
 
   Position originalSelectionEnd = endingSelection().end();
-  VisiblePosition endAfterSelection =
-      endOfParagraphDeprecated(nextPositionOf(endOfLastParagraph));
+  Position endAfterSelection =
+      endOfParagraph(nextPositionOf(endOfLastParagraph)).deepEquivalent();
 
-  while (endOfCurrentParagraph.deepEquivalent() !=
-         endAfterSelection.deepEquivalent()) {
-    VisiblePosition endOfNextParagraph = endOfParagraphDeprecated(
-        nextPositionOfDeprecated(endOfCurrentParagraph));
+  while (endOfCurrentParagraph.deepEquivalent() != endAfterSelection) {
+    PositionWithAffinity endOfNextParagraph =
+        endOfParagraph(nextPositionOf(endOfCurrentParagraph))
+            .toPositionWithAffinity();
     if (endOfCurrentParagraph.deepEquivalent() ==
-        endOfLastParagraph.deepEquivalent())
-      setEndingSelection(createVisibleSelectionDeprecated(
-          originalSelectionEnd, TextAffinity::Downstream));
-    else
+        endOfLastParagraph.deepEquivalent()) {
+      setEndingSelection(createVisibleSelection(originalSelectionEnd,
+                                                TextAffinity::Downstream));
+    } else {
       setEndingSelection(endOfCurrentParagraph);
+    }
 
     outdentParagraph(editingState);
     if (editingState->isAborted())
       return;
 
     // outdentParagraph could move more than one paragraph if the paragraph
     // is in a list item. As a result, endAfterSelection and endOfNextParagraph
     // could refer to positions no longer in the document.
-    if (endAfterSelection.isNotNull() &&
-        !endAfterSelection.deepEquivalent().isConnected())
+    if (endAfterSelection.isNotNull() && !endAfterSelection.isConnected())
       break;
 
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
     if (endOfNextParagraph.isNotNull() &&
-        !endOfNextParagraph.deepEquivalent().isConnected()) {
-      endOfCurrentParagraph =
-          createVisiblePositionDeprecated(endingSelection().end());
-      endOfNextParagraph =
-          endOfParagraphDeprecated(nextPositionOf(endOfCurrentParagraph));
+        !endOfNextParagraph.position().isConnected()) {
+      endOfCurrentParagraph = createVisiblePosition(endingSelection().end());
+      endOfNextParagraph = endOfParagraph(nextPositionOf(endOfCurrentParagraph))
+                               .toPositionWithAffinity();
     }
-    endOfCurrentParagraph = endOfNextParagraph;
+    endOfCurrentParagraph = createVisiblePosition(endOfNextParagraph);
   }
 }
 
 void IndentOutdentCommand::formatSelection(
     const VisiblePosition& startOfSelection,
     const VisiblePosition& endOfSelection,
     EditingState* editingState) {
   if (m_typeOfAction == Indent)
     ApplyBlockElementCommand::formatSelection(startOfSelection, endOfSelection,
                                               editingState);
@@ skipping 15 matching lines @@
   else
     indentIntoBlockquote(start, end, blockquoteForNextIndent, editingState);
 }
 
 InputEvent::InputType IndentOutdentCommand::inputType() const {
   return m_typeOfAction == Indent ? InputEvent::InputType::Indent
                                   : InputEvent::InputType::Outdent;
 }
 
 }  // namespace blink