Get rid of EUpdateStyle parameter from isEditablePosition()

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 26 matching lines @@
 #include "core/editing/PlainTextRange.h"
 #include "core/editing/PositionIterator.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleSelection.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/serializers/HTMLInterchange.h"
 #include "core/editing/state_machines/BackspaceStateMachine.h"
 #include "core/editing/state_machines/BackwardGraphemeBoundaryStateMachine.h"
 #include "core/editing/state_machines/ForwardGraphemeBoundaryStateMachine.h"
+#include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLDivElement.h"
 #include "core/html/HTMLLIElement.h"
 #include "core/html/HTMLParagraphElement.h"
 #include "core/html/HTMLSpanElement.h"
 #include "core/html/HTMLTableCellElement.h"
 #include "core/html/HTMLUListElement.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTableCell.h"
 #include "wtf/Assertions.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/Unicode.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
+
 std::ostream& operator<<(std::ostream& os, PositionMoveType type)
 {
     static const char* const texts[] = {
         "CodeUnit", "BackwardDeletion", "GraphemeCluster"
     };
     const auto& it = std::begin(texts) + static_cast<size_t>(type);
     DCHECK_GE(it, std::begin(texts)) << "Unknown PositionMoveType value";
     DCHECK_LT(it, std::end(texts)) << "Unknown PositionMoveType value";
     return os << *it;
 }
+
 } // namespace
 
+bool needsLayoutTreeUpdate(const Node& node)
+{
+    const Document& document = node.document();
+    if (document.needsLayoutTreeUpdate())
+        return true;
+    // TODO(yosin): We should make |document::needsLayoutTreeUpdate()| to
+    // check |LayoutView::needsLayout()|.
+    return document.view() && document.view()->needsLayout();
+}
+
+bool needsLayoutTreeUpdate(const Position& position)
+{
+    const Node* node = position.anchorNode();
+    if (!node)
+        return false;
+    return needsLayoutTreeUpdate(*node);
+}
+
 // Atomic means that the node has no children, or has children which are ignored for the
 // purposes of editing.
 bool isAtomicNode(const Node *node)
 {
     return node && (!node->hasChildren() || editingIgnoresContent(node));
 }
 
 template <typename Traversal>
 static int comparePositions(Node* containerA, int offsetA, Node* containerB, int offsetB, bool* disconnected)
 {
@@ skipping 165 matching lines @@
     }
 
     return highestRoot;
 }
 
 ContainerNode* highestEditableRoot(const PositionInFlatTree& position, EditableType editableType)
 {
     return highestEditableRoot(toPositionInDOMTree(position), editableType);
 }
 
-bool isEditablePosition(const Position& p, EditableType editableType, EUpdateStyle updateStyle)
+bool isEditablePosition(const Position& position, EditableType editableType)
 {
-    Node* node = p.parentAnchoredEquivalent().anchorNode();
+    Node* node = position.parentAnchoredEquivalent().anchorNode();
     if (!node)
         return false;
-    if (updateStyle == UpdateStyle)
-        node->document().updateStyleAndLayoutIgnorePendingStylesheets();
-    else
-        DCHECK_EQ(updateStyle, DoNotUpdateStyle);
+    DCHECK(node->document().isActive());
+    if (node->document().lifecycle().state() >= DocumentLifecycle::InStyleRecalc) {
+        // TODO(yosin): Once we change |LayoutObject::adjustStyleDifference()|
+        // not to call |FrameSelection::hasCaret()|, we should not assume
+        // calling |isEditablePosition()| in |InStyleRecalc| is safe.
+    } else {
+        DCHECK(!needsLayoutTreeUpdate(position)) << position;
+    }
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
 
     if (node->isDocumentNode())
         return false;
     return node->hasEditableStyle(editableType);
 }
 
-bool isEditablePosition(const PositionInFlatTree& p, EditableType editableType, EUpdateStyle updateStyle)
+bool isEditablePosition(const PositionInFlatTree& p, EditableType editableType)
 {
-    return isEditablePosition(toPositionInDOMTree(p), editableType, updateStyle);
+    return isEditablePosition(toPositionInDOMTree(p), editableType);
 }
 
 bool isAtUnsplittableElement(const Position& pos)
 {
     Node* node = pos.anchorNode();
     return (node == rootEditableElementOf(pos) || node == enclosingNodeOfType(pos, &isTableCell));
 }
 
 
 bool isRichlyEditablePosition(const Position& p, EditableType editableType)
@@ skipping 178 matching lines @@
 }
 
 VisiblePositionInFlatTree firstEditableVisiblePositionAfterPositionInRoot(const PositionInFlatTree& position, ContainerNode& highestRoot)
 {
     return createVisiblePosition(firstEditablePositionAfterPositionInRoot(position, highestRoot));
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> firstEditablePositionAfterPositionInRootAlgorithm(const PositionTemplate<Strategy>& position, Node& highestRoot)
 {
+    DCHECK(!needsLayoutTreeUpdate(highestRoot)) << position << ' ' << highestRoot;
     // position falls before highestRoot.
     if (position.compareTo(PositionTemplate<Strategy>::firstPositionInNode(&highestRoot)) == -1 && highestRoot.hasEditableStyle())
         return PositionTemplate<Strategy>::firstPositionInNode(&highestRoot);
 
     PositionTemplate<Strategy> editablePosition = position;
 
     if (position.anchorNode()->treeScope() != highestRoot.treeScope()) {
         Node* shadowAncestor = highestRoot.treeScope().ancestorInThisScope(editablePosition.anchorNode());
         if (!shadowAncestor)
             return PositionTemplate<Strategy>();
@@ skipping 26 matching lines @@
 }
 
 VisiblePositionInFlatTree lastEditableVisiblePositionBeforePositionInRoot(const PositionInFlatTree& position, ContainerNode& highestRoot)
 {
     return createVisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> lastEditablePositionBeforePositionInRootAlgorithm(const PositionTemplate<Strategy>& position, Node& highestRoot)
 {
+    DCHECK(!needsLayoutTreeUpdate(highestRoot)) << position << ' ' << highestRoot;
     // When position falls after highestRoot, the result is easy to compute.
     if (position.compareTo(PositionTemplate<Strategy>::lastPositionInNode(&highestRoot)) == 1)
         return PositionTemplate<Strategy>::lastPositionInNode(&highestRoot);
 
     PositionTemplate<Strategy> editablePosition = position;
 
     if (position.anchorNode()->treeScope() != highestRoot.treeScope()) {
         Node* shadowAncestor = highestRoot.treeScope().ancestorInThisScope(editablePosition.anchorNode());
         if (!shadowAncestor)
             return PositionTemplate<Strategy>();
@@ skipping 870 matching lines @@
             return currentPos;
         }
     }
 
     return position;
 }
 
 // This assumes that it starts in editable content.
 Position leadingWhitespacePosition(const Position& position, TextAffinity affinity, WhitespacePositionOption option)
 {
-    DCHECK(isEditablePosition(position, ContentIsEditable, DoNotUpdateStyle)) << position;
+    DCHECK(isEditablePosition(position, ContentIsEditable)) << position;
     if (position.isNull())
         return Position();
 
     if (isHTMLBRElement(*mostBackwardCaretPosition(position).anchorNode()))
         return Position();
 
     const Position& prev = previousCharacterPosition(position, affinity);
     if (prev == position)
         return Position();
     const Node* const anchorNode = prev.anchorNode();
     if (!anchorNode || !anchorNode->isTextNode())
         return Position();
     if (enclosingBlockFlowElement(*anchorNode) != enclosingBlockFlowElement(*position.anchorNode()))
         return Position();
     if (option == NotConsiderNonCollapsibleWhitespace && anchorNode->layoutObject() && !anchorNode->layoutObject()->style()->collapseWhiteSpace())
         return Position();
     const String& string = toText(anchorNode)->data();
     const UChar previousCharacter = string[prev.computeOffsetInContainerNode()];
     const bool isSpace = option == ConsiderNonCollapsibleWhitespace ? (isSpaceOrNewline(previousCharacter) || previousCharacter == noBreakSpaceCharacter) : 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(isEditablePosition(position, ContentIsEditable, DoNotUpdateStyle)) << position;
+    DCHECK(isEditablePosition(position, ContentIsEditable)) << position;
     if (position.isNull())
         return 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 325 matching lines @@
 {
     if (!RuntimeEnabledFeatures::inputEventEnabled())
         return DispatchEventResult::NotCanceled;
     if (!target)
         return DispatchEventResult::NotCanceled;
     InputEvent* beforeInputEvent = InputEvent::createBeforeInput(inputType, data, InputEvent::EventCancelable::IsCancelable, InputEvent::EventIsComposing::NotComposing, ranges);
     return target->dispatchEvent(beforeInputEvent);
 }
 
 } // namespace blink