[Editing][DOM][CodeHealth] Move Node::*editable* functions to core/editing

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 237 matching lines @@
 int comparePositions(const PositionWithAffinity& a, const PositionWithAffinity& b)
 {
     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)
+{
+    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)
+{
+    if (blink::hasEditableStyle(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);
+}
+
+bool isContentRichlyEditable(const Node& node)
+{
+    node.document().updateStyleAndLayoutTree();
+    return blink::hasEditableStyle(node, RichlyEditable);
+}
+
+bool hasEditableStyle(const Node& node, EditableType editableType)
+{
+    switch (editableType) {
+    case ContentIsEditable:
+        return blink::hasEditableStyle(node, Editable);
+    case HasEditableAXRole:
+        return isEditableToAccessibility(node, Editable);
+    }
+    NOTREACHED();
+    return false;
+}
+
+bool layoutObjectIsRichlyEditable(const Node& node, EditableType editableType)
+{
+    switch (editableType) {
+    case ContentIsEditable:
+        return blink::hasEditableStyle(node, RichlyEditable);
+    case HasEditableAXRole:
+        return isEditableToAccessibility(node, RichlyEditable);
+    }
+    NOTREACHED();
+    return false;
+}
+
+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)
+{
+    const Node* result = nullptr;
+    for (const Node* n = &node; n && hasEditableStyle(*n); n = n->parentNode()) {
+        if (n->isElementNode())
+            result = n;
+        if (node.document().body() == n)
+            break;
+    }
+    return toElement(const_cast<Node*>(result));
+}
+
+Element* rootEditableElement(const Node& node, EditableType editableType)
+{
+    if (editableType == HasEditableAXRole) {
+        if (AXObjectCache* cache = node.document().existingAXObjectCache())
+            return const_cast<Element*>(cache->rootAXEditableElement(&node));
+    }
+
+    return rootEditableElement(node);
+}
+
 ContainerNode* highestEditableRoot(const Position& position, EditableType editableType)
 {
     if (position.isNull())
         return 0;
 
     ContainerNode* highestRoot = rootEditableElementOf(position, editableType);
     if (!highestRoot)
         return 0;
 
     if (isHTMLBodyElement(*highestRoot))
@@ skipping 1548 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