Make editingIgnoresContents() as global function

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
@@ skipping 1912 matching lines @@
             return PositionTemplate<Strategy>(toText(nextNodeItreator),
                                               i + text->textStartOffset());
         }
       }
 
       candidateNode = nextNodeItreator;
       candidateType = PositionAnchorType::OffsetInAnchor;
       candidateOffset =
           layoutObject->caretMaxOffset() + text->textStartOffset();
       nextNodeItreator = Strategy::next(*nextNodeItreator, startBlock);
-    } else if (Strategy::editingIgnoresContent(nextNodeItreator) ||
+    } else if (editingIgnoresContent(nextNodeItreator) ||
                isDisplayInsideTable(nextNodeItreator)) {
       candidateNode = nextNodeItreator;
       candidateType = PositionAnchorType::AfterAnchor;
       nextNodeItreator =
           Strategy::nextSkippingChildren(*nextNodeItreator, startBlock);
     } else {
       nextNodeItreator = Strategy::next(*nextNodeItreator, startBlock);
     }
   }
 
@@ skipping 896 matching lines @@
 
     // Don't move past a position that is visually distinct.  We could rely on
     // code above to terminate and return lastVisible on the next iteration, but
     // we terminate early to avoid doing a nodeIndex() call.
     if (endsOfNodeAreVisuallyDistinctPositions(currentNode) &&
         currentPos.atStartOfNode())
       return lastVisible.deprecatedComputePosition();
 
     // Return position after tables and nodes which have content that can be
     // ignored.
-    if (Strategy::editingIgnoresContent(currentNode) ||
+    if (editingIgnoresContent(currentNode) ||
         isDisplayInsideTable(currentNode)) {
       if (currentPos.atEndOfNode())
         return PositionTemplate<Strategy>::afterNode(currentNode);
       continue;
     }
 
     // return current position if it is in laid out text
     if (layoutObject->isText() && toLayoutText(layoutObject)->firstTextBox()) {
       LayoutText* const textLayoutObject = toLayoutText(layoutObject);
       const unsigned textStartOffset = textLayoutObject->textStartOffset();
@@ skipping 156 matching lines @@
       lastVisible = currentPos;
       break;
     }
 
     // track last visible streamer position
     if (isStreamer<Strategy>(currentPos))
       lastVisible = currentPos;
 
     // Return position before tables and nodes which have content that can be
     // ignored.
-    if (Strategy::editingIgnoresContent(currentNode) ||
+    if (editingIgnoresContent(currentNode) ||
         isDisplayInsideTable(currentNode)) {
       if (currentPos.offsetInLeafNode() <= layoutObject->caretMinOffset())
         return PositionTemplate<Strategy>::editingPositionOf(
             currentNode, layoutObject->caretMinOffset());
       continue;
     }
 
     // return current position if it is in laid out text
     if (layoutObject->isText() && toLayoutText(layoutObject)->firstTextBox()) {
       LayoutText* const textLayoutObject = toLayoutText(layoutObject);
@@ skipping 127 matching lines @@
   if (layoutObject->isText())
     return layoutObject->isSelectable() && inRenderedText(position);
 
   if (layoutObject->isSVG()) {
     // We don't consider SVG elements are contenteditable except for
     // associated |layoutObject| returns |isText()| true,
     // e.g. |LayoutSVGInlineText|.
     return false;
   }
 
-  if (isDisplayInsideTable(anchorNode) ||
-      Strategy::editingIgnoresContent(anchorNode)) {
+  if (isDisplayInsideTable(anchorNode) || editingIgnoresContent(anchorNode)) {
     if (!position.atFirstEditingPositionForNode() &&
         !position.atLastEditingPositionForNode())
       return false;
     const Node* parent = Strategy::parent(*anchorNode);
     return parent->layoutObject() && parent->layoutObject()->isSelectable();
   }
 
   if (anchorNode->document().documentElement() == anchorNode ||
       anchorNode->isDocumentNode())
     return false;
@@ skipping 657 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink