Changeset 160966 in webkit

Timestamp:

Dec 21, 2013 10:51:04 AM (11 years ago)

Author:

Antti Koivisto

Message:

Figure out if node is focusable without requiring renderer
​https://bugs.webkit.org/show_bug.cgi?id=126118

Reviewed by Andreas Kling.

• dom/Element.cpp:

(WebCore::Element::computedStyle):

Use inDocument() test instead of the attached() test. We can compute style for anything that
is in document.

• dom/Node.cpp:

(WebCore::Node::isContentEditable):
(WebCore::Node::isContentRichlyEditable):
(WebCore::Node::hasEditableStyle):

Use computedStyle instead of getting the style from renderer. Computed style gets constructed
on demand if renderer does not exist. If it does then the existing style is used.

(WebCore::Node::isEditableToAccessibility):
(WebCore::Node::canStartSelection):
(WebCore::Node::isRootEditableElement):
(WebCore::Node::rootEditableElement):

• dom/Node.h:

(WebCore::Node::hasEditableStyle):
(WebCore::Node::hasRichlyEditableStyle):

Renamed from rendererIsEditable since these no longer require renderer.

(WebCore::HTMLElement::supportsFocus):

Stop calling updateStyleIfNeeded() and forcing render tree construction.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• accessibility/AccessibilityNodeObject.cpp (modified) (3 diffs)
• accessibility/AccessibilityRenderObject.cpp (modified) (3 diffs)
• accessibility/AccessibilityTable.cpp (modified) (1 diff)
• dom/Document.cpp (modified) (1 diff)
• dom/Element.cpp (modified) (1 diff)
• dom/Node.cpp (modified) (9 diffs)
• dom/Node.h (modified) (3 diffs)
• dom/Position.cpp (modified) (9 diffs)
• dom/PositionIterator.cpp (modified) (1 diff)
• editing/AppendNodeCommand.cpp (modified) (3 diffs)
• editing/ApplyStyleCommand.cpp (modified) (4 diffs)
• editing/CompositeEditCommand.cpp (modified) (1 diff)
• editing/DeleteButtonController.cpp (modified) (2 diffs)
• editing/DeleteFromTextNodeCommand.cpp (modified) (1 diff)
• editing/DeleteSelectionCommand.cpp (modified) (2 diffs)
• editing/EditingStyle.cpp (modified) (1 diff)
• editing/Editor.cpp (modified) (3 diffs)
• editing/EditorCommand.cpp (modified) (1 diff)
• editing/FormatBlockCommand.cpp (modified) (1 diff)
• editing/FrameSelection.cpp (modified) (2 diffs)
• editing/FrameSelection.h (modified) (1 diff)
• editing/IndentOutdentCommand.cpp (modified) (2 diffs)
• editing/InsertIntoTextNodeCommand.cpp (modified) (2 diffs)
• editing/InsertNodeBeforeCommand.cpp (modified) (1 diff)
• editing/MergeIdenticalElementsCommand.cpp (modified) (2 diffs)
• editing/RemoveNodeCommand.cpp (modified) (1 diff)
• editing/ReplaceSelectionCommand.cpp (modified) (3 diffs)
• editing/SplitElementCommand.cpp (modified) (2 diffs)
• editing/SplitTextNodeCommand.cpp (modified) (3 diffs)
• editing/SplitTextNodeContainingElementCommand.cpp (modified) (1 diff)
• editing/VisiblePosition.cpp (modified) (1 diff)
• editing/VisibleSelection.cpp (modified) (1 diff)
• editing/VisibleSelection.h (modified) (1 diff)
• editing/VisibleUnits.cpp (modified) (6 diffs)
• editing/WrapContentsInDummySpanCommand.cpp (modified) (2 diffs)
• editing/htmlediting.cpp (modified) (9 diffs)
• html/HTMLAnchorElement.cpp (modified) (5 diffs)
• html/HTMLBodyElement.cpp (modified) (1 diff)
• html/HTMLElement.cpp (modified) (1 diff)
• page/DragController.cpp (modified) (2 diffs)
• page/EventHandler.cpp (modified) (3 diffs)
• page/FocusController.cpp (modified) (1 diff)
• rendering/HitTestResult.cpp (modified) (1 diff)
• rendering/RenderBlock.cpp (modified) (2 diffs)
• rendering/RenderBox.cpp (modified) (1 diff)
• rendering/RenderButton.cpp (modified) (1 diff)
• rendering/RenderObject.cpp (modified) (1 diff)
• rendering/RenderTextFragment.cpp (modified) (1 diff)
• rendering/RootInlineBox.cpp (modified) (1 diff)
• svg/SVGAElement.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-12-21  Antti Koivisto  <antti@apple.com>
+
+        Figure out if node is focusable without requiring renderer
+        https://bugs.webkit.org/show_bug.cgi?id=126118
+
+        Reviewed by Andreas Kling.
+
+        * dom/Element.cpp:
+        (WebCore::Element::computedStyle):
+        
+            Use inDocument() test instead of the attached() test. We can compute style for anything that
+            is in document.
+
+        * dom/Node.cpp:
+        (WebCore::Node::isContentEditable):
+        (WebCore::Node::isContentRichlyEditable):
+        (WebCore::Node::hasEditableStyle):
+        
+            Use computedStyle instead of getting the style from renderer. Computed style gets constructed
+            on demand if renderer does not exist. If it does then the existing style is used.
+
+        (WebCore::Node::isEditableToAccessibility):
+        (WebCore::Node::canStartSelection):
+        (WebCore::Node::isRootEditableElement):
+        (WebCore::Node::rootEditableElement):
+        * dom/Node.h:
+        (WebCore::Node::hasEditableStyle):
+        (WebCore::Node::hasRichlyEditableStyle):
+        
+            Renamed from rendererIsEditable since these no longer require renderer.
+
+        (WebCore::HTMLElement::supportsFocus):
+        
+            Stop calling updateStyleIfNeeded() and forcing render tree construction.
+
 2013-12-21  Carlos Garcia Campos  <cgarcia@igalia.com>
 

trunk/Source/WebCore/accessibility/AccessibilityNodeObject.cpp

@@ -151 +151 @@
         
         // If this element is an ARIA text control, notify the AT of changes.
-        if (parent->isARIATextControl() && !parent->isNativeTextControl() && !parent->node()->rendererIsEditable())
+        if (parent->isARIATextControl() && !parent->isNativeTextControl() && !parent->node()->hasEditableStyle())
             axObjectCache()->postNotification(parent, parent->document(), AXObjectCache::AXValueChanged);
     }
@@ -738 +738 @@
     }
 
-    return !node->rendererIsEditable();
+    return !node->hasEditableStyle();
 }
 
@@ -2049 +2049 @@
 }   
 
-// If you call node->rendererIsEditable() since that will return true if an ancestor is editable.
+// If you call node->hasEditableStyle() since that will return true if an ancestor is editable.
 // This only returns true if this is the element that actually has the contentEditable attribute set.
 bool AccessibilityNodeObject::hasContentEditableAttributeSet() const

trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

@@ -543 +543 @@
     if (isWebArea()) {
         if (HTMLElement* body = m_renderer->document().body()) {
-            if (body->rendererIsEditable())
+            if (body->hasEditableStyle())
                 return false;
         }
 
-        return !m_renderer->document().rendererIsEditable();
+        return !m_renderer->document().hasEditableStyle();
     }
 
@@ -1256 +1256 @@
     
     // Anything that is content editable should not be ignored.
-    // However, one cannot just call node->rendererIsEditable() since that will ask if its parents
+    // However, one cannot just call node->hasEditableStyle() since that will ask if its parents
     // are also editable. Only the top level content editable region should be exposed.
     if (hasContentEditableAttributeSet())
@@ -2745 +2745 @@
             cache->postNotification(renderParent, AXObjectCache::AXLiveRegionChanged);
 
-        if (parent->isARIATextControl() && !parent->isNativeTextControl() && !parent->node()->rendererIsEditable())
+        if (parent->isARIATextControl() && !parent->isNativeTextControl() && !parent->node()->hasEditableStyle())
             cache->postNotification(renderParent, AXObjectCache::AXValueChanged);
     }

trunk/Source/WebCore/accessibility/AccessibilityTable.cpp

@@ -103 +103 @@
     // treated as data tables, otherwise users may not be able to work with rich
     // text editors that allow creating and editing tables.
-    if (node() && node()->rendererIsEditable())
+    if (node() && node()->hasEditableStyle())
         return true;
 

trunk/Source/WebCore/dom/Document.cpp

@@ -329 +329 @@
 {
     ASSERT(node);
-    ASSERT(node->rendererIsEditable());
+    ASSERT(node->hasEditableStyle());
 
     Node* root = node->rootEditableElement();

trunk/Source/WebCore/dom/Element.cpp

@@ -2149 +2149 @@
     }
 
-    if (!attached()) {
+    if (!inDocument()) {
         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
         // document tree and figure out when to destroy the computed style for such elements.

trunk/Source/WebCore/dom/Node.cpp

@@ -57 +57 @@
 #include "Logging.h"
 #include "MutationEvent.h"
+#include "NodeRenderStyle.h"
 #include "PlatformMouseEvent.h"
 #include "PlatformWheelEvent.h"
@@ -544 +545 @@
 {
     document().updateStyleIfNeeded();
-    return rendererIsEditable(Editable, treatment);
+    return hasEditableStyle(Editable, treatment);
 }
 
@@ -550 +551 @@
 {
     document().updateStyleIfNeeded();
-    return rendererIsEditable(RichlyEditable, UserSelectAllIsAlwaysNonEditable);
+    return hasEditableStyle(RichlyEditable, UserSelectAllIsAlwaysNonEditable);
 }
 
@@ -561 +562 @@
 }
 
-bool Node::rendererIsEditable(EditableLevel editableLevel, UserSelectAllTreatment treatment) const
-{
+bool Node::hasEditableStyle(EditableLevel editableLevel, UserSelectAllTreatment treatment) const
+{
+    if (!document().hasLivingRenderTree())
+        return false;
     if (document().frame() && document().frame()->page() && document().frame()->page()->isEditable() && !containingShadowRoot())
         return true;
@@ -574 +577 @@
 
     for (const Node* node = this; node; node = node->parentNode()) {
-        if ((node->isHTMLElement() || node->isDocumentNode()) && node->renderer()) {
+        RenderStyle* style = node->isDocumentNode() ? node->renderStyle() : const_cast<Node*>(node)->computedStyle();
+        if (!style)
+            continue;
+        if (style->display() == NONE)
+            continue;
 #if ENABLE(USERSELECT_ALL)
-            // Elements with user-select: all style are considered atomic
-            // therefore non editable.
-            if (treatment == UserSelectAllIsAlwaysNonEditable && node->renderer()->style().userSelect() == SELECT_ALL)
-                return false;
+        // Elements with user-select: all style are considered atomic
+        // therefore non editable.
+        if (treatment == UserSelectAllIsAlwaysNonEditable && style->userSelect() == SELECT_ALL)
+            return false;
 #else
-            UNUSED_PARAM(treatment);
-#endif
-            switch (node->renderer()->style().userModify()) {
-            case READ_ONLY:
-                return false;
-            case READ_WRITE:
-                return true;
-            case READ_WRITE_PLAINTEXT_ONLY:
-                return editableLevel != RichlyEditable;
-            }
-            ASSERT_NOT_REACHED();
+        UNUSED_PARAM(treatment);
+#endif
+        switch (style->userModify()) {
+        case READ_ONLY:
             return false;
-        }
-    }
-
+        case READ_WRITE:
+            return true;
+        case READ_WRITE_PLAINTEXT_ONLY:
+            return editableLevel != RichlyEditable;
+        }
+        ASSERT_NOT_REACHED();
+        return false;
+    }
     return false;
 }
@@ -601 +606 @@
 bool Node::isEditableToAccessibility(EditableLevel editableLevel) const
 {
-    if (rendererIsEditable(editableLevel))
+    if (hasEditableStyle(editableLevel))
         return true;
 
@@ -922 +927 @@
 bool Node::canStartSelection() const
 {
-    if (rendererIsEditable())
+    if (hasEditableStyle())
         return true;
 
@@ -1018 +1023 @@
 bool Node::isRootEditableElement() const
 {
-    return rendererIsEditable() && isElementNode() && (!parentNode() || !parentNode()->rendererIsEditable()
+    return hasEditableStyle() && isElementNode() && (!parentNode() || !parentNode()->hasEditableStyle()
         || !parentNode()->isElementNode() || hasTagName(bodyTag));
 }
@@ -1035 +1040 @@
 {
     Element* result = 0;
-    for (Node* n = const_cast<Node*>(this); n && n->rendererIsEditable(); n = n->parentNode()) {
+    for (Node* n = const_cast<Node*>(this); n && n->hasEditableStyle(); n = n->parentNode()) {
         if (n->isElementNode())
             result = toElement(n);

trunk/Source/WebCore/dom/Node.h

@@ -342 +342 @@
     void inspect();
 
-    bool rendererIsEditable(EditableType editableType = ContentIsEditable, UserSelectAllTreatment treatment = UserSelectAllIsAlwaysNonEditable) const
+    bool hasEditableStyle(EditableType editableType = ContentIsEditable, UserSelectAllTreatment treatment = UserSelectAllIsAlwaysNonEditable) const
     {
         switch (editableType) {
         case ContentIsEditable:
-            return rendererIsEditable(Editable, treatment);
+            return hasEditableStyle(Editable, treatment);
         case HasEditableAXRole:
             return isEditableToAccessibility(Editable);
@@ -354 +354 @@
     }
 
-    bool rendererIsRichlyEditable(EditableType editableType = ContentIsEditable) const
+    bool hasRichlyEditableStyle(EditableType editableType = ContentIsEditable) const
     {
         switch (editableType) {
         case ContentIsEditable:
-            return rendererIsEditable(RichlyEditable, UserSelectAllIsAlwaysNonEditable);
+            return hasEditableStyle(RichlyEditable, UserSelectAllIsAlwaysNonEditable);
         case HasEditableAXRole:
             return isEditableToAccessibility(RichlyEditable);
@@ -655 +655 @@
 
     enum EditableLevel { Editable, RichlyEditable };
-    bool rendererIsEditable(EditableLevel, UserSelectAllTreatment = UserSelectAllIsAlwaysNonEditable) const;
+    bool hasEditableStyle(EditableLevel, UserSelectAllTreatment = UserSelectAllIsAlwaysNonEditable) const;
     bool isEditableToAccessibility(EditableLevel) const;
 

trunk/Source/WebCore/dom/Position.cpp

@@ -68 +68 @@
     while ((node = nextLeafNode(node))) {
         RenderObject* renderer = node->renderer();
-        if (!renderer || !node->rendererIsEditable())
+        if (!renderer || !node->hasEditableStyle())
             continue;
         if (hasInlineBoxWrapper(*renderer))
@@ -80 +80 @@
     while ((node = previousLeafNode(node))) {
         RenderObject* renderer = node->renderer();
-        if (!renderer || !node->rendererIsEditable())
+        if (!renderer || !node->hasEditableStyle())
             continue;
         if (hasInlineBoxWrapper(*renderer))
@@ -435 +435 @@
 {
     Position nextPosition = downstream(CanCrossEditingBoundary);
-    if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.deprecatedNode()->rendererIsEditable())
+    if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.deprecatedNode()->hasEditableStyle())
         return true;
         
     Position prevPosition = upstream(CanCrossEditingBoundary);
-    if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->rendererIsEditable())
+    if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->hasEditableStyle())
         return true;
         
-    return nextPosition.isNotNull() && !nextPosition.deprecatedNode()->rendererIsEditable()
-        && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->rendererIsEditable();
+    return nextPosition.isNotNull() && !nextPosition.deprecatedNode()->hasEditableStyle()
+        && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->hasEditableStyle();
 }
 
@@ -456 +456 @@
 
     Node* boundary = m_anchorNode.get();
-    while (boundary != documentElement && boundary->nonShadowBoundaryParentNode() && m_anchorNode->rendererIsEditable() == boundary->parentNode()->rendererIsEditable())
+    while (boundary != documentElement && boundary->nonShadowBoundaryParentNode() && m_anchorNode->hasEditableStyle() == boundary->parentNode()->hasEditableStyle())
         boundary = boundary->nonShadowBoundaryParentNode();
     
@@ -591 +591 @@
     PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : *this;
     PositionIterator currentPos = lastVisible;
-    bool startEditable = startNode->rendererIsEditable();
+    bool startEditable = startNode->hasEditableStyle();
     Node* lastNode = startNode;
     bool boundaryCrossed = false;
@@ -598 +598 @@
         
         // Don't check for an editability change if we haven't moved to a different node,
-        // to avoid the expense of computing rendererIsEditable().
+        // to avoid the expense of computing hasEditableStyle().
         if (currentNode != lastNode) {
             // Don't change editability.
-            bool currentEditable = currentNode->rendererIsEditable();
+            bool currentEditable = currentNode->hasEditableStyle();
             if (startEditable != currentEditable) {
                 if (rule == CannotCrossEditingBoundary)
@@ -718 +718 @@
     PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : *this;
     PositionIterator currentPos = lastVisible;
-    bool startEditable = startNode->rendererIsEditable();
+    bool startEditable = startNode->hasEditableStyle();
     Node* lastNode = startNode;
     bool boundaryCrossed = false;
@@ -725 +725 @@
         
         // Don't check for an editability change if we haven't moved to a different node,
-        // to avoid the expense of computing rendererIsEditable().
+        // to avoid the expense of computing hasEditableStyle().
         if (currentNode != lastNode) {
             // Don't change editability.
-            bool currentEditable = currentNode->rendererIsEditable();
+            bool currentEditable = currentNode->hasEditableStyle();
             if (startEditable != currentEditable) {
                 if (rule == CannotCrossEditingBoundary)
@@ -943 +943 @@
             if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(block))
                 return atFirstEditingPositionForNode() && !Position::nodeIsUserSelectNone(deprecatedNode());
-            return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
+            return m_anchorNode->hasEditableStyle() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
         }
     } else
-        return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
+        return m_anchorNode->hasEditableStyle() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
 
     return false;

trunk/Source/WebCore/dom/PositionIterator.cpp

@@ -166 +166 @@
             if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(block))
                 return atStartOfNode() && !Position::nodeIsUserSelectNone(m_anchorNode);
-            return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(m_anchorNode) && Position(*this).atEditingBoundary();
+            return m_anchorNode->hasEditableStyle() && !Position::nodeIsUserSelectNone(m_anchorNode) && Position(*this).atEditingBoundary();
         }
     }

trunk/Source/WebCore/editing/AppendNodeCommand.cpp

@@ -43 +43 @@
     ASSERT(!m_node->parentNode());
 
-    ASSERT(m_parent->rendererIsEditable() || !m_parent->attached());
+    ASSERT(m_parent->hasEditableStyle() || !m_parent->attached());
 }
 
@@ -59 +59 @@
 void AppendNodeCommand::doApply()
 {
-    if (!m_parent->rendererIsEditable() && m_parent->attached())
+    if (!m_parent->hasEditableStyle() && m_parent->attached())
         return;
 
@@ -70 +70 @@
 void AppendNodeCommand::doUnapply()
 {
-    if (!m_parent->rendererIsEditable())
+    if (!m_parent->hasEditableStyle())
         return;
         

trunk/Source/WebCore/editing/ApplyStyleCommand.cpp

@@ -712 +712 @@
 static bool containsNonEditableRegion(Node* node)
 {
-    if (!node->rendererIsEditable())
+    if (!node->hasEditableStyle())
         return true;
 
     Node* sibling = NodeTraversal::nextSkippingChildren(node);
     for (Node* descendent = node->firstChild(); descendent && descendent != sibling; descendent = NodeTraversal::next(descendent)) {
-        if (!descendent->rendererIsEditable())
+        if (!descendent->hasEditableStyle())
             return true;
     }
@@ -758 +758 @@
         next = NodeTraversal::next(node.get());
 
-        if (!node->renderer() || !node->rendererIsEditable())
+        if (!node->renderer() || !node->hasEditableStyle())
             continue;
         
-        if (!node->rendererIsRichlyEditable() && node->isHTMLElement()) {
+        if (!node->hasRichlyEditableStyle() && node->isHTMLElement()) {
             // This is a plaintext-only region. Only proceed if it's fully selected.
             // pastEndNode is the node after the last fully selected node, so if it's inside node then
@@ -781 +781 @@
         
         if (node->childNodeCount()) {
-            if (node->contains(pastEndNode.get()) || containsNonEditableRegion(node.get()) || !node->parentNode()->rendererIsEditable())
+            if (node->contains(pastEndNode.get()) || containsNonEditableRegion(node.get()) || !node->parentNode()->hasEditableStyle())
                 continue;
             if (editingIgnoresContent(node.get())) {
@@ -1361 +1361 @@
     RefPtr<Node> nextSibling = element->nextSibling();
     RefPtr<Node> previousSibling = element->previousSibling();
-    if (nextSibling && nextSibling->isElementNode() && nextSibling->rendererIsEditable()
+    if (nextSibling && nextSibling->isElementNode() && nextSibling->hasEditableStyle()
         && areIdenticalElements(element.get(), toElement(nextSibling.get())))
         mergeIdenticalElements(element.get(), toElement(nextSibling.get()));
 
-    if (previousSibling && previousSibling->isElementNode() && previousSibling->rendererIsEditable()) {
+    if (previousSibling && previousSibling->isElementNode() && previousSibling->hasEditableStyle()) {
         Node* mergedElement = previousSibling->nextSibling();
-        if (mergedElement->isElementNode() && mergedElement->rendererIsEditable()
+        if (mergedElement->isElementNode() && mergedElement->hasEditableStyle()
             && areIdenticalElements(toElement(previousSibling.get()), toElement(mergedElement)))
             mergeIdenticalElements(toElement(previousSibling.get()), toElement(mergedElement));

trunk/Source/WebCore/editing/CompositeEditCommand.cpp

@@ -1279 +1279 @@
     if (!listNode
         || (!listNode->hasTagName(ulTag) && !listNode->hasTagName(olTag))
-        || !listNode->rendererIsEditable()
+        || !listNode->hasEditableStyle()
         || listNode == emptyListItem->rootEditableElement())
         return false;

trunk/Source/WebCore/editing/DeleteButtonController.cpp

@@ -62 +62 @@
 static bool isDeletableElement(const Node* node)
 {
-    if (!node || !node->isHTMLElement() || !node->inDocument() || !node->rendererIsEditable())
+    if (!node || !node->isHTMLElement() || !node->inDocument() || !node->hasEditableStyle())
         return false;
 
@@ -153 +153 @@
     // The enclosingNodeOfType function only works on nodes that are editable
     // (which is strange, given its name).
-    if (!container->rendererIsEditable())
+    if (!container->hasEditableStyle())
         return 0;
 

trunk/Source/WebCore/editing/DeleteFromTextNodeCommand.cpp

@@ -68 +68 @@
     ASSERT(m_node);
 
-    if (!m_node->rendererIsEditable())
+    if (!m_node->hasEditableStyle())
         return;
 

trunk/Source/WebCore/editing/DeleteSelectionCommand.cpp

@@ -341 +341 @@
     ASSERT(node);
     Node* next = node;
-    while (next && !next->rendererIsEditable())
+    while (next && !next->hasEditableStyle())
         next = NodeTraversal::next(next, node);
     return next ? firstPositionInOrBeforeNode(next) : Position();
@@ -353 +353 @@
     if (m_startRoot != m_endRoot && !(node->isDescendantOf(m_startRoot.get()) && node->isDescendantOf(m_endRoot.get()))) {
         // If a node is not in both the start and end editable roots, remove it only if its inside an editable region.
-        if (!node->parentNode()->rendererIsEditable()) {
+        if (!node->parentNode()->hasEditableStyle()) {
             // Don't remove non-editable atomic nodes.
             if (!node->firstChild())

trunk/Source/WebCore/editing/EditingStyle.cpp

@@ -689 +689 @@
     bool nodeIsStart = true;
     for (Node* node = selection.start().deprecatedNode(); node; node = NodeTraversal::next(node)) {
-        if (node->renderer() && node->rendererIsEditable()) {
+        if (node->renderer() && node->hasEditableStyle()) {
             ComputedStyleExtractor computedStyle(node);
             TriState nodeState = triStateOfStyle(&computedStyle, node->isTextNode() ? EditingStyle::DoNotIgnoreTextOnlyProperties : EditingStyle::IgnoreTextOnlyProperties);

trunk/Source/WebCore/editing/Editor.cpp

@@ -313 +313 @@
         return false;
     
-    if (!startContainer->rendererIsEditable() || !endContainer->rendererIsEditable())
+    if (!startContainer->hasEditableStyle() || !endContainer->hasEditableStyle())
         return false;
 
@@ -2075 +2075 @@
     // If we're not in an editable node, bail.
     Node* editableNode = searchRange->startContainer();
-    if (!editableNode || !editableNode->rendererIsEditable())
+    if (!editableNode || !editableNode->hasEditableStyle())
         return;
 
@@ -2144 +2144 @@
     // If we're not in an editable node, bail.
     Node* editableNode = spellingRange->startContainer();
-    if (!editableNode || !editableNode->rendererIsEditable())
+    if (!editableNode || !editableNode->hasEditableStyle())
         return;
 

trunk/Source/WebCore/editing/EditorCommand.cpp

@@ -256 +256 @@
         return 0;
     const RenderStyle& style = renderer->style();
-    if (!(style.overflowY() == OSCROLL || style.overflowY() == OAUTO || focusedElement->rendererIsEditable()))
+    if (!(style.overflowY() == OSCROLL || style.overflowY() == OAUTO || focusedElement->hasEditableStyle()))
         return 0;
     int height = std::min<int>(toRenderBox(renderer)->clientHeight(), frame.view()->visibleHeight());

trunk/Source/WebCore/editing/FormatBlockCommand.cpp

@@ -150 +150 @@
     Node* lastBlock = startNode;
     for (Node* n = startNode; n; n = n->parentNode()) {
-        if (!n->rendererIsEditable())
+        if (!n->hasEditableStyle())
             return lastBlock;
-        if (isTableCell(n) || n->hasTagName(bodyTag) || !n->parentNode() || !n->parentNode()->rendererIsEditable() || isElementForFormatBlock(n))
+        if (isTableCell(n) || n->hasTagName(bodyTag) || !n->parentNode() || !n->parentNode()->hasEditableStyle() || isElementForFormatBlock(n))
             return n;
         if (isBlock(n))
             lastBlock = n;
         if (isListElement(n))
-            return n->parentNode()->rendererIsEditable() ? n->parentNode() : n;
+            return n->parentNode()->hasEditableStyle() ? n->parentNode() : n;
     }
     return lastBlock;

trunk/Source/WebCore/editing/FrameSelection.cpp

@@ -1590 +1590 @@
         
     // This method's purpose is it to make it easier to select iframes (in order to delete them).  Don't do anything if the iframe isn't deletable.
-    if (!ownerElementParent->rendererIsEditable())
+    if (!ownerElementParent->hasEditableStyle())
         return;
 
@@ -2025 +2025 @@
     Document* document = m_frame->document();
     bool caretBrowsing = m_frame->settings().caretBrowsingEnabled();
-    if (!isNone() || !(document->rendererIsEditable() || caretBrowsing))
+    if (!isNone() || !(document->hasEditableStyle() || caretBrowsing))
         return;
 

trunk/Source/WebCore/editing/FrameSelection.h

@@ -134 +134 @@
     Element* rootEditableElementOrDocumentElement() const;
 
-    bool rendererIsEditable() const { return m_selection.rendererIsEditable(); }
+    bool hasEditableStyle() const { return m_selection.hasEditableStyle(); }
     bool isContentEditable() const { return m_selection.isContentEditable(); }
     bool isContentRichlyEditable() const { return m_selection.isContentRichlyEditable(); }

trunk/Source/WebCore/editing/IndentOutdentCommand.cpp

@@ -126 +126 @@
 
     Node* enclosingNode = enclosingNodeOfType(visibleStartOfParagraph.deepEquivalent(), &isListOrIndentBlockquote);
-    if (!enclosingNode || !enclosingNode->parentNode()->rendererIsEditable()) // We can't outdent if there is no place to go!
+    if (!enclosingNode || !enclosingNode->parentNode()->hasEditableStyle()) // We can't outdent if there is no place to go!
         return;
 
@@ -157 +157 @@
                 if (splitPointParent->hasTagName(blockquoteTag)
                     && !splitPoint->hasTagName(blockquoteTag)
-                    && splitPointParent->parentNode()->rendererIsEditable()) // We can't outdent if there is no place to go!
+                    && splitPointParent->parentNode()->hasEditableStyle()) // We can't outdent if there is no place to go!
                     splitElement(toElement(splitPointParent), splitPoint);
             }

trunk/Source/WebCore/editing/InsertIntoTextNodeCommand.cpp

@@ -54 +54 @@
         document().updateLayoutIgnorePendingStylesheets();
 
-    if (!m_node->rendererIsEditable())
+    if (!m_node->hasEditableStyle())
         return;
 
@@ -71 +71 @@
 void InsertIntoTextNodeCommand::doUnapply()
 {
-    if (!m_node->rendererIsEditable())
+    if (!m_node->hasEditableStyle())
         return;
         

trunk/Source/WebCore/editing/InsertNodeBeforeCommand.cpp

@@ -46 +46 @@
     ASSERT(m_refChild->parentNode());
 
-    ASSERT(m_refChild->parentNode()->rendererIsEditable() || !m_refChild->parentNode()->attached());
+    ASSERT(m_refChild->parentNode()->hasEditableStyle() || !m_refChild->parentNode()->attached());
 }
 

trunk/Source/WebCore/editing/MergeIdenticalElementsCommand.cpp

@@ -43 +43 @@
 void MergeIdenticalElementsCommand::doApply()
 {
-    if (m_element1->nextSibling() != m_element2 || !m_element1->rendererIsEditable() || !m_element2->rendererIsEditable())
+    if (m_element1->nextSibling() != m_element2 || !m_element1->hasEditableStyle() || !m_element2->hasEditableStyle())
         return;
 
@@ -67 +67 @@
 
     ContainerNode* parent = m_element2->parentNode();
-    if (!parent || !parent->rendererIsEditable())
+    if (!parent || !parent->hasEditableStyle())
         return;
 

trunk/Source/WebCore/editing/RemoveNodeCommand.cpp

@@ -60 +60 @@
     RefPtr<ContainerNode> parent = m_parent.release();
     RefPtr<Node> refChild = m_refChild.release();
-    if (!parent || !parent->rendererIsEditable())
+    if (!parent || !parent->hasEditableStyle())
         return;
 

trunk/Source/WebCore/editing/ReplaceSelectionCommand.cpp

@@ -161 +161 @@
         // FIXME: Remove these checks once textareas and textfields actually register an event handler.
         !(shadowAncestorNode && shadowAncestorNode->renderer() && shadowAncestorNode->renderer()->isTextControl()) &&
-        editableRoot->rendererIsRichlyEditable()) {
+        editableRoot->hasRichlyEditableStyle()) {
         removeInterchangeNodes(m_fragment.get());
         return;
@@ -182 +182 @@
     RefPtr<BeforeTextInsertedEvent> evt = BeforeTextInsertedEvent::create(text);
     editableRoot->dispatchEvent(evt, ASSERT_NO_EXCEPTION);
-    if (text != evt->text() || !editableRoot->rendererIsRichlyEditable()) {
+    if (text != evt->text() || !editableRoot->hasRichlyEditableStyle()) {
         restoreAndRemoveTestRenderingNodesToFragment(holder.get());
 
@@ -534 +534 @@
         }
 
-        if (element->parentNode()->rendererIsRichlyEditable())
+        if (element->parentNode()->hasRichlyEditableStyle())
             removeNodeAttribute(element, contenteditableAttr);
 

trunk/Source/WebCore/editing/SplitElementCommand.cpp

@@ -55 +55 @@
     
     ContainerNode* parent = m_element2->parentNode();
-    if (!parent || !parent->rendererIsEditable())
+    if (!parent || !parent->hasEditableStyle())
         return;
     parent->insertBefore(m_element1.get(), m_element2.get(), ec);
@@ -78 +78 @@
 void SplitElementCommand::doUnapply()
 {
-    if (!m_element1 || !m_element1->rendererIsEditable() || !m_element2->rendererIsEditable())
+    if (!m_element1 || !m_element1->hasEditableStyle() || !m_element2->hasEditableStyle())
         return;
 

trunk/Source/WebCore/editing/SplitTextNodeCommand.cpp

@@ -52 +52 @@
 {
     ContainerNode* parent = m_text2->parentNode();
-    if (!parent || !parent->rendererIsEditable())
+    if (!parent || !parent->hasEditableStyle())
         return;
 
@@ -68 +68 @@
 void SplitTextNodeCommand::doUnapply()
 {
-    if (!m_text1 || !m_text1->rendererIsEditable())
+    if (!m_text1 || !m_text1->hasEditableStyle())
         return;
 
@@ -87 +87 @@
 
     ContainerNode* parent = m_text2->parentNode();
-    if (!parent || !parent->rendererIsEditable())
+    if (!parent || !parent->hasEditableStyle())
         return;
 

trunk/Source/WebCore/editing/SplitTextNodeContainingElementCommand.cpp

@@ -51 +51 @@
 
     Element* parent = m_text->parentElement();
-    if (!parent || !parent->parentElement() || !parent->parentElement()->rendererIsEditable())
+    if (!parent || !parent->parentElement() || !parent->parentElement()->hasEditableStyle())
         return;
 

trunk/Source/WebCore/editing/VisiblePosition.cpp

@@ -537 +537 @@
     // 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->hasTagName(htmlTag) && !node->rendererIsEditable() && node->document().body() && node->document().body()->rendererIsEditable())
+    if (node && node->hasTagName(htmlTag) && !node->hasEditableStyle() && node->document().body() && node->document().body()->hasEditableStyle())
         return next.isNotNull() ? next : prev;
 

trunk/Source/WebCore/editing/VisibleSelection.cpp

@@ -627 +627 @@
 }
 
-bool VisibleSelection::rendererIsEditable() const
+bool VisibleSelection::hasEditableStyle() const
 {
     return isEditablePosition(start(), ContentIsEditable, DoNotUpdateStyle);

trunk/Source/WebCore/editing/VisibleSelection.h

@@ -100 +100 @@
     Element* rootEditableElement() const;
     bool isContentEditable() const;
-    bool rendererIsEditable() const;
+    bool hasEditableStyle() const;
     bool isContentRichlyEditable() const;
     // Returns a shadow tree node for legacy shadow trees, a child of the

trunk/Source/WebCore/editing/VisibleUnits.cpp

@@ -49 +49 @@
 static Node* previousLeafWithSameEditability(Node* node, EditableType editableType)
 {
-    bool editable = node->rendererIsEditable(editableType);
+    bool editable = node->hasEditableStyle(editableType);
     node = previousLeafNode(node);
     while (node) {
-        if (editable == node->rendererIsEditable(editableType))
+        if (editable == node->hasEditableStyle(editableType))
             return node;
         node = previousLeafNode(node);
@@ -64 +64 @@
         return 0;
     
-    bool editable = node->rendererIsEditable(editableType);
+    bool editable = node->hasEditableStyle(editableType);
     node = nextLeafNode(node);
     while (node) {
-        if (editable == node->rendererIsEditable(editableType))
+        if (editable == node->hasEditableStyle(editableType))
             return node;
         node = nextLeafNode(node);
@@ -965 +965 @@
     // 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->rendererIsEditable(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
+    Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
@@ -1023 +1023 @@
     // 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->rendererIsEditable(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
+    Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
@@ -1104 +1104 @@
     while (n) {
 #if ENABLE(USERSELECT_ALL)
-        if (boundaryCrossingRule == CannotCrossEditingBoundary && !Position::nodeIsUserSelectAll(n) && n->rendererIsEditable() != startNode->rendererIsEditable())
+        if (boundaryCrossingRule == CannotCrossEditingBoundary && !Position::nodeIsUserSelectAll(n) && n->hasEditableStyle() != startNode->hasEditableStyle())
 #else
-        if (boundaryCrossingRule == CannotCrossEditingBoundary && n->rendererIsEditable() != startNode->rendererIsEditable())
+        if (boundaryCrossingRule == CannotCrossEditingBoundary && n->hasEditableStyle() != startNode->hasEditableStyle())
 #endif
             break;
         if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
-            while (n && n->rendererIsEditable() != startNode->rendererIsEditable())
+            while (n && n->hasEditableStyle() != startNode->hasEditableStyle())
                 n = NodeTraversal::previousPostOrder(n, startBlock);
             if (!n || !n->isDescendantOf(highestRoot))
@@ -1184 +1184 @@
     while (n) {
 #if ENABLE(USERSELECT_ALL)
-        if (boundaryCrossingRule == CannotCrossEditingBoundary && !Position::nodeIsUserSelectAll(n) && n->rendererIsEditable() != startNode->rendererIsEditable())
+        if (boundaryCrossingRule == CannotCrossEditingBoundary && !Position::nodeIsUserSelectAll(n) && n->hasEditableStyle() != startNode->hasEditableStyle())
 #else
-        if (boundaryCrossingRule == CannotCrossEditingBoundary && n->rendererIsEditable() != startNode->rendererIsEditable())
+        if (boundaryCrossingRule == CannotCrossEditingBoundary && n->hasEditableStyle() != startNode->hasEditableStyle())
 #endif
             break;
         if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
-            while (n && n->rendererIsEditable() != startNode->rendererIsEditable())
+            while (n && n->hasEditableStyle() != startNode->hasEditableStyle())
                 n = NodeTraversal::next(n, stayInsideBlock);
             if (!n || !n->isDescendantOf(highestRoot))

trunk/Source/WebCore/editing/WrapContentsInDummySpanCommand.cpp

@@ -63 +63 @@
     ASSERT(m_element);
 
-    if (!m_dummySpan || !m_element->rendererIsEditable())
+    if (!m_dummySpan || !m_element->hasEditableStyle())
         return;
 
@@ -81 +81 @@
     ASSERT(m_element);
     
-    if (!m_dummySpan || !m_element->rendererIsEditable())
+    if (!m_dummySpan || !m_element->hasEditableStyle())
         return;
 

trunk/Source/WebCore/editing/htmlediting.cpp

@@ -117 +117 @@
         if (!node)
             break;
-        if (node->rendererIsEditable(editableType))
+        if (node->hasEditableStyle(editableType))
             highestEditableRoot = node;
     }
@@ -130 +130 @@
     
     while (node) {
-        if (node->rendererIsEditable())
+        if (node->hasEditableStyle())
             return node->rootEditableElement();
         if (node->hasTagName(bodyTag))
@@ -153 +153 @@
         node = node->parentNode();
     
-    return node->rendererIsEditable(editableType);
+    return node->hasEditableStyle(editableType);
 }
 
@@ -172 +172 @@
         node = node->parentNode();
     
-    return node->rendererIsRichlyEditable(editableType);
+    return node->hasRichlyEditableStyle(editableType);
 }
 
@@ -250 +250 @@
 {
     // position falls before highestRoot.
-    if (comparePositions(position, firstPositionInNode(highestRoot)) == -1 && highestRoot->rendererIsEditable())
+    if (comparePositions(position, firstPositionInNode(highestRoot)) == -1 && highestRoot->hasEditableStyle())
         return firstPositionInNode(highestRoot);
 
@@ -549 +549 @@
     Node* root = highestEditableRoot(p);
     for (Node* n = p.deprecatedNode(); n; n = n->parentNode()) {
-        if (root && !n->rendererIsEditable())
+        if (root && !n->hasEditableStyle())
             continue;
         if (n->hasTagName(tagName))
@@ -571 +571 @@
         // Don't return a non-editable node if the input position was editable, since
         // the callers from editing will no doubt want to perform editing inside the returned node.
-        if (root && !n->rendererIsEditable())
+        if (root && !n->hasEditableStyle())
             continue;
         if (nodeIsOfType(n))
@@ -587 +587 @@
     Node* root = rule == CannotCrossEditingBoundary ? highestEditableRoot(p) : 0;
     for (Node* n = p.containerNode(); n && n != stayWithin; n = n->parentNode()) {
-        if (root && !n->rendererIsEditable())
+        if (root && !n->hasEditableStyle())
             continue;
         if (nodeIsOfType(n))
@@ -744 +744 @@
 
     return firstList->hasTagName(secondList->tagQName()) // make sure the list types match (ol vs. ul)
-    && firstList->rendererIsEditable() && secondList->rendererIsEditable() // both lists are editable
+    && firstList->hasEditableStyle() && secondList->hasEditableStyle() // both lists are editable
     && firstList->rootEditableElement() == secondList->rootEditableElement() // don't cross editing boundaries
     && isVisiblyAdjacent(positionInParentAfterNode(firstList), positionInParentBeforeNode(secondList));

trunk/Source/WebCore/html/HTMLAnchorElement.cpp

@@ -87 +87 @@
 bool HTMLAnchorElement::supportsFocus() const
 {
-    if (rendererIsEditable())
+    if (hasEditableStyle())
         return HTMLElement::supportsFocus();
     // If not a link we should still be able to focus the element if it has tabIndex.
@@ -192 +192 @@
         }
 
-        if (rendererIsEditable()) {
+        if (hasEditableStyle()) {
             // This keeps track of the editable block that the selection was in (if it was in one) just before the link was clicked
             // for the LiveWhenNotFocused editable link behavior
@@ -212 +212 @@
 void HTMLAnchorElement::setActive(bool down, bool pause)
 {
-    if (rendererIsEditable()) {
+    if (hasEditableStyle()) {
         EditableLinkBehavior editableLinkBehavior = EditableLinkDefaultBehavior;
         if (Settings* settings = document().settings())
@@ -280 +280 @@
     if (!isLink())
         return HTMLElement::canStartSelection();
-    return rendererIsEditable();
+    return hasEditableStyle();
 }
 
@@ -562 +562 @@
 bool HTMLAnchorElement::treatLinkAsLiveForEventType(EventType eventType) const
 {
-    if (!rendererIsEditable())
+    if (!hasEditableStyle())
         return true;
 

trunk/Source/WebCore/html/HTMLBodyElement.cpp

@@ -186 +186 @@
 bool HTMLBodyElement::supportsFocus() const
 {
-    return rendererIsEditable() || HTMLElement::supportsFocus();
+    return hasEditableStyle() || HTMLElement::supportsFocus();
 }
 

trunk/Source/WebCore/html/HTMLElement.cpp

@@ -663 +663 @@
 bool HTMLElement::supportsFocus() const
 {
-    if (!document().view()->isInLayout() && !document().view()->isPainting())
-        document().updateStyleIfNeeded();
-    return Element::supportsFocus() || (rendererIsEditable() && parentNode() && !parentNode()->rendererIsEditable());
+    return Element::supportsFocus() || (hasEditableStyle() && parentNode() && !parentNode()->hasEditableStyle());
 }
 

trunk/Source/WebCore/page/DragController.cpp

@@ -406 +406 @@
     }
 
-    if (doc && (m_didInitiateDrag || (doc->isPluginDocument() && !pluginDocumentAcceptsDrags) || doc->rendererIsEditable()))
+    if (doc && (m_didInitiateDrag || (doc->isPluginDocument() && !pluginDocumentAcceptsDrags) || doc->hasEditableStyle()))
         return DragOperationNone;
     return dragOperation(dragData);
@@ -554 +554 @@
 
     if (result.innerNonSharedNode()->isPluginElement()) {
-        if (!toHTMLPlugInElement(result.innerNonSharedNode())->canProcessDrag() && !result.innerNonSharedNode()->rendererIsEditable())
+        if (!toHTMLPlugInElement(result.innerNonSharedNode())->canProcessDrag() && !result.innerNonSharedNode()->hasEditableStyle())
             return false;
-    } else if (!result.innerNonSharedNode()->rendererIsEditable())
+    } else if (!result.innerNonSharedNode()->hasEditableStyle())
         return false;
 

trunk/Source/WebCore/page/EventHandler.cpp

@@ -938 +938 @@
         Node* node = event.targetNode();
         bool caretBrowsing = m_frame.settings().caretBrowsingEnabled();
-        if (node && node->renderer() && (caretBrowsing || node->rendererIsEditable())) {
+        if (node && node->renderer() && (caretBrowsing || node->hasEditableStyle())) {
             VisiblePosition pos = node->renderer()->positionForPoint(event.localPoint());
             newSelection = VisibleSelection(pos);
@@ -1195 +1195 @@
         return false;
 
-    bool editable = node->rendererIsEditable();
+    bool editable = node->hasEditableStyle();
     bool editableLinkEnabled = false;
 
@@ -1344 +1344 @@
     switch (style ? style->cursor() : CURSOR_AUTO) {
     case CURSOR_AUTO: {
-        bool editable = node->rendererIsEditable();
+        bool editable = node->hasEditableStyle();
 
         if (useHandCursor(node, result.isOverLink(), shiftKey))

trunk/Source/WebCore/page/FocusController.cpp

@@ -537 +537 @@
 {
     ASSERT(node);
-    ASSERT(node->rendererIsEditable());
+    ASSERT(node->hasEditableStyle());
 
     Node* root = node->rootEditableElement();

trunk/Source/WebCore/rendering/HitTestResult.cpp

@@ -579 +579 @@
         return toHTMLInputElement(m_innerNonSharedNode.get())->isTextField();
 
-    return m_innerNonSharedNode->rendererIsEditable();
+    return m_innerNonSharedNode->hasEditableStyle();
 }
 

trunk/Source/WebCore/rendering/RenderBlock.cpp

@@ -2484 +2484 @@
     if (type == CursorCaret) {
         caretPainter = frame().selection().caretRenderer();
-        isContentEditable = frame().selection().rendererIsEditable();
+        isContentEditable = frame().selection().hasEditableStyle();
     } else {
         caretPainter = frame().page()->dragCaretController().caretRenderer();
@@ -3539 +3539 @@
     ASSERT(child.nonPseudoNode());
     return !ancestor || !ancestor->parent() || (ancestor->hasLayer() && ancestor->parent()->isRenderView())
-        || ancestor->nonPseudoElement()->rendererIsEditable() == child.nonPseudoNode()->rendererIsEditable();
+        || ancestor->nonPseudoElement()->hasEditableStyle() == child.nonPseudoNode()->hasEditableStyle();
 }
 

trunk/Source/WebCore/rendering/RenderBox.cpp

@@ -822 +822 @@
         return true;
 
-    return element() && element()->rendererIsEditable();
+    return element() && element()->hasEditableStyle();
 }
 

trunk/Source/WebCore/rendering/RenderButton.cpp

@@ -57 +57 @@
 bool RenderButton::canBeSelectionLeaf() const
 {
-    return formControlElement().rendererIsEditable();
+    return formControlElement().hasEditableStyle();
 }
 

trunk/Source/WebCore/rendering/RenderObject.cpp

@@ -2355 +2355 @@
     // If this is a non-anonymous renderer in an editable area, then it's simple.
     if (Node* node = nonPseudoNode()) {
-        if (!node->rendererIsEditable()) {
+        if (!node->hasEditableStyle()) {
             // If it can be found, we prefer a visually equivalent position that is editable. 
             Position position = createLegacyEditingPosition(node, offset);
             Position candidate = position.downstream(CanCrossEditingBoundary);
-            if (candidate.deprecatedNode()->rendererIsEditable())
+            if (candidate.deprecatedNode()->hasEditableStyle())
                 return VisiblePosition(candidate, affinity);
             candidate = position.upstream(CanCrossEditingBoundary);
-            if (candidate.deprecatedNode()->rendererIsEditable())
+            if (candidate.deprecatedNode()->hasEditableStyle())
                 return VisiblePosition(candidate, affinity);
         }

trunk/Source/WebCore/rendering/RenderTextFragment.cpp

@@ -61 +61 @@
 bool RenderTextFragment::canBeSelectionLeaf() const
 {
-    return textNode() && textNode()->rendererIsEditable();
+    return textNode() && textNode()->hasEditableStyle();
 }
 

trunk/Source/WebCore/rendering/RootInlineBox.cpp

@@ -694 +694 @@
 static bool isEditableLeaf(InlineBox* leaf)
 {
-    return leaf && leaf->renderer().node() && leaf->renderer().node()->rendererIsEditable();
+    return leaf && leaf->renderer().node() && leaf->renderer().node()->hasEditableStyle();
 }
 

trunk/Source/WebCore/svg/SVGAElement.cpp

@@ -190 +190 @@
 bool SVGAElement::supportsFocus() const
 {
-    if (rendererIsEditable())
+    if (hasEditableStyle())
         return SVGGraphicsElement::supportsFocus();
     return true;