Changeset 81965 in webkit


Ignore:
Timestamp:
Mar 25, 2011 9:21:30 AM (13 years ago)
Author:
commit-queue@webkit.org
Message:

2011-03-25 Chang Shu <​cshu@webkit.org>

Reviewed by Ryosuke Niwa.

rename Node::isContentEditable and all call sites to rendererIsEditable
​https://bugs.webkit.org/show_bug.cgi?id=54290

This is part of the effort to separate JS API HTMLElement isContentEditable from
internal Node::rendererIsEditable.

Code refactoring. No new tests.

  • accessibility/AccessibilityRenderObject.cpp: (WebCore::AccessibilityRenderObject::isReadOnly): (WebCore::AccessibilityRenderObject::accessibilityIsIgnored):
  • dom/Document.cpp: (WebCore::acceptsEditingFocus):
  • dom/Node.cpp: (WebCore::Node::rendererIsEditable): (WebCore::Node::shouldUseInputMethod): (WebCore::Node::canStartSelection): (WebCore::Node::rootEditableElement):
  • dom/Node.h: (WebCore::Node::isContentEditable): (WebCore::Node::rendererIsEditable): (WebCore::Node::rendererIsRichlyEditable):
  • dom/Position.cpp: (WebCore::nextRenderedEditable): (WebCore::previousRenderedEditable): (WebCore::Position::atEditingBoundary): (WebCore::Position::parentEditingBoundary): (WebCore::Position::upstream): (WebCore::Position::downstream): (WebCore::Position::isCandidate):
  • dom/PositionIterator.cpp: (WebCore::PositionIterator::isCandidate):
  • editing/AppendNodeCommand.cpp: (WebCore::AppendNodeCommand::AppendNodeCommand): (WebCore::AppendNodeCommand::doApply): (WebCore::AppendNodeCommand::doUnapply):
  • editing/ApplyStyleCommand.cpp: (WebCore::containsNonEditableRegion): (WebCore::ApplyStyleCommand::applyInlineStyleToNodeRange): (WebCore::ApplyStyleCommand::removeInlineStyleFromElement): (WebCore::ApplyStyleCommand::surroundNodeRangeWithElement):
  • editing/CompositeEditCommand.cpp: (WebCore::CompositeEditCommand::breakOutOfEmptyListItem):
  • editing/DeleteButtonController.cpp: (WebCore::isDeletableElement): (WebCore::enclosingDeletableElement):
  • editing/DeleteFromTextNodeCommand.cpp: (WebCore::DeleteFromTextNodeCommand::doApply): (WebCore::DeleteFromTextNodeCommand::doUnapply):
  • editing/DeleteSelectionCommand.cpp: (WebCore::DeleteSelectionCommand::removeNode):
  • editing/Editor.cpp: (WebCore::Editor::canDeleteRange): (WebCore::Editor::markMisspellingsOrBadGrammar): (WebCore::Editor::markAllMisspellingsAndBadGrammarInRanges):
  • editing/EditorCommand.cpp: (WebCore::verticalScrollDistance):
  • editing/FormatBlockCommand.cpp: (WebCore::enclosingBlockToSplitTreeTo):
  • editing/IndentOutdentCommand.cpp: (WebCore::IndentOutdentCommand::outdentParagraph):
  • editing/InsertIntoTextNodeCommand.cpp: (WebCore::InsertIntoTextNodeCommand::doApply): (WebCore::InsertIntoTextNodeCommand::doUnapply):
  • editing/InsertNodeBeforeCommand.cpp: (WebCore::InsertNodeBeforeCommand::InsertNodeBeforeCommand): (WebCore::InsertNodeBeforeCommand::doApply): (WebCore::InsertNodeBeforeCommand::doUnapply):
  • editing/JoinTextNodesCommand.cpp: (WebCore::JoinTextNodesCommand::doApply): (WebCore::JoinTextNodesCommand::doUnapply):
  • editing/MergeIdenticalElementsCommand.cpp: (WebCore::MergeIdenticalElementsCommand::doApply): (WebCore::MergeIdenticalElementsCommand::doUnapply):
  • editing/RemoveNodeCommand.cpp: (WebCore::RemoveNodeCommand::doApply): (WebCore::RemoveNodeCommand::doUnapply):
  • editing/ReplaceSelectionCommand.cpp: (WebCore::ReplacementFragment::ReplacementFragment):
  • editing/SelectionController.cpp: (WebCore::SelectionController::selectFrameElementInParentIfFullySelected): (WebCore::SelectionController::setSelectionFromNone):
  • editing/SplitElementCommand.cpp: (WebCore::SplitElementCommand::executeApply): (WebCore::SplitElementCommand::doUnapply):
  • editing/SplitTextNodeCommand.cpp: (WebCore::SplitTextNodeCommand::doApply): (WebCore::SplitTextNodeCommand::doUnapply): (WebCore::SplitTextNodeCommand::doReapply):
  • editing/SplitTextNodeContainingElementCommand.cpp: (WebCore::SplitTextNodeContainingElementCommand::doApply):
  • editing/VisiblePosition.cpp: (WebCore::VisiblePosition::canonicalPosition):
  • editing/WrapContentsInDummySpanCommand.cpp: (WebCore::WrapContentsInDummySpanCommand::doUnapply): (WebCore::WrapContentsInDummySpanCommand::doReapply):
  • editing/htmlediting.cpp: (WebCore::highestEditableRoot): (WebCore::lowestEditableAncestor): (WebCore::isEditablePosition): (WebCore::isRichlyEditablePosition): (WebCore::firstEditablePositionAfterPositionInRoot): (WebCore::extendRangeToWrappingNodes): (WebCore::enclosingNodeWithTag): (WebCore::enclosingNodeOfType): (WebCore::highestEnclosingNodeOfType): (WebCore::canMergeLists):
  • editing/visible_units.cpp: (WebCore::previousLeafWithSameEditability): (WebCore::previousLinePosition): (WebCore::nextLeafWithSameEditability): (WebCore::nextLinePosition): (WebCore::startOfParagraph): (WebCore::endOfParagraph):
  • html/HTMLAnchorElement.cpp: (WebCore::HTMLAnchorElement::supportsFocus): (WebCore::HTMLAnchorElement::defaultEventHandler): (WebCore::HTMLAnchorElement::setActive): (WebCore::HTMLAnchorElement::canStartSelection): (WebCore::HTMLAnchorElement::treatLinkAsLiveForEventType):
  • html/HTMLBodyElement.cpp: (WebCore::HTMLBodyElement::supportsFocus):
  • html/HTMLElement.cpp: (WebCore::HTMLElement::supportsFocus): (WebCore::HTMLElement::isContentEditable): (WebCore::HTMLElement::contentEditable):
  • html/HTMLElement.h:
  • page/DragController.cpp: (WebCore::DragController::operationForLoad): (WebCore::DragController::canProcessDrag):
  • page/EventHandler.cpp: (WebCore::EventHandler::handleMouseReleaseEvent): (WebCore::EventHandler::selectCursor):
  • page/FocusController.cpp: (WebCore::relinquishesEditingFocus):
  • rendering/HitTestResult.cpp: (WebCore::HitTestResult::isContentEditable):
  • rendering/RenderBlock.cpp: (WebCore::positionForPointRespectingEditingBoundaries): (WebCore::RenderBlock::hasLineIfEmpty):
  • rendering/RenderBlockLineLayout.cpp: (WebCore::RenderBlock::addOverflowFromInlineChildren):
  • rendering/RenderBox.cpp: (WebCore::RenderBox::canBeProgramaticallyScrolled):
  • rendering/RenderObject.cpp: (WebCore::RenderObject::createVisiblePosition):
  • rendering/RootInlineBox.cpp: (WebCore::isEditableLeaf):
  • svg/SVGAElement.cpp: (WebCore::SVGAElement::supportsFocus):

2011-03-25 Chang Shu <​cshu@webkit.org>

Reviewed by Ryosuke Niwa.

rename Node::isContentEditable and all call sites to rendererIsEditable
​https://bugs.webkit.org/show_bug.cgi?id=54290

This is part of the effort to separate JS API HTMLElement isContentEditable from
internal Node::rendererIsEditable.

  • src/WebNode.cpp: (WebKit::WebNode::isContentEditable):
  • src/WebViewImpl.cpp: (WebKit::WebViewImpl::setFocus): (WebKit::WebViewImpl::setComposition): (WebKit::WebViewImpl::confirmComposition):

2011-03-25 Chang Shu <​cshu@webkit.org>

Reviewed by Ryosuke Niwa.

rename Node::isContentEditable and all call sites to rendererIsEditable
​https://bugs.webkit.org/show_bug.cgi?id=54290

This is part of the effort to separate JS API HTMLElement isContentEditable from
internal Node::rendererIsEditable.

  • WebCoreSupport/EditorClientHaiku.cpp: (WebCore::EditorClientHaiku::handleKeyboardEvent):

2011-03-25 Chang Shu <​cshu@webkit.org>

Reviewed by Ryosuke Niwa.

rename Node::isContentEditable and all call sites to rendererIsEditable
​https://bugs.webkit.org/show_bug.cgi?id=54290

This is part of the effort to separate JS API HTMLElement isContentEditable from
internal Node::rendererIsEditable.

  • WebCoreSupport/EditorClientQt.cpp: (WebCore::EditorClientQt::handleKeyboardEvent):
Location:
trunk/Source
Files:
52 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r81964 r81965  
     12011-03-25  Chang Shu  <cshu@webkit.org>
     2
     3        Reviewed by Ryosuke Niwa.
     4
     5        rename Node::isContentEditable and all call sites to rendererIsEditable
     6        https://bugs.webkit.org/show_bug.cgi?id=54290
     7
     8        This is part of the effort to separate JS API HTMLElement isContentEditable from
     9        internal Node::rendererIsEditable.
     10
     11        Code refactoring. No new tests.
     12
     13        * accessibility/AccessibilityRenderObject.cpp:
     14        (WebCore::AccessibilityRenderObject::isReadOnly):
     15        (WebCore::AccessibilityRenderObject::accessibilityIsIgnored):
     16        * dom/Document.cpp:
     17        (WebCore::acceptsEditingFocus):
     18        * dom/Node.cpp:
     19        (WebCore::Node::rendererIsEditable):
     20        (WebCore::Node::shouldUseInputMethod):
     21        (WebCore::Node::canStartSelection):
     22        (WebCore::Node::rootEditableElement):
     23        * dom/Node.h:
     24        (WebCore::Node::isContentEditable):
     25        (WebCore::Node::rendererIsEditable):
     26        (WebCore::Node::rendererIsRichlyEditable):
     27        * dom/Position.cpp:
     28        (WebCore::nextRenderedEditable):
     29        (WebCore::previousRenderedEditable):
     30        (WebCore::Position::atEditingBoundary):
     31        (WebCore::Position::parentEditingBoundary):
     32        (WebCore::Position::upstream):
     33        (WebCore::Position::downstream):
     34        (WebCore::Position::isCandidate):
     35        * dom/PositionIterator.cpp:
     36        (WebCore::PositionIterator::isCandidate):
     37        * editing/AppendNodeCommand.cpp:
     38        (WebCore::AppendNodeCommand::AppendNodeCommand):
     39        (WebCore::AppendNodeCommand::doApply):
     40        (WebCore::AppendNodeCommand::doUnapply):
     41        * editing/ApplyStyleCommand.cpp:
     42        (WebCore::containsNonEditableRegion):
     43        (WebCore::ApplyStyleCommand::applyInlineStyleToNodeRange):
     44        (WebCore::ApplyStyleCommand::removeInlineStyleFromElement):
     45        (WebCore::ApplyStyleCommand::surroundNodeRangeWithElement):
     46        * editing/CompositeEditCommand.cpp:
     47        (WebCore::CompositeEditCommand::breakOutOfEmptyListItem):
     48        * editing/DeleteButtonController.cpp:
     49        (WebCore::isDeletableElement):
     50        (WebCore::enclosingDeletableElement):
     51        * editing/DeleteFromTextNodeCommand.cpp:
     52        (WebCore::DeleteFromTextNodeCommand::doApply):
     53        (WebCore::DeleteFromTextNodeCommand::doUnapply):
     54        * editing/DeleteSelectionCommand.cpp:
     55        (WebCore::DeleteSelectionCommand::removeNode):
     56        * editing/Editor.cpp:
     57        (WebCore::Editor::canDeleteRange):
     58        (WebCore::Editor::markMisspellingsOrBadGrammar):
     59        (WebCore::Editor::markAllMisspellingsAndBadGrammarInRanges):
     60        * editing/EditorCommand.cpp:
     61        (WebCore::verticalScrollDistance):
     62        * editing/FormatBlockCommand.cpp:
     63        (WebCore::enclosingBlockToSplitTreeTo):
     64        * editing/IndentOutdentCommand.cpp:
     65        (WebCore::IndentOutdentCommand::outdentParagraph):
     66        * editing/InsertIntoTextNodeCommand.cpp:
     67        (WebCore::InsertIntoTextNodeCommand::doApply):
     68        (WebCore::InsertIntoTextNodeCommand::doUnapply):
     69        * editing/InsertNodeBeforeCommand.cpp:
     70        (WebCore::InsertNodeBeforeCommand::InsertNodeBeforeCommand):
     71        (WebCore::InsertNodeBeforeCommand::doApply):
     72        (WebCore::InsertNodeBeforeCommand::doUnapply):
     73        * editing/JoinTextNodesCommand.cpp:
     74        (WebCore::JoinTextNodesCommand::doApply):
     75        (WebCore::JoinTextNodesCommand::doUnapply):
     76        * editing/MergeIdenticalElementsCommand.cpp:
     77        (WebCore::MergeIdenticalElementsCommand::doApply):
     78        (WebCore::MergeIdenticalElementsCommand::doUnapply):
     79        * editing/RemoveNodeCommand.cpp:
     80        (WebCore::RemoveNodeCommand::doApply):
     81        (WebCore::RemoveNodeCommand::doUnapply):
     82        * editing/ReplaceSelectionCommand.cpp:
     83        (WebCore::ReplacementFragment::ReplacementFragment):
     84        * editing/SelectionController.cpp:
     85        (WebCore::SelectionController::selectFrameElementInParentIfFullySelected):
     86        (WebCore::SelectionController::setSelectionFromNone):
     87        * editing/SplitElementCommand.cpp:
     88        (WebCore::SplitElementCommand::executeApply):
     89        (WebCore::SplitElementCommand::doUnapply):
     90        * editing/SplitTextNodeCommand.cpp:
     91        (WebCore::SplitTextNodeCommand::doApply):
     92        (WebCore::SplitTextNodeCommand::doUnapply):
     93        (WebCore::SplitTextNodeCommand::doReapply):
     94        * editing/SplitTextNodeContainingElementCommand.cpp:
     95        (WebCore::SplitTextNodeContainingElementCommand::doApply):
     96        * editing/VisiblePosition.cpp:
     97        (WebCore::VisiblePosition::canonicalPosition):
     98        * editing/WrapContentsInDummySpanCommand.cpp:
     99        (WebCore::WrapContentsInDummySpanCommand::doUnapply):
     100        (WebCore::WrapContentsInDummySpanCommand::doReapply):
     101        * editing/htmlediting.cpp:
     102        (WebCore::highestEditableRoot):
     103        (WebCore::lowestEditableAncestor):
     104        (WebCore::isEditablePosition):
     105        (WebCore::isRichlyEditablePosition):
     106        (WebCore::firstEditablePositionAfterPositionInRoot):
     107        (WebCore::extendRangeToWrappingNodes):
     108        (WebCore::enclosingNodeWithTag):
     109        (WebCore::enclosingNodeOfType):
     110        (WebCore::highestEnclosingNodeOfType):
     111        (WebCore::canMergeLists):
     112        * editing/visible_units.cpp:
     113        (WebCore::previousLeafWithSameEditability):
     114        (WebCore::previousLinePosition):
     115        (WebCore::nextLeafWithSameEditability):
     116        (WebCore::nextLinePosition):
     117        (WebCore::startOfParagraph):
     118        (WebCore::endOfParagraph):
     119        * html/HTMLAnchorElement.cpp:
     120        (WebCore::HTMLAnchorElement::supportsFocus):
     121        (WebCore::HTMLAnchorElement::defaultEventHandler):
     122        (WebCore::HTMLAnchorElement::setActive):
     123        (WebCore::HTMLAnchorElement::canStartSelection):
     124        (WebCore::HTMLAnchorElement::treatLinkAsLiveForEventType):
     125        * html/HTMLBodyElement.cpp:
     126        (WebCore::HTMLBodyElement::supportsFocus):
     127        * html/HTMLElement.cpp:
     128        (WebCore::HTMLElement::supportsFocus):
     129        (WebCore::HTMLElement::isContentEditable):
     130        (WebCore::HTMLElement::contentEditable):
     131        * html/HTMLElement.h:
     132        * page/DragController.cpp:
     133        (WebCore::DragController::operationForLoad):
     134        (WebCore::DragController::canProcessDrag):
     135        * page/EventHandler.cpp:
     136        (WebCore::EventHandler::handleMouseReleaseEvent):
     137        (WebCore::EventHandler::selectCursor):
     138        * page/FocusController.cpp:
     139        (WebCore::relinquishesEditingFocus):
     140        * rendering/HitTestResult.cpp:
     141        (WebCore::HitTestResult::isContentEditable):
     142        * rendering/RenderBlock.cpp:
     143        (WebCore::positionForPointRespectingEditingBoundaries):
     144        (WebCore::RenderBlock::hasLineIfEmpty):
     145        * rendering/RenderBlockLineLayout.cpp:
     146        (WebCore::RenderBlock::addOverflowFromInlineChildren):
     147        * rendering/RenderBox.cpp:
     148        (WebCore::RenderBox::canBeProgramaticallyScrolled):
     149        * rendering/RenderObject.cpp:
     150        (WebCore::RenderObject::createVisiblePosition):
     151        * rendering/RootInlineBox.cpp:
     152        (WebCore::isEditableLeaf):
     153        * svg/SVGAElement.cpp:
     154        (WebCore::SVGAElement::supportsFocus):
     155
    11562011-03-25  Maciej Stachowiak  <mjs@apple.com>
    2157

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r81600 r81965  
    662662       
    663663        HTMLElement* body = document->body();
    664         if (body && body->isContentEditable())
     664        if (body && body->rendererIsEditable())
    665665            return false;
    666666
    667         return !document->isContentEditable();
     667        return !document->rendererIsEditable();
    668668    }
    669669
    … …  
    676676    }
    677677
    678     return !m_renderer->node() || !m_renderer->node()->isContentEditable();
     678    return !m_renderer->node() || !m_renderer->node()->rendererIsEditable();
    679679}
    680680
    … …  
    18301830   
    18311831    // Anything that is content editable should not be ignored.
    1832     // However, one cannot just call node->isContentEditable() since that will ask if its parents
     1832    // However, one cannot just call node->rendererIsEditable() since that will ask if its parents
    18331833    // are also editable. Only the top level content editable region should be exposed.
    18341834    if (node && node->isElementNode()) {

  • trunk/Source/WebCore/dom/Document.cpp

    r81567 r81965  
    320320{
    321321    ASSERT(node);
    322     ASSERT(node->isContentEditable());
     322    ASSERT(node->rendererIsEditable());
    323323
    324324    Node* root = node->rootEditableElement();

  • trunk/Source/WebCore/dom/Node.cpp

    r81932 r81965  
    712712}
    713713
    714 bool Node::isContentEditable(EditableLevel editableLevel) const
     714bool Node::rendererIsEditable(EditableLevel editableLevel) const
    715715{
    716716    if (document()->inDesignMode() || (document()->frame() && document()->frame()->page() && document()->frame()->page()->isEditable()))
    … …  
    741741bool Node::shouldUseInputMethod() const
    742742{
    743     return isContentEditable();
     743    return rendererIsEditable();
    744744}
    745745
    … …  
    15151515bool Node::canStartSelection() const
    15161516{
    1517     if (isContentEditable())
     1517    if (rendererIsEditable())
    15181518        return true;
    15191519
    … …  
    15931593{
    15941594    Element* result = 0;
    1595     for (Node* n = const_cast<Node*>(this); n && n->isContentEditable(); n = n->parentNode()) {
     1595    for (Node* n = const_cast<Node*>(this); n && n->rendererIsEditable(); n = n->parentNode()) {
    15961596        if (n->isElementNode())
    15971597            result = static_cast<Element*>(n);

  • trunk/Source/WebCore/dom/Node.h

    r81932 r81965  
    320320    virtual bool isMouseFocusable() const;
    321321
    322     bool isContentEditable() const { return isContentEditable(Editable); }
    323     bool isContentRichlyEditable() const { return isContentEditable(RichlyEditable); }
     322#if PLATFORM(MAC)
     323    // Objective-C extensions
     324    bool isContentEditable() const { return rendererIsEditable(Editable); }
     325#endif
     326    bool rendererIsEditable() const { return rendererIsEditable(Editable); }
     327    bool rendererIsRichlyEditable() const { return rendererIsEditable(RichlyEditable); }
    324328    virtual bool shouldUseInputMethod() const;
    325329    virtual IntRect getRect() const;
    … …  
    652656
    653657    enum EditableLevel { Editable, RichlyEditable };
    654     bool isContentEditable(EditableLevel) const;
     658    bool rendererIsEditable(EditableLevel) const;
    655659
    656660    void setStyleChange(StyleChangeType);

  • trunk/Source/WebCore/dom/Position.cpp

    r81518 r81965  
    4747{
    4848    while ((node = node->nextLeafNode())) {
    49         if (!node->isContentEditable())
     49        if (!node->rendererIsEditable())
    5050            continue;
    5151        RenderObject* renderer = node->renderer();
    … …  
    6161{
    6262    while ((node = node->previousLeafNode())) {
    63         if (!node->isContentEditable())
     63        if (!node->rendererIsEditable())
    6464            continue;
    6565        RenderObject* renderer = node->renderer();
    … …  
    346346{
    347347    Position nextPosition = downstream(CanCrossEditingBoundary);
    348     if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.deprecatedNode()->isContentEditable())
     348    if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.deprecatedNode()->rendererIsEditable())
    349349        return true;
    350350       
    351351    Position prevPosition = upstream(CanCrossEditingBoundary);
    352     if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->isContentEditable())
     352    if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->rendererIsEditable())
    353353        return true;
    354354       
    355     return nextPosition.isNotNull() && !nextPosition.deprecatedNode()->isContentEditable()
    356         && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->isContentEditable();
     355    return nextPosition.isNotNull() && !nextPosition.deprecatedNode()->rendererIsEditable()
     356        && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->rendererIsEditable();
    357357}
    358358
    … …  
    367367
    368368    Node* boundary = m_anchorNode.get();
    369     while (boundary != documentElement && boundary->parentNode() && m_anchorNode->isContentEditable() == boundary->parentNode()->isContentEditable())
     369    while (boundary != documentElement && boundary->parentNode() && m_anchorNode->rendererIsEditable() == boundary->parentNode()->rendererIsEditable())
    370370        boundary = boundary->parentNode();
    371371   
    … …  
    526526    PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? Position(m_anchorNode, caretMaxOffset(m_anchorNode.get())) : *this;
    527527    PositionIterator currentPos = lastVisible;
    528     bool startEditable = startNode->isContentEditable();
     528    bool startEditable = startNode->rendererIsEditable();
    529529    Node* lastNode = startNode;
    530530    bool boundaryCrossed = false;
    … …  
    533533       
    534534        // Don't check for an editability change if we haven't moved to a different node,
    535         // to avoid the expense of computing isContentEditable().
     535        // to avoid the expense of computing rendererIsEditable().
    536536        if (currentNode != lastNode) {
    537537            // Don't change editability.
    538             bool currentEditable = currentNode->isContentEditable();
     538            bool currentEditable = currentNode->rendererIsEditable();
    539539            if (startEditable != currentEditable) {
    540540                if (rule == CannotCrossEditingBoundary)
    … …  
    648648    PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? Position(m_anchorNode, caretMaxOffset(m_anchorNode.get())) : *this;
    649649    PositionIterator currentPos = lastVisible;
    650     bool startEditable = startNode->isContentEditable();
     650    bool startEditable = startNode->rendererIsEditable();
    651651    Node* lastNode = startNode;
    652652    bool boundaryCrossed = false;
    … …  
    655655       
    656656        // Don't check for an editability change if we haven't moved to a different node,
    657         // to avoid the expense of computing isContentEditable().
     657        // to avoid the expense of computing rendererIsEditable().
    658658        if (currentNode != lastNode) {
    659659            // Don't change editability.
    660             bool currentEditable = currentNode->isContentEditable();
     660            bool currentEditable = currentNode->rendererIsEditable();
    661661            if (startEditable != currentEditable) {
    662662                if (rule == CannotCrossEditingBoundary)
    … …  
    800800            if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(renderer))
    801801                return atFirstEditingPositionForNode() && !Position::nodeIsUserSelectNone(deprecatedNode());
    802             return m_anchorNode->isContentEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
     802            return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
    803803        }
    804804    } else
    805         return m_anchorNode->isContentEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
     805        return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
    806806
    807807    return false;

  • trunk/Source/WebCore/dom/PositionIterator.cpp

    r81374 r81965  
    170170            if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(renderer))
    171171                return atStartOfNode() && !Position::nodeIsUserSelectNone(m_anchorNode);
    172             return m_anchorNode->isContentEditable() && !Position::nodeIsUserSelectNone(m_anchorNode) && Position(*this).atEditingBoundary();
     172            return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(m_anchorNode) && Position(*this).atEditingBoundary();
    173173        }
    174174    }

  • trunk/Source/WebCore/editing/AppendNodeCommand.cpp

    r81185 r81965  
    4141    ASSERT(!m_node->parentNode());
    4242
    43     ASSERT(m_parent->isContentEditable() || !m_parent->attached());
     43    ASSERT(m_parent->rendererIsEditable() || !m_parent->attached());
    4444}
    4545
    … …  
    5757void AppendNodeCommand::doApply()
    5858{
    59     if (!m_parent->isContentEditable() && m_parent->attached())
     59    if (!m_parent->rendererIsEditable() && m_parent->attached())
    6060        return;
    6161       
    … …  
    6969void AppendNodeCommand::doUnapply()
    7070{
    71     if (!m_parent->isContentEditable())
     71    if (!m_parent->rendererIsEditable())
    7272        return;
    7373       

  • trunk/Source/WebCore/editing/ApplyStyleCommand.cpp

    r81374 r81965  
    10181018static bool containsNonEditableRegion(Node* node)
    10191019{
    1020     if (!node->isContentEditable())
     1020    if (!node->rendererIsEditable())
    10211021        return true;
    10221022
    10231023    Node* sibling = node->traverseNextSibling();
    10241024    for (Node* descendent = node->firstChild(); descendent && descendent != sibling; descendent = descendent->traverseNextNode()) {
    1025         if (!descendent->isContentEditable())
     1025        if (!descendent->rendererIsEditable())
    10261026            return true;
    10271027    }
    … …  
    10381038        next = node->traverseNextNode();
    10391039
    1040         if (!node->renderer() || !node->isContentEditable())
     1040        if (!node->renderer() || !node->rendererIsEditable())
    10411041            continue;
    10421042       
    1043         if (!node->isContentRichlyEditable() && node->isHTMLElement()) {
     1043        if (!node->rendererIsRichlyEditable() && node->isHTMLElement()) {
    10441044            // This is a plaintext-only region. Only proceed if it's fully selected.
    10451045            // pastEndNode is the node after the last fully selected node, so if it's inside node then
    … …  
    10601060       
    10611061        if (node->childNodeCount()) {
    1062             if (node->contains(pastEndNode) || containsNonEditableRegion(node) || !node->parentNode()->isContentEditable())
     1062            if (node->contains(pastEndNode) || containsNonEditableRegion(node) || !node->parentNode()->rendererIsEditable())
    10631063                continue;
    10641064            if (editingIgnoresContent(node)) {
    … …  
    11351135    ASSERT(element);
    11361136
    1137     if (!element->parentNode() || !element->parentNode()->isContentEditable())
     1137    if (!element->parentNode() || !element->parentNode()->rendererIsEditable())
    11381138        return false;
    11391139
    … …  
    16521652    RefPtr<Node> nextSibling = element->nextSibling();
    16531653    RefPtr<Node> previousSibling = element->previousSibling();
    1654     if (nextSibling && nextSibling->isElementNode() && nextSibling->isContentEditable()
     1654    if (nextSibling && nextSibling->isElementNode() && nextSibling->rendererIsEditable()
    16551655        && areIdenticalElements(element.get(), static_cast<Element*>(nextSibling.get())))
    16561656        mergeIdenticalElements(element.get(), static_cast<Element*>(nextSibling.get()));
    16571657
    1658     if (previousSibling && previousSibling->isElementNode() && previousSibling->isContentEditable()) {
     1658    if (previousSibling && previousSibling->isElementNode() && previousSibling->rendererIsEditable()) {
    16591659        Node* mergedElement = previousSibling->nextSibling();
    1660         if (mergedElement->isElementNode() && mergedElement->isContentEditable()
     1660        if (mergedElement->isElementNode() && mergedElement->rendererIsEditable()
    16611661            && areIdenticalElements(static_cast<Element*>(previousSibling.get()), static_cast<Element*>(mergedElement)))
    16621662            mergeIdenticalElements(static_cast<Element*>(previousSibling.get()), static_cast<Element*>(mergedElement));

  • trunk/Source/WebCore/editing/CompositeEditCommand.cpp

    r81185 r81965  
    10491049    if (!listNode
    10501050        || (!listNode->hasTagName(ulTag) && !listNode->hasTagName(olTag))
    1051         || !listNode->isContentEditable()
     1051        || !listNode->rendererIsEditable()
    10521052        || listNode == emptyListItem->rootEditableElement())
    10531053        return false;

  • trunk/Source/WebCore/editing/DeleteButtonController.cpp

    r78150 r81965  
    6464static bool isDeletableElement(const Node* node)
    6565{
    66     if (!node || !node->isHTMLElement() || !node->inDocument() || !node->isContentEditable())
     66    if (!node || !node->isHTMLElement() || !node->inDocument() || !node->rendererIsEditable())
    6767        return false;
    6868
    … …  
    157157    // The enclosingNodeOfType function only works on nodes that are editable
    158158    // (which is strange, given its name).
    159     if (!container->isContentEditable())
     159    if (!container->rendererIsEditable())
    160160        return 0;
    161161

  • trunk/Source/WebCore/editing/DeleteFromTextNodeCommand.cpp

    r68078 r81965  
    4747    ASSERT(m_node);
    4848
    49     if (!m_node->isContentEditable())
     49    if (!m_node->rendererIsEditable())
    5050        return;
    5151
    … …  
    6666    ASSERT(m_node);
    6767
    68     if (!m_node->isContentEditable())
     68    if (!m_node->rendererIsEditable())
    6969        return;
    7070       

  • trunk/Source/WebCore/editing/DeleteSelectionCommand.cpp

    r81295 r81965  
    343343    if (m_startRoot != m_endRoot && !(node->isDescendantOf(m_startRoot.get()) && node->isDescendantOf(m_endRoot.get()))) {
    344344        // If a node is not in both the start and end editable roots, remove it only if its inside an editable region.
    345         if (!node->parentNode()->isContentEditable()) {
     345        if (!node->parentNode()->rendererIsEditable()) {
    346346            // Don't remove non-editable atomic nodes.
    347347            if (!node->firstChild())

  • trunk/Source/WebCore/editing/Editor.cpp

    r81855 r81965  
    290290        return false;
    291291   
    292     if (!startContainer->isContentEditable() || !endContainer->isContentEditable())
     292    if (!startContainer->rendererIsEditable() || !endContainer->rendererIsEditable())
    293293        return false;
    294294   
    … …  
    21602160    // If we're not in an editable node, bail.
    21612161    Node* editableNode = searchRange->startContainer();
    2162     if (!editableNode || !editableNode->isContentEditable())
     2162    if (!editableNode || !editableNode->rendererIsEditable())
    21632163        return;
    21642164
    … …  
    22252225    // If we're not in an editable node, bail.
    22262226    Node* editableNode = spellingRange->startContainer();
    2227     if (!editableNode || !editableNode->isContentEditable())
     2227    if (!editableNode || !editableNode->rendererIsEditable())
    22282228        return;
    22292229

  • trunk/Source/WebCore/editing/EditorCommand.cpp

    r81847 r81965  
    255255    if (!style)
    256256        return 0;
    257     if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || focusedNode->isContentEditable()))
     257    if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || focusedNode->rendererIsEditable()))
    258258        return 0;
    259259    int height = std::min<int>(toRenderBox(renderer)->clientHeight(),

  • trunk/Source/WebCore/editing/FormatBlockCommand.cpp

    r79196 r81965  
    150150    Node* lastBlock = startNode;
    151151    for (Node* n = startNode; n; n = n->parentNode()) {
    152         if (!n->isContentEditable())
     152        if (!n->rendererIsEditable())
    153153            return lastBlock;
    154         if (isTableCell(n) || n->hasTagName(bodyTag) || !n->parentNode() || !n->parentNode()->isContentEditable() || isElementForFormatBlock(n))
     154        if (isTableCell(n) || n->hasTagName(bodyTag) || !n->parentNode() || !n->parentNode()->rendererIsEditable() || isElementForFormatBlock(n))
    155155            return n;
    156156        if (isBlock(n))
    157157            lastBlock = n;
    158158        if (isListElement(n))
    159             return n->parentNode()->isContentEditable() ? n->parentNode() : n;
     159            return n->parentNode()->rendererIsEditable() ? n->parentNode() : n;
    160160    }
    161161    return lastBlock;

  • trunk/Source/WebCore/editing/IndentOutdentCommand.cpp

    r79196 r81965  
    121121
    122122    Node* enclosingNode = enclosingNodeOfType(visibleStartOfParagraph.deepEquivalent(), &isListOrIndentBlockquote);
    123     if (!enclosingNode || !enclosingNode->parentNode()->isContentEditable()) // We can't outdent if there is no place to go!
     123    if (!enclosingNode || !enclosingNode->parentNode()->rendererIsEditable()) // We can't outdent if there is no place to go!
    124124        return;
    125125
    … …  
    152152                if (splitPointParent->hasTagName(blockquoteTag)
    153153                    && !splitPoint->hasTagName(blockquoteTag)
    154                     && splitPointParent->parentNode()->isContentEditable()) // We can't outdent if there is no place to go!
     154                    && splitPointParent->parentNode()->rendererIsEditable()) // We can't outdent if there is no place to go!
    155155                    splitElement(static_cast<Element*>(splitPointParent), splitPoint);
    156156            }

  • trunk/Source/WebCore/editing/InsertIntoTextNodeCommand.cpp

    r68078 r81965  
    4545void InsertIntoTextNodeCommand::doApply()
    4646{
    47     if (!m_node->isContentEditable())
     47    if (!m_node->rendererIsEditable())
    4848        return;
    4949   
    … …  
    5757void InsertIntoTextNodeCommand::doUnapply()
    5858{
    59     if (!m_node->isContentEditable())
     59    if (!m_node->rendererIsEditable())
    6060        return;
    6161       

  • trunk/Source/WebCore/editing/InsertNodeBeforeCommand.cpp

    r69868 r81965  
    4242    ASSERT(m_refChild->parentNode());
    4343
    44     ASSERT(m_refChild->parentNode()->isContentEditable() || !m_refChild->parentNode()->attached());
     44    ASSERT(m_refChild->parentNode()->rendererIsEditable() || !m_refChild->parentNode()->attached());
    4545}
    4646
    … …  
    4848{
    4949    ContainerNode* parent = m_refChild->parentNode();
    50     if (!parent || !parent->isContentEditable())
     50    if (!parent || !parent->rendererIsEditable())
    5151        return;
    5252
    … …  
    6060void InsertNodeBeforeCommand::doUnapply()
    6161{
    62     if (!m_insertChild->isContentEditable())
     62    if (!m_insertChild->rendererIsEditable())
    6363        return;
    6464       

  • trunk/Source/WebCore/editing/JoinTextNodesCommand.cpp

    r69868 r81965  
    4747
    4848    ContainerNode* parent = m_text2->parentNode();
    49     if (!parent || !parent->isContentEditable())
     49    if (!parent || !parent->rendererIsEditable())
    5050        return;
    5151   
    … …  
    6464
    6565    ContainerNode* parent = m_text2->parentNode();
    66     if (!parent || !parent->isContentEditable())
     66    if (!parent || !parent->rendererIsEditable())
    6767        return;
    6868

  • trunk/Source/WebCore/editing/MergeIdenticalElementsCommand.cpp

    r72259 r81965  
    4343void MergeIdenticalElementsCommand::doApply()
    4444{
    45     if (m_element1->nextSibling() != m_element2 || !m_element1->isContentEditable() || !m_element2->isContentEditable())
     45    if (m_element1->nextSibling() != m_element2 || !m_element1->rendererIsEditable() || !m_element2->rendererIsEditable())
    4646        return;
    4747
    … …  
    6969
    7070    ContainerNode* parent = m_element2->parentNode();
    71     if (!parent || !parent->isContentEditable())
     71    if (!parent || !parent->rendererIsEditable())
    7272        return;
    7373

  • trunk/Source/WebCore/editing/RemoveNodeCommand.cpp

    r69868 r81965  
    4343{
    4444    ContainerNode* parent = m_node->parentNode();
    45     if (!parent || !parent->isContentEditable())
     45    if (!parent || !parent->rendererIsEditable())
    4646        return;
    4747
    … …  
    5757    RefPtr<ContainerNode> parent = m_parent.release();
    5858    RefPtr<Node> refChild = m_refChild.release();
    59     if (!parent || !parent->isContentEditable())
     59    if (!parent || !parent->rendererIsEditable())
    6060        return;
    6161

  • trunk/Source/WebCore/editing/ReplaceSelectionCommand.cpp

    r81887 r81965  
    149149        // FIXME: Remove these checks once textareas and textfields actually register an event handler.
    150150        !(shadowAncestorNode && shadowAncestorNode->renderer() && shadowAncestorNode->renderer()->isTextControl()) &&
    151         editableRoot->isContentRichlyEditable()) {
     151        editableRoot->rendererIsRichlyEditable()) {
    152152        removeInterchangeNodes(m_fragment.get());
    153153        return;
    … …  
    164164    editableRoot->dispatchEvent(evt, ec);
    165165    ASSERT(ec == 0);
    166     if (text != evt->text() || !editableRoot->isContentRichlyEditable()) {
     166    if (text != evt->text() || !editableRoot->rendererIsRichlyEditable()) {
    167167        restoreTestRenderingNodesToFragment(holder.get());
    168168        removeNode(holder);

  • trunk/Source/WebCore/editing/SelectionController.cpp

    r81600 r81965  
    13631363       
    13641364    // 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.
    1365     if (!ownerElementParent->isContentEditable())
     1365    if (!ownerElementParent->rendererIsEditable())
    13661366        return;
    13671367
    … …  
    18251825    Document* document = m_frame->document();
    18261826    bool caretBrowsing = m_frame->settings() && m_frame->settings()->caretBrowsingEnabled();
    1827     if (!isNone() || !(document->isContentEditable() || caretBrowsing))
     1827    if (!isNone() || !(document->rendererIsEditable() || caretBrowsing))
    18281828        return;
    18291829

  • trunk/Source/WebCore/editing/SplitElementCommand.cpp

    r69868 r81965  
    5555   
    5656    ContainerNode* parent = m_element2->parentNode();
    57     if (!parent || !parent->isContentEditable())
     57    if (!parent || !parent->rendererIsEditable())
    5858        return;
    5959    parent->insertBefore(m_element1.get(), m_element2.get(), ec);
    … …  
    7979void SplitElementCommand::doUnapply()
    8080{
    81     if (!m_element1 || !m_element1->isContentEditable() || !m_element2->isContentEditable())
     81    if (!m_element1 || !m_element1->rendererIsEditable() || !m_element2->rendererIsEditable())
    8282        return;
    8383

  • trunk/Source/WebCore/editing/SplitTextNodeCommand.cpp

    r74969 r81965  
    5252{
    5353    ContainerNode* parent = m_text2->parentNode();
    54     if (!parent || !parent->isContentEditable())
     54    if (!parent || !parent->rendererIsEditable())
    5555        return;
    5656
    … …  
    6969void SplitTextNodeCommand::doUnapply()
    7070{
    71     if (!m_text1 || !m_text1->isContentEditable())
     71    if (!m_text1 || !m_text1->rendererIsEditable())
    7272        return;
    7373
    … …  
    9090
    9191    ContainerNode* parent = m_text2->parentNode();
    92     if (!parent || !parent->isContentEditable())
     92    if (!parent || !parent->rendererIsEditable())
    9393        return;
    9494

  • trunk/Source/WebCore/editing/SplitTextNodeContainingElementCommand.cpp

    r64083 r81965  
    4949
    5050    Element* parent = m_text->parentElement();
    51     if (!parent || !parent->parentElement() || !parent->parentElement()->isContentEditable())
     51    if (!parent || !parent->parentElement() || !parent->parentElement()->rendererIsEditable())
    5252        return;
    5353

  • trunk/Source/WebCore/editing/VisiblePosition.cpp

    r80766 r81965  
    474474    // The new position must be in the same editable element. Enforce that first.
    475475    // Unless the descent is from a non-editable html element to an editable body.
    476     if (node && node->hasTagName(htmlTag) && !node->isContentEditable() && node->document()->body() && node->document()->body()->isContentEditable())
     476    if (node && node->hasTagName(htmlTag) && !node->rendererIsEditable() && node->document()->body() && node->document()->body()->rendererIsEditable())
    477477        return next.isNotNull() ? next : prev;
    478478

  • trunk/Source/WebCore/editing/WrapContentsInDummySpanCommand.cpp

    r51645 r81965  
    6565    ASSERT(m_element);
    6666
    67     if (!m_dummySpan || !m_element->isContentEditable())
     67    if (!m_dummySpan || !m_element->rendererIsEditable())
    6868        return;
    6969
    … …  
    8585    ASSERT(m_element);
    8686   
    87     if (!m_dummySpan || !m_element->isContentEditable())
     87    if (!m_dummySpan || !m_element->rendererIsEditable())
    8888        return;
    8989

  • trunk/Source/WebCore/editing/htmlediting.cpp

    r81537 r81965  
    144144    node = highestRoot;
    145145    while (node) {
    146         if (node->isContentEditable())
     146        if (node->rendererIsEditable())
    147147            highestRoot = node;
    148148        if (node->hasTagName(bodyTag))
    … …  
    161161    Node *lowestRoot = 0;
    162162    while (node) {
    163         if (node->isContentEditable())
     163        if (node->rendererIsEditable())
    164164            return node->rootEditableElement();
    165165        if (node->hasTagName(bodyTag))
    … …  
    180180        node = node->parentNode();
    181181   
    182     return node->isContentEditable();
     182    return node->rendererIsEditable();
    183183}
    184184
    … …  
    199199        node = node->parentNode();
    200200   
    201     return node->isContentRichlyEditable();
     201    return node->rendererIsRichlyEditable();
    202202}
    203203
    … …  
    277277{
    278278    // position falls before highestRoot.
    279     if (comparePositions(position, firstPositionInNode(highestRoot)) == -1 && highestRoot->isContentEditable())
     279    if (comparePositions(position, firstPositionInNode(highestRoot)) == -1 && highestRoot->rendererIsEditable())
    280280        return firstPositionInNode(highestRoot);
    281281
    … …  
    562562    Node* highestNode = 0;
    563563    // traverse through ancestors as long as they are contained within the range, content-editable, and below rootNode (could be =0).
    564     while (ancestor && ancestor->isContentEditable() && isNodeVisiblyContainedWithin(ancestor, maximumRange) && ancestor != rootNode) {
     564    while (ancestor && ancestor->rendererIsEditable() && isNodeVisiblyContainedWithin(ancestor, maximumRange) && ancestor != rootNode) {
    565565        highestNode = ancestor;
    566566        ancestor = ancestor->parentNode();
    … …  
    593593    Node* root = highestEditableRoot(p);
    594594    for (Node* n = p.deprecatedNode(); n; n = n->parentNode()) {
    595         if (root && !n->isContentEditable())
     595        if (root && !n->rendererIsEditable())
    596596            continue;
    597597        if (n->hasTagName(tagName))
    … …  
    615615        // Don't return a non-editable node if the input position was editable, since
    616616        // the callers from editing will no doubt want to perform editing inside the returned node.
    617         if (root && !n->isContentEditable())
     617        if (root && !n->rendererIsEditable())
    618618            continue;
    619619        if (nodeIsOfType(n))
    … …  
    631631    Node* root = rule == CannotCrossEditingBoundary ? highestEditableRoot(p) : 0;
    632632    for (Node* n = p.deprecatedNode(); n; n = n->parentNode()) {
    633         if (root && !n->isContentEditable())
     633        if (root && !n->rendererIsEditable())
    634634            continue;
    635635        if (nodeIsOfType(n))
    … …  
    759759
    760760    return firstList->hasTagName(secondList->tagQName())// make sure the list types match (ol vs. ul)
    761     && firstList->isContentEditable() && secondList->isContentEditable()// both lists are editable
     761    && firstList->rendererIsEditable() && secondList->rendererIsEditable() // both lists are editable
    762762    && firstList->rootEditableElement() == secondList->rootEditableElement()// don't cross editing boundaries
    763763    && isVisiblyAdjacent(positionInParentAfterNode(firstList), positionInParentBeforeNode(secondList));

  • trunk/Source/WebCore/editing/visible_units.cpp

    r81374 r81965  
    478478static Node* previousLeafWithSameEditability(Node* node)
    479479{
    480     bool editable = node->isContentEditable();
     480    bool editable = node->rendererIsEditable();
    481481    Node* n = node->previousLeafNode();
    482482    while (n) {
    483         if (editable == n->isContentEditable())
     483        if (editable == n->rendererIsEditable())
    484484            return n;
    485485        n = n->previousLeafNode();
    … …  
    573573    // Move to the start of the content in this block, which effectively moves us
    574574    // to the start of the line we're on.
    575     Element* rootElement = node->isContentEditable() ? node->rootEditableElement() : node->document()->documentElement();
     575    Element* rootElement = node->rendererIsEditable() ? node->rootEditableElement() : node->document()->documentElement();
    576576    if (!rootElement)
    577577        return VisiblePosition();
    … …  
    581581static Node* nextLeafWithSameEditability(Node* node, int offset)
    582582{
    583     bool editable = node->isContentEditable();
     583    bool editable = node->rendererIsEditable();
    584584    ASSERT(offset >= 0);
    585585    Node* child = node->childNode(offset);
    586586    Node* n = child ? child->nextLeafNode() : node->lastDescendant()->nextLeafNode();
    587587    while (n) {
    588         if (editable == n->isContentEditable())
     588        if (editable == n->rendererIsEditable())
    589589            return n;
    590590        n = n->nextLeafNode();
    … …  
    598598        return 0;
    599599   
    600     bool editable = node->isContentEditable();
     600    bool editable = node->rendererIsEditable();
    601601    Node* n = node->nextLeafNode();
    602602    while (n) {
    603         if (editable == n->isContentEditable())
     603        if (editable == n->rendererIsEditable())
    604604            return n;
    605605        n = n->nextLeafNode();
    … …  
    680680    // Move to the end of the content in this block, which effectively moves us
    681681    // to the end of the line we're on.
    682     Element* rootElement = node->isContentEditable() ? node->rootEditableElement() : node->document()->documentElement();
     682    Element* rootElement = node->rendererIsEditable() ? node->rootEditableElement() : node->document()->documentElement();
    683683    if (!rootElement)
    684684        return VisiblePosition();
    … …  
    760760    Node* n = startNode;
    761761    while (n) {
    762         if (boundaryCrossingRule == CannotCrossEditingBoundary && n->isContentEditable() != startNode->isContentEditable())
     762        if (boundaryCrossingRule == CannotCrossEditingBoundary && n->rendererIsEditable() != startNode->rendererIsEditable())
    763763            break;
    764764        if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
    765             while (n && n->isContentEditable() != startNode->isContentEditable())
     765            while (n && n->rendererIsEditable() != startNode->rendererIsEditable())
    766766                n = n->traversePreviousNodePostOrder(startBlock);
    767767            if (!n || !n->isDescendantOf(highestRoot))
    … …  
    832832    Node* n = startNode;
    833833    while (n) {
    834         if (boundaryCrossingRule == CannotCrossEditingBoundary && n->isContentEditable() != startNode->isContentEditable())
     834        if (boundaryCrossingRule == CannotCrossEditingBoundary && n->rendererIsEditable() != startNode->rendererIsEditable())
    835835            break;
    836836        if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
    837             while (n && n->isContentEditable() != startNode->isContentEditable())
     837            while (n && n->rendererIsEditable() != startNode->rendererIsEditable())
    838838                n = n->traverseNextNode(stayInsideBlock);
    839839            if (!n || !n->isDescendantOf(highestRoot))

  • trunk/Source/WebCore/html/HTMLAnchorElement.cpp

    r77329 r81965  
    7373bool HTMLAnchorElement::supportsFocus() const
    7474{
    75     if (isContentEditable())
     75    if (rendererIsEditable())
    7676        return HTMLElement::supportsFocus();
    7777    // If not a link we should still be able to focus the element if it has tabIndex.
    … …  
    155155        }
    156156
    157         if (isContentEditable()) {
     157        if (rendererIsEditable()) {
    158158            // This keeps track of the editable block that the selection was in (if it was in one) just before the link was clicked
    159159            // for the LiveWhenNotFocused editable link behavior
    … …  
    175175void HTMLAnchorElement::setActive(bool down, bool pause)
    176176{
    177     if (isContentEditable()) {
     177    if (rendererIsEditable()) {
    178178        EditableLinkBehavior editableLinkBehavior = EditableLinkDefaultBehavior;
    179179        if (Settings* settings = document()->settings())
    … …  
    248248    if (!isLink())
    249249        return HTMLElement::canStartSelection();
    250     return isContentEditable();
     250    return rendererIsEditable();
    251251}
    252252
    … …  
    502502bool HTMLAnchorElement::treatLinkAsLiveForEventType(EventType eventType) const
    503503{
    504     if (!isContentEditable())
     504    if (!rendererIsEditable())
    505505        return true;
    506506

  • trunk/Source/WebCore/html/HTMLBodyElement.cpp

    r79208 r81965  
    211211bool HTMLBodyElement::supportsFocus() const
    212212{
    213     return isContentEditable() || HTMLElement::supportsFocus();
     213    return rendererIsEditable() || HTMLElement::supportsFocus();
    214214}
    215215

  • trunk/Source/WebCore/html/HTMLElement.cpp

    r81220 r81965  
    655655bool HTMLElement::supportsFocus() const
    656656{
    657     return Element::supportsFocus() || (isContentEditable() && parentNode() && !parentNode()->isContentEditable());
    658 }
    659 
    660 String HTMLElement::contentEditable() const
     657    return Element::supportsFocus() || (rendererIsEditable() && parentNode() && !parentNode()->rendererIsEditable());
     658}
     659
     660bool HTMLElement::isContentEditable() const
     661{
     662    return rendererIsEditable();
     663}
     664
     665String HTMLElement::contentEditable() const
    661666{
    662667    const AtomicString& value = fastGetAttribute(contenteditableAttr);

  • trunk/Source/WebCore/html/HTMLElement.h

    r81220 r81965  
    5757
    5858    virtual bool supportsFocus() const;
     59
     60    bool isContentEditable() const;
    5961
    6062    String contentEditable() const;

  • trunk/Source/WebCore/page/DragController.cpp

    r81600 r81965  
    354354    ASSERT(dragData);
    355355    Document* doc = m_page->mainFrame()->documentAtPoint(dragData->clientPosition());
    356     if (doc && (m_didInitiateDrag || doc->isPluginDocument() || doc->isContentEditable()))
     356    if (doc && (m_didInitiateDrag || doc->isPluginDocument() || doc->rendererIsEditable()))
    357357        return DragOperationNone;
    358358    return dragOperation(dragData);
    … …  
    512512        return true;
    513513
    514     if (!result.innerNonSharedNode()->isContentEditable())
     514    if (!result.innerNonSharedNode()->rendererIsEditable())
    515515        return false;
    516516

  • trunk/Source/WebCore/page/EventHandler.cpp

    r81835 r81965  
    724724        Node* node = event.targetNode();
    725725        bool caretBrowsing = m_frame->settings()->caretBrowsingEnabled();
    726         if (node && (caretBrowsing || node->isContentEditable()) && node->renderer()) {
     726        if (node && (caretBrowsing || node->rendererIsEditable()) && node->renderer()) {
    727727            VisiblePosition pos = node->renderer()->positionForPoint(event.localPoint());
    728728            newSelection = VisibleSelection(pos);
    … …  
    11761176    switch (style ? style->cursor() : CURSOR_AUTO) {
    11771177    case CURSOR_AUTO: {
    1178         bool editable = (node && node->isContentEditable());
     1178        bool editable = (node && node->rendererIsEditable());
    11791179        bool editableLinkEnabled = false;
    11801180

  • trunk/Source/WebCore/page/FocusController.cpp

    r81209 r81965  
    302302{
    303303    ASSERT(node);
    304     ASSERT(node->isContentEditable());
     304    ASSERT(node->rendererIsEditable());
    305305
    306306    Node* root = node->rootEditableElement();

  • trunk/Source/WebCore/rendering/HitTestResult.cpp

    r78846 r81965  
    526526        return static_cast<HTMLInputElement*>(m_innerNonSharedNode.get())->isTextField();
    527527
    528     return m_innerNonSharedNode->isContentEditable();
     528    return m_innerNonSharedNode->rendererIsEditable();
    529529}
    530530

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r81816 r81965  
    40554055
    40564056    // If we can't find an ancestor to check editability on, or editability is unchanged, we recur like normal
    4057     if (!ancestor || ancestor->node()->isContentEditable() == childNode->isContentEditable())
     4057    if (!ancestor || ancestor->node()->rendererIsEditable() == childNode->rendererIsEditable())
    40584058        return child->positionForPoint(pointInChildCoordinates);
    40594059
    … …  
    50815081        return false;
    50825082   
    5083     if (node()->isContentEditable() && node()->rootEditableElement() == node())
     5083    if (node()->rendererIsEditable() && node()->rootEditableElement() == node())
    50845084        return true;
    50855085   

  • trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp

    r81794 r81965  
    21232123    int endPadding = hasOverflowClip() ? paddingEnd() : 0;
    21242124    // FIXME: Need to find another way to do this, since scrollbars could show when we don't want them to.
    2125     if (hasOverflowClip() && !endPadding && node() && node()->isContentEditable() && node() == node()->rootEditableElement() && style()->isLeftToRightDirection())
     2125    if (hasOverflowClip() && !endPadding && node() && node()->rendererIsEditable() && node() == node()->rootEditableElement() && style()->isLeftToRightDirection())
    21262126        endPadding = 1;
    21272127    for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {

  • trunk/Source/WebCore/rendering/RenderBox.cpp

    r81816 r81965  
    642642bool RenderBox::canBeProgramaticallyScrolled(bool) const
    643643{
    644     return (hasOverflowClip() && (scrollsOverflow() || (node() && node()->isContentEditable()))) || (node() && node()->isDocumentNode());
     644    return (hasOverflowClip() && (scrollsOverflow() || (node() && node()->rendererIsEditable()))) || (node() && node()->isDocumentNode());
    645645}
    646646

  • trunk/Source/WebCore/rendering/RenderObject.cpp

    r81816 r81965  
    26462646    // If this is a non-anonymous renderer in an editable area, then it's simple.
    26472647    if (Node* node = this->node()) {
    2648         if (!node->isContentEditable()) {
     2648        if (!node->rendererIsEditable()) {
    26492649            // If it can be found, we prefer a visually equivalent position that is editable.
    26502650            Position position(node, offset);
    26512651            Position candidate = position.downstream(CanCrossEditingBoundary);
    2652             if (candidate.deprecatedNode()->isContentEditable())
     2652            if (candidate.deprecatedNode()->rendererIsEditable())
    26532653                return VisiblePosition(candidate, affinity);
    26542654            candidate = position.upstream(CanCrossEditingBoundary);
    2655             if (candidate.deprecatedNode()->isContentEditable())
     2655            if (candidate.deprecatedNode()->rendererIsEditable())
    26562656                return VisiblePosition(candidate, affinity);
    26572657        }

  • trunk/Source/WebCore/rendering/RootInlineBox.cpp

    r81716 r81965  
    463463static bool isEditableLeaf(InlineBox* leaf)
    464464{
    465     return leaf && leaf->renderer() && leaf->renderer()->node() && leaf->renderer()->node()->isContentEditable();
     465    return leaf && leaf->renderer() && leaf->renderer()->node() && leaf->renderer()->node()->rendererIsEditable();
    466466}
    467467

  • trunk/Source/WebCore/svg/SVGAElement.cpp

    r78345 r81965  
    196196bool SVGAElement::supportsFocus() const
    197197{
    198     if (isContentEditable())
     198    if (rendererIsEditable())
    199199        return SVGStyledTransformableElement::supportsFocus();
    200200    return true;

  • trunk/Source/WebKit/chromium/ChangeLog

    r81955 r81965  
     12011-03-25  Chang Shu  <cshu@webkit.org>
     2
     3        Reviewed by Ryosuke Niwa.
     4
     5        rename Node::isContentEditable and all call sites to rendererIsEditable
     6        https://bugs.webkit.org/show_bug.cgi?id=54290
     7
     8        This is part of the effort to separate JS API HTMLElement isContentEditable from
     9        internal Node::rendererIsEditable.
     10
     11        * src/WebNode.cpp:
     12        (WebKit::WebNode::isContentEditable):
     13        * src/WebViewImpl.cpp:
     14        (WebKit::WebViewImpl::setFocus):
     15        (WebKit::WebViewImpl::setComposition):
     16        (WebKit::WebViewImpl::confirmComposition):
     17
    1182011-03-25  Mikhail Naganov  <mnaganov@chromium.org>
    219

  • trunk/Source/WebKit/chromium/src/WebNode.cpp

    r81873 r81965  
    153153bool WebNode::isContentEditable() const
    154154{
    155     return m_private->isContentEditable();
     155    return m_private->rendererIsEditable();
    156156}
    157157

  • trunk/Source/WebKit/chromium/src/WebViewImpl.cpp

    r81881 r81965  
    12571257                if (element->isTextFormControl())
    12581258                    element->updateFocusAppearance(true);
    1259                 else if (focusedNode->isContentEditable()) {
     1259                else if (focusedNode->rendererIsEditable()) {
    12601260                    // updateFocusAppearance() selects all the text of
    12611261                    // contentseditable DIVs. So we set the selection explicitly
    … …  
    13191319    if (range) {
    13201320        const Node* node = range->startContainer();
    1321         if (!node || !node->isContentEditable())
     1321        if (!node || !node->rendererIsEditable())
    13221322            return false;
    13231323    }
    … …  
    13681368    if (range) {
    13691369        const Node* node = range->startContainer();
    1370         if (!node || !node->isContentEditable())
     1370        if (!node || !node->rendererIsEditable())
    13711371            return false;
    13721372    }

  • trunk/Source/WebKit/haiku/ChangeLog

    r81933 r81965  
     12011-03-25  Chang Shu  <cshu@webkit.org>
     2
     3        Reviewed by Ryosuke Niwa.
     4
     5        rename Node::isContentEditable and all call sites to rendererIsEditable
     6        https://bugs.webkit.org/show_bug.cgi?id=54290
     7
     8        This is part of the effort to separate JS API HTMLElement isContentEditable from
     9        internal Node::rendererIsEditable.
     10
     11        * WebCoreSupport/EditorClientHaiku.cpp:
     12        (WebCore::EditorClientHaiku::handleKeyboardEvent):
     13
    1142011-03-24  Sheriff Bot  <webkit.review.bot@gmail.com>
    215

  • trunk/Source/WebKit/haiku/WebCoreSupport/EditorClientHaiku.cpp

    r79953 r81965  
    255255        return;
    256256
    257     if (start->isContentEditable()) {
     257    if (start->rendererIsEditable()) {
    258258        switch (kevent->windowsVirtualKeyCode()) {
    259259        case VK_BACK:

  • trunk/Source/WebKit/qt/ChangeLog

    r81959 r81965  
     12011-03-25  Chang Shu  <cshu@webkit.org>
     2
     3        Reviewed by Ryosuke Niwa.
     4
     5        rename Node::isContentEditable and all call sites to rendererIsEditable
     6        https://bugs.webkit.org/show_bug.cgi?id=54290
     7
     8        This is part of the effort to separate JS API HTMLElement isContentEditable from
     9        internal Node::rendererIsEditable.
     10
     11        * WebCoreSupport/EditorClientQt.cpp:
     12        (WebCore::EditorClientQt::handleKeyboardEvent):
     13
    1142011-03-25  Alexis Menard  <alexis.menard@openbossa.org>
    215

  • trunk/Source/WebKit/qt/WebCoreSupport/EditorClientQt.cpp

    r79953 r81965  
    421421
    422422    // FIXME: refactor all of this to use Actions or something like them
    423     if (start->isContentEditable()) {
     423    if (start->rendererIsEditable()) {
    424424        bool doSpatialNavigation = false;
    425425        if (isSpatialNavigationEnabled(frame)) {
Note: See TracChangeset for help on using the changeset viewer.