[Editing][CodeHealth] Make Node::rootEditableElement static

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 321 matching lines @@
 
 Element* rootEditableElementOf(const Position& p, EditableType editableType)
 {
     Node* node = p.computeContainerNode();
     if (!node)
         return 0;
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
 
-    return node->rootEditableElement(editableType);
+    return rootEditableElement(*node, editableType);
 }
 
 Element* rootEditableElementOf(const PositionInFlatTree& p, EditableType editableType)
 {
     return rootEditableElementOf(toPositionInDOMTree(p), editableType);
 }
 
 // TODO(yosin) This does not handle [table, 0] correctly.
 Element* rootEditableElementOf(const VisiblePosition& visiblePosition)
 {
     Node* anchorNode = visiblePosition.deepEquivalent().anchorNode();
-    return anchorNode ? anchorNode->rootEditableElement() : nullptr;
+    return anchorNode ? rootEditableElement(*anchorNode) : nullptr;
 }
 
 // Finds the enclosing element until which the tree can be split.
 // When a user hits ENTER, they won't expect this element to be split into two.
 // You may pass it as the second argument of splitTreeToNode.
 Element* unsplittableElementForPosition(const Position& p)
 {
     // Since enclosingNodeOfType won't search beyond the highest root editable node,
     // this code works even if the closest table cell was outside of the root editable node.
     Element* enclosingCell = toElement(enclosingNodeOfType(p, &isTableCell));
@@ skipping 541 matching lines @@
         return true;
 
     if (layoutObject->style()->isFloating())
         return true;
 
     return false;
 }
 
 static HTMLElement* firstInSpecialElement(const Position& pos)
 {
-    Element* rootEditableElement = pos.computeContainerNode()->rootEditableElement();
+    Element* element = rootEditableElement(*pos.computeContainerNode());
     for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*pos.anchorNode())) {
-        if (runner.rootEditableElement() != rootEditableElement)
+        if (rootEditableElement(runner) != element)
             break;
         if (isSpecialHTMLElement(runner)) {
             HTMLElement* specialElement = toHTMLElement(&runner);
             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)
 {
-    Element* rootEditableElement = pos.computeContainerNode()->rootEditableElement();
+    Element* element = rootEditableElement(*pos.computeContainerNode());
     for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*pos.anchorNode())) {
-        if (runner.rootEditableElement() != rootEditableElement)
+        if (rootEditableElement(runner) != element)
             break;
         if (isSpecialHTMLElement(runner)) {
             HTMLElement* specialElement = toHTMLElement(&runner);
             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)
 {
     HTMLElement* n = firstInSpecialElement(pos);
     if (!n)
         return pos;
     Position result = Position::inParentBeforeNode(*n);
-    if (result.isNull() || result.anchorNode()->rootEditableElement() != pos.anchorNode()->rootEditableElement())
+    if (result.isNull() || rootEditableElement(*result.anchorNode()) != rootEditableElement(*pos.anchorNode()))
         return pos;
     if (containingSpecialElement)
         *containingSpecialElement = n;
     return result;
 }
 
 Position positionAfterContainingSpecialElement(const Position& pos, HTMLElement** containingSpecialElement)
 {
     HTMLElement* n = lastInSpecialElement(pos);
     if (!n)
         return pos;
     Position result = Position::inParentAfterNode(*n);
-    if (result.isNull() || result.anchorNode()->rootEditableElement() != pos.anchorNode()->rootEditableElement())
+    if (result.isNull() || rootEditableElement(*result.anchorNode()) != rootEditableElement(*pos.anchorNode()))
         return pos;
     if (containingSpecialElement)
         *containingSpecialElement = n;
     return result;
 }
 
 template <typename Strategy>
 static Element* tableElementJustBeforeAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     const PositionTemplate<Strategy> upstream(mostBackwardCaretPosition(visiblePosition.deepEquivalent()));
@@ skipping 186 matching lines @@
         if (n->layoutObject())
             return true;
         n = NodeTraversal::next(*n, node);
     }
     return false;
 }
 
 Node* highestNodeToRemoveInPruning(Node* node, Node* excludeNode)
 {
     Node* previousNode = nullptr;
-    Element* rootEditableElement = node ? node->rootEditableElement() : nullptr;
+    Element* element = node ? rootEditableElement(*node) : nullptr;
     for (; node; node = node->parentNode()) {
         if (LayoutObject* layoutObject = node->layoutObject()) {
-            if (!layoutObject->canHaveChildren() || hasARenderedDescendant(node, previousNode) || rootEditableElement == node || excludeNode == node)
+            if (!layoutObject->canHaveChildren() || hasARenderedDescendant(node, previousNode) || element == node || excludeNode == node)
                 return previousNode;
         }
         previousNode = node;
     }
     return 0;
 }
 
 Element* enclosingTableCell(const Position& p)
 {
     return toElement(enclosingNodeOfType(p, isTableCell));
@@ skipping 86 matching lines @@
     return createVisiblePosition(first).deepEquivalent() == createVisiblePosition(mostBackwardCaretPosition(second)).deepEquivalent();
 }
 
 bool canMergeLists(Element* firstList, Element* secondList)
 {
     if (!firstList || !secondList || !firstList->isHTMLElement() || !secondList->isHTMLElement())
         return false;
 
     return firstList->hasTagName(secondList->tagQName()) // make sure the list types match (ol vs. ul)
     && firstList->hasEditableStyle() && secondList->hasEditableStyle() // both lists are editable
-    && firstList->rootEditableElement() == secondList->rootEditableElement() // don't cross editing boundaries
+    && rootEditableElement(*firstList) == rootEditableElement(*secondList) // don't cross editing boundaries
     && isVisiblyAdjacent(Position::inParentAfterNode(*firstList), Position::inParentBeforeNode(*secondList));
     // Make sure there is no visible content between this li and the previous list
 }
 
 bool isDisplayInsideTable(const Node* node)
 {
     if (!node || !node->isElementNode())
         return false;
 
     LayoutObject* layoutObject = node->layoutObject();
@@ skipping 110 matching lines @@
 
     return layoutObject->style()->visibility() == VISIBLE;
 }
 
 // return first preceding DOM position rendered at a different location, or "this"
 static Position previousCharacterPosition(const Position& position, TextAffinity affinity)
 {
     if (position.isNull())
         return Position();
 
-    Element* fromRootEditableElement = position.anchorNode()->rootEditableElement();
+    Element* fromRootEditableElement = rootEditableElement(*position.anchorNode());
 
     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 (currentPos.anchorNode()->rootEditableElement() != fromRootEditableElement)
+        if (rootEditableElement(*currentPos.anchorNode()) != fromRootEditableElement)
             return position;
 
         if (atStartOfLine || !rendered) {
             if (isVisuallyEquivalentCandidate(currentPos))
                 return currentPos;
         } else if (rendersInDifferentPosition(position, currentPos)) {
             return currentPos;
         }
     }
 
@@ skipping 370 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