Prune createVisiblePositionDeprecated from EditingUtilities

third_party/WebKit/Source/core/editing/EditingUtilities.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 1014 matching lines @@
       layoutObject->style()->display() == EDisplay::InlineTable)
     return true;
 
   if (layoutObject->style()->isFloating())
     return true;
 
   return false;
 }
 
 static HTMLElement* firstInSpecialElement(const Position& pos) {
+  DCHECK(!needsLayoutTreeUpdate(pos));
   Element* element = rootEditableElement(*pos.computeContainerNode());
   for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*pos.anchorNode())) {
     if (rootEditableElement(runner) != element)
       break;
     if (isSpecialHTMLElement(runner)) {
       HTMLElement* specialElement = toHTMLElement(&runner);
-      VisiblePosition vPos = createVisiblePositionDeprecated(pos);
-      VisiblePosition firstInElement = createVisiblePositionDeprecated(
-          firstPositionInOrBeforeNode(specialElement));
+      VisiblePosition vPos = createVisiblePosition(pos);
+      VisiblePosition firstInElement =
+          createVisiblePosition(firstPositionInOrBeforeNode(specialElement));
       if (isDisplayInsideTable(specialElement) &&
           vPos.deepEquivalent() ==
               nextPositionOf(firstInElement).deepEquivalent())
         return specialElement;
       if (vPos.deepEquivalent() == firstInElement.deepEquivalent())
         return specialElement;
     }
   }
   return 0;
 }
 
 static HTMLElement* lastInSpecialElement(const Position& pos) {
+  DCHECK(!needsLayoutTreeUpdate(pos));
   Element* element = rootEditableElement(*pos.computeContainerNode());
   for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*pos.anchorNode())) {
     if (rootEditableElement(runner) != element)
       break;
     if (isSpecialHTMLElement(runner)) {
       HTMLElement* specialElement = toHTMLElement(&runner);
-      VisiblePosition vPos = createVisiblePositionDeprecated(pos);
-      VisiblePosition lastInElement = createVisiblePositionDeprecated(
-          lastPositionInOrAfterNode(specialElement));
+      VisiblePosition vPos = createVisiblePosition(pos);
+      VisiblePosition lastInElement =
+          createVisiblePosition(lastPositionInOrAfterNode(specialElement));
       if (isDisplayInsideTable(specialElement) &&
           vPos.deepEquivalent() ==
               previousPositionOf(lastInElement).deepEquivalent())
         return specialElement;
       if (vPos.deepEquivalent() == lastInElement.deepEquivalent())
         return specialElement;
     }
   }
   return 0;
 }
 
 Position positionBeforeContainingSpecialElement(
     const Position& pos,
     HTMLElement** containingSpecialElement) {
+  DCHECK(!needsLayoutTreeUpdate(pos));
   HTMLElement* n = firstInSpecialElement(pos);
   if (!n)
     return pos;
   Position result = Position::inParentBeforeNode(*n);
   if (result.isNull() ||
       rootEditableElement(*result.anchorNode()) !=
           rootEditableElement(*pos.anchorNode()))
     return pos;
   if (containingSpecialElement)
     *containingSpecialElement = n;
   return result;
 }
 
 Position positionAfterContainingSpecialElement(
     const Position& pos,
     HTMLElement** containingSpecialElement) {
+  DCHECK(!needsLayoutTreeUpdate(pos));
   HTMLElement* n = lastInSpecialElement(pos);
   if (!n)
     return pos;
   Position result = Position::inParentAfterNode(*n);
   if (result.isNull() ||
       rootEditableElement(*result.anchorNode()) !=
           rootEditableElement(*pos.anchorNode()))
     return pos;
   if (containingSpecialElement)
     *containingSpecialElement = n;
@@ skipping 70 matching lines @@
   while (node) {
     if (isAtomicNode(node))
       return node;
     node = nextNodeConsideringAtomicNodes(*node);
   }
   return nullptr;
 }
 
 // Returns the visible position at the beginning of a node
 VisiblePosition visiblePositionBeforeNode(Node& node) {
+  DCHECK(!needsLayoutTreeUpdate(node));
   if (node.hasChildren())
-    return createVisiblePositionDeprecated(firstPositionInOrBeforeNode(&node));
+    return createVisiblePosition(firstPositionInOrBeforeNode(&node));
   DCHECK(node.parentNode()) << node;
   DCHECK(!node.parentNode()->isShadowRoot()) << node.parentNode();
   return VisiblePosition::inParentBeforeNode(node);
 }
 
 // Returns the visible position at the ending of a node
 VisiblePosition visiblePositionAfterNode(Node& node) {
+  DCHECK(!needsLayoutTreeUpdate(node));
   if (node.hasChildren())
-    return createVisiblePositionDeprecated(lastPositionInOrAfterNode(&node));
+    return createVisiblePosition(lastPositionInOrAfterNode(&node));
   DCHECK(node.parentNode()) << node.parentNode();
   DCHECK(!node.parentNode()->isShadowRoot()) << node.parentNode();
   return VisiblePosition::inParentAfterNode(node);
 }
 
 bool isHTMLListElement(Node* n) {
   return (n && (isHTMLUListElement(*n) || isHTMLOListElement(*n) ||
                 isHTMLDListElement(*n)));
 }
 
@@ skipping 217 matching lines @@
       break;
     list = nextList;
   }
 
   return list;
 }
 
 // Determines whether two positions are visibly next to each other (first then
 // second) while ignoring whitespaces and unrendered nodes
 static bool isVisiblyAdjacent(const Position& first, const Position& second) {
-  return createVisiblePositionDeprecated(first).deepEquivalent() ==
-         createVisiblePositionDeprecated(mostBackwardCaretPosition(second))
+  return createVisiblePosition(first).deepEquivalent() ==
+         createVisiblePosition(mostBackwardCaretPosition(second))
              .deepEquivalent();
 }
 
 bool canMergeLists(Element* firstList, Element* secondList) {
   if (!firstList || !secondList || !firstList->isHTMLElement() ||
       !secondList->isHTMLElement())
     return false;
 
+  DCHECK(!needsLayoutTreeUpdate(*firstList));
+  DCHECK(!needsLayoutTreeUpdate(*secondList));
   return firstList->hasTagName(
              secondList
                  ->tagQName())  // make sure the list types match (ol vs. ul)
          && hasEditableStyle(*firstList) &&
          hasEditableStyle(*secondList)  // both lists are editable
          &&
          rootEditableElement(*firstList) ==
              rootEditableElement(*secondList)  // don't cross editing boundaries
          && isVisiblyAdjacent(Position::inParentAfterNode(*firstList),
                               Position::inParentBeforeNode(*secondList));
@@ skipping 115 matching lines @@
   if (!layoutObject)
     return false;
 
   return layoutObject->style()->visibility() == EVisibility::Visible;
 }
 
 // return first preceding DOM position rendered at a different location, or
 // "this"
 static Position previousCharacterPosition(const Position& position,
                                           TextAffinity affinity) {
+  DCHECK(!needsLayoutTreeUpdate(position));
   if (position.isNull())
     return Position();
 
   Element* fromRootEditableElement =
       rootEditableElement(*position.anchorNode());
 
-  bool atStartOfLine =
-      isStartOfLine(createVisiblePositionDeprecated(position, affinity));
+  bool atStartOfLine = isStartOfLine(createVisiblePosition(position, affinity));
   bool rendered = isVisuallyEquivalentCandidate(position);
 
   Position currentPos = position;
   while (!currentPos.atStartOfTree()) {
     // TODO(yosin) When we use |previousCharacterPosition()| other than
     // finding leading whitespace, we should use |Character| instead of
     // |CodePoint|.
     currentPos = previousPositionOf(currentPos, PositionMoveType::CodeUnit);
 
     if (rootEditableElement(*currentPos.anchorNode()) !=
         fromRootEditableElement)
       return position;
 
     if (atStartOfLine || !rendered) {
       if (isVisuallyEquivalentCandidate(currentPos))
         return currentPos;
     } else if (rendersInDifferentPosition(position, currentPos)) {
       return currentPos;
     }
   }
 
   return position;
 }
 
 // This assumes that it starts in editable content.
 Position leadingWhitespacePosition(const Position& position,
                                    TextAffinity affinity,
                                    WhitespacePositionOption option) {
+  DCHECK(!needsLayoutTreeUpdate(position));
   DCHECK(isEditablePosition(position)) << position;
   if (position.isNull())
     return Position();
 
   if (isHTMLBRElement(*mostBackwardCaretPosition(position).anchorNode()))
     return Position();
 
   const Position& prev = previousCharacterPosition(position, affinity);
   if (prev == position)
     return Position();
@@ skipping 15 matching lines @@
                            : isCollapsibleWhitespace(previousCharacter);
   if (!isSpace || !isEditablePosition(prev))
     return Position();
   return prev;
 }
 
 // This assumes that it starts in editable content.
 Position trailingWhitespacePosition(const Position& position,
                                     TextAffinity,
                                     WhitespacePositionOption option) {
+  DCHECK(!needsLayoutTreeUpdate(position));
   DCHECK(isEditablePosition(position)) << position;
   if (position.isNull())
     return Position();
 
-  VisiblePosition visiblePosition = createVisiblePositionDeprecated(position);
+  VisiblePosition visiblePosition = createVisiblePosition(position);
   UChar characterAfterVisiblePosition = characterAfter(visiblePosition);
   bool isSpace = option == ConsiderNonCollapsibleWhitespace
                      ? (isSpaceOrNewline(characterAfterVisiblePosition) ||
                         characterAfterVisiblePosition == noBreakSpaceCharacter)
                      : isCollapsibleWhitespace(characterAfterVisiblePosition);
   // The space must not be in another paragraph and it must be editable.
   if (isSpace && !isEndOfParagraph(visiblePosition) &&
       nextPositionOf(visiblePosition, CannotCrossEditingBoundary).isNotNull())
     return position;
   return Position();
@@ skipping 223 matching lines @@
   // TextIteratorEmitsCharactersBetweenAllVisiblePositions.
   if (range.isNull())
     return VisiblePosition();
   return createVisiblePosition(range.startPosition());
 }
 
 // Determines whether a node is inside a range or visibly starts and ends at the
 // boundaries of the range. Call this function to determine whether a node is
 // visibly fit inside selectedRange
 bool isNodeVisiblyContainedWithin(Node& node, const Range& selectedRange) {
+  DCHECK(!needsLayoutTreeUpdate(node));
+  DocumentLifecycle::DisallowTransitionScope disallowTransition(
+      node.document().lifecycle());
+
   if (selectedRange.isNodeFullyContained(node))
     return true;
 
   bool startIsVisuallySame =
       visiblePositionBeforeNode(node).deepEquivalent() ==
-      createVisiblePositionDeprecated(selectedRange.startPosition())
-          .deepEquivalent();
+      createVisiblePosition(selectedRange.startPosition()).deepEquivalent();
   if (startIsVisuallySame &&
       comparePositions(Position::inParentAfterNode(node),
                        selectedRange.endPosition()) < 0)
     return true;
 
   bool endIsVisuallySame =
       visiblePositionAfterNode(node).deepEquivalent() ==
-      createVisiblePositionDeprecated(selectedRange.endPosition())
-          .deepEquivalent();
+      createVisiblePosition(selectedRange.endPosition()).deepEquivalent();
   if (endIsVisuallySame &&
       comparePositions(selectedRange.startPosition(),
                        Position::inParentBeforeNode(node)) < 0)
     return true;
 
   return startIsVisuallySame && endIsVisuallySame;
 }
 
 bool isRenderedAsNonInlineTableImageOrHR(const Node* node) {
   if (!node)
@@ skipping 148 matching lines @@
         return InputType::DeleteWordBackward;
       if (granularity == LineBoundary)
         return InputType::DeleteLineBackward;
       return InputType::DeleteContentBackward;
     default:
       return InputType::None;
   }
 }
 
 }  // namespace blink