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

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 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 107 matching lines @@
     // (upstream/downstream won't leave blocks or enter new ones), we search
     // forward and backward until we find one.
     PositionType next = canonicalizeCandidate(nextCandidate(position));
     PositionType prev = canonicalizeCandidate(previousCandidate(position));
     Node* nextNode = next.anchorNode();
     Node* prevNode = prev.anchorNode();
 
     // The new position must be in the same editable element. Enforce that
     // first. Unless the descent is from a non-editable html element to an
     // editable body.
-    if (node && node->document().documentElement() == node && !node->hasEditableStyle() && node->document().body() && node->document().body()->hasEditableStyle())
+    if (node && node->document().documentElement() == node && !hasEditableStyle(*node) && node->document().body() && hasEditableStyle(*node->document().body()))
         return next.isNotNull() ? next : prev;
 
     Element* editingRoot = rootEditableElementOf(position);
 
     // If the html element is editable, descending into its body will look like
     // a descent from non-editable to editable content since
     // |rootEditableElementOf()| always stops at the body.
     if ((editingRoot && editingRoot->document().documentElement() == editingRoot) || position.anchorNode()->isDocumentNode())
         return next.isNotNull() ? next : prev;
 
@@ skipping 93 matching lines @@
     if (!highestRoot)
         return VisiblePositionTemplate<Strategy>();
 
     // Return the next position after |pos| that is in the same editable region
     // as this position
     return firstEditableVisiblePositionAfterPositionInRoot(pos.deepEquivalent(), *highestRoot);
 }
 
 static Node* previousLeafWithSameEditability(Node* node, EditableType editableType)
 {
-    bool editable = node->hasEditableStyle(editableType);
+    bool editable = hasEditableStyle(*node, editableType);
     node = previousAtomicLeafNode(*node);
     while (node) {
-        if (editable == node->hasEditableStyle(editableType))
+        if (editable == hasEditableStyle(*node, editableType))
             return node;
         node = previousAtomicLeafNode(*node);
     }
     return 0;
 }
 
 static Node* nextLeafWithSameEditability(Node* node, EditableType editableType = ContentIsEditable)
 {
     if (!node)
         return 0;
 
-    bool editable = node->hasEditableStyle(editableType);
+    bool editable = hasEditableStyle(*node, editableType);
     node = nextAtomicLeafNode(*node);
     while (node) {
-        if (editable == node->hasEditableStyle(editableType))
+        if (editable == hasEditableStyle(*node, editableType))
             return node;
         node = nextAtomicLeafNode(*node);
     }
     return 0;
 }
 
 // FIXME: consolidate with code in previousLinePosition.
 static Position previousRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
@@ skipping 369 matching lines @@
 {
     Node* const anchorNode = position.anchorNode();
     if (!anchorNode)
         return nullptr;
 
     Node* documentElement = anchorNode->document().documentElement();
     if (!documentElement)
         return nullptr;
 
     Node* boundary = position.computeContainerNode();
-    while (boundary != documentElement && nonShadowBoundaryParentNode<Strategy>(boundary) && anchorNode->hasEditableStyle() == Strategy::parent(*boundary)->hasEditableStyle())
+    while (boundary != documentElement && nonShadowBoundaryParentNode<Strategy>(boundary) && hasEditableStyle(*anchorNode) == hasEditableStyle(*Strategy::parent(*boundary)))
         boundary = nonShadowBoundaryParentNode<Strategy>(boundary);
 
     return boundary;
 }
 
 enum BoundarySearchContextAvailability { DontHaveMoreContext, MayHaveMoreContext };
 
 typedef unsigned (*BoundarySearchFunction)(const UChar*, unsigned length, unsigned offset, BoundarySearchContextAvailability, bool& needMoreContext);
 
 template <typename Strategy>
@@ skipping 668 matching lines @@
         LineLayoutItem lineLayoutItem = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p, ContentIsEditable))->getLineLayoutItem();
         Node* node = lineLayoutItem.node();
         if (node && editingIgnoresContent(node))
             return VisiblePosition::inParentBeforeNode(*node);
         return createVisiblePosition(lineLayoutItem.positionForPoint(pointInLine));
     }
 
     // Could not find a previous line. This means we must already be on the first line.
     // Move to the start of the content in this block, which effectively moves us
     // to the start of the line we're on.
-    Element* rootElement = node->hasEditableStyle(editableType) ? rootEditableElement(*node, editableType) : node->document().documentElement();
+    Element* rootElement = hasEditableStyle(*node, editableType) ? rootEditableElement(*node, editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
     return VisiblePosition::firstPositionInNode(rootElement);
 }
 
 VisiblePosition nextLinePosition(const VisiblePosition& visiblePosition, LayoutUnit lineDirectionPoint, EditableType editableType)
 {
     Position p = visiblePosition.deepEquivalent();
     Node* node = p.anchorNode();
 
@@ skipping 35 matching lines @@
         LineLayoutItem lineLayoutItem = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->getLineLayoutItem();
         Node* node = lineLayoutItem.node();
         if (node && editingIgnoresContent(node))
             return VisiblePosition::inParentBeforeNode(*node);
         return createVisiblePosition(lineLayoutItem.positionForPoint(pointInLine));
     }
 
     // Could not find a next line. This means we must already be on the last line.
     // Move to the end of the content in this block, which effectively moves us
     // to the end of the line we're on.
-    Element* rootElement = node->hasEditableStyle(editableType) ? rootEditableElement(*node, editableType) : node->document().documentElement();
+    Element* rootElement = hasEditableStyle(*node, editableType) ? rootEditableElement(*node, editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
     return VisiblePosition::lastPositionInNode(rootElement);
 }
 
 // ---------
 
 static unsigned startSentenceBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
@@ skipping 82 matching lines @@
         return createVisiblePosition(PositionTemplate<Strategy>::beforeNode(startNode));
 
     Element* startBlock = enclosingBlock(PositionTemplate<Strategy>::firstPositionInOrBeforeNode(startNode), CannotCrossEditingBoundary);
 
     Node* node = startNode;
     ContainerNode* highestRoot = highestEditableRoot(p);
     int offset = p.computeEditingOffset();
     PositionAnchorType type = p.anchorType();
 
     Node* n = startNode;
-    bool startNodeIsEditable = startNode->hasEditableStyle();
+    bool startNodeIsEditable = hasEditableStyle(*startNode);
     while (n) {
-        if (boundaryCrossingRule == CannotCrossEditingBoundary && !nodeIsUserSelectAll(n) && n->hasEditableStyle() != startNodeIsEditable)
+        if (boundaryCrossingRule == CannotCrossEditingBoundary && !nodeIsUserSelectAll(n) && hasEditableStyle(*n) != startNodeIsEditable)
             break;
         if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
-            while (n && n->hasEditableStyle() != startNodeIsEditable)
+            while (n && hasEditableStyle(*n) != startNodeIsEditable)
                 n = Strategy::previousPostOrder(*n, startBlock);
             if (!n || !n->isDescendantOf(highestRoot))
                 break;
         }
         LayoutObject* r = n->layoutObject();
         LayoutItem ri = LayoutItem(r);
         if (ri.isNull()) {
             n = Strategy::previousPostOrder(*n, startBlock);
             continue;
         }
@@ skipping 62 matching lines @@
 
     Element* startBlock = enclosingBlock(PositionTemplate<Strategy>::firstPositionInOrBeforeNode(startNode), CannotCrossEditingBoundary);
     Element* stayInsideBlock = startBlock;
 
     Node* node = startNode;
     ContainerNode* highestRoot = highestEditableRoot(p);
     int offset = p.computeEditingOffset();
     PositionAnchorType type = p.anchorType();
 
     Node* n = startNode;
-    bool startNodeIsEditable = startNode->hasEditableStyle();
+    bool startNodeIsEditable = hasEditableStyle(*startNode);
     while (n) {
-        if (boundaryCrossingRule == CannotCrossEditingBoundary && !nodeIsUserSelectAll(n) && n->hasEditableStyle() != startNodeIsEditable)
+        if (boundaryCrossingRule == CannotCrossEditingBoundary && !nodeIsUserSelectAll(n) && hasEditableStyle(*n) != startNodeIsEditable)
             break;
         if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
-            while (n && n->hasEditableStyle() != startNodeIsEditable)
+            while (n && hasEditableStyle(*n) != startNodeIsEditable)
                 n = Strategy::next(*n, stayInsideBlock);
             if (!n || !n->isDescendantOf(highestRoot))
                 break;
         }
 
         LayoutObject* r = n->layoutObject();
         if (!r) {
             n = Strategy::next(*n, stayInsideBlock);
             continue;
         }
@@ skipping 755 matching lines @@
 
     Node* startNode = position.anchorNode();
     if (!startNode)
         return PositionTemplate<Strategy>();
 
     // iterate backward from there, looking for a qualified position
     Node* boundary = enclosingVisualBoundary<Strategy>(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
     PositionIteratorAlgorithm<Strategy> lastVisible(position.isAfterAnchor() ? PositionTemplate<Strategy>::editingPositionOf(position.anchorNode(), Strategy::caretMaxOffset(*position.anchorNode())) : position);
     PositionIteratorAlgorithm<Strategy> currentPos = lastVisible;
-    bool startEditable = startNode->hasEditableStyle();
+    bool startEditable = hasEditableStyle(*startNode);
     Node* lastNode = startNode;
     bool boundaryCrossed = false;
     for (; !currentPos.atStart(); currentPos.decrement()) {
         Node* currentNode = currentPos.node();
         // Don't check for an editability change if we haven't moved to a different node,
         // to avoid the expense of computing hasEditableStyle().
         if (currentNode != lastNode) {
             // Don't change editability.
-            bool currentEditable = currentNode->hasEditableStyle();
+            bool currentEditable = hasEditableStyle(*currentNode);
             if (startEditable != currentEditable) {
                 if (rule == CannotCrossEditingBoundary)
                     break;
                 boundaryCrossed = true;
             }
             lastNode = currentNode;
         }
 
         // If we've moved to a position that is visually distinct, return the last saved position. There
         // is code below that terminates early if we're *about* to move to a visually distinct position.
@@ skipping 111 matching lines @@
 
     Node* startNode = position.anchorNode();
     if (!startNode)
         return PositionTemplate<Strategy>();
 
     // iterate forward from there, looking for a qualified position
     Node* boundary = enclosingVisualBoundary<Strategy>(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
     PositionIteratorAlgorithm<Strategy> lastVisible(position.isAfterAnchor() ? PositionTemplate<Strategy>::editingPositionOf(position.anchorNode(), Strategy::caretMaxOffset(*position.anchorNode())) : position);
     PositionIteratorAlgorithm<Strategy> currentPos = lastVisible;
-    bool startEditable = startNode->hasEditableStyle();
+    bool startEditable = hasEditableStyle(*startNode);
     Node* lastNode = startNode;
     bool boundaryCrossed = false;
     for (; !currentPos.atEnd(); currentPos.increment()) {
         Node* currentNode = currentPos.node();
         // Don't check for an editability change if we haven't moved to a different node,
         // to avoid the expense of computing hasEditableStyle().
         if (currentNode != lastNode) {
             // Don't change editability.
-            bool currentEditable = currentNode->hasEditableStyle();
+            bool currentEditable = hasEditableStyle(*currentNode);
             if (startEditable != currentEditable) {
                 if (rule == CannotCrossEditingBoundary)
                     break;
                 boundaryCrossed = true;
             }
 
             lastNode = currentNode;
         }
 
         // stop before going above the body, up into the head
@@ skipping 101 matching lines @@
 // 1. It is the first position in the node and the next visually equivalent
 //    position is non editable.
 // 2. It is the last position in the node and the previous visually equivalent
 //    position is non editable.
 // 3. It is an editable position and both the next and previous visually
 //    equivalent positions are both non editable.
 template <typename Strategy>
 static bool atEditingBoundary(const PositionTemplate<Strategy> positions)
 {
     PositionTemplate<Strategy> nextPosition = mostForwardCaretPosition(positions, CanCrossEditingBoundary);
-    if (positions.atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.anchorNode()->hasEditableStyle())
+    if (positions.atFirstEditingPositionForNode() && nextPosition.isNotNull() && !hasEditableStyle(*nextPosition.anchorNode()))
         return true;
 
     PositionTemplate<Strategy> prevPosition = mostBackwardCaretPosition(positions, CanCrossEditingBoundary);
-    if (positions.atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.anchorNode()->hasEditableStyle())
+    if (positions.atLastEditingPositionForNode() && prevPosition.isNotNull() && !hasEditableStyle(*prevPosition.anchorNode()))
         return true;
 
-    return nextPosition.isNotNull() && !nextPosition.anchorNode()->hasEditableStyle()
-        && prevPosition.isNotNull() && !prevPosition.anchorNode()->hasEditableStyle();
+    return nextPosition.isNotNull() && !hasEditableStyle(*nextPosition.anchorNode())
+        && prevPosition.isNotNull() && !hasEditableStyle(*prevPosition.anchorNode());
 }
 
 template <typename Strategy>
 static bool isVisuallyEquivalentCandidateAlgorithm(const PositionTemplate<Strategy>& position)
 {
     Node* const anchorNode = position.anchorNode();
     if (!anchorNode)
         return false;
 
     LayoutObject* layoutObject = anchorNode->layoutObject();
@@ skipping 35 matching lines @@
     if (anchorNode->document().documentElement() == anchorNode || anchorNode->isDocumentNode())
         return false;
 
     if (!layoutObject->isSelectable())
         return false;
 
     if (layoutObject->isLayoutBlockFlow() || layoutObject->isFlexibleBox() || layoutObject->isLayoutGrid()) {
         if (toLayoutBlock(layoutObject)->logicalHeight() || isHTMLBodyElement(*anchorNode)) {
             if (!hasRenderedNonAnonymousDescendantsWithHeight(layoutObject))
                 return position.atFirstEditingPositionForNode();
-            return anchorNode->hasEditableStyle() && atEditingBoundary(position);
+            return hasEditableStyle(*anchorNode) && atEditingBoundary(position);
         }
     } else {
         LocalFrame* frame = anchorNode->document().frame();
         bool caretBrowsing = frame->settings() && frame->settings()->caretBrowsingEnabled();
-        return (caretBrowsing || anchorNode->hasEditableStyle()) && atEditingBoundary(position);
+        return (caretBrowsing || hasEditableStyle(*anchorNode)) && atEditingBoundary(position);
     }
 
     return false;
 }
 
 bool isVisuallyEquivalentCandidate(const Position& position)
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingStrategy>(position);
 }
 
@@ skipping 533 matching lines @@
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink