[Editing][CodeHealth] Remove redundant Editabletype arguments in layoutObjectIsRichlyEditable

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 238 matching lines @@
 {
     return comparePositions(a.position(), b.position());
 }
 
 int comparePositions(const VisiblePosition& a, const VisiblePosition& b)
 {
     return comparePositions(a.deepEquivalent(), b.deepEquivalent());
 }
 
 enum EditableLevel { Editable, RichlyEditable };
-static bool hasEditableStyle(const Node& node, EditableLevel editableLevel)
+static bool hasEditableLevel(const Node& node, EditableLevel editableLevel)
 {
     if (node.isPseudoElement())
         return false;
 
     // Ideally we'd call DCHECK(!needsStyleRecalc()) here, but
     // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion
     // would fire in the middle of Document::setFocusedNode().
 
     for (const Node& ancestor : NodeTraversal::inclusiveAncestorsOf(node)) {
         if ((ancestor.isHTMLElement() || ancestor.isDocumentNode()) && ancestor.layoutObject()) {
             switch (ancestor.layoutObject()->style()->userModify()) {
             case READ_ONLY:
                 return false;
             case READ_WRITE:
                 return true;
             case READ_WRITE_PLAINTEXT_ONLY:
                 return editableLevel != RichlyEditable;
             }
             NOTREACHED();
             return false;
         }
     }
 
     return false;
 }
 
-static bool isEditableToAccessibility(const Node& node, EditableLevel editableLevel)
+static bool hasAXEditableLevel(const Node& node, EditableLevel editableLevel)
 {
-    if (blink::hasEditableStyle(node, editableLevel))
+    if (hasEditableLevel(node, editableLevel))
         return true;
 
     // FIXME: Respect editableLevel for ARIA editable elements.
     if (editableLevel == RichlyEditable)
         return false;
 
     // FIXME(dmazzoni): support ScopedAXObjectCache (crbug/489851).
     if (AXObjectCache* cache = node.document().existingAXObjectCache())
         return cache->rootAXEditableElement(&node);
 
     return false;
 }
 
 bool isContentEditable(const Node& node)
 {
     node.document().updateStyleAndLayoutTree();
-    return blink::hasEditableStyle(node, Editable);
+    return hasEditableLevel(node, Editable);
 }
 
 bool isContentRichlyEditable(const Node& node)
 {
     node.document().updateStyleAndLayoutTree();
-    return blink::hasEditableStyle(node, RichlyEditable);
+    return hasEditableLevel(node, RichlyEditable);
 }
 
 bool hasEditableStyle(const Node& node, EditableType editableType)
 {
     switch (editableType) {
     case ContentIsEditable:
-        return blink::hasEditableStyle(node, Editable);
+        return hasEditableLevel(node, Editable);
     case HasEditableAXRole:
-        return isEditableToAccessibility(node, Editable);
+        return hasAXEditableLevel(node, Editable);
     }
     NOTREACHED();
     return false;
 }
 
-bool layoutObjectIsRichlyEditable(const Node& node, EditableType editableType)
+bool hasRichlyEditableStyle(const Node& node)
 {
-    switch (editableType) {
-    case ContentIsEditable:
-        return blink::hasEditableStyle(node, RichlyEditable);
-    case HasEditableAXRole:
-        return isEditableToAccessibility(node, RichlyEditable);
-    }
-    NOTREACHED();
-    return false;
+    return hasEditableLevel(node, RichlyEditable);
 }
 
 bool isRootEditableElement(const Node& node)
 {
     return hasEditableStyle(node) && node.isElementNode() && (!node.parentNode() || !hasEditableStyle(*node.parentNode())
         || !node.parentNode()->isElementNode() || &node == node.document().body());
 }
 
 Element* rootEditableElement(const Node& node)
 {
@@ skipping 82 matching lines @@
 
 bool isRichlyEditablePosition(const Position& p)
 {
     Node* node = p.anchorNode();
     if (!node)
         return false;
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
 
-    return layoutObjectIsRichlyEditable(*node);
+    return hasRichlyEditableStyle(*node);
 }
 
 Element* rootEditableElementOf(const Position& p, EditableType editableType)
 {
     Node* node = p.computeContainerNode();
     if (!node)
         return 0;
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
@@ skipping 1475 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