Prune deprecated editing functions from ApplyBlockElementCommand and its subclasses

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

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2010 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 39 matching lines @@
       m_inlineStyle(inlineStyle) {}
 
 ApplyBlockElementCommand::ApplyBlockElementCommand(Document& document,
                                                    const QualifiedName& tagName)
     : CompositeEditCommand(document), m_tagName(tagName) {}
 
 void ApplyBlockElementCommand::doApply(EditingState* editingState) {
   if (!endingSelection().rootEditableElement())
     return;
 
-  VisiblePosition visibleEnd = endingSelection().visibleEndDeprecated();
-  VisiblePosition visibleStart = endingSelection().visibleStartDeprecated();
+  // ApplyBlockElementCommands are only created directly by editor commands'
+  // execution, which updates layout before entering doApply().
+  DCHECK(!document().needsLayoutTreeUpdate());
+
+  VisiblePosition visibleEnd = endingSelection().visibleEnd();
+  VisiblePosition visibleStart = endingSelection().visibleStart();
   if (visibleStart.isNull() || visibleStart.isOrphan() || visibleEnd.isNull() ||
       visibleEnd.isOrphan())
     return;
 
   // When a selection ends at the start of a paragraph, we rarely paint
   // the selection gap before that paragraph, because there often is no gap.
   // In a case like this, it's not obvious to the user that the selection
   // ends "inside" that paragraph, so it would be confusing if Indent/Outdent
   // operated on that paragraph.
   // FIXME: We paint the gap before some paragraphs that are indented with left
   // margin/padding, but not others.  We should make the gap painting more
   // consistent and then use a left margin/padding rule here.
   if (visibleEnd.deepEquivalent() != visibleStart.deepEquivalent() &&
-      isStartOfParagraphDeprecated(visibleEnd)) {
-    VisibleSelection newSelection = createVisibleSelectionDeprecated(
+      isStartOfParagraph(visibleEnd)) {
+    VisibleSelection newSelection = createVisibleSelection(
         visibleStart,
         previousPositionOf(visibleEnd, CannotCrossEditingBoundary),
         endingSelection().isDirectional());
     if (newSelection.isNone())
       return;
     setEndingSelection(newSelection);
   }
 
   VisibleSelection selection =
       selectionForParagraphIteration(endingSelection());
-  VisiblePosition startOfSelection = selection.visibleStartDeprecated();
-  VisiblePosition endOfSelection = selection.visibleEndDeprecated();
+  VisiblePosition startOfSelection = selection.visibleStart();
+  VisiblePosition endOfSelection = selection.visibleEnd();
   DCHECK(!startOfSelection.isNull());
   DCHECK(!endOfSelection.isNull());
   ContainerNode* startScope = nullptr;
   int startIndex = indexForVisiblePosition(startOfSelection, startScope);
   ContainerNode* endScope = nullptr;
   int endIndex = indexForVisiblePosition(endOfSelection, endScope);
 
   formatSelection(startOfSelection, endOfSelection, editingState);
   if (editingState->isAborted())
     return;
 
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   DCHECK_EQ(startScope, endScope);
   DCHECK_GE(startIndex, 0);
   DCHECK_LE(startIndex, endIndex);
   if (startScope == endScope && startIndex >= 0 && startIndex <= endIndex) {
     VisiblePosition start(visiblePositionForIndex(startIndex, startScope));
     VisiblePosition end(visiblePositionForIndex(endIndex, endScope));
     if (start.isNotNull() && end.isNotNull())
-      setEndingSelection(createVisibleSelectionDeprecated(
+      setEndingSelection(createVisibleSelection(
           start, end, endingSelection().isDirectional()));
   }
 }
 
 static bool isAtUnsplittableElement(const Position& pos) {
   Node* node = pos.anchorNode();
   return node == rootEditableElementOf(pos) ||
          node == enclosingNodeOfType(pos, &isTableCell);
 }
 
 void ApplyBlockElementCommand::formatSelection(
     const VisiblePosition& startOfSelection,
     const VisiblePosition& endOfSelection,
     EditingState* editingState) {
   // Special case empty unsplittable elements because there's nothing to split
   // and there's nothing to move.
   Position start = mostForwardCaretPosition(startOfSelection.deepEquivalent());
   if (isAtUnsplittableElement(start)) {
     HTMLElement* blockquote = createBlockElement();
     insertNodeAt(blockquote, start, editingState);
     if (editingState->isAborted())
       return;
     HTMLBRElement* placeholder = HTMLBRElement::create(document());
     appendNode(placeholder, blockquote, editingState);
     if (editingState->isAborted())
       return;
-    setEndingSelection(createVisibleSelectionDeprecated(
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+    setEndingSelection(createVisibleSelection(
         Position::beforeNode(placeholder), TextAffinity::Downstream,
         endingSelection().isDirectional()));
     return;
   }
 
   HTMLElement* blockquoteForNextIndent = nullptr;
-  VisiblePosition endOfCurrentParagraph =
-      endOfParagraphDeprecated(startOfSelection);
-  VisiblePosition endOfLastParagraph = endOfParagraphDeprecated(endOfSelection);
-  VisiblePosition endAfterSelection =
-      endOfParagraphDeprecated(nextPositionOf(endOfLastParagraph));
+  VisiblePosition endOfCurrentParagraph = endOfParagraph(startOfSelection);
+  VisiblePosition endOfLastParagraph = endOfParagraph(endOfSelection);
+  Position endAfterSelection =
+      endOfParagraph(nextPositionOf(endOfLastParagraph)).deepEquivalent();
   m_endOfLastParagraph = endOfLastParagraph.deepEquivalent();
 
   bool atEnd = false;
   Position end;
-  while (endOfCurrentParagraph.deepEquivalent() !=
-             endAfterSelection.deepEquivalent() &&
+  while (endOfCurrentParagraph.deepEquivalent() != endAfterSelection &&
          !atEnd) {
     if (endOfCurrentParagraph.deepEquivalent() == m_endOfLastParagraph)
       atEnd = true;
 
     rangeForParagraphSplittingTextNodesIfNeeded(endOfCurrentParagraph, start,
                                                 end);
-    endOfCurrentParagraph = createVisiblePositionDeprecated(end);
+    endOfCurrentParagraph = createVisiblePosition(end);
 
     Node* enclosingCell = enclosingNodeOfType(start, &isTableCell);
-    VisiblePosition endOfNextParagraph =
+    PositionWithAffinity endOfNextParagraph =
         endOfNextParagrahSplittingTextNodesIfNeeded(endOfCurrentParagraph,
-                                                    start, end);
+                                                    start, end)
+            .toPositionWithAffinity();
 
     formatRange(start, end, m_endOfLastParagraph, blockquoteForNextIndent,
                 editingState);
     if (editingState->isAborted())
       return;
 
     // Don't put the next paragraph in the blockquote we just created for this paragraph unless
     // the next paragraph is in the same cell.
     if (enclosingCell &&
-        enclosingCell != enclosingNodeOfType(
-                             endOfNextParagraph.deepEquivalent(), &isTableCell))
+        enclosingCell !=
+            enclosingNodeOfType(endOfNextParagraph.position(), &isTableCell))
       blockquoteForNextIndent = nullptr;
 
     // indentIntoBlockquote could move more than one paragraph if the paragraph
     // is in a list item or a table. As a result, endAfterSelection could refer to a position
     // no longer in the document.
-    if (endAfterSelection.isNotNull() &&
-        !endAfterSelection.deepEquivalent().isConnected())
+    if (endAfterSelection.isNotNull() && !endAfterSelection.isConnected())
       break;
-    // Sanity check: Make sure our moveParagraph calls didn't remove endOfNextParagraph.deepEquivalent().anchorNode()
+    // Sanity check: Make sure our moveParagraph calls didn't remove endOfNextParagraph.position().anchorNode()
     // If somehow, e.g. mutation event handler, we did, return to prevent crashes.
     if (endOfNextParagraph.isNotNull() &&
-        !endOfNextParagraph.deepEquivalent().isConnected())
+        !endOfNextParagraph.position().isConnected())
       return;
-    endOfCurrentParagraph = endOfNextParagraph;
+
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+    endOfCurrentParagraph = createVisiblePosition(endOfNextParagraph);
   }
 }
 
 static bool isNewLineAtPosition(const Position& position) {
   Node* textNode = position.computeContainerNode();
   int offset = position.offsetInContainerNode();
   if (!textNode || !textNode->isTextNode() || offset < 0 ||
       offset >= textNode->maxCharacterOffset())
     return false;
 
@@ skipping 11 matching lines @@
   if (!position.isOffsetInAnchor() || !position.computeContainerNode() ||
       !position.computeContainerNode()->isTextNode())
     return 0;
   return position.computeContainerNode()->computedStyle();
 }
 
 void ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded(
     const VisiblePosition& endOfCurrentParagraph,
     Position& start,
     Position& end) {
-  start = startOfParagraphDeprecated(endOfCurrentParagraph).deepEquivalent();
+  start = startOfParagraph(endOfCurrentParagraph).deepEquivalent();
   end = endOfCurrentParagraph.deepEquivalent();
 
-  document().updateStyleAndLayoutTree();
-
   bool isStartAndEndOnSameNode = false;
   if (const ComputedStyle* startStyle =
           computedStyleOfEnclosingTextNode(start)) {
     isStartAndEndOnSameNode =
         computedStyleOfEnclosingTextNode(end) &&
         start.computeContainerNode() == end.computeContainerNode();
     bool isStartAndEndOfLastParagraphOnSameNode =
         computedStyleOfEnclosingTextNode(m_endOfLastParagraph) &&
         start.computeContainerNode() ==
             m_endOfLastParagraph.computeContainerNode();
 
     // Avoid obtanining the start of next paragraph for start
     // TODO(yosin) We should use |PositionMoveType::CodePoint| for
     // |previousPositionOf()|.
     if (startStyle->preserveNewline() && isNewLineAtPosition(start) &&
         !isNewLineAtPosition(
             previousPositionOf(start, PositionMoveType::CodeUnit)) &&
         start.offsetInContainerNode() > 0)
-      start = startOfParagraphDeprecated(
-                  createVisiblePositionDeprecated(
-                      previousPositionOf(end, PositionMoveType::CodeUnit)))
+      start = startOfParagraph(createVisiblePosition(previousPositionOf(
+                                   end, PositionMoveType::CodeUnit)))
                   .deepEquivalent();
 
     // If start is in the middle of a text node, split.
     if (!startStyle->collapseWhiteSpace() &&
         start.offsetInContainerNode() > 0) {
       int startOffset = start.offsetInContainerNode();
       Text* startText = toText(start.computeContainerNode());
       splitTextNode(startText, startOffset);
+      document().updateStyleAndLayoutTree();
+
       start = Position::firstPositionInNode(startText);
       if (isStartAndEndOnSameNode) {
         DCHECK_GE(end.offsetInContainerNode(), startOffset);
         end = Position(startText, end.offsetInContainerNode() - startOffset);
       }
       if (isStartAndEndOfLastParagraphOnSameNode) {
         DCHECK_GE(m_endOfLastParagraph.offsetInContainerNode(), startOffset);
         m_endOfLastParagraph =
             Position(startText, m_endOfLastParagraph.offsetInContainerNode() -
                                     startOffset);
       }
     }
   }
 
-  document().updateStyleAndLayoutTree();
-
   if (const ComputedStyle* endStyle = computedStyleOfEnclosingTextNode(end)) {
     bool isEndAndEndOfLastParagraphOnSameNode =
         computedStyleOfEnclosingTextNode(m_endOfLastParagraph) &&
         end.anchorNode() == m_endOfLastParagraph.anchorNode();
     // Include \n at the end of line if we're at an empty paragraph
     if (endStyle->preserveNewline() && start == end &&
         end.offsetInContainerNode() <
             end.computeContainerNode()->maxCharacterOffset()) {
       int endOffset = end.offsetInContainerNode();
       // TODO(yosin) We should use |PositionMoveType::CodePoint| for
       // |previousPositionOf()|.
       if (!isNewLineAtPosition(
               previousPositionOf(end, PositionMoveType::CodeUnit)) &&
           isNewLineAtPosition(end))
         end = Position(end.computeContainerNode(), endOffset + 1);
       if (isEndAndEndOfLastParagraphOnSameNode &&
           end.offsetInContainerNode() >=
               m_endOfLastParagraph.offsetInContainerNode())
         m_endOfLastParagraph = end;
     }
 
     // If end is in the middle of a text node, split.
     if (endStyle->userModify() != READ_ONLY &&
         !endStyle->collapseWhiteSpace() && end.offsetInContainerNode() &&
         end.offsetInContainerNode() <
             end.computeContainerNode()->maxCharacterOffset()) {
       Text* endContainer = toText(end.computeContainerNode());
       splitTextNode(endContainer, end.offsetInContainerNode());
+      document().updateStyleAndLayoutTree();
+
       if (isStartAndEndOnSameNode)
         start = firstPositionInOrBeforeNode(endContainer->previousSibling());
       if (isEndAndEndOfLastParagraphOnSameNode) {
         if (m_endOfLastParagraph.offsetInContainerNode() ==
             end.offsetInContainerNode())
           m_endOfLastParagraph =
               lastPositionInOrAfterNode(endContainer->previousSibling());
         else
           m_endOfLastParagraph = Position(
               endContainer, m_endOfLastParagraph.offsetInContainerNode() -
                                 end.offsetInContainerNode());
       }
       end = Position::lastPositionInNode(endContainer->previousSibling());
     }
   }
 }
 
 VisiblePosition
 ApplyBlockElementCommand::endOfNextParagrahSplittingTextNodesIfNeeded(
     VisiblePosition& endOfCurrentParagraph,
     Position& start,
     Position& end) {
   VisiblePosition endOfNextParagraph =
-      endOfParagraphDeprecated(nextPositionOf(endOfCurrentParagraph));
+      endOfParagraph(nextPositionOf(endOfCurrentParagraph));
   Position position = endOfNextParagraph.deepEquivalent();
   const ComputedStyle* style = computedStyleOfEnclosingTextNode(position);
   if (!style)
     return endOfNextParagraph;
 
   Text* text = toText(position.computeContainerNode());
   if (!style->preserveNewline() || !position.offsetInContainerNode() ||
       !isNewLineAtPosition(Position::firstPositionInNode(text)))
     return endOfNextParagraph;
 
   // \n at the beginning of the text node immediately following the current paragraph is trimmed by moveParagraphWithClones.
   // If endOfNextParagraph was pointing at this same text node, endOfNextParagraph will be shifted by one paragraph.
   // Avoid this by splitting "\n"
   splitTextNode(text, 1);
+  document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   if (text == start.computeContainerNode() && text->previousSibling() &&
       text->previousSibling()->isTextNode()) {
     DCHECK_LT(start.offsetInContainerNode(), position.offsetInContainerNode());
     start = Position(toText(text->previousSibling()),
                      start.offsetInContainerNode());
   }
   if (text == end.computeContainerNode() && text->previousSibling() &&
       text->previousSibling()->isTextNode()) {
     DCHECK_LT(end.offsetInContainerNode(), position.offsetInContainerNode());
     end =
         Position(toText(text->previousSibling()), end.offsetInContainerNode());
   }
   if (text == m_endOfLastParagraph.computeContainerNode()) {
     if (m_endOfLastParagraph.offsetInContainerNode() <
         position.offsetInContainerNode()) {
       // We can only fix endOfLastParagraph if the previous node was still text and hasn't been modified by script.
       if (text->previousSibling()->isTextNode() &&
           static_cast<unsigned>(m_endOfLastParagraph.offsetInContainerNode()) <=
               toText(text->previousSibling())->length())
         m_endOfLastParagraph =
             Position(toText(text->previousSibling()),
                      m_endOfLastParagraph.offsetInContainerNode());
     } else {
       m_endOfLastParagraph =
           Position(text, m_endOfLastParagraph.offsetInContainerNode() - 1);
     }
   }
 
-  return createVisiblePositionDeprecated(
+  return createVisiblePosition(
       Position(text, position.offsetInContainerNode() - 1));
 }
 
 HTMLElement* ApplyBlockElementCommand::createBlockElement() const {
   HTMLElement* element = createHTMLElement(document(), m_tagName);
   if (m_inlineStyle.length())
     element->setAttribute(styleAttr, m_inlineStyle);
   return element;
 }
 
 DEFINE_TRACE(ApplyBlockElementCommand) {
   visitor->trace(m_endOfLastParagraph);
   CompositeEditCommand::trace(visitor);
 }
 
 }  // namespace blink