Rename editableRootElementForPosition() to rootEditableElementOf()

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 203 matching lines @@
 int comparePositions(const VisiblePosition& a, const VisiblePosition& b)
 {
     return comparePositions(a.deepEquivalent(), b.deepEquivalent());
 }
 
 ContainerNode* highestEditableRoot(const Position& position, EditableType editableType)
 {
     if (position.isNull())
         return 0;
 
-    ContainerNode* highestRoot = editableRootElementForPosition(position, editableType);
+    ContainerNode* highestRoot = rootEditableElementOf(position, editableType);
     if (!highestRoot)
         return 0;
 
     if (isHTMLBodyElement(*highestRoot))
         return highestRoot;
 
     ContainerNode* node = highestRoot->parentNode();

[tkent, 2016/01/21 13:19:38]

Not related to this CL, but I wonder why we need to scan ancestors of
rootEditableElement.

[tkent, 2016/01/26 04:23:59]

I realized this function could return a Document if BODY is missing.  Is this
intentional?

     while (node) {
         if (node->hasEditableStyle(editableType))
             highestRoot = node;
         if (isHTMLBodyElement(*node))
             break;
         node = node->parentNode();
     }
 
     return highestRoot;
 }
@@ skipping 22 matching lines @@
 }
 
 bool isEditablePosition(const PositionInComposedTree& p, EditableType editableType, EUpdateStyle updateStyle)
 {
     return isEditablePosition(toPositionInDOMTree(p), editableType, updateStyle);
 }
 
 bool isAtUnsplittableElement(const Position& pos)
 {
     Node* node = pos.anchorNode();
-    return (node == editableRootElementForPosition(pos) || node == enclosingNodeOfType(pos, &isTableCell));
+    return (node == rootEditableElementOf(pos) || node == enclosingNodeOfType(pos, &isTableCell));
 }
 
 
 bool isRichlyEditablePosition(const Position& p, EditableType editableType)
 {
     Node* node = p.anchorNode();
     if (!node)
         return false;
 
     if (isRenderedHTMLTableElement(node))
         node = node->parentNode();
 
     return node->layoutObjectIsRichlyEditable(editableType);
 }
 
-Element* editableRootElementForPosition(const Position& p, EditableType editableType)
+Element* rootEditableElementOf(const Position& p, EditableType editableType)
 {
     Node* node = p.computeContainerNode();
     if (!node)
         return 0;
 
     if (isRenderedHTMLTableElement(node))
         node = node->parentNode();
 
     return node->rootEditableElement(editableType);
 }
 
-Element* editableRootElementForPosition(const PositionInComposedTree& p, EditableType editableType)
+Element* rootEditableElementOf(const PositionInComposedTree& p, EditableType editableType)
 {
-    return editableRootElementForPosition(toPositionInDOMTree(p), 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;
 }
 
 // Finds the enclosing element until which the tree can be split.
 // When a user hits ENTER, he/she 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));
     if (enclosingCell)
         return enclosingCell;
 
-    return editableRootElementForPosition(p);
+    return rootEditableElementOf(p);
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> nextCandidateAlgorithm(const PositionTemplate<Strategy>& position)
 {
     TRACE_EVENT0("input", "EditingUtility::nextCandidateAlgorithm");
     PositionIteratorAlgorithm<Strategy> p(position);
 
     p.increment();
     while (!p.atEnd()) {
@@ skipping 1315 matching lines @@
     // instead of possibly at the end of the last node before the selection
     return mostForwardCaretPosition(visiblePosition.deepEquivalent());
 }
 
 bool isTextSecurityNode(const Node* node)
 {
     return node && node->layoutObject() && node->layoutObject()->style()->textSecurity() != TSNONE;
 }
 
 } // namespace blink