[Editing][DOM][CodeHealth] Make Node::hasEditableStyle global functions.

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 251 matching lines @@
 
     ContainerNode* highestRoot = rootEditableElementOf(position, editableType);
     if (!highestRoot)
         return 0;
 
     if (isHTMLBodyElement(*highestRoot))
         return highestRoot;
 
     ContainerNode* node = highestRoot->parentNode();
     while (node) {
-        if (node->hasEditableStyle(editableType))
+        if (hasEditableStyle(*node, editableType))
             highestRoot = node;
         if (isHTMLBodyElement(*node))
             break;
         node = node->parentNode();
     }
 
     return highestRoot;
 }
 
 ContainerNode* highestEditableRoot(const PositionInFlatTree& position, EditableType editableType)
@@ skipping 13 matching lines @@
         // 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);
+    return hasEditableStyle(*node, editableType);
 }
 
 bool isEditablePosition(const PositionInFlatTree& p, EditableType editableType)
 {
     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)
 {
     Node* node = p.anchorNode();
     if (!node)
         return false;
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
 
-    return node->layoutObjectIsRichlyEditable(editableType);
+    return layoutObjectIsRichlyEditable(*node, editableType);
 }
 
 Element* rootEditableElementOf(const Position& p, EditableType editableType)
 {
     Node* node = p.computeContainerNode();
     if (!node)
         return 0;
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
@@ skipping 161 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())
+    if (position.compareTo(PositionTemplate<Strategy>::firstPositionInNode(&highestRoot)) == -1 && hasEditableStyle(highestRoot))
         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>();
 
         editablePosition = PositionTemplate<Strategy>::afterNode(shadowAncestor);
@@ skipping 572 matching lines @@
 }
 
 Element* enclosingElementWithTag(const Position& p, const QualifiedName& tagName)
 {
     if (p.isNull())
         return 0;
 
     ContainerNode* root = highestEditableRoot(p);
     Element* ancestor = p.anchorNode()->isElementNode() ? toElement(p.anchorNode()) : p.anchorNode()->parentElement();
     for (; ancestor; ancestor = ancestor->parentElement()) {
-        if (root && !ancestor->hasEditableStyle())
+        if (root && !hasEditableStyle(*ancestor))
             continue;
         if (ancestor->hasTagName(tagName))
             return ancestor;
         if (ancestor == root)
             return 0;
     }
 
     return 0;
 }
 
 template <typename Strategy>
 static Node* enclosingNodeOfTypeAlgorithm(const PositionTemplate<Strategy>& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule)
 {
     // TODO(yosin) support CanSkipCrossEditingBoundary
     DCHECK(rule == CanCrossEditingBoundary || rule == CannotCrossEditingBoundary) << rule;
     if (p.isNull())
         return nullptr;
 
     ContainerNode* const root = rule == CannotCrossEditingBoundary ? highestEditableRoot(p) : nullptr;
     for (Node* n = p.anchorNode(); n; n = Strategy::parent(*n)) {
         // Don't return a non-editable node if the input position was editable, since
         // the callers from editing will no doubt want to perform editing inside the returned node.
-        if (root && !n->hasEditableStyle())
+        if (root && !hasEditableStyle(*n))
             continue;
         if (nodeIsOfType(n))
             return n;
         if (n == root)
             return nullptr;
     }
 
     return nullptr;
 }
 
 Node* enclosingNodeOfType(const Position& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule)
 {
     return enclosingNodeOfTypeAlgorithm<EditingStrategy>(p, nodeIsOfType, rule);
 }
 
 Node* enclosingNodeOfType(const PositionInFlatTree& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule)
 {
     return enclosingNodeOfTypeAlgorithm<EditingInFlatTreeStrategy>(p, nodeIsOfType, rule);
 }
 
 Node* highestEnclosingNodeOfType(const Position& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule, Node* stayWithin)
 {
     Node* highest = nullptr;
     ContainerNode* root = rule == CannotCrossEditingBoundary ? highestEditableRoot(p) : nullptr;
     for (Node* n = p.computeContainerNode(); n && n != stayWithin; n = n->parentNode()) {
-        if (root && !n->hasEditableStyle())
+        if (root && !hasEditableStyle(*n))
             continue;
         if (nodeIsOfType(n))
             highest = n;
         if (n == root)
             break;
     }
 
     return highest;
 }
 
@@ skipping 116 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
+    && hasEditableStyle(*firstList) && hasEditableStyle(*secondList) // both lists are editable
     && 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;
 
@@ skipping 421 matching lines @@
         return false;
 
     const Element& firstElement = toElement(first);
     const Element& secondElement = toElement(second);
     if (!firstElement.hasTagName(secondElement.tagQName()))
         return false;
 
     if (!firstElement.hasEquivalentAttributes(&secondElement))
         return false;
 
-    return firstElement.hasEditableStyle() && secondElement.hasEditableStyle();
+    return hasEditableStyle(firstElement) && hasEditableStyle(secondElement);
 }
 
 bool isNonTableCellHTMLBlockElement(const Node* node)
 {
     if (!node->isHTMLElement())
         return false;
 
     const HTMLElement& element = toHTMLElement(*node);
     return element.hasTagName(listingTag)
         || element.hasTagName(olTag)
@@ skipping 72 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