2011-02-17 Ryosuke Niwa <rniwa@webkit.org>
authorrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 21 Feb 2011 09:28:48 +0000 (09:28 +0000)
committerrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 21 Feb 2011 09:28:48 +0000 (09:28 +0000)
        Reviewed by Kent Tamura.

        Rename Position::node() to Position::deprecatedNode()
        https://bugs.webkit.org/show_bug.cgi?id=54622

        Done the rename. All calls to node() are replaced by calls to deprecatedNode().

        * src/WebViewImpl.cpp:
        (WebKit::WebViewImpl::setComposition): Check the nullity of startContainer() instead of startPosition()->node().
        (WebKit::WebViewImpl::confirmComposition): Ditto.
        (WebKit::WebViewImpl::textInputType):
        (WebKit::WebViewImpl::caretOrSelectionBounds):
2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>

        Reviewed by Kent Tamura.

        Rename Position::node() to Position::deprecatedNode()
        https://bugs.webkit.org/show_bug.cgi?id=54622

        Replaced the call to node() by a call to containerNode() because the returned node is
        used to determine whether or not the selected contents are editable and such a check
        must be done against the container node.

        * WebCoreSupport/EditorClientQt.cpp:
        (WebCore::EditorClientQt::handleKeyboardEvent):
2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>

        Reviewed by Kent Tamura.

        Rename Position::node() to Position::deprecatedNode()
        https://bugs.webkit.org/show_bug.cgi?id=54622

        Done the rename. All calls to node() are replaced by calls to deprecatedNode().

        * webkit/webkitwebview.cpp:
        (webkit_web_view_popup_menu_handler):
2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>

        Reviewed by Kent Tamura.

        Rename Position::node() to Position::deprecatedNode()
        https://bugs.webkit.org/show_bug.cgi?id=54622

        * WebView/WebFrame.mm:
        (-[WebFrame _smartDeleteRangeForProposedRange:]):
2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>

        Reviewed by Kent Tamura.

        Rename Position::node() to Position::deprecatedNode()
        https://bugs.webkit.org/show_bug.cgi?id=54622

        Replaced the call to node() by a call to containerNode() because the returned node is
        used to determine whether or not the selected contents are editable and such a check
        must be done against the container node.

        * WebCoreSupport/EditorClientHaiku.cpp:
        (WebCore::EditorClientHaiku::handleKeyboardEvent):
2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>

        Reviewed by Kent Tamura.

        Rename Position::node() to Position::deprecatedNode()
        https://bugs.webkit.org/show_bug.cgi?id=54622

        Done the rename. All calls to node() are replaced by calls to deprecatedNode() except when
        calls were of the form node()->document() and node()->inDocument() in which case they were
        replaced by anchorNode()->document() and anchorNode()->inDocument() respectively.

        * WebCore.exp.in: Added Position::containerNode.

        The rest abbreviated for simplicity. Please see svn log.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@79196 268f45cc-cd09-0410-ab3c-d52691b4dbfc

55 files changed:
Source/WebCore/ChangeLog
Source/WebCore/WebCore.exp.in
Source/WebCore/accessibility/AXObjectCache.cpp
Source/WebCore/accessibility/AccessibilityObject.cpp
Source/WebCore/accessibility/AccessibilityRenderObject.cpp
Source/WebCore/accessibility/gtk/AccessibilityObjectWrapperAtk.cpp
Source/WebCore/dom/Position.cpp
Source/WebCore/dom/Position.h
Source/WebCore/editing/ApplyBlockElementCommand.cpp
Source/WebCore/editing/ApplyStyleCommand.cpp
Source/WebCore/editing/BreakBlockquoteCommand.cpp
Source/WebCore/editing/CompositeEditCommand.cpp
Source/WebCore/editing/DeleteSelectionCommand.cpp
Source/WebCore/editing/EditingStyle.cpp
Source/WebCore/editing/Editor.cpp
Source/WebCore/editing/FormatBlockCommand.cpp
Source/WebCore/editing/IndentOutdentCommand.cpp
Source/WebCore/editing/InsertLineBreakCommand.cpp
Source/WebCore/editing/InsertListCommand.cpp
Source/WebCore/editing/InsertParagraphSeparatorCommand.cpp
Source/WebCore/editing/InsertTextCommand.cpp
Source/WebCore/editing/ModifySelectionListLevel.cpp
Source/WebCore/editing/MoveSelectionCommand.cpp
Source/WebCore/editing/ReplaceSelectionCommand.cpp
Source/WebCore/editing/SelectionController.cpp
Source/WebCore/editing/SetSelectionCommand.cpp
Source/WebCore/editing/TextIterator.cpp
Source/WebCore/editing/TypingCommand.cpp
Source/WebCore/editing/VisiblePosition.cpp
Source/WebCore/editing/VisiblePosition.h
Source/WebCore/editing/VisibleSelection.cpp
Source/WebCore/editing/chromium/SelectionControllerChromium.cpp
Source/WebCore/editing/gtk/SelectionControllerGtk.cpp
Source/WebCore/editing/htmlediting.cpp
Source/WebCore/editing/mac/EditorMac.mm
Source/WebCore/editing/mac/SelectionControllerMac.mm
Source/WebCore/editing/markup.cpp
Source/WebCore/editing/visible_units.cpp
Source/WebCore/page/DOMSelection.cpp
Source/WebCore/page/DragController.cpp
Source/WebCore/page/EventHandler.cpp
Source/WebCore/page/FocusController.cpp
Source/WebCore/rendering/RenderObject.cpp
Source/WebCore/rendering/RenderTextControl.cpp
Source/WebCore/rendering/RenderTreeAsText.cpp
Source/WebKit/chromium/ChangeLog
Source/WebKit/chromium/src/WebViewImpl.cpp
Source/WebKit/gtk/ChangeLog
Source/WebKit/gtk/webkit/webkitwebview.cpp
Source/WebKit/haiku/ChangeLog
Source/WebKit/haiku/WebCoreSupport/EditorClientHaiku.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/WebView/WebFrame.mm
Source/WebKit/qt/ChangeLog
Source/WebKit/qt/WebCoreSupport/EditorClientQt.cpp

index 7220534..bd072c1 100644 (file)
@@ -1,3 +1,18 @@
+2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Reviewed by Kent Tamura.
+
+        Rename Position::node() to Position::deprecatedNode()
+        https://bugs.webkit.org/show_bug.cgi?id=54622
+
+        Done the rename. All calls to node() are replaced by calls to deprecatedNode() except when
+        calls were of the form node()->document() and node()->inDocument() in which case they were
+        replaced by anchorNode()->document() and anchorNode()->inDocument() respectively.
+
+        * WebCore.exp.in: Added Position::containerNode.
+
+        The rest abbreviated for simplicity. Please see svn log.
+
 2011-02-20  Gavin Barraclough  <barraclough@apple.com>
 
         Build fix (remove includes).
index a176779..8461cad 100644 (file)
@@ -1226,6 +1226,7 @@ __ZNK7WebCore8Document6domainEv
 __ZNK7WebCore8IntPointcv7CGPointEv
 __ZNK7WebCore8IntPointcv8_NSPointEv
 __ZNK7WebCore8Position10downstreamENS_27EditingBoundaryCrossingRuleE
+__ZNK7WebCore8Position13containerNodeEv
 __ZNK7WebCore8Position24parentAnchoredEquivalentEv
 __ZNK7WebCore8Position25leadingWhitespacePositionENS_9EAffinityEb
 __ZNK7WebCore8Position26trailingWhitespacePositionENS_9EAffinityEb
index d0d19f7..deab912 100644 (file)
@@ -578,7 +578,7 @@ VisiblePosition AXObjectCache::visiblePositionForTextMarkerData(TextMarkerData&
     if (deepPos.isNull())
         return VisiblePosition();
     
-    RenderObject* renderer = deepPos.node()->renderer();
+    RenderObject* renderer = deepPos.deprecatedNode()->renderer();
     if (!renderer)
         return VisiblePosition();
     
@@ -586,7 +586,7 @@ VisiblePosition AXObjectCache::visiblePositionForTextMarkerData(TextMarkerData&
     if (!cache->isIDinUse(textMarkerData.axID))
         return VisiblePosition();
     
-    if (deepPos.node() != textMarkerData.node || deepPos.deprecatedEditingOffset() != textMarkerData.offset)
+    if (deepPos.deprecatedNode() != textMarkerData.node || deepPos.deprecatedEditingOffset() != textMarkerData.offset)
         return VisiblePosition();
     
     return visiblePos;
@@ -602,7 +602,7 @@ void AXObjectCache::textMarkerDataForVisiblePosition(TextMarkerData& textMarkerD
         return;
     
     Position deepPos = visiblePos.deepEquivalent();
-    Node* domNode = deepPos.node();
+    Node* domNode = deepPos.deprecatedNode();
     ASSERT(domNode);
     if (!domNode)
         return;
index ba03ef4..b1b7522 100644 (file)
@@ -222,9 +222,9 @@ static VisiblePosition updateAXLineStartForVisiblePosition(const VisiblePosition
         if (tempPosition.isNull())
             break;
         p = tempPosition.deepEquivalent();
-        if (!p.node())
+        if (!p.deprecatedNode())
             break;
-        renderer = p.node()->renderer();
+        renderer = p.deprecatedNode()->renderer();
         if (!renderer || (renderer->isRenderBlock() && !p.deprecatedEditingOffset()))
             break;
         InlineBox* box;
@@ -318,7 +318,7 @@ VisiblePositionRange AccessibilityObject::paragraphForPosition(const VisiblePosi
 
 static VisiblePosition startOfStyleRange(const VisiblePosition visiblePos)
 {
-    RenderObject* renderer = visiblePos.deepEquivalent().node()->renderer();
+    RenderObject* renderer = visiblePos.deepEquivalent().deprecatedNode()->renderer();
     RenderObject* startRenderer = renderer;
     RenderStyle* style = renderer->style();
 
@@ -341,7 +341,7 @@ static VisiblePosition startOfStyleRange(const VisiblePosition visiblePos)
 
 static VisiblePosition endOfStyleRange(const VisiblePosition& visiblePos)
 {
-    RenderObject* renderer = visiblePos.deepEquivalent().node()->renderer();
+    RenderObject* renderer = visiblePos.deepEquivalent().deprecatedNode()->renderer();
     RenderObject* endRenderer = renderer;
     RenderStyle* style = renderer->style();
 
@@ -649,7 +649,7 @@ AccessibilityObject* AccessibilityObject::accessibilityObjectForPosition(const V
     if (visiblePos.isNull())
         return 0;
 
-    RenderObject* obj = visiblePos.deepEquivalent().node()->renderer();
+    RenderObject* obj = visiblePos.deepEquivalent().deprecatedNode()->renderer();
     if (!obj)
         return 0;
 
index 2641ca8..224e995 100644 (file)
@@ -2482,13 +2482,13 @@ int AccessibilityRenderObject::indexForVisiblePosition(const VisiblePosition& po
         return 0;
     
     Position indexPosition = pos.deepEquivalent();
-    if (!indexPosition.node() || indexPosition.node()->rootEditableElement() != node)
+    if (!indexPosition.anchorNode() || indexPosition.anchorNode()->rootEditableElement() != node)
         return 0;
     
     ExceptionCode ec = 0;
     RefPtr<Range> range = Range::create(m_renderer->document());
     range->setStart(node, 0, ec);
-    range->setEnd(indexPosition.node(), indexPosition.deprecatedEditingOffset(), ec);
+    range->setEnd(indexPosition.anchorNode(), indexPosition.deprecatedEditingOffset(), ec);
     return TextIterator::rangeLength(range.get());
 }
 
@@ -2621,7 +2621,7 @@ int AccessibilityRenderObject::index(const VisiblePosition& position) const
     if (!isTextControl())
         return -1;
     
-    Node* node = position.deepEquivalent().node();
+    Node* node = position.deepEquivalent().deprecatedNode();
     if (!node)
         return -1;
     
index 4cbc5f8..e5406a0 100644 (file)
@@ -1223,7 +1223,7 @@ static gint webkit_accessible_text_get_caret_offset(AtkText* text)
     if (!coreObject->isAccessibilityRenderObject())
         return 0;
 
-    Node* focusedNode = coreObject->selection().end().node();
+    Node* focusedNode = coreObject->selection().end().deprecatedNode();
     if (!focusedNode)
         return 0;
 
index 7e830a6..f77125b 100644 (file)
@@ -230,7 +230,7 @@ PassRefPtr<CSSComputedStyleDeclaration> Position::computedStyle() const
 
 Position Position::previous(PositionMoveType moveType) const
 {
-    Node* n = node();
+    Node* n = deprecatedNode();
     if (!n)
         return *this;
     
@@ -269,7 +269,7 @@ Position Position::next(PositionMoveType moveType) const
 {
     ASSERT(moveType != BackwardDeletion);
 
-    Node* n = node();
+    Node* n = deprecatedNode();
     if (!n)
         return *this;
     
@@ -323,7 +323,7 @@ bool Position::atLastEditingPositionForNode() const
 {
     if (isNull())
         return true;
-    return m_offset >= lastOffsetForEditing(node());
+    return m_offset >= lastOffsetForEditing(deprecatedNode());
 }
 
 // A position is considered at editing boundary if one of the following is true:
@@ -336,15 +336,15 @@ bool Position::atLastEditingPositionForNode() const
 bool Position::atEditingBoundary() const
 {
     Position nextPosition = downstream(CanCrossEditingBoundary);
-    if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.node()->isContentEditable())
+    if (atFirstEditingPositionForNode() && nextPosition.isNotNull() && !nextPosition.deprecatedNode()->isContentEditable())
         return true;
         
     Position prevPosition = upstream(CanCrossEditingBoundary);
-    if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.node()->isContentEditable())
+    if (atLastEditingPositionForNode() && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->isContentEditable())
         return true;
         
-    return nextPosition.isNotNull() && !nextPosition.node()->isContentEditable()
-        && prevPosition.isNotNull() && !prevPosition.node()->isContentEditable();
+    return nextPosition.isNotNull() && !nextPosition.deprecatedNode()->isContentEditable()
+        && prevPosition.isNotNull() && !prevPosition.deprecatedNode()->isContentEditable();
 }
 
 Node* Position::parentEditingBoundary() const
@@ -368,26 +368,26 @@ bool Position::atStartOfTree() const
 {
     if (isNull())
         return true;
-    return !node()->parentNode() && m_offset <= 0;
+    return !deprecatedNode()->parentNode() && m_offset <= 0;
 }
 
 bool Position::atEndOfTree() const
 {
     if (isNull())
         return true;
-    return !node()->parentNode() && m_offset >= lastOffsetForEditing(node());
+    return !deprecatedNode()->parentNode() && m_offset >= lastOffsetForEditing(deprecatedNode());
 }
 
 int Position::renderedOffset() const
 {
-    if (!node()->isTextNode())
+    if (!deprecatedNode()->isTextNode())
         return m_offset;
    
-    if (!node()->renderer())
+    if (!deprecatedNode()->renderer())
         return m_offset;
                     
     int result = 0;
-    RenderText *textRenderer = toRenderText(node()->renderer());
+    RenderText* textRenderer = toRenderText(deprecatedNode()->renderer());
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         int start = box->start();
         int end = box->start() + box->len();
@@ -408,7 +408,7 @@ Position Position::previousCharacterPosition(EAffinity affinity) const
     if (isNull())
         return Position();
 
-    Node *fromRootEditableElement = node()->rootEditableElement();
+    Node* fromRootEditableElement = deprecatedNode()->rootEditableElement();
 
     bool atStartOfLine = isStartOfLine(VisiblePosition(*this, affinity));
     bool rendered = isCandidate();
@@ -417,7 +417,7 @@ Position Position::previousCharacterPosition(EAffinity affinity) const
     while (!currentPos.atStartOfTree()) {
         currentPos = currentPos.previous();
 
-        if (currentPos.node()->rootEditableElement() != fromRootEditableElement)
+        if (currentPos.deprecatedNode()->rootEditableElement() != fromRootEditableElement)
             return *this;
 
         if (atStartOfLine || !rendered) {
@@ -436,7 +436,7 @@ Position Position::nextCharacterPosition(EAffinity affinity) const
     if (isNull())
         return Position();
 
-    Node *fromRootEditableElement = node()->rootEditableElement();
+    Node* fromRootEditableElement = deprecatedNode()->rootEditableElement();
 
     bool atEndOfLine = isEndOfLine(VisiblePosition(*this, affinity));
     bool rendered = isCandidate();
@@ -445,7 +445,7 @@ Position Position::nextCharacterPosition(EAffinity affinity) const
     while (!currentPos.atEndOfTree()) {
         currentPos = currentPos.next();
 
-        if (currentPos.node()->rootEditableElement() != fromRootEditableElement)
+        if (currentPos.deprecatedNode()->rootEditableElement() != fromRootEditableElement)
             return *this;
 
         if (atEndOfLine || !rendered) {
@@ -507,7 +507,7 @@ static bool isStreamer(const PositionIterator& pos)
 // in boundary, where endsOfNodeAreVisuallyDistinctPositions(boundary) is true.
 Position Position::upstream(EditingBoundaryCrossingRule rule) const
 {
-    Node* startNode = node();
+    Node* startNode = deprecatedNode();
     if (!startNode)
         return Position();
     
@@ -628,7 +628,7 @@ Position Position::upstream(EditingBoundaryCrossingRule rule) const
 // in boundary after the last candidate, where endsOfNodeAreVisuallyDistinctPositions(boundary).
 Position Position::downstream(EditingBoundaryCrossingRule rule) const
 {
-    Node* startNode = node();
+    Node* startNode = deprecatedNode();
     if (!startNode)
         return Position();
 
@@ -764,7 +764,7 @@ bool Position::isCandidate() const
     if (isNull())
         return false;
         
-    RenderObject *renderer = node()->renderer();
+    RenderObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
     
@@ -772,13 +772,13 @@ bool Position::isCandidate() const
         return false;
 
     if (renderer->isBR())
-        return !m_offset && !nodeIsUserSelectNone(node()->parentNode());
+        return !m_offset && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
 
     if (renderer->isText())
-        return !nodeIsUserSelectNone(node()) && inRenderedText();
+        return !nodeIsUserSelectNone(deprecatedNode()) && inRenderedText();
 
-    if (isTableElement(node()) || editingIgnoresContent(node()))
-        return (atFirstEditingPositionForNode() || atLastEditingPositionForNode()) && !nodeIsUserSelectNone(node()->parentNode());
+    if (isTableElement(deprecatedNode()) || editingIgnoresContent(deprecatedNode()))
+        return (atFirstEditingPositionForNode() || atLastEditingPositionForNode()) && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
 
     if (m_anchorNode->hasTagName(htmlTag))
         return false;
@@ -786,21 +786,21 @@ bool Position::isCandidate() const
     if (renderer->isBlockFlow()) {
         if (toRenderBlock(renderer)->height() || m_anchorNode->hasTagName(bodyTag)) {
             if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(renderer))
-                return atFirstEditingPositionForNode() && !Position::nodeIsUserSelectNone(node());
-            return m_anchorNode->isContentEditable() && !Position::nodeIsUserSelectNone(node()) && atEditingBoundary();
+                return atFirstEditingPositionForNode() && !Position::nodeIsUserSelectNone(deprecatedNode());
+            return m_anchorNode->isContentEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
         }
     } else
-        return m_anchorNode->isContentEditable() && !Position::nodeIsUserSelectNone(node()) && atEditingBoundary();
+        return m_anchorNode->isContentEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
 
     return false;
 }
 
 bool Position::inRenderedText() const
 {
-    if (isNull() || !node()->isTextNode())
+    if (isNull() || !deprecatedNode()->isTextNode())
         return false;
         
-    RenderObject *renderer = node()->renderer();
+    RenderObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
     
@@ -833,10 +833,10 @@ static unsigned caretMaxRenderedOffset(const Node* n)
 
 bool Position::isRenderedCharacter() const
 {
-    if (isNull() || !node()->isTextNode())
+    if (isNull() || !deprecatedNode()->isTextNode())
         return false;
         
-    RenderObject* renderer = node()->renderer();
+    RenderObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
     
@@ -860,11 +860,11 @@ bool Position::rendersInDifferentPosition(const Position &pos) const
     if (isNull() || pos.isNull())
         return false;
 
-    RenderObject *renderer = node()->renderer();
+    RenderObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
     
-    RenderObject *posRenderer = pos.node()->renderer();
+    RenderObject* posRenderer = pos.deprecatedNode()->renderer();
     if (!posRenderer)
         return false;
 
@@ -872,32 +872,32 @@ bool Position::rendersInDifferentPosition(const Position &pos) const
         posRenderer->style()->visibility() != VISIBLE)
         return false;
     
-    if (node() == pos.node()) {
-        if (node()->hasTagName(brTag))
+    if (deprecatedNode() == pos.deprecatedNode()) {
+        if (deprecatedNode()->hasTagName(brTag))
             return false;
 
         if (m_offset == pos.deprecatedEditingOffset())
             return false;
             
-        if (!node()->isTextNode() && !pos.node()->isTextNode()) {
+        if (!deprecatedNode()->isTextNode() && !pos.deprecatedNode()->isTextNode()) {
             if (m_offset != pos.deprecatedEditingOffset())
                 return true;
         }
     }
     
-    if (node()->hasTagName(brTag) && pos.isCandidate())
+    if (deprecatedNode()->hasTagName(brTag) && pos.isCandidate())
         return true;
                 
-    if (pos.node()->hasTagName(brTag) && isCandidate())
+    if (pos.deprecatedNode()->hasTagName(brTag) && isCandidate())
         return true;
                 
-    if (node()->enclosingBlockFlowElement() != pos.node()->enclosingBlockFlowElement())
+    if (deprecatedNode()->enclosingBlockFlowElement() != pos.deprecatedNode()->enclosingBlockFlowElement())
         return true;
 
-    if (node()->isTextNode() && !inRenderedText())
+    if (deprecatedNode()->isTextNode() && !inRenderedText())
         return false;
 
-    if (pos.node()->isTextNode() && !pos.inRenderedText())
+    if (pos.deprecatedNode()->isTextNode() && !pos.inRenderedText())
         return false;
 
     int thisRenderedOffset = renderedOffset();
@@ -916,8 +916,8 @@ bool Position::rendersInDifferentPosition(const Position &pos) const
     LOG(Editing, "thisRenderedOffset:         %d\n", thisRenderedOffset);
     LOG(Editing, "posRenderer:            %p [%p]\n", posRenderer, b2);
     LOG(Editing, "posRenderedOffset:      %d\n", posRenderedOffset);
-    LOG(Editing, "node min/max:           %d:%d\n", caretMinOffset(node()), caretMaxRenderedOffset(node()));
-    LOG(Editing, "pos node min/max:       %d:%d\n", caretMinOffset(pos.node()), caretMaxRenderedOffset(pos.node()));
+    LOG(Editing, "node min/max:           %d:%d\n", caretMinOffset(deprecatedNode()), caretMaxRenderedOffset(deprecatedNode()));
+    LOG(Editing, "pos node min/max:       %d:%d\n", caretMinOffset(pos.deprecatedNode()), caretMaxRenderedOffset(pos.deprecatedNode()));
     LOG(Editing, "----------------------------------------------------------------------\n");
 
     if (!b1 || !b2) {
@@ -928,13 +928,13 @@ bool Position::rendersInDifferentPosition(const Position &pos) const
         return true;
     }
 
-    if (nextRenderedEditable(node()) == pos.node() && 
-        thisRenderedOffset == (int)caretMaxRenderedOffset(node()) && posRenderedOffset == 0) {
+    if (nextRenderedEditable(deprecatedNode()) == pos.deprecatedNode()
+        && thisRenderedOffset == (int)caretMaxRenderedOffset(deprecatedNode()) && !posRenderedOffset) {
         return false;
     }
     
-    if (previousRenderedEditable(node()) == pos.node() && 
-        thisRenderedOffset == 0 && posRenderedOffset == (int)caretMaxRenderedOffset(pos.node())) {
+    if (previousRenderedEditable(deprecatedNode()) == pos.deprecatedNode()
+        && !thisRenderedOffset && posRenderedOffset == (int)caretMaxRenderedOffset(pos.deprecatedNode())) {
         return false;
     }
 
@@ -948,12 +948,12 @@ Position Position::leadingWhitespacePosition(EAffinity affinity, bool considerNo
     if (isNull())
         return Position();
     
-    if (upstream().node()->hasTagName(brTag))
+    if (upstream().deprecatedNode()->hasTagName(brTag))
         return Position();
 
     Position prev = previousCharacterPosition(affinity);
-    if (prev != *this && prev.node()->inSameContainingBlockFlowElement(node()) && prev.node()->isTextNode()) {
-        String string = static_cast<Text *>(prev.node())->data();
+    if (prev != *this && prev.deprecatedNode()->inSameContainingBlockFlowElement(deprecatedNode()) && prev.deprecatedNode()->isTextNode()) {
+        String string = static_cast<Text *>(prev.deprecatedNode())->data();
         UChar c = string[prev.deprecatedEditingOffset()];
         if (considerNonCollapsibleWhitespace ? (isSpaceOrNewline(c) || c == noBreakSpace) : isCollapsibleWhitespace(c))
             if (isEditablePosition(prev))
@@ -1045,11 +1045,11 @@ static Position upstreamIgnoringEditingBoundaries(Position position)
 void Position::getInlineBoxAndOffset(EAffinity affinity, TextDirection primaryDirection, InlineBox*& inlineBox, int& caretOffset) const
 {
     caretOffset = m_offset;
-    RenderObject* renderer = node()->renderer();
+    RenderObject* renderer = deprecatedNode()->renderer();
 
     if (!renderer->isText()) {
         inlineBox = 0;
-        if (canHaveChildrenForEditing(node()) && renderer->isBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(renderer)) {
+        if (canHaveChildrenForEditing(deprecatedNode()) && renderer->isBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(renderer)) {
             // Try a visually equivalent position with possibly opposite editability. This helps in case |this| is in
             // an editable block but surrounded by non-editable positions. It acts to negate the logic at the beginning
             // of RenderObject::createVisiblePosition().
@@ -1211,7 +1211,7 @@ void Position::debugPosition(const char* msg) const
     if (isNull())
         fprintf(stderr, "Position [%s]: null\n", msg);
     else
-        fprintf(stderr, "Position [%s]: %s [%p] at %d\n", msg, node()->nodeName().utf8().data(), node(), m_offset);
+        fprintf(stderr, "Position [%s]: %s [%p] at %d\n", msg, deprecatedNode()->nodeName().utf8().data(), deprecatedNode(), m_offset);
 }
 
 #ifndef NDEBUG
@@ -1227,7 +1227,7 @@ void Position::formatForDebugger(char* buffer, unsigned length) const
         result += "offset ";
         result += String::number(m_offset);
         result += " of ";
-        node()->formatForDebugger(s, sizeof(s));
+        deprecatedNode()->formatForDebugger(s, sizeof(s));
         result += s;
     }
           
@@ -1254,8 +1254,8 @@ void Position::showAnchorTypeAndOffset() const
 
 void Position::showTreeForThis() const
 {
-    if (node()) {
-        node()->showTreeForThis();
+    if (anchorNode()) {
+        anchorNode()->showTreeForThis();
         showAnchorTypeAndOffset();
     }
 }
index a59b16c..3e3788b 100644 (file)
@@ -105,7 +105,7 @@ public:
     // FIXME: Callers should be moved off of node(), node() is not always the container for this position.
     // For nodes which editingIgnoresContent(node()) returns true, positions like [ignoredNode, 0]
     // will be treated as before ignoredNode (thus node() is really after the position, not containing it).
-    Node* node() const { return m_anchorNode.get(); }
+    Node* deprecatedNode() const { return m_anchorNode.get(); }
 
     // These should only be used for PositionIsOffsetInAnchor positions, unless
     // the position is a legacy editing position.
index e700875..7e20acc 100644 (file)
@@ -134,11 +134,11 @@ void ApplyBlockElementCommand::formatSelection(const VisiblePosition& startOfSel
         // indentIntoBlockquote could move more than one paragraph if the paragraph
         // is in a list item or a table. As a result, endAfterSelection could refer to a position
         // no longer in the document.
-        if (endAfterSelection.isNotNull() && !endAfterSelection.deepEquivalent().node()->inDocument())
+        if (endAfterSelection.isNotNull() && !endAfterSelection.deepEquivalent().anchorNode()->inDocument())
             break;
-        // Sanity check: Make sure our moveParagraph calls didn't remove endOfNextParagraph.deepEquivalent().node()
+        // Sanity check: Make sure our moveParagraph calls didn't remove endOfNextParagraph.deepEquivalent().deprecatedNode()
         // If somehow we did, return to prevent crashes.
-        if (endOfNextParagraph.isNotNull() && !endOfNextParagraph.deepEquivalent().node()->inDocument()) {
+        if (endOfNextParagraph.isNotNull() && !endOfNextParagraph.deepEquivalent().anchorNode()->inDocument()) {
             ASSERT_NOT_REACHED();
             return;
         }
@@ -182,8 +182,8 @@ void ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded(const
     RenderStyle* startStyle = renderStyleOfEnclosingTextNode(start);
     bool isStartAndEndOnSameNode = false;
     if (startStyle) {
-        isStartAndEndOnSameNode = renderStyleOfEnclosingTextNode(end) && start.node() == end.node();
-        bool isStartAndEndOfLastParagraphOnSameNode = renderStyleOfEnclosingTextNode(m_endOfLastParagraph) && start.node() == m_endOfLastParagraph.node();
+        isStartAndEndOnSameNode = renderStyleOfEnclosingTextNode(end) && start.deprecatedNode() == end.deprecatedNode();
+        bool isStartAndEndOfLastParagraphOnSameNode = renderStyleOfEnclosingTextNode(m_endOfLastParagraph) && start.deprecatedNode() == m_endOfLastParagraph.deprecatedNode();
 
         // Avoid obtanining the start of next paragraph for start
         if (startStyle->preserveNewline() && isNewLineAtPosition(start) && !isNewLineAtPosition(start.previous()) && start.offsetInContainerNode() > 0)
@@ -192,15 +192,15 @@ void ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded(const
         // If start is in the middle of a text node, split.
         if (!startStyle->collapseWhiteSpace() && start.offsetInContainerNode() > 0) {
             int startOffset = start.offsetInContainerNode();
-            splitTextNode(static_cast<Text*>(start.node()), startOffset);
-            start = positionBeforeNode(start.node());
+            splitTextNode(static_cast<Text*>(start.deprecatedNode()), startOffset);
+            start = positionBeforeNode(start.deprecatedNode());
             if (isStartAndEndOnSameNode) {
                 ASSERT(end.offsetInContainerNode() >= startOffset);
-                end = Position(end.node(), end.offsetInContainerNode() - startOffset, Position::PositionIsOffsetInAnchor);
+                end = Position(end.deprecatedNode(), end.offsetInContainerNode() - startOffset, Position::PositionIsOffsetInAnchor);
             }
             if (isStartAndEndOfLastParagraphOnSameNode) {
                 ASSERT(m_endOfLastParagraph.offsetInContainerNode() >= startOffset);
-                m_endOfLastParagraph = Position(m_endOfLastParagraph.node(), m_endOfLastParagraph.offsetInContainerNode() - startOffset,
+                m_endOfLastParagraph = Position(m_endOfLastParagraph.deprecatedNode(), m_endOfLastParagraph.offsetInContainerNode() - startOffset,
                     Position::PositionIsOffsetInAnchor);
             }
         }
@@ -208,13 +208,13 @@ void ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded(const
 
     RenderStyle* endStyle = renderStyleOfEnclosingTextNode(end);
     if (endStyle) {
-        bool isEndAndEndOfLastParagraphOnSameNode = renderStyleOfEnclosingTextNode(m_endOfLastParagraph) && end.node() == m_endOfLastParagraph.node();
+        bool isEndAndEndOfLastParagraphOnSameNode = renderStyleOfEnclosingTextNode(m_endOfLastParagraph) && end.deprecatedNode() == m_endOfLastParagraph.deprecatedNode();
         // Include \n at the end of line if we're at an empty paragraph
         if (endStyle->preserveNewline() && start == end
             && end.offsetInContainerNode() < end.containerNode()->maxCharacterOffset()) {
             int endOffset = end.offsetInContainerNode();
             if (!isNewLineAtPosition(end.previous()) && isNewLineAtPosition(end))
-                end = Position(end.node(), endOffset + 1, Position::PositionIsOffsetInAnchor);
+                end = Position(end.deprecatedNode(), endOffset + 1, Position::PositionIsOffsetInAnchor);
             if (isEndAndEndOfLastParagraphOnSameNode && end.offsetInContainerNode() >= m_endOfLastParagraph.offsetInContainerNode())
                 m_endOfLastParagraph = end;
         }
@@ -222,17 +222,17 @@ void ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded(const
         // If end is in the middle of a text node, split.
         if (!endStyle->collapseWhiteSpace() && end.offsetInContainerNode()
             && end.offsetInContainerNode() < end.containerNode()->maxCharacterOffset()) {
-            splitTextNode(static_cast<Text*>(end.node()), end.offsetInContainerNode());
+            splitTextNode(static_cast<Text*>(end.deprecatedNode()), end.offsetInContainerNode());
             if (isStartAndEndOnSameNode)
-                start = positionBeforeNode(end.node()->previousSibling());
+                start = positionBeforeNode(end.deprecatedNode()->previousSibling());
             if (isEndAndEndOfLastParagraphOnSameNode) {
                 if (m_endOfLastParagraph.offsetInContainerNode() == end.offsetInContainerNode())
-                    m_endOfLastParagraph = lastPositionInNode(end.node()->previousSibling());
+                    m_endOfLastParagraph = lastPositionInNode(end.deprecatedNode()->previousSibling());
                 else
-                    m_endOfLastParagraph = Position(end.node(), m_endOfLastParagraph.offsetInContainerNode() - end.offsetInContainerNode(),
+                    m_endOfLastParagraph = Position(end.deprecatedNode(), m_endOfLastParagraph.offsetInContainerNode() - end.offsetInContainerNode(),
                                                     Position::PositionIsOffsetInAnchor);
             }
-            end = lastPositionInNode(end.node()->previousSibling());
+            end = lastPositionInNode(end.deprecatedNode()->previousSibling());
         }
     }
 }
index 55b1092..b322834 100644 (file)
@@ -141,7 +141,7 @@ StyleChange::StyleChange(CSSStyleDeclaration* style, const Position& position)
 
 void StyleChange::init(PassRefPtr<CSSStyleDeclaration> style, const Position& position)
 {
-    Document* document = position.node() ? position.node()->document() : 0;
+    Document* document = position.anchorNode() ? position.anchorNode()->document() : 0;
     if (!document || !document->frame())
         return;
 
@@ -153,7 +153,7 @@ void StyleChange::init(PassRefPtr<CSSStyleDeclaration> style, const Position& po
         extractTextStyles(document, mutableStyle.get(), computedStyle->useFixedFontDefaultSize());
 
     // Changing the whitespace style in a tab span would collapse the tab into a space.
-    if (isTabSpanTextNode(position.node()) || isTabSpanNode((position.node())))
+    if (isTabSpanTextNode(position.deprecatedNode()) || isTabSpanNode((position.deprecatedNode())))
         mutableStyle->removeProperty(CSSPropertyWhiteSpace);
 
     // If unicode-bidi is present in mutableStyle and direction is not, then add direction to mutableStyle.
@@ -581,7 +581,7 @@ void ApplyStyleCommand::applyBlockStyle(EditingStyle *style)
     // Save and restore the selection endpoints using their indices in the document, since
     // addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.
     // Calculate start and end indices from the start of the tree that they're in.
-    Node* scope = highestAncestor(visibleStart.deepEquivalent().node());
+    Node* scope = highestAncestor(visibleStart.deepEquivalent().deprecatedNode());
     RefPtr<Range> startRange = Range::create(document(), firstPositionInNode(scope), visibleStart.deepEquivalent().parentAnchoredEquivalent());
     RefPtr<Range> endRange = Range::create(document(), firstPositionInNode(scope), visibleEnd.deepEquivalent().parentAnchoredEquivalent());
     int startIndex = TextIterator::rangeLength(startRange.get(), true);
@@ -593,7 +593,7 @@ void ApplyStyleCommand::applyBlockStyle(EditingStyle *style)
     while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {
         StyleChange styleChange(style->style(), paragraphStart.deepEquivalent());
         if (styleChange.cssStyle().length() || m_removeOnly) {
-            RefPtr<Node> block = enclosingBlock(paragraphStart.deepEquivalent().node());
+            RefPtr<Node> block = enclosingBlock(paragraphStart.deepEquivalent().deprecatedNode());
             if (!m_removeOnly) {
                 RefPtr<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());
                 if (newBlock)
@@ -636,13 +636,13 @@ void ApplyStyleCommand::applyRelativeFontStyleChange(EditingStyle* style)
     }
 
     // Join up any adjacent text nodes.
-    if (start.node()->isTextNode()) {
-        joinChildTextNodes(start.node()->parentNode(), start, end);
+    if (start.deprecatedNode()->isTextNode()) {
+        joinChildTextNodes(start.deprecatedNode()->parentNode(), start, end);
         start = startPosition();
         end = endPosition();
     }
-    if (end.node()->isTextNode() && start.node()->parentNode() != end.node()->parentNode()) {
-        joinChildTextNodes(end.node()->parentNode(), start, end);
+    if (end.deprecatedNode()->isTextNode() && start.deprecatedNode()->parentNode() != end.deprecatedNode()->parentNode()) {
+        joinChildTextNodes(end.deprecatedNode()->parentNode(), start, end);
         start = startPosition();
         end = endPosition();
     }
@@ -664,13 +664,13 @@ void ApplyStyleCommand::applyRelativeFontStyleChange(EditingStyle* style)
     // If the end node is before the start node (can only happen if the end node is
     // an ancestor of the start node), we gather nodes up to the next sibling of the end node
     Node *beyondEnd;
-    if (start.node()->isDescendantOf(end.node()))
-        beyondEnd = end.node()->traverseNextSibling();
+    if (start.deprecatedNode()->isDescendantOf(end.deprecatedNode()))
+        beyondEnd = end.deprecatedNode()->traverseNextSibling();
     else
-        beyondEnd = end.node()->traverseNextNode();
+        beyondEnd = end.deprecatedNode()->traverseNextNode();
     
     start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
-    Node *startNode = start.node();
+    Node* startNode = start.deprecatedNode();
     if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
         startNode = startNode->traverseNextNode();
 
@@ -874,25 +874,25 @@ void ApplyStyleCommand::applyInlineStyle(EditingStyle* style)
     // split the start node and containing element if the selection starts inside of it
     bool splitStart = isValidCaretPositionInTextNode(start);
     if (splitStart) {
-        if (shouldSplitTextElement(start.node()->parentElement(), style->style()))
+        if (shouldSplitTextElement(start.deprecatedNode()->parentElement(), style->style()))
             splitTextElementAtStart(start, end);
         else
             splitTextAtStart(start, end);
         start = startPosition();
         end = endPosition();
-        startDummySpanAncestor = dummySpanAncestorForNode(start.node());
+        startDummySpanAncestor = dummySpanAncestorForNode(start.deprecatedNode());
     }
 
     // split the end node and containing element if the selection ends inside of it
     bool splitEnd = isValidCaretPositionInTextNode(end);
     if (splitEnd) {
-        if (shouldSplitTextElement(end.node()->parentElement(), style->style()))
+        if (shouldSplitTextElement(end.deprecatedNode()->parentElement(), style->style()))
             splitTextElementAtEnd(start, end);
         else
             splitTextAtEnd(start, end);
         start = startPosition();
         end = endPosition();
-        endDummySpanAncestor = dummySpanAncestorForNode(end.node());
+        endDummySpanAncestor = dummySpanAncestorForNode(end.deprecatedNode());
     }
 
     // Remove style from the selection.
@@ -909,10 +909,10 @@ void ApplyStyleCommand::applyInlineStyle(EditingStyle* style)
         style->textDirection(textDirection);
 
         // Leave alone an ancestor that provides the desired single level embedding, if there is one.
-        HTMLElement* startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.node(), true, textDirection);
-        HTMLElement* endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.node(), false, textDirection);
-        removeEmbeddingUpToEnclosingBlock(start.node(), startUnsplitAncestor);
-        removeEmbeddingUpToEnclosingBlock(end.node(), endUnsplitAncestor);
+        HTMLElement* startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.deprecatedNode(), true, textDirection);
+        HTMLElement* endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.deprecatedNode(), false, textDirection);
+        removeEmbeddingUpToEnclosingBlock(start.deprecatedNode(), startUnsplitAncestor);
+        removeEmbeddingUpToEnclosingBlock(end.deprecatedNode(), endUnsplitAncestor);
 
         // Avoid removing the dir attribute and the unicode-bidi and direction properties from the unsplit ancestors.
         Position embeddingRemoveStart = removeStart;
@@ -959,8 +959,8 @@ void ApplyStyleCommand::applyInlineStyle(EditingStyle* style)
     RefPtr<CSSMutableStyleDeclaration> styleToApply = style->isEmpty() ? CSSMutableStyleDeclaration::create() : style->style();
     if (unicodeBidi) {
         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
-        Node* embeddingStartNode = highestEmbeddingAncestor(start.node(), enclosingBlock(start.node()));
-        Node* embeddingEndNode = highestEmbeddingAncestor(end.node(), enclosingBlock(end.node()));
+        Node* embeddingStartNode = highestEmbeddingAncestor(start.deprecatedNode(), enclosingBlock(start.deprecatedNode()));
+        Node* embeddingEndNode = highestEmbeddingAncestor(end.deprecatedNode(), enclosingBlock(end.deprecatedNode()));
 
         if (embeddingStartNode || embeddingEndNode) {
             Position embeddingApplyStart = embeddingStartNode ? positionInParentAfterNode(embeddingStartNode) : start;
@@ -987,22 +987,22 @@ void ApplyStyleCommand::applyInlineStyle(EditingStyle* style)
 
 void ApplyStyleCommand::fixRangeAndApplyInlineStyle(CSSMutableStyleDeclaration* style, const Position& start, const Position& end)
 {
-    Node* startNode = start.node();
+    Node* startNode = start.deprecatedNode();
 
-    if (start.deprecatedEditingOffset() >= caretMaxOffset(start.node())) {
+    if (start.deprecatedEditingOffset() >= caretMaxOffset(start.deprecatedNode())) {
         startNode = startNode->traverseNextNode();
         if (!startNode || comparePositions(end, firstPositionInOrBeforeNode(startNode)) < 0)
             return;
     }
 
-    Node* pastEndNode = end.node();
-    if (end.deprecatedEditingOffset() >= caretMaxOffset(end.node()))
-        pastEndNode = end.node()->traverseNextSibling();
+    Node* pastEndNode = end.deprecatedNode();
+    if (end.deprecatedEditingOffset() >= caretMaxOffset(end.deprecatedNode()))
+        pastEndNode = end.deprecatedNode()->traverseNextSibling();
 
     // FIXME: Callers should perform this operation on a Range that includes the br
     // if they want style applied to the empty line.
-    if (start == end && start.node()->hasTagName(brTag))
-        pastEndNode = start.node()->traverseNextNode();
+    if (start == end && start.deprecatedNode()->hasTagName(brTag))
+        pastEndNode = start.deprecatedNode()->traverseNextNode();
 
     // Start from the highest fully selected ancestor so that we can modify the fully selected node.
     // e.g. When applying font-size: large on <font color="blue">hello</font>, we need to include the font element in our run
@@ -1478,8 +1478,8 @@ void ApplyStyleCommand::removeInlineStyle(PassRefPtr<CSSMutableStyleDeclaration>
 {
     ASSERT(start.isNotNull());
     ASSERT(end.isNotNull());
-    ASSERT(start.node()->inDocument());
-    ASSERT(end.node()->inDocument());
+    ASSERT(start.anchorNode()->inDocument());
+    ASSERT(end.anchorNode()->inDocument());
     ASSERT(comparePositions(start, end) <= 0);
 
     RefPtr<CSSValue> textDecorationSpecialProperty = style ? style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect) : 0;
@@ -1497,18 +1497,18 @@ void ApplyStyleCommand::removeInlineStyle(PassRefPtr<CSSMutableStyleDeclaration>
         && pushDownStart.computeOffsetInContainerNode() == pushDownStartContainer->maxCharacterOffset())
         pushDownStart = nextVisuallyDistinctCandidate(pushDownStart);
     Position pushDownEnd = end.upstream();
-    pushDownInlineStyleAroundNode(style.get(), pushDownStart.node());
-    pushDownInlineStyleAroundNode(style.get(), pushDownEnd.node());
+    pushDownInlineStyleAroundNode(style.get(), pushDownStart.deprecatedNode());
+    pushDownInlineStyleAroundNode(style.get(), pushDownEnd.deprecatedNode());
 
     // The s and e variables store the positions used to set the ending selection after style removal
     // takes place. This will help callers to recognize when either the start node or the end node
     // are removed from the document during the work of this function.
-    // If pushDownInlineStyleAroundNode has pruned start.node() or end.node(),
+    // If pushDownInlineStyleAroundNode has pruned start.deprecatedNode() or end.deprecatedNode(),
     // use pushDownStart or pushDownEnd instead, which pushDownInlineStyleAroundNode won't prune.
     Position s = start.isNull() || start.isOrphan() ? pushDownStart : start;
     Position e = end.isNull() || end.isOrphan() ? pushDownEnd : end;
 
-    Node* node = start.node();
+    Node* node = start.deprecatedNode();
     while (node) {
         RefPtr<Node> next = node->traverseNextNode();
         if (node->isHTMLElement() && nodeFullySelected(node, start, end)) {
@@ -1524,13 +1524,13 @@ void ApplyStyleCommand::removeInlineStyle(PassRefPtr<CSSMutableStyleDeclaration>
 
             removeInlineStyleFromElement(style.get(), elem.get(), RemoveIfNeeded, styleToPushDown.get());
             if (!elem->inDocument()) {
-                if (s.node() == elem) {
+                if (s.deprecatedNode() == elem) {
                     // Since elem must have been fully selected, and it is at the start
                     // of the selection, it is clear we can set the new s offset to 0.
                     ASSERT(s.anchorType() == Position::PositionIsBeforeAnchor || s.offsetInContainerNode() <= 0);
                     s = firstPositionInOrBeforeNode(next.get());
                 }
-                if (e.node() == elem) {
+                if (e.deprecatedNode() == elem) {
                     // Since elem must have been fully selected, and it is at the end
                     // of the selection, it is clear we can set the new e offset to
                     // the max range offset of prev.
@@ -1545,7 +1545,7 @@ void ApplyStyleCommand::removeInlineStyle(PassRefPtr<CSSMutableStyleDeclaration>
                     applyInlineStyleToPushDown(childNode.get(), styleToPushDown.get());
             }
         }
-        if (node == end.node())
+        if (node == end.deprecatedNode())
             break;
         node = next.get();
     }
@@ -1583,9 +1583,9 @@ void ApplyStyleCommand::splitTextAtStart(const Position& start, const Position&
     else
         newEnd = end;
 
-    Text* text = static_cast<Text*>(start.node());
+    Text* text = static_cast<Text*>(start.deprecatedNode());
     splitTextNode(text, start.offsetInContainerNode());
-    updateStartEnd(firstPositionInNode(start.node()), newEnd);
+    updateStartEnd(firstPositionInNode(start.deprecatedNode()), newEnd);
 }
 
 void ApplyStyleCommand::splitTextAtEnd(const Position& start, const Position& end)
@@ -1593,7 +1593,7 @@ void ApplyStyleCommand::splitTextAtEnd(const Position& start, const Position& en
     ASSERT(end.anchorType() == Position::PositionIsOffsetInAnchor);
 
     bool shouldUpdateStart = start.anchorType() == Position::PositionIsOffsetInAnchor && start.containerNode() == end.containerNode();
-    Text* text = static_cast<Text *>(end.node());
+    Text* text = static_cast<Text *>(end.deprecatedNode());
     splitTextNode(text, end.offsetInContainerNode());
 
     Node* prevNode = text->previousSibling();
@@ -1612,9 +1612,9 @@ void ApplyStyleCommand::splitTextElementAtStart(const Position& start, const Pos
     else
         newEnd = end;
 
-    Text* text = static_cast<Text*>(start.node());
+    Text* text = static_cast<Text*>(start.deprecatedNode());
     splitTextNodeContainingElement(text, start.deprecatedEditingOffset());
-    updateStartEnd(Position(start.node()->parentNode(), start.node()->nodeIndex(), Position::PositionIsOffsetInAnchor), newEnd);
+    updateStartEnd(Position(start.deprecatedNode()->parentNode(), start.deprecatedNode()->nodeIndex(), Position::PositionIsOffsetInAnchor), newEnd);
 }
 
 void ApplyStyleCommand::splitTextElementAtEnd(const Position& start, const Position& end)
@@ -1622,7 +1622,7 @@ void ApplyStyleCommand::splitTextElementAtEnd(const Position& start, const Posit
     ASSERT(end.anchorType() == Position::PositionIsOffsetInAnchor);
 
     bool shouldUpdateStart = start.anchorType() == Position::PositionIsOffsetInAnchor && start.containerNode() == end.containerNode();
-    Text* text = static_cast<Text*>(end.node());
+    Text* text = static_cast<Text*>(end.deprecatedNode());
     splitTextNodeContainingElement(text, end.deprecatedEditingOffset());
 
     Node* prevNode = text->parentNode()->previousSibling()->lastChild();
@@ -1713,9 +1713,9 @@ bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position& start,
         mergeIdenticalElements(previousElement, element);
 
         int startOffsetAdjustment = startChild->nodeIndex();
-        int endOffsetAdjustment = startNode == end.node() ? startOffsetAdjustment : 0;
+        int endOffsetAdjustment = startNode == end.deprecatedNode() ? startOffsetAdjustment : 0;
         updateStartEnd(Position(startNode, startOffsetAdjustment, Position::PositionIsOffsetInAnchor),
-                       Position(end.node(), end.deprecatedEditingOffset() + endOffsetAdjustment, Position::PositionIsOffsetInAnchor)); 
+                       Position(end.deprecatedNode(), end.deprecatedEditingOffset() + endOffsetAdjustment, Position::PositionIsOffsetInAnchor)); 
         return true;
     }
 
@@ -1731,11 +1731,11 @@ bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position& start, const
         if (endOffset < lastOffsetInNode(endNode))
             return false;
 
-        unsigned parentLastOffset = end.node()->parentNode()->childNodes()->length() - 1;
-        if (end.node()->nextSibling())
+        unsigned parentLastOffset = end.deprecatedNode()->parentNode()->childNodes()->length() - 1;
+        if (end.deprecatedNode()->nextSibling())
             return false;
 
-        endNode = end.node()->parentNode();
+        endNode = end.deprecatedNode()->parentNode();
         endOffset = parentLastOffset;
     }
 
index ae409c6..011a787 100644 (file)
@@ -67,7 +67,7 @@ void BreakBlockquoteCommand::doApply()
     
     // Find the top-most blockquote from the start.
     Element* topBlockquote = 0;
-    for (ContainerNode* node = pos.node()->parentNode(); node; node = node->parentNode()) {
+    for (ContainerNode* node = pos.deprecatedNode()->parentNode(); node; node = node->parentNode()) {
         if (isMailBlockquote(node))
             topBlockquote = static_cast<Element*>(node);
     }
@@ -103,11 +103,11 @@ void BreakBlockquoteCommand::doApply()
         pos = pos.next();
         
     // Adjust the position so we don't split at the beginning of a quote.  
-    while (isFirstVisiblePositionInNode(VisiblePosition(pos), nearestMailBlockquote(pos.node())))
+    while (isFirstVisiblePositionInNode(VisiblePosition(pos), nearestMailBlockquote(pos.deprecatedNode())))
         pos = pos.previous();
     
     // startNode is the first node that we need to move to the new blockquote.
-    Node* startNode = pos.node();
+    Node* startNode = pos.deprecatedNode();
         
     // Split at pos if in the middle of a text node.
     if (startNode->isTextNode()) {
index fc698b3..c1febf0 100644 (file)
@@ -160,7 +160,7 @@ void CompositeEditCommand::insertNodeAt(PassRefPtr<Node> insertChild, const Posi
     // For editing positions like [table, 0], insert before the table,
     // likewise for replaced elements, brs, etc.
     Position p = editingPosition.parentAnchoredEquivalent();
-    Node* refChild = p.node();
+    Node* refChild = p.deprecatedNode();
     int offset = p.deprecatedEditingOffset();
     
     if (canHaveChildrenForEditing(refChild)) {
@@ -342,18 +342,18 @@ void CompositeEditCommand::replaceTextInNode(PassRefPtr<Text> node, unsigned off
 
 Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos)
 {
-    if (!isTabSpanTextNode(pos.node()))
+    if (!isTabSpanTextNode(pos.deprecatedNode()))
         return pos;
     
-    Node* tabSpan = tabSpanNode(pos.node());
+    Node* tabSpan = tabSpanNode(pos.deprecatedNode());
     
-    if (pos.deprecatedEditingOffset() <= caretMinOffset(pos.node()))
+    if (pos.deprecatedEditingOffset() <= caretMinOffset(pos.deprecatedNode()))
         return positionInParentBeforeNode(tabSpan);
         
-    if (pos.deprecatedEditingOffset() >= caretMaxOffset(pos.node()))
+    if (pos.deprecatedEditingOffset() >= caretMaxOffset(pos.deprecatedNode()))
         return positionInParentAfterNode(tabSpan);
 
-    splitTextNodeContainingElement(static_cast<Text *>(pos.node()), pos.deprecatedEditingOffset());
+    splitTextNodeContainingElement(static_cast<Text *>(pos.deprecatedNode()), pos.deprecatedEditingOffset());
     return positionInParentBeforeNode(tabSpan);
 }
 
@@ -475,7 +475,7 @@ void CompositeEditCommand::rebalanceWhitespaceOnTextSubstring(RefPtr<Text> textN
 
 void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& position)
 {
-    Node* node = position.node();
+    Node* node = position.deprecatedNode();
     if (!node || !node->isTextNode())
         return;
     Text* textNode = static_cast<Text*>(node);    
@@ -495,10 +495,10 @@ void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& positio
     VisiblePosition previousVisiblePos(visiblePos.previous());
     Position previous(previousVisiblePos.deepEquivalent());
     
-    if (isCollapsibleWhitespace(previousVisiblePos.characterAfter()) && previous.node()->isTextNode() && !previous.node()->hasTagName(brTag))
-        replaceTextInNode(static_cast<Text*>(previous.node()), previous.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
-    if (isCollapsibleWhitespace(visiblePos.characterAfter()) && position.node()->isTextNode() && !position.node()->hasTagName(brTag))
-        replaceTextInNode(static_cast<Text*>(position.node()), position.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
+    if (isCollapsibleWhitespace(previousVisiblePos.characterAfter()) && previous.deprecatedNode()->isTextNode() && !previous.deprecatedNode()->hasTagName(brTag))
+        replaceTextInNode(static_cast<Text*>(previous.deprecatedNode()), previous.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
+    if (isCollapsibleWhitespace(visiblePos.characterAfter()) && position.deprecatedNode()->isTextNode() && !position.deprecatedNode()->hasTagName(brTag))
+        replaceTextInNode(static_cast<Text*>(position.deprecatedNode()), position.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
 }
 
 void CompositeEditCommand::rebalanceWhitespace()
@@ -600,15 +600,15 @@ void CompositeEditCommand::deleteInsignificantText(const Position& start, const
         return;
 
     Node* next;
-    for (Node* node = start.node(); node; node = next) {
+    for (Node* node = start.deprecatedNode(); node; node = next) {
         next = node->traverseNextNode();
         if (node->isTextNode()) {
             Text* textNode = static_cast<Text*>(node);
-            int startOffset = node == start.node() ? start.deprecatedEditingOffset() : 0;
-            int endOffset = node == end.node() ? end.deprecatedEditingOffset() : static_cast<int>(textNode->length());
+            int startOffset = node == start.deprecatedNode() ? start.deprecatedEditingOffset() : 0;
+            int endOffset = node == end.deprecatedNode() ? end.deprecatedEditingOffset() : static_cast<int>(textNode->length());
             deleteInsignificantText(textNode, startOffset, endOffset);
         }
-        if (node == end.node())
+        if (node == end.deprecatedNode())
             break;
     }
 }
@@ -638,7 +638,7 @@ PassRefPtr<Node> CompositeEditCommand::insertBlockPlaceholder(const Position& po
         return 0;
 
     // Should assert isBlockFlow || isInlineFlow when deletion improves.  See 4244964.
-    ASSERT(pos.node()->renderer());
+    ASSERT(pos.deprecatedNode()->renderer());
 
     RefPtr<Node> placeholder = createBlockPlaceholderElement(document());
     insertNodeAt(placeholder, pos);
@@ -714,28 +714,26 @@ PassRefPtr<Node> CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessar
         return 0;
 
     // Perform some checks to see if we need to perform work in this function.
-    if (isBlock(upstreamStart.node())) {
+    if (isBlock(upstreamStart.deprecatedNode())) {
         // If the block is the root editable element, always move content to a new block,
         // since it is illegal to modify attributes on the root editable element for editing.
-        if (upstreamStart.node() == editableRootForPosition(upstreamStart)) {
+        if (upstreamStart.deprecatedNode() == editableRootForPosition(upstreamStart)) {
             // If the block is the root editable element and it contains no visible content, create a new
             // block but don't try and move content into it, since there's nothing for moveParagraphs to move.
-            if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(upstreamStart.node()->renderer()))
+            if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(upstreamStart.deprecatedNode()->renderer()))
                 return insertNewDefaultParagraphElementAt(upstreamStart);
-        } else if (isBlock(upstreamEnd.node())) {
-            if (!upstreamEnd.node()->isDescendantOf(upstreamStart.node())) {
+        } else if (isBlock(upstreamEnd.deprecatedNode())) {
+            if (!upstreamEnd.deprecatedNode()->isDescendantOf(upstreamStart.deprecatedNode())) {
                 // If the paragraph end is a descendant of paragraph start, then we need to run
                 // the rest of this function. If not, we can bail here.
                 return 0;
             }
-        }
-        else if (enclosingBlock(upstreamEnd.node()) != upstreamStart.node()) {
+        } else if (enclosingBlock(upstreamEnd.deprecatedNode()) != upstreamStart.deprecatedNode()) {
             // The visibleEnd.  It must be an ancestor of the paragraph start.
             // We can bail as we have a full block to work with.
-            ASSERT(upstreamStart.node()->isDescendantOf(enclosingBlock(upstreamEnd.node())));
+            ASSERT(upstreamStart.deprecatedNode()->isDescendantOf(enclosingBlock(upstreamEnd.deprecatedNode())));
             return 0;
-        }
-        else if (isEndOfDocument(visibleEnd)) {
+        } else if (isEndOfDocument(visibleEnd)) {
             // At the end of the document. We can bail here as well.
             return 0;
         }
@@ -743,7 +741,7 @@ PassRefPtr<Node> CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessar
 
     RefPtr<Node> newBlock = insertNewDefaultParagraphElementAt(upstreamStart);
 
-    bool endWasBr = visibleParagraphEnd.deepEquivalent().node()->hasTagName(brTag);
+    bool endWasBr = visibleParagraphEnd.deepEquivalent().deprecatedNode()->hasTagName(brTag);
 
     moveParagraphs(visibleParagraphStart, visibleParagraphEnd, VisiblePosition(firstPositionInNode(newBlock.get())));
 
@@ -778,14 +776,14 @@ void CompositeEditCommand::cloneParagraphUnderNewElement(Position& start, Positi
     appendNode(topNode, blockElement);
     RefPtr<Node> lastNode = topNode;
 
-    if (start.node() != outerNode) {
+    if (start.deprecatedNode() != outerNode) {
         Vector<RefPtr<Node> > ancestors;
         
         // Insert each node from innerNode to outerNode (excluded) in a list.
-        for (Node* n = start.node(); n && n != outerNode; n = n->parentNode())
+        for (Node* n = start.deprecatedNode(); n && n != outerNode; n = n->parentNode())
             ancestors.append(n);
 
-        // Clone every node between start.node() and outerBlock.
+        // Clone every node between start.deprecatedNode() and outerBlock.
 
         for (size_t i = ancestors.size(); i != 0; --i) {
             Node* item = ancestors[i - 1].get();
@@ -796,25 +794,25 @@ void CompositeEditCommand::cloneParagraphUnderNewElement(Position& start, Positi
     }
 
     // Handle the case of paragraphs with more than one node,
-    // cloning all the siblings until end.node() is reached.
+    // cloning all the siblings until end.deprecatedNode() is reached.
     
-    if (start.node() != end.node() && !start.node()->isDescendantOf(end.node())) {
+    if (start.deprecatedNode() != end.deprecatedNode() && !start.deprecatedNode()->isDescendantOf(end.deprecatedNode())) {
         // If end is not a descendant of outerNode we need to
         // find the first common ancestor and adjust the insertion
         // point accordingly.
-        while (!end.node()->isDescendantOf(outerNode)) {
+        while (!end.deprecatedNode()->isDescendantOf(outerNode)) {
             outerNode = outerNode->parentNode();
             topNode = topNode->parentNode();
         }
 
-        for (Node* n = start.node()->traverseNextSibling(outerNode); n; n = n->traverseNextSibling(outerNode)) {
-            if (n->parentNode() != start.node()->parentNode())
+        for (Node* n = start.deprecatedNode()->traverseNextSibling(outerNode); n; n = n->traverseNextSibling(outerNode)) {
+            if (n->parentNode() != start.deprecatedNode()->parentNode())
                 lastNode = topNode->lastChild();
 
             RefPtr<Node> clonedNode = n->cloneNode(true);
             insertNodeAfter(clonedNode, lastNode);
             lastNode = clonedNode.release();
-            if (n == end.node() || end.node()->isDescendantOf(n))
+            if (n == end.deprecatedNode() || end.deprecatedNode()->isDescendantOf(n))
                 break;
         }
     }
@@ -833,7 +831,7 @@ void CompositeEditCommand::cleanupAfterDeletion()
     if (isStartOfParagraph(caretAfterDelete) && isEndOfParagraph(caretAfterDelete)) {
         // Note: We want the rightmost candidate.
         Position position = caretAfterDelete.deepEquivalent().downstream();
-        Node* node = position.node();
+        Node* node = position.deprecatedNode();
         // Normally deletion will leave a br as a placeholder.
         if (node->hasTagName(brTag))
             removeNodeAndPruneAncestors(node);
@@ -895,7 +893,7 @@ void CompositeEditCommand::moveParagraphWithClones(const VisiblePosition& startO
     beforeParagraph = VisiblePosition(beforeParagraph.deepEquivalent());
     afterParagraph = VisiblePosition(afterParagraph.deepEquivalent());
 
-    if (beforeParagraph.isNotNull() && !isTableElement(beforeParagraph.deepEquivalent().node())
+    if (beforeParagraph.isNotNull() && !isTableElement(beforeParagraph.deepEquivalent().deprecatedNode())
         && ((!isEndOfParagraph(beforeParagraph) && !isStartOfParagraph(beforeParagraph)) || beforeParagraph == afterParagraph)) {
         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
         insertNodeAt(createBreakElement(document()), beforeParagraph.deepEquivalent());
@@ -955,7 +953,7 @@ void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagrap
     // start and end can't be used directly to create a Range; they are "editing positions"
     Position startRangeCompliant = start.parentAnchoredEquivalent();
     Position endRangeCompliant = end.parentAnchoredEquivalent();
-    RefPtr<Range> range = Range::create(document(), startRangeCompliant.node(), startRangeCompliant.deprecatedEditingOffset(), endRangeCompliant.node(), endRangeCompliant.deprecatedEditingOffset());
+    RefPtr<Range> range = Range::create(document(), startRangeCompliant.deprecatedNode(), startRangeCompliant.deprecatedEditingOffset(), endRangeCompliant.deprecatedNode(), endRangeCompliant.deprecatedEditingOffset());
 
     // FIXME: This is an inefficient way to preserve style on nodes in the paragraph to move. It
     // shouldn't matter though, since moved paragraphs will usually be quite small.
@@ -980,10 +978,10 @@ void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagrap
     document()->frame()->editor()->clearMisspellingsAndBadGrammar(endingSelection());
     deleteSelection(false, false, false, false);
 
-    ASSERT(destination.deepEquivalent().node()->inDocument());
+    ASSERT(destination.deepEquivalent().anchorNode()->inDocument());
 
     cleanupAfterDeletion();
-    ASSERT(destination.deepEquivalent().node()->inDocument());
+    ASSERT(destination.deepEquivalent().anchorNode()->inDocument());
 
     // Add a br if pruning an empty block level element caused a collapse. For example:
     // foo^
@@ -1131,15 +1129,15 @@ bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph()
     
     Position caretPos(caret.deepEquivalent());
     // A line break is either a br or a preserved newline.
-    ASSERT(caretPos.node()->hasTagName(brTag) || (caretPos.node()->isTextNode() && caretPos.node()->renderer()->style()->preserveNewline()));
+    ASSERT(caretPos.deprecatedNode()->hasTagName(brTag) || (caretPos.deprecatedNode()->isTextNode() && caretPos.deprecatedNode()->renderer()->style()->preserveNewline()));
     
-    if (caretPos.node()->hasTagName(brTag)) {
-        Position beforeBR(positionInParentBeforeNode(caretPos.node()));
-        removeNode(caretPos.node());
-        prune(beforeBR.node());
+    if (caretPos.deprecatedNode()->hasTagName(brTag)) {
+        Position beforeBR(positionInParentBeforeNode(caretPos.deprecatedNode()));
+        removeNode(caretPos.deprecatedNode());
+        prune(beforeBR.deprecatedNode());
     } else {
         ASSERT(caretPos.deprecatedEditingOffset() == 0);
-        Text* textNode = static_cast<Text*>(caretPos.node());
+        Text* textNode = static_cast<Text*>(caretPos.deprecatedNode());
         ContainerNode* parentNode = textNode->parentNode();
         // The preserved newline must be the first thing in the node, since otherwise the previous
         // paragraph would be quoted, and we verified that it wasn't above.
@@ -1175,7 +1173,7 @@ Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(const Posi
         if (visiblePos == lastInAnchor) {
             // Make sure anchors are pushed down before avoiding them so that we don't
             // also avoid structural elements like lists and blocks (5142012).
-            if (original.node() != enclosingAnchor && original.node()->parentNode() != enclosingAnchor) {
+            if (original.deprecatedNode() != enclosingAnchor && original.deprecatedNode()->parentNode() != enclosingAnchor) {
                 pushAnchorElementDown(enclosingAnchor);
                 enclosingAnchor = enclosingAnchorElement(original);
                 if (!enclosingAnchor)
@@ -1184,7 +1182,7 @@ Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(const Posi
             // Don't insert outside an anchor if doing so would skip over a line break.  It would
             // probably be safe to move the line break so that we could still avoid the anchor here.
             Position downstream(visiblePos.deepEquivalent().downstream());
-            if (lineBreakExistsAtVisiblePosition(visiblePos) && downstream.node()->isDescendantOf(enclosingAnchor))
+            if (lineBreakExistsAtVisiblePosition(visiblePos) && downstream.deprecatedNode()->isDescendantOf(enclosingAnchor))
                 return original;
             
             result = positionInParentAfterNode(enclosingAnchor);
@@ -1194,7 +1192,7 @@ Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(const Posi
         if (visiblePos == firstInAnchor) {
             // Make sure anchors are pushed down before avoiding them so that we don't
             // also avoid structural elements like lists and blocks (5142012).
-            if (original.node() != enclosingAnchor && original.node()->parentNode() != enclosingAnchor) {
+            if (original.deprecatedNode() != enclosingAnchor && original.deprecatedNode()->parentNode() != enclosingAnchor) {
                 pushAnchorElementDown(enclosingAnchor);
                 enclosingAnchor = enclosingAnchorElement(original);
             }
index 3ba5ae9..897c305 100644 (file)
@@ -84,7 +84,7 @@ DeleteSelectionCommand::DeleteSelectionCommand(Document *document, bool smartDel
 }
 
 DeleteSelectionCommand::DeleteSelectionCommand(const VisibleSelection& selection, bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
-    : CompositeEditCommand(selection.start().node()->document()), 
+    : CompositeEditCommand(selection.start().anchorNode()->document()), 
       m_hasSelectionToDelete(true), 
       m_smartDelete(smartDelete), 
       m_mergeBlocksAfterDelete(mergeBlocksAfterDelete),
@@ -110,10 +110,10 @@ void DeleteSelectionCommand::initializeStartEnd(Position& start, Position& end)
  
     // For HRs, we'll get a position at (HR,1) when hitting delete from the beginning of the previous line, or (HR,0) when forward deleting,
     // but in these cases, we want to delete it, so manually expand the selection
-    if (start.node()->hasTagName(hrTag))
-        start = positionBeforeNode(start.node());
-    else if (end.node()->hasTagName(hrTag))
-        end = positionAfterNode(end.node());
+    if (start.deprecatedNode()->hasTagName(hrTag))
+        start = positionBeforeNode(start.deprecatedNode());
+    else if (end.deprecatedNode()->hasTagName(hrTag))
+        end = positionAfterNode(end.deprecatedNode());
     
     // FIXME: This is only used so that moveParagraphs can avoid the bugs in special element expansion.
     if (!m_expandForSpecialElements)
@@ -275,7 +275,7 @@ void DeleteSelectionCommand::saveTypingStyleState()
     // typing style at the start of the selection, nor is there a reason to 
     // compute the style at the start of the selection after deletion (see the 
     // early return in calculateTypingStyleAfterDelete).
-    if (m_upstreamStart.node() == m_downstreamEnd.node() && m_upstreamStart.node()->isTextNode())
+    if (m_upstreamStart.deprecatedNode() == m_downstreamEnd.deprecatedNode() && m_upstreamStart.deprecatedNode()->isTextNode())
         return;
 
     // Figure out the typing style in effect before the delete is done.
@@ -284,7 +284,7 @@ void DeleteSelectionCommand::saveTypingStyleState()
 
     // If we're deleting into a Mail blockquote, save the style at end() instead of start()
     // We'll use this later in computeTypingStyleAfterDelete if we end up outside of a Mail blockquote
-    if (nearestMailBlockquote(m_selectionToDelete.start().node()))
+    if (nearestMailBlockquote(m_selectionToDelete.start().deprecatedNode()))
         m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.end());
     else
         m_deleteIntoBlockquoteStyle = 0;
@@ -293,11 +293,11 @@ void DeleteSelectionCommand::saveTypingStyleState()
 bool DeleteSelectionCommand::handleSpecialCaseBRDelete()
 {
     // Check for special-case where the selection contains only a BR on a line by itself after another BR.
-    bool upstreamStartIsBR = m_upstreamStart.node()->hasTagName(brTag);
-    bool downstreamStartIsBR = m_downstreamStart.node()->hasTagName(brTag);
-    bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && m_downstreamStart.node() == m_upstreamEnd.node();
+    bool upstreamStartIsBR = m_upstreamStart.deprecatedNode()->hasTagName(brTag);
+    bool downstreamStartIsBR = m_downstreamStart.deprecatedNode()->hasTagName(brTag);
+    bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && m_downstreamStart.deprecatedNode() == m_upstreamEnd.deprecatedNode();
     if (isBROnLineByItself) {
-        removeNode(m_downstreamStart.node());
+        removeNode(m_downstreamStart.deprecatedNode());
         return true;
     }
 
@@ -416,7 +416,7 @@ void DeleteSelectionCommand::deleteTextFromNode(PassRefPtr<Text> node, unsigned
 void DeleteSelectionCommand::handleGeneralDelete()
 {
     int startOffset = m_upstreamStart.deprecatedEditingOffset();
-    Node* startNode = m_upstreamStart.node();
+    Node* startNode = m_upstreamStart.deprecatedNode();
     
     // Never remove the start block unless it's a table, in which case we won't merge content in.
     if (startNode == m_startBlock && startOffset == 0 && canHaveChildrenForEditing(startNode) && !startNode->hasTagName(tableTag)) {
@@ -439,7 +439,7 @@ void DeleteSelectionCommand::handleGeneralDelete()
     if (!startNode)
         return;
 
-    if (startNode == m_downstreamEnd.node()) {
+    if (startNode == m_downstreamEnd.deprecatedNode()) {
         if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) {
             if (startNode->isTextNode()) {
                 // in a text node that needs to be trimmed
@@ -456,7 +456,7 @@ void DeleteSelectionCommand::handleGeneralDelete()
             removeNode(startNode);
     }
     else {
-        bool startNodeWasDescendantOfEndNode = m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node());
+        bool startNodeWasDescendantOfEndNode = m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode());
         // The selection to delete spans more than one node.
         RefPtr<Node> node(startNode);
         
@@ -469,21 +469,21 @@ void DeleteSelectionCommand::handleGeneralDelete()
             } else {
                 node = startNode->childNode(startOffset);
             }
-        } else if (startNode == m_upstreamEnd.node() && startNode->isTextNode()) {
-            Text* text = static_cast<Text*>(m_upstreamEnd.node());
+        } else if (startNode == m_upstreamEnd.deprecatedNode() && startNode->isTextNode()) {
+            Text* text = static_cast<Text*>(m_upstreamEnd.deprecatedNode());
             deleteTextFromNode(text, 0, m_upstreamEnd.deprecatedEditingOffset());
         }
         
         // handle deleting all nodes that are completely selected
-        while (node && node != m_downstreamEnd.node()) {
+        while (node && node != m_downstreamEnd.deprecatedNode()) {
             if (comparePositions(firstPositionInOrBeforeNode(node.get()), m_downstreamEnd) >= 0) {
                 // traverseNextSibling just blew past the end position, so stop deleting
                 node = 0;
-            } else if (!m_downstreamEnd.node()->isDescendantOf(node.get())) {
+            } else if (!m_downstreamEnd.deprecatedNode()->isDescendantOf(node.get())) {
                 RefPtr<Node> nextNode = node->traverseNextSibling();
                 // if we just removed a node from the end container, update end position so the
                 // check above will work
-                if (node->parentNode() == m_downstreamEnd.node()) {
+                if (node->parentNode() == m_downstreamEnd.deprecatedNode()) {
                     ASSERT(m_downstreamEnd.deprecatedEditingOffset());
                     ASSERT(node->nodeIndex() < (unsigned)m_downstreamEnd.deprecatedEditingOffset());
                     m_downstreamEnd.moveToOffset(m_downstreamEnd.deprecatedEditingOffset() - 1);
@@ -492,7 +492,7 @@ void DeleteSelectionCommand::handleGeneralDelete()
                 node = nextNode.get();
             } else {
                 Node* n = node->lastDescendant();
-                if (m_downstreamEnd.node() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(n)) {
+                if (m_downstreamEnd.deprecatedNode() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(n)) {
                     removeNode(node.get());
                     node = 0;
                 } else
@@ -500,33 +500,33 @@ void DeleteSelectionCommand::handleGeneralDelete()
             }
         }
         
-        if (m_downstreamEnd.node() != startNode && !m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node()) && m_downstreamEnd.node()->inDocument() && m_downstreamEnd.deprecatedEditingOffset() >= caretMinOffset(m_downstreamEnd.node())) {
-            if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.node())) {
+        if (m_downstreamEnd.deprecatedNode() != startNode && !m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode()) && m_downstreamEnd.anchorNode()->inDocument() && m_downstreamEnd.deprecatedEditingOffset() >= caretMinOffset(m_downstreamEnd.deprecatedNode())) {
+            if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.deprecatedNode())) {
                 // The node itself is fully selected, not just its contents.  Delete it.
-                removeNode(m_downstreamEnd.node());
+                removeNode(m_downstreamEnd.deprecatedNode());
             } else {
-                if (m_downstreamEnd.node()->isTextNode()) {
+                if (m_downstreamEnd.deprecatedNode()->isTextNode()) {
                     // in a text node that needs to be trimmed
-                    Text *text = static_cast<Text *>(m_downstreamEnd.node());
+                    Text* text = static_cast<Text*>(m_downstreamEnd.deprecatedNode());
                     if (m_downstreamEnd.deprecatedEditingOffset() > 0) {
                         deleteTextFromNode(text, 0, m_downstreamEnd.deprecatedEditingOffset());
                     }
-                // Remove children of m_downstreamEnd.node() that come after m_upstreamStart.
-                // Don't try to remove children if m_upstreamStart was inside m_downstreamEnd.node()
+                // Remove children of m_downstreamEnd.deprecatedNode() that come after m_upstreamStart.
+                // Don't try to remove children if m_upstreamStart was inside m_downstreamEnd.deprecatedNode()
                 // and m_upstreamStart has been removed from the document, because then we don't 
                 // know how many children to remove.
                 // FIXME: Make m_upstreamStart a position we update as we remove content, then we can
                 // always know which children to remove.
-                } else if (!(startNodeWasDescendantOfEndNode && !m_upstreamStart.node()->inDocument())) {
+                } else if (!(startNodeWasDescendantOfEndNode && !m_upstreamStart.anchorNode()->inDocument())) {
                     int offset = 0;
-                    if (m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node())) {
-                        Node *n = m_upstreamStart.node();
-                        while (n && n->parentNode() != m_downstreamEnd.node())
+                    if (m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode())) {
+                        Node* n = m_upstreamStart.deprecatedNode();
+                        while (n && n->parentNode() != m_downstreamEnd.deprecatedNode())
                             n = n->parentNode();
                         if (n)
                             offset = n->nodeIndex() + 1;
                     }
-                    removeChildrenInRange(m_downstreamEnd.node(), offset, m_downstreamEnd.deprecatedEditingOffset());
+                    removeChildrenInRange(m_downstreamEnd.deprecatedNode(), offset, m_downstreamEnd.deprecatedEditingOffset());
                     m_downstreamEnd.moveToOffset(offset);
                 }
             }
@@ -538,13 +538,13 @@ void DeleteSelectionCommand::fixupWhitespace()
 {
     updateLayout();
     // FIXME: isRenderedCharacter should be removed, and we should use VisiblePosition::characterAfter and VisiblePosition::characterBefore
-    if (m_leadingWhitespace.isNotNull() && !m_leadingWhitespace.isRenderedCharacter() && m_leadingWhitespace.node()->isTextNode()) {
-        Text* textNode = static_cast<Text*>(m_leadingWhitespace.node());
+    if (m_leadingWhitespace.isNotNull() && !m_leadingWhitespace.isRenderedCharacter() && m_leadingWhitespace.deprecatedNode()->isTextNode()) {
+        Text* textNode = static_cast<Text*>(m_leadingWhitespace.deprecatedNode());
         ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
         replaceTextInNode(textNode, m_leadingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
     }
-    if (m_trailingWhitespace.isNotNull() && !m_trailingWhitespace.isRenderedCharacter() && m_trailingWhitespace.node()->isTextNode()) {
-        Text* textNode = static_cast<Text*>(m_trailingWhitespace.node());
+    if (m_trailingWhitespace.isNotNull() && !m_trailingWhitespace.isRenderedCharacter() && m_trailingWhitespace.deprecatedNode()->isTextNode()) {
+        Text* textNode = static_cast<Text*>(m_trailingWhitespace.deprecatedNode());
         ASSERT(!textNode->renderer() ||textNode->renderer()->style()->collapseWhiteSpace());
         replaceTextInNode(textNode, m_trailingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
     }
@@ -569,7 +569,7 @@ void DeleteSelectionCommand::mergeParagraphs()
     ASSERT(!m_pruneStartBlockIfNecessary);
 
     // FIXME: Deletion should adjust selection endpoints as it removes nodes so that we never get into this state (4099839).
-    if (!m_downstreamEnd.node()->inDocument() || !m_upstreamStart.node()->inDocument())
+    if (!m_downstreamEnd.anchorNode()->inDocument() || !m_upstreamStart.anchorNode()->inDocument())
          return;
          
     // FIXME: The deletion algorithm shouldn't let this happen.
@@ -585,14 +585,14 @@ void DeleteSelectionCommand::mergeParagraphs()
     
     // m_downstreamEnd's block has been emptied out by deletion.  There is no content inside of it to
     // move, so just remove it.
-    Element* endBlock = static_cast<Element*>(enclosingBlock(m_downstreamEnd.node()));
-    if (!startOfParagraphToMove.deepEquivalent().node() || !endBlock->contains(startOfParagraphToMove.deepEquivalent().node())) {
-        removeNode(enclosingBlock(m_downstreamEnd.node()));
+    Element* endBlock = static_cast<Element*>(enclosingBlock(m_downstreamEnd.deprecatedNode()));
+    if (!startOfParagraphToMove.deepEquivalent().deprecatedNode() || !endBlock->contains(startOfParagraphToMove.deepEquivalent().deprecatedNode())) {
+        removeNode(enclosingBlock(m_downstreamEnd.deprecatedNode()));
         return;
     }
     
     // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.
-    if (!mergeDestination.deepEquivalent().node() || !mergeDestination.deepEquivalent().node()->isDescendantOf(m_upstreamStart.node()->enclosingBlockFlowElement()) || m_startsAtEmptyLine) {
+    if (!mergeDestination.deepEquivalent().deprecatedNode() || !mergeDestination.deepEquivalent().deprecatedNode()->isDescendantOf(m_upstreamStart.deprecatedNode()->enclosingBlockFlowElement()) || m_startsAtEmptyLine) {
         insertNodeAt(createBreakElement(document()).get(), m_upstreamStart);
         mergeDestination = VisiblePosition(m_upstreamStart);
     }
@@ -608,8 +608,8 @@ void DeleteSelectionCommand::mergeParagraphs()
     // The rule for merging into an empty block is: only do so if its farther to the right.
     // FIXME: Consider RTL.
     if (!m_startsAtEmptyLine && isStartOfParagraph(mergeDestination) && startOfParagraphToMove.absoluteCaretBounds().x() > mergeDestination.absoluteCaretBounds().x()) {
-        if (mergeDestination.deepEquivalent().downstream().node()->hasTagName(brTag)) {
-            removeNodeAndPruneAncestors(mergeDestination.deepEquivalent().downstream().node());
+        if (mergeDestination.deepEquivalent().downstream().deprecatedNode()->hasTagName(brTag)) {
+            removeNodeAndPruneAncestors(mergeDestination.deepEquivalent().downstream().deprecatedNode());
             m_endingPosition = startOfParagraphToMove.deepEquivalent();
             return;
         }
@@ -618,7 +618,7 @@ void DeleteSelectionCommand::mergeParagraphs()
     // Block images, tables and horizontal rules cannot be made inline with content at mergeDestination.  If there is 
     // any (!isStartOfParagraph(mergeDestination)), don't merge, just move the caret to just before the selection we deleted.
     // See https://bugs.webkit.org/show_bug.cgi?id=25439
-    if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().node()) && !isStartOfParagraph(mergeDestination)) {
+    if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().deprecatedNode()) && !isStartOfParagraph(mergeDestination)) {
         m_endingPosition = m_upstreamStart;
         return;
     }
@@ -666,7 +666,7 @@ void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows()
     if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow)
         if (isTableRowEmpty(m_endTableRow.get())) {
             // Don't remove m_endTableRow if it's where we're putting the ending selection.
-            if (!m_endingPosition.node()->isDescendantOf(m_endTableRow.get())) {
+            if (!m_endingPosition.deprecatedNode()->isDescendantOf(m_endTableRow.get())) {
                 // FIXME: We probably shouldn't remove m_endTableRow unless it's fully selected, even if it is empty.
                 // We'll need to start adjusting the selection endpoints during deletion to know whether or not m_endTableRow
                 // was fully selected here.
@@ -687,7 +687,7 @@ void DeleteSelectionCommand::calculateTypingStyleAfterDelete()
     // has completed.
     
     // If we deleted into a blockquote, but are now no longer in a blockquote, use the alternate typing style
-    if (m_deleteIntoBlockquoteStyle && !nearestMailBlockquote(m_endingPosition.node()))
+    if (m_deleteIntoBlockquoteStyle && !nearestMailBlockquote(m_endingPosition.deprecatedNode()))
         m_typingStyle = m_deleteIntoBlockquoteStyle;
     m_deleteIntoBlockquoteStyle = 0;
 
@@ -742,7 +742,7 @@ void DeleteSelectionCommand::doApply()
 
     // If the deletion is occurring in a text field, and we're not deleting to replace the selection, then let the frame call across the bridge to notify the form delegate. 
     if (!m_replace) {
-        Node* startNode = m_selectionToDelete.start().node();
+        Node* startNode = m_selectionToDelete.start().deprecatedNode();
         Node* ancestorNode = startNode ? startNode->shadowAncestorNode() : 0;
         if (ancestorNode && ancestorNode->hasTagName(inputTag)
                 && static_cast<HTMLInputElement*>(ancestorNode)->isTextField()
@@ -762,7 +762,7 @@ void DeleteSelectionCommand::doApply()
         // and ends inside it (we do need placeholders to hold open empty cells, but that's
         // handled elsewhere).
         if (Node* table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart()))
-            if (m_selectionToDelete.end().node()->isDescendantOf(table))
+            if (m_selectionToDelete.end().deprecatedNode()->isDescendantOf(table))
                 m_needPlaceholder = false;
     }
         
index a3f66be..24de941 100644 (file)
@@ -101,7 +101,7 @@ EditingStyle::EditingStyle(const Position& position)
     : m_shouldUseFixedDefaultFontSize(false)
     , m_fontSizeDelta(NoFontDelta)
 {
-    init(position.node(), OnlyInheritableProperties);
+    init(position.deprecatedNode(), OnlyInheritableProperties);
 }
 
 EditingStyle::EditingStyle(const CSSStyleDeclaration* style)
@@ -346,7 +346,7 @@ void EditingStyle::prepareToApplyAt(const Position& position, ShouldPreserveWrit
 PassRefPtr<EditingStyle> editingStyleIncludingTypingStyle(const Position& position)
 {
     RefPtr<EditingStyle> editingStyle = EditingStyle::create(position);
-    RefPtr<EditingStyle> typingStyle = position.node()->document()->frame()->selection()->typingStyle();
+    RefPtr<EditingStyle> typingStyle = position.anchorNode()->document()->frame()->selection()->typingStyle();
     if (typingStyle && typingStyle->style())
         editingStyle->style()->merge(copyEditingProperties(typingStyle->style()).get());
     return editingStyle;
index 289dade..90e06a2 100644 (file)
@@ -143,7 +143,7 @@ VisibleSelection Editor::selectionForCommand(Event* event)
     // If the target is a text control, and the current selection is outside of its shadow tree,
     // then use the saved selection for that text control.
     Node* target = event->target()->toNode();
-    Node* selectionStart = selection.start().node();
+    Node* selectionStart = selection.start().deprecatedNode();
     if (target && (!selectionStart || target->shadowAncestorNode() != selectionStart->shadowAncestorNode())) {
         RefPtr<Range> range;
         if (target->hasTagName(inputTag) && static_cast<HTMLInputElement*>(target)->isTextField())
@@ -306,7 +306,7 @@ bool Editor::canDeleteRange(Range* range) const
         VisiblePosition start(startContainer, range->startOffset(ec), DOWNSTREAM);
         VisiblePosition previous = start.previous();
         // FIXME: We sometimes allow deletions at the start of editable roots, like when the caret is in an empty list item.
-        if (previous.isNull() || previous.deepEquivalent().node()->rootEditableElement() != startContainer->rootEditableElement())
+        if (previous.isNull() || previous.deepEquivalent().deprecatedNode()->rootEditableElement() != startContainer->rootEditableElement())
             return false;
     }
     return true;
@@ -575,7 +575,7 @@ void Editor::respondToChangedSelection(const VisibleSelection& oldSelection)
 void Editor::respondToChangedContents(const VisibleSelection& endingSelection)
 {
     if (AXObjectCache::accessibilityEnabled()) {
-        Node* node = endingSelection.start().node();
+        Node* node = endingSelection.start().deprecatedNode();
         if (node)
             m_frame->document()->axObjectCache()->postNotification(node->renderer(), AXObjectCache::AXValueChanged, false);
     }
@@ -613,7 +613,7 @@ const SimpleFontData* Editor::fontForSelection(bool& hasMultipleFonts) const
     const SimpleFontData* font = 0;
 
     RefPtr<Range> range = m_frame->selection()->toNormalizedRange();
-    Node* startNode = range->editingStartPosition().node();
+    Node* startNode = range->editingStartPosition().deprecatedNode();
     if (startNode) {
         Node* pastEnd = range->pastLastNode();
         // In the loop below, n should eventually match pastEnd and not become nil, but we've seen at least one
@@ -648,7 +648,7 @@ WritingDirection Editor::textDirectionForSelection(bool& hasNestedOrMultipleEmbe
 
     Position position = m_frame->selection()->selection().start().downstream();
 
-    Node* node = position.node();
+    Node* node = position.deprecatedNode();
     if (!node)
         return NaturalWritingDirection;
 
@@ -680,7 +680,7 @@ WritingDirection Editor::textDirectionForSelection(bool& hasNestedOrMultipleEmbe
             hasNestedOrMultipleEmbeddings = false;
             return direction;
         }
-        node = m_frame->selection()->selection().visibleStart().deepEquivalent().node();
+        node = m_frame->selection()->selection().visibleStart().deepEquivalent().deprecatedNode();
     }
 
     // The selection is either a caret with no typing attributes or a range in which no embedding is added, so just use the start position
@@ -719,7 +719,7 @@ WritingDirection Editor::textDirectionForSelection(bool& hasNestedOrMultipleEmbe
             return NaturalWritingDirection;
 
         // In the range case, make sure that the embedding element persists until the end of the range.
-        if (m_frame->selection()->isRange() && !end.node()->isDescendantOf(node))
+        if (m_frame->selection()->isRange() && !end.deprecatedNode()->isDescendantOf(node))
             return NaturalWritingDirection;
 
         foundDirection = directionValue == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
@@ -735,12 +735,12 @@ bool Editor::hasBidiSelection() const
 
     Node* startNode;
     if (m_frame->selection()->isRange()) {
-        startNode = m_frame->selection()->selection().start().downstream().node();
-        Node* endNode = m_frame->selection()->selection().end().upstream().node();
+        startNode = m_frame->selection()->selection().start().downstream().deprecatedNode();
+        Node* endNode = m_frame->selection()->selection().end().upstream().deprecatedNode();
         if (enclosingBlock(startNode) != enclosingBlock(endNode))
             return false;
     } else
-        startNode = m_frame->selection()->selection().visibleStart().deepEquivalent().node();
+        startNode = m_frame->selection()->selection().visibleStart().deepEquivalent().deprecatedNode();
 
     RenderObject* renderer = startNode->renderer();
     while (renderer && !renderer->isRenderBlock())
@@ -1003,18 +1003,18 @@ TriState Editor::selectionHasStyle(CSSStyleDeclaration* style) const
             return FalseTriState;
         state = triStateOfStyle(style, selectionStyle.get());
     } else {
-        for (Node* node = m_frame->selection()->start().node(); node; node = node->traverseNextNode()) {
+        for (Node* node = m_frame->selection()->start().deprecatedNode(); node; node = node->traverseNextNode()) {
             RefPtr<CSSComputedStyleDeclaration> nodeStyle = computedStyle(node);
             if (nodeStyle) {
                 TriState nodeState = triStateOfStyle(style, nodeStyle.get(), !node->isTextNode());
-                if (node == m_frame->selection()->start().node())
+                if (node == m_frame->selection()->start().deprecatedNode())
                     state = nodeState;
                 else if (state != nodeState && node->isTextNode()) {
                     state = MixedTriState;
                     break;
                 }
             }
-            if (node == m_frame->selection()->end().node())
+            if (node == m_frame->selection()->end().deprecatedNode())
                 break;
         }
     }
@@ -1218,7 +1218,7 @@ bool Editor::insertTextWithoutSendingTextEvent(const String& text, bool selectIn
     // that is contained in the event target.
     selection = selectionForCommand(triggeringEvent);
     if (selection.isContentEditable()) {
-        if (Node* selectionStart = selection.start().node()) {
+        if (Node* selectionStart = selection.start().deprecatedNode()) {
             RefPtr<Document> document = selectionStart->document();
             
             // Insert the text
@@ -1281,7 +1281,7 @@ void Editor::cut()
 #if REMOVE_MARKERS_UPON_EDITING
         removeSpellAndCorrectionMarkersFromWordsToBeEdited(true);
 #endif
-        if (isNodeInTextFormControl(m_frame->selection()->start().node()))
+        if (isNodeInTextFormControl(m_frame->selection()->start().deprecatedNode()))
             Pasteboard::generalPasteboard()->writePlainText(selectedText());
         else
             Pasteboard::generalPasteboard()->writeSelection(selection.get(), canSmartCopyOrDelete(), m_frame);
@@ -1299,7 +1299,7 @@ void Editor::copy()
         return;
     }
 
-    if (isNodeInTextFormControl(m_frame->selection()->start().node()))
+    if (isNodeInTextFormControl(m_frame->selection()->start().deprecatedNode()))
         Pasteboard::generalPasteboard()->writePlainText(selectedText());
     else {
         Document* document = m_frame->document();
@@ -1724,9 +1724,9 @@ void Editor::setComposition(const String& text, const Vector<CompositionUnderlin
         // Find out what node has the composition now.
         Position base = m_frame->selection()->base().downstream();
         Position extent = m_frame->selection()->extent();
-        Node* baseNode = base.node();
+        Node* baseNode = base.deprecatedNode();
         unsigned baseOffset = base.deprecatedEditingOffset();
-        Node* extentNode = extent.node();
+        Node* extentNode = extent.deprecatedNode();
         unsigned extentOffset = extent.deprecatedEditingOffset();
 
         if (baseNode && baseNode == extentNode && baseNode->isTextNode() && baseOffset + text.length() == extentOffset) {
@@ -1792,7 +1792,7 @@ void Editor::advanceToNextMisspelling(bool startBeforeSelection)
     RefPtr<Range> spellingSearchRange(rangeOfContents(frame()->document()));
 
     bool startedWithSelection = false;
-    if (selection.start().node()) {
+    if (selection.start().deprecatedNode()) {
         startedWithSelection = true;
         if (startBeforeSelection) {
             VisiblePosition start(selection.visibleStart());
@@ -1816,7 +1816,7 @@ void Editor::advanceToNextMisspelling(bool startBeforeSelection)
             return;
         
         Position rangeCompliantPosition = position.parentAnchoredEquivalent();
-        spellingSearchRange->setStart(rangeCompliantPosition.node(), rangeCompliantPosition.deprecatedEditingOffset(), ec);
+        spellingSearchRange->setStart(rangeCompliantPosition.deprecatedNode(), rangeCompliantPosition.deprecatedEditingOffset(), ec);
         startedWithSelection = false; // won't need to wrap
     }
     
@@ -2221,7 +2221,7 @@ bool Editor::isSpellCheckingEnabledFor(Node* node) const
 
 bool Editor::isSpellCheckingEnabledInFocusedNode() const
 {
-    return isSpellCheckingEnabledFor(m_frame->selection()->start().node());
+    return isSpellCheckingEnabledFor(m_frame->selection()->start().deprecatedNode());
 }
 
 void Editor::markMisspellings(const VisibleSelection& selection, RefPtr<Range>& firstMisspellingRange)
@@ -2852,10 +2852,10 @@ bool Editor::getCompositionSelection(unsigned& selectionStart, unsigned& selecti
     if (!m_compositionNode)
         return false;
     Position start = m_frame->selection()->start();
-    if (start.node() != m_compositionNode)
+    if (start.deprecatedNode() != m_compositionNode)
         return false;
     Position end = m_frame->selection()->end();
-    if (end.node() != m_compositionNode)
+    if (end.deprecatedNode() != m_compositionNode)
         return false;
 
     if (static_cast<unsigned>(start.deprecatedEditingOffset()) < m_compositionStart)
@@ -3111,7 +3111,7 @@ IntRect Editor::firstRectForRange(Range* range) const
         return IntRect();
     startPosition.getInlineBoxAndOffset(DOWNSTREAM, startInlineBox, startCaretOffset);
 
-    RenderObject* startRenderer = startPosition.node()->renderer();
+    RenderObject* startRenderer = startPosition.deprecatedNode()->renderer();
     ASSERT(startRenderer);
     IntRect startCaretRect = startRenderer->localCaretRect(startInlineBox, startCaretOffset, &extraWidthToEndOfLine);
     if (startCaretRect != IntRect())
@@ -3124,7 +3124,7 @@ IntRect Editor::firstRectForRange(Range* range) const
         return IntRect();
     endPosition.getInlineBoxAndOffset(UPSTREAM, endInlineBox, endCaretOffset);
 
-    RenderObject* endRenderer = endPosition.node()->renderer();
+    RenderObject* endRenderer = endPosition.deprecatedNode()->renderer();
     ASSERT(endRenderer);
     IntRect endCaretRect = endRenderer->localCaretRect(endInlineBox, endCaretOffset);
     if (endCaretRect != IntRect())
@@ -3284,12 +3284,12 @@ RenderStyle* Editor::styleForSelectionStart(Node *&nodeToRemove) const
     Position position = m_frame->selection()->selection().visibleStart().deepEquivalent();
     if (!position.isCandidate())
         return 0;
-    if (!position.node())
+    if (!position.deprecatedNode())
         return 0;
 
     RefPtr<EditingStyle> typingStyle = m_frame->selection()->typingStyle();
     if (!typingStyle || !typingStyle->style())
-        return position.node()->renderer()->style();
+        return position.deprecatedNode()->renderer()->style();
 
     RefPtr<Element> styleElement = m_frame->document()->createElement(spanTag, false);
 
@@ -3301,7 +3301,7 @@ RenderStyle* Editor::styleForSelectionStart(Node *&nodeToRemove) const
     styleElement->appendChild(m_frame->document()->createEditingTextNode(""), ec);
     ASSERT(!ec);
 
-    position.node()->parentNode()->appendChild(styleElement, ec);
+    position.deprecatedNode()->parentNode()->appendChild(styleElement, ec);
     ASSERT(!ec);
 
     nodeToRemove = styleElement.get();
@@ -3537,7 +3537,7 @@ void Editor::respondToChangedSelection(const VisibleSelection& oldSelection, Sel
         // When typing we check spelling elsewhere, so don't redo it here.
         // If this is a change in selection resulting from a delete operation,
         // oldSelection may no longer be in the document.
-        if (shouldCheckSpellingAndGrammar && closeTyping && oldSelection.isContentEditable() && oldSelection.start().node() && oldSelection.start().node()->inDocument()) {
+        if (shouldCheckSpellingAndGrammar && closeTyping && oldSelection.isContentEditable() && oldSelection.start().deprecatedNode() && oldSelection.start().anchorNode()->inDocument()) {
             VisiblePosition oldStart(oldSelection.visibleStart());
             VisibleSelection oldAdjacentWords = VisibleSelection(startOfWord(oldStart, LeftWordIfOnBoundary), endOfWord(oldStart, RightWordIfOnBoundary));
             if (oldAdjacentWords != newAdjacentWords) {
@@ -3576,7 +3576,7 @@ static Node* findFirstMarkable(Node* node)
         if (node->renderer()->isText())
             return node;
         if (node->renderer()->isTextControl())
-            node = toRenderTextControl(node->renderer())->visiblePositionForIndex(1).deepEquivalent().node();
+            node = toRenderTextControl(node->renderer())->visiblePositionForIndex(1).deepEquivalent().deprecatedNode();
         else if (node->firstChild())
             node = node->firstChild();
         else
@@ -3588,7 +3588,7 @@ static Node* findFirstMarkable(Node* node)
 
 bool Editor::selectionStartHasSpellingMarkerFor(int from, int length) const
 {
-    Node* node = findFirstMarkable(m_frame->selection()->start().node());
+    Node* node = findFirstMarkable(m_frame->selection()->start().deprecatedNode());
     if (!node)
         return false;
 
index 58157af..9d90a1e 100644 (file)
@@ -60,8 +60,8 @@ void FormatBlockCommand::formatSelection(const VisiblePosition& startOfSelection
 
 void FormatBlockCommand::formatRange(const Position& start, const Position& end, const Position& endOfSelection, RefPtr<Element>& blockNode)
 {
-    Node* nodeToSplitTo = enclosingBlockToSplitTreeTo(start.node());
-    RefPtr<Node> outerBlock = (start.node() == nodeToSplitTo) ? start.node() : splitTreeToNode(start.node(), nodeToSplitTo);
+    Node* nodeToSplitTo = enclosingBlockToSplitTreeTo(start.deprecatedNode());
+    RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTreeToNode(start.deprecatedNode(), nodeToSplitTo);
     RefPtr<Node> nodeAfterInsertionPosition = outerBlock;
 
     RefPtr<Range> range = Range::create(document(), start, endOfSelection);
index 9d1adc1..82bec06 100644 (file)
@@ -59,7 +59,7 @@ IndentOutdentCommand::IndentOutdentCommand(Document* document, EIndentType typeO
 bool IndentOutdentCommand::tryIndentingAsListItem(const Position& start, const Position& end)
 {
     // If our selection is not inside a list, bail out.
-    Node* lastNodeInSelectedParagraph = start.node();
+    Node* lastNodeInSelectedParagraph = start.deprecatedNode();
     RefPtr<Element> listNode = enclosingList(lastNodeInSelectedParagraph);
     if (!listNode)
         return false;
@@ -94,15 +94,15 @@ void IndentOutdentCommand::indentIntoBlockquote(const Position& start, const Pos
     Node* nodeToSplitTo;
     if (enclosingCell)
         nodeToSplitTo = enclosingCell;
-    else if (enclosingList(start.node()))
-        nodeToSplitTo = enclosingBlock(start.node());
+    else if (enclosingList(start.deprecatedNode()))
+        nodeToSplitTo = enclosingBlock(start.deprecatedNode());
     else
         nodeToSplitTo = editableRootForPosition(start);
 
     if (!nodeToSplitTo)
         return;
 
-    RefPtr<Node> outerBlock = (start.node() == nodeToSplitTo) ? start.node() : splitTreeToNode(start.node(), nodeToSplitTo);
+    RefPtr<Node> outerBlock = (start.deprecatedNode() == nodeToSplitTo) ? start.deprecatedNode() : splitTreeToNode(start.deprecatedNode(), nodeToSplitTo);
 
     if (!targetBlockquote) {
         // Create a new blockquote and insert it as a child of the root editable element. We accomplish
@@ -166,13 +166,13 @@ void IndentOutdentCommand::outdentParagraph()
 
         return;
     }
-    Node* enclosingBlockFlow = enclosingBlock(visibleStartOfParagraph.deepEquivalent().node());
+    Node* enclosingBlockFlow = enclosingBlock(visibleStartOfParagraph.deepEquivalent().deprecatedNode());
     RefPtr<Node> splitBlockquoteNode = enclosingNode;
     if (enclosingBlockFlow != enclosingNode)
         splitBlockquoteNode = splitTreeToNode(enclosingBlockFlow, enclosingNode, true);
     else {
         // We split the blockquote at where we start outdenting.
-        splitElement(static_cast<Element*>(enclosingNode), visibleStartOfParagraph.deepEquivalent().node());
+        splitElement(static_cast<Element*>(enclosingNode), visibleStartOfParagraph.deepEquivalent().deprecatedNode());
     }
     RefPtr<Node> placeholder = createBreakElement(document());
     insertNodeBefore(placeholder, splitBlockquoteNode);
@@ -205,10 +205,10 @@ void IndentOutdentCommand::outdentRegion(const VisiblePosition& startOfSelection
         // outdentParagraph could move more than one paragraph if the paragraph
         // is in a list item. As a result, endAfterSelection and endOfNextParagraph
         // could refer to positions no longer in the document.
-        if (endAfterSelection.isNotNull() && !endAfterSelection.deepEquivalent().node()->inDocument())
+        if (endAfterSelection.isNotNull() && !endAfterSelection.deepEquivalent().anchorNode()->inDocument())
             break;
             
-        if (endOfNextParagraph.isNotNull() && !endOfNextParagraph.deepEquivalent().node()->inDocument()) {
+        if (endOfNextParagraph.isNotNull() && !endOfNextParagraph.deepEquivalent().anchorNode()->inDocument()) {
             endOfCurrentParagraph = endingSelection().end();
             endOfNextParagraph = endOfParagraph(endOfCurrentParagraph.next());
         }
index af8f2fc..0f975a6 100644 (file)
@@ -57,11 +57,11 @@ void InsertLineBreakCommand::insertNodeAfterPosition(Node* node, const Position&
     // Insert the BR after the caret position. In the case the
     // position is a block, do an append. We don't want to insert
     // the BR *after* the block.
-    Element* cb = pos.node()->enclosingBlockFlowElement();
-    if (cb == pos.node())
+    Element* cb = pos.deprecatedNode()->enclosingBlockFlowElement();
+    if (cb == pos.deprecatedNode())
         appendNode(node, cb);
     else
-        insertNodeAfter(node, pos.node());
+        insertNodeAfter(node, pos.deprecatedNode());
 }
 
 void InsertLineBreakCommand::insertNodeBeforePosition(Node* node, const Position& pos)
@@ -69,11 +69,11 @@ void InsertLineBreakCommand::insertNodeBeforePosition(Node* node, const Position
     // Insert the BR after the caret position. In the case the
     // position is a block, do an append. We don't want to insert
     // the BR *before* the block.
-    Element* cb = pos.node()->enclosingBlockFlowElement();
-    if (cb == pos.node())
+    Element* cb = pos.deprecatedNode()->enclosingBlockFlowElement();
+    if (cb == pos.deprecatedNode())
         appendNode(node, cb);
     else
-        insertNodeBefore(node, pos.node());
+        insertNodeBefore(node, pos.deprecatedNode());
 }
 
 // Whether we should insert a break element or a '\n'.
@@ -83,7 +83,7 @@ bool InsertLineBreakCommand::shouldUseBreakElement(const Position& insertionPos)
     // the input element, and in that case we need to check the input element's
     // parent's renderer.
     Position p(insertionPos.parentAnchoredEquivalent());
-    return p.node()->renderer() && !p.node()->renderer()->style()->preserveNewline();
+    return p.deprecatedNode()->renderer() && !p.deprecatedNode()->renderer()->style()->preserveNewline();
 }
 
 void InsertLineBreakCommand::doApply()
@@ -114,7 +114,7 @@ void InsertLineBreakCommand::doApply()
     // FIXME: Need to merge text nodes when inserting just after or before text.
     
     if (isEndOfParagraph(caret) && !lineBreakExistsAtVisiblePosition(caret)) {
-        bool needExtraLineBreak = !pos.node()->hasTagName(hrTag) && !pos.node()->hasTagName(tableTag);
+        bool needExtraLineBreak = !pos.deprecatedNode()->hasTagName(hrTag) && !pos.deprecatedNode()->hasTagName(tableTag);
         
         insertNodeAt(nodeToInsert.get(), pos);
         
@@ -123,7 +123,7 @@ void InsertLineBreakCommand::doApply()
         
         VisiblePosition endingPosition(positionBeforeNode(nodeToInsert.get()));
         setEndingSelection(VisibleSelection(endingPosition));
-    } else if (pos.deprecatedEditingOffset() <= caretMinOffset(pos.node())) {
+    } else if (pos.deprecatedEditingOffset() <= caretMinOffset(pos.deprecatedNode())) {
         insertNodeAt(nodeToInsert.get(), pos);
         
         // Insert an extra br or '\n' if the just inserted one collapsed.
@@ -133,12 +133,12 @@ void InsertLineBreakCommand::doApply()
         setEndingSelection(VisibleSelection(positionInParentAfterNode(nodeToInsert.get()), DOWNSTREAM));
     // If we're inserting after all of the rendered text in a text node, or into a non-text node,
     // a simple insertion is sufficient.
-    } else if (pos.deprecatedEditingOffset() >= caretMaxOffset(pos.node()) || !pos.node()->isTextNode()) {
+    } else if (pos.deprecatedEditingOffset() >= caretMaxOffset(pos.deprecatedNode()) || !pos.deprecatedNode()->isTextNode()) {
         insertNodeAt(nodeToInsert.get(), pos);
         setEndingSelection(VisibleSelection(positionInParentAfterNode(nodeToInsert.get()), DOWNSTREAM));
-    } else if (pos.node()->isTextNode()) {
+    } else if (pos.deprecatedNode()->isTextNode()) {
         // Split a text node
-        Text* textNode = static_cast<Text*>(pos.node());
+        Text* textNode = static_cast<Text*>(pos.deprecatedNode());
         splitTextNode(textNode, pos.deprecatedEditingOffset());
         insertNodeBefore(nodeToInsert, textNode);
         Position endingPosition = firstPositionInNode(textNode);
index c24c683..68661b4 100644 (file)
@@ -84,12 +84,12 @@ bool InsertListCommand::selectionHasListOfType(const VisibleSelection& selection
 {
     VisiblePosition start = selection.visibleStart();
 
-    if (!enclosingList(start.deepEquivalent().node()))
+    if (!enclosingList(start.deepEquivalent().deprecatedNode()))
         return false;
 
     VisiblePosition end = selection.visibleEnd();
     while (start.isNotNull() && start != end) {
-        Element* listNode = enclosingList(start.deepEquivalent().node());
+        Element* listNode = enclosingList(start.deepEquivalent().deprecatedNode());
         if (!listNode || !listNode->hasTagName(listTag))
             return false;
         start = startOfNextParagraph(start);
@@ -143,7 +143,7 @@ void InsertListCommand::doApply()
                 // infinite loop and because there is no more work to be done.
                 // FIXME(<rdar://problem/5983974>): The endingSelection() may be incorrect here.  Compute 
                 // the new location of endOfSelection and use it as the end of the new selection.
-                if (!startOfLastParagraph.deepEquivalent().node()->inDocument())
+                if (!startOfLastParagraph.deepEquivalent().anchorNode()->inDocument())
                     return;
                 setEndingSelection(startOfCurrentParagraph);
 
@@ -191,7 +191,7 @@ void InsertListCommand::doApplyForSingleParagraph(bool forceCreateList, const Qu
     // FIXME: This will produce unexpected results for a selection that starts just before a
     // table and ends inside the first cell, selectionForParagraphIteration should probably
     // be renamed and deployed inside setEndingSelection().
-    Node* selectionNode = endingSelection().start().node();
+    Node* selectionNode = endingSelection().start().deprecatedNode();
     Node* listChildNode = enclosingListChild(selectionNode);
     bool switchListType = false;
     if (listChildNode) {
@@ -217,7 +217,7 @@ void InsertListCommand::doApplyForSingleParagraph(bool forceCreateList, const Qu
             RefPtr<HTMLElement> newList = createHTMLElement(document(), listTag);
             insertNodeBefore(newList, listNode);
 
-            Node* firstChildInList = enclosingListChild(VisiblePosition(firstPositionInNode(listNode.get())).deepEquivalent().node(), listNode.get());
+            Node* firstChildInList = enclosingListChild(VisiblePosition(firstPositionInNode(listNode.get())).deepEquivalent().deprecatedNode(), listNode.get());
             Node* outerBlock = firstChildInList->isBlockFlow() ? firstChildInList : listNode.get();
             
             moveParagraphWithClones(firstPositionInNode(listNode.get()), lastPositionInNode(listNode.get()), newList.get(), outerBlock);
@@ -265,9 +265,9 @@ void InsertListCommand::unlistifyParagraph(const VisiblePosition& originalStart,
         // A paragraph is visually a list item minus a list marker.  The paragraph will be moved.
         start = startOfParagraph(originalStart);
         end = endOfParagraph(start);
-        nextListChild = enclosingListChild(end.next().deepEquivalent().node(), listNode);
+        nextListChild = enclosingListChild(end.next().deepEquivalent().deprecatedNode(), listNode);
         ASSERT(nextListChild != listChildNode);
-        previousListChild = enclosingListChild(start.previous().deepEquivalent().node(), listNode);
+        previousListChild = enclosingListChild(start.previous().deepEquivalent().deprecatedNode(), listNode);
         ASSERT(previousListChild != listChildNode);
     }
     // When removing a list, we must always create a placeholder to act as a point of insertion
@@ -308,7 +308,7 @@ void InsertListCommand::unlistifyParagraph(const VisiblePosition& originalStart,
 
 static Element* adjacentEnclosingList(const VisiblePosition& pos, const VisiblePosition& adjacentPos, const QualifiedName& listTag)
 {
-    Element* listNode = outermostEnclosingList(adjacentPos.deepEquivalent().node());
+    Element* listNode = outermostEnclosingList(adjacentPos.deepEquivalent().deprecatedNode());
 
     if (!listNode)
         return 0;
@@ -317,9 +317,9 @@ static Element* adjacentEnclosingList(const VisiblePosition& pos, const VisibleP
     Node* currentCell = enclosingTableCell(adjacentPos.deepEquivalent());
 
     if (!listNode->hasTagName(listTag)
-        || listNode->contains(pos.deepEquivalent().node())
+        || listNode->contains(pos.deepEquivalent().deprecatedNode())
         || previousCell != currentCell
-        || enclosingList(listNode) != enclosingList(pos.deepEquivalent().node()))
+        || enclosingList(listNode) != enclosingList(pos.deepEquivalent().deprecatedNode()))
         return 0;
 
     return listNode;
@@ -351,7 +351,7 @@ PassRefPtr<HTMLElement> InsertListCommand::listifyParagraph(const VisiblePositio
         listElement = createHTMLElement(document(), listTag);
         appendNode(listItemElement, listElement);
 
-        if (start == end && isBlock(start.deepEquivalent().node())) {
+        if (start == end && isBlock(start.deepEquivalent().deprecatedNode())) {
             // Inserting the list into an empty paragraph that isn't held open 
             // by a br or a '\n', will invalidate start and end.  Insert 
             // a placeholder and then recompute start and end.
@@ -367,7 +367,7 @@ PassRefPtr<HTMLElement> InsertListCommand::listifyParagraph(const VisiblePositio
         // clean markup when inline elements are pushed down as far as possible.
         Position insertionPos(start.deepEquivalent().upstream());
         // Also avoid the containing list item.
-        Node* listChild = enclosingListChild(insertionPos.node());
+        Node* listChild = enclosingListChild(insertionPos.deprecatedNode());
         if (listChild && listChild->hasTagName(liTag))
             insertionPos = positionInParentBeforeNode(listChild);
 
index 1d50851..4bb1e95 100644 (file)
@@ -169,8 +169,8 @@ void InsertParagraphSeparatorCommand::doApply()
             || isTableCell(startBlock)
             || startBlock->hasTagName(formTag)
             // FIXME: If the node is hidden, we don't have a canonical position so we will do the wrong thing for tables and <hr>. https://bugs.webkit.org/show_bug.cgi?id=40342
-            || (!canonicalPos.isNull() && canonicalPos.node()->renderer() && canonicalPos.node()->renderer()->isTable())
-            || (!canonicalPos.isNull() && canonicalPos.node()->hasTagName(hrTag))) {
+            || (!canonicalPos.isNull() && canonicalPos.deprecatedNode()->renderer() && canonicalPos.deprecatedNode()->renderer()->isTable())
+            || (!canonicalPos.isNull() && canonicalPos.deprecatedNode()->hasTagName(hrTag))) {
         applyCommandToComposite(InsertLineBreakCommand::create(document()));
         return;
     }
@@ -237,7 +237,7 @@ void InsertParagraphSeparatorCommand::doApply()
         // Recreate the same structure in the new paragraph.
         
         Vector<Element*> ancestors;
-        getAncestorsInsideBlock(insertionPosition.node(), startBlock, ancestors);      
+        getAncestorsInsideBlock(insertionPosition.deprecatedNode(), startBlock, ancestors);      
         RefPtr<Element> parent = cloneHierarchyUnderNewBlock(ancestors, blockToInsert);
         
         appendBlockPlaceholder(parent);
@@ -254,11 +254,11 @@ void InsertParagraphSeparatorCommand::doApply()
         Node *refNode;
         if (isFirstInBlock && !nestNewBlock)
             refNode = startBlock;
-        else if (insertionPosition.node() == startBlock && nestNewBlock) {
+        else if (insertionPosition.deprecatedNode() == startBlock && nestNewBlock) {
             refNode = startBlock->childNode(insertionPosition.deprecatedEditingOffset());
             ASSERT(refNode); // must be true or we'd be in the end of block case
         } else
-            refNode = insertionPosition.node();
+            refNode = insertionPosition.deprecatedNode();
 
         // find ending selection position easily before inserting the paragraph
         insertionPosition = insertionPosition.downstream();
@@ -268,7 +268,7 @@ void InsertParagraphSeparatorCommand::doApply()
         // Recreate the same structure in the new paragraph.
 
         Vector<Element*> ancestors;
-        getAncestorsInsideBlock(positionAvoidingSpecialElementBoundary(insertionPosition).node(), startBlock, ancestors);
+        getAncestorsInsideBlock(positionAvoidingSpecialElementBoundary(insertionPosition).deprecatedNode(), startBlock, ancestors);
         
         appendBlockPlaceholder(cloneHierarchyUnderNewBlock(ancestors, blockToInsert));
         
@@ -301,22 +301,22 @@ void InsertParagraphSeparatorCommand::doApply()
 
     // Build up list of ancestors in between the start node and the start block.
     Vector<Element*> ancestors;
-    getAncestorsInsideBlock(insertionPosition.node(), startBlock, ancestors);
+    getAncestorsInsideBlock(insertionPosition.deprecatedNode(), startBlock, ancestors);
 
     // Make sure we do not cause a rendered space to become unrendered.
     // FIXME: We need the affinity for pos, but pos.downstream() does not give it
     Position leadingWhitespace = insertionPosition.leadingWhitespacePosition(VP_DEFAULT_AFFINITY);
     // FIXME: leadingWhitespacePosition is returning the position before preserved newlines for positions
     // after the preserved newline, causing the newline to be turned into a nbsp.
-    if (leadingWhitespace.isNotNull() && leadingWhitespace.node()->isTextNode()) {
-        Text* textNode = static_cast<Text*>(leadingWhitespace.node());
+    if (leadingWhitespace.isNotNull() && leadingWhitespace.deprecatedNode()->isTextNode()) {
+        Text* textNode = static_cast<Text*>(leadingWhitespace.deprecatedNode());
         ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
         replaceTextInNode(textNode, leadingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
     }
     
     // Split at pos if in the middle of a text node.
-    if (insertionPosition.node()->isTextNode()) {
-        Text* textNode = static_cast<Text*>(insertionPosition.node());
+    if (insertionPosition.deprecatedNode()->isTextNode()) {
+        Text* textNode = static_cast<Text*>(insertionPosition.deprecatedNode());
         bool atEnd = (unsigned)insertionPosition.deprecatedEditingOffset() >= textNode->length();
         if (insertionPosition.deprecatedEditingOffset() > 0 && !atEnd) {
             splitTextNode(textNode, insertionPosition.deprecatedEditingOffset());
@@ -344,8 +344,8 @@ void InsertParagraphSeparatorCommand::doApply()
         appendNode(createBreakElement(document()).get(), blockToInsert.get());
         
     // Move the start node and the siblings of the start node.
-    if (insertionPosition.node() != startBlock) {
-        Node* n = insertionPosition.node();
+    if (insertionPosition.deprecatedNode() != startBlock) {
+        Node* n = insertionPosition.deprecatedNode();
         if (insertionPosition.deprecatedEditingOffset() >= caretMaxOffset(n))
             n = n->nextSibling();
 
@@ -382,10 +382,10 @@ void InsertParagraphSeparatorCommand::doApply()
             insertionPosition.moveToOffset(0);
         if (!insertionPosition.isRenderedCharacter()) {
             // Clear out all whitespace and insert one non-breaking space
-            ASSERT(!insertionPosition.node()->renderer() || insertionPosition.node()->renderer()->style()->collapseWhiteSpace());
+            ASSERT(!insertionPosition.deprecatedNode()->renderer() || insertionPosition.deprecatedNode()->renderer()->style()->collapseWhiteSpace());
             deleteInsignificantTextDownstream(insertionPosition);
-            if (insertionPosition.node()->isTextNode())
-                insertTextIntoNode(static_cast<Text*>(insertionPosition.node()), 0, nonBreakingSpaceString());
+            if (insertionPosition.deprecatedNode()->isTextNode())
+                insertTextIntoNode(static_cast<Text*>(insertionPosition.deprecatedNode()), 0, nonBreakingSpaceString());
         }
     }
 
index 1ec11ad..7e3d99d 100644 (file)
@@ -58,13 +58,13 @@ Position InsertTextCommand::prepareForTextInsertion(const Position& p)
     Position pos = p;
     // Prepare for text input by looking at the specified position.
     // It may be necessary to insert a text node to receive characters.
-    if (!pos.node()->isTextNode()) {
+    if (!pos.deprecatedNode()->isTextNode()) {
         RefPtr<Node> textNode = document()->createEditingTextNode("");
         insertNodeAt(textNode.get(), pos);
         return firstPositionInNode(textNode.get());
     }
 
-    if (isTabSpanTextNode(pos.node())) {
+    if (isTabSpanTextNode(pos.deprecatedNode())) {
         RefPtr<Node> textNode = document()->createEditingTextNode("");
         insertNodeAtTabSpanPosition(textNode.get(), pos);
         return firstPositionInNode(textNode.get());
@@ -147,9 +147,9 @@ void InsertTextCommand::input(const String& text, bool selectInsertedText, Rebal
     
     // It is possible for the node that contains startPosition to contain only unrendered whitespace,
     // and so deleteInsignificantText could remove it.  Save the position before the node in case that happens.
-    Position positionBeforeStartNode(positionInParentBeforeNode(startPosition.node()));
+    Position positionBeforeStartNode(positionInParentBeforeNode(startPosition.deprecatedNode()));
     deleteInsignificantText(startPosition.upstream(), startPosition.downstream());
-    if (!startPosition.node()->inDocument())
+    if (!startPosition.anchorNode()->inDocument())
         startPosition = positionBeforeStartNode;
     if (!startPosition.isCandidate())
         startPosition = startPosition.downstream();
@@ -168,7 +168,7 @@ void InsertTextCommand::input(const String& text, bool selectInsertedText, Rebal
         startPosition = prepareForTextInsertion(startPosition);
         if (placeholder.isNotNull())
             removePlaceholderAt(placeholder);
-        Text *textNode = static_cast<Text *>(startPosition.node());
+        Text* textNode = static_cast<Text*>(startPosition.deprecatedNode());
         int offset = startPosition.deprecatedEditingOffset();
 
         insertTextIntoNode(textNode, offset, text);
@@ -209,7 +209,7 @@ Position InsertTextCommand::insertTab(const Position& pos)
 {
     Position insertPos = VisiblePosition(pos, DOWNSTREAM).deepEquivalent();
         
-    Node *node = insertPos.node();
+    Node* node = insertPos.deprecatedNode();
     unsigned int offset = insertPos.deprecatedEditingOffset();
 
     // keep tabs coalesced in tab span
index 3e6754e..2a6e2f4 100644 (file)
@@ -52,12 +52,12 @@ static bool getStartEndListChildren(const VisibleSelection& selection, Node*& st
         return false;
 
     // start must be in a list child
-    Node* startListChild = enclosingListChild(selection.start().node());
+    Node* startListChild = enclosingListChild(selection.start().deprecatedNode());
     if (!startListChild)
         return false;
         
     // end must be in a list child
-    Node* endListChild = selection.isRange() ? enclosingListChild(selection.end().node()) : startListChild;
+    Node* endListChild = selection.isRange() ? enclosingListChild(selection.end().deprecatedNode()) : startListChild;
     if (!endListChild)
         return false;
     
index 2f63217..cdf05ee 100644 (file)
@@ -32,7 +32,7 @@
 namespace WebCore {
 
 MoveSelectionCommand::MoveSelectionCommand(PassRefPtr<DocumentFragment> fragment, const Position& position, bool smartInsert, bool smartDelete) 
-    : CompositeEditCommand(position.node()->document()), m_fragment(fragment), m_position(position), m_smartInsert(smartInsert), m_smartDelete(smartDelete)
+    : CompositeEditCommand(position.anchorNode()->document()), m_fragment(fragment), m_position(position), m_smartInsert(smartInsert), m_smartDelete(smartDelete)
 {
     ASSERT(m_fragment);
 }
@@ -62,7 +62,7 @@ void MoveSelectionCommand::doApply()
     // set the destination to the ending point after the deletion.
     // Fixes: <rdar://problem/3910425> REGRESSION (Mail): Crash in ReplaceSelectionCommand; 
     //        selection is empty, leading to null deref
-    if (!pos.node()->inDocument())
+    if (!pos.anchorNode()->inDocument())
         pos = endingSelection().start();
 
     setEndingSelection(VisibleSelection(pos, endingSelection().affinity()));
index 1783631..8e048a0 100644 (file)
@@ -110,15 +110,15 @@ static bool isInterchangeConvertedSpaceSpan(const Node *node)
 static Position positionAvoidingPrecedingNodes(Position pos)
 {
     // If we're already on a break, it's probably a placeholder and we shouldn't change our position.
-    if (pos.node()->hasTagName(brTag))
+    if (pos.deprecatedNode()->hasTagName(brTag))
         return pos;
 
     // We also stop when changing block flow elements because even though the visual position is the
     // same.  E.g.,
     //   <div>foo^</div>^
     // The two positions above are the same visual position, but we want to stay in the same block.
-    Node* stopNode = pos.node()->enclosingBlockFlowElement();
-    while (stopNode != pos.node() && VisiblePosition(pos) == VisiblePosition(pos.next()))
+    Node* stopNode = pos.deprecatedNode()->enclosingBlockFlowElement();
+    while (stopNode != pos.deprecatedNode() && VisiblePosition(pos) == VisiblePosition(pos.next()))
         pos = pos.next();
     return pos;
 }
@@ -152,7 +152,7 @@ ReplacementFragment::ReplacementFragment(Document* document, DocumentFragment* f
         return;
     }
 
-    Node* styleNode = selection.base().node();
+    Node* styleNode = selection.base().deprecatedNode();
     RefPtr<StyledElement> holder = insertFragmentForTestRendering(styleNode);
     
     RefPtr<Range> range = VisibleSelection::selectionFromContentsOfNode(holder.get()).toNormalizedRange();
@@ -357,7 +357,7 @@ static bool hasMatchingQuoteLevel(VisiblePosition endOfExistingContent, VisibleP
 {
     Position existing = endOfExistingContent.deepEquivalent();
     Position inserted = endOfInsertedContent.deepEquivalent();
-    bool isInsideMailBlockquote = nearestMailBlockquote(inserted.node());
+    bool isInsideMailBlockquote = nearestMailBlockquote(inserted.deprecatedNode());
     return isInsideMailBlockquote && (numEnclosingMailBlockquotes(existing) == numEnclosingMailBlockquotes(inserted));
 }
 
@@ -379,11 +379,11 @@ bool ReplaceSelectionCommand::shouldMergeStart(bool selectionStartWasStartOfPara
     if (isStartOfParagraph(startOfInsertedContent) && selectionStartWasInsideMailBlockquote && hasMatchingQuoteLevel(prev, positionAtEndOfInsertedContent()))
         return true;
 
-    return !selectionStartWasStartOfParagraph && 
-           !fragmentHasInterchangeNewlineAtStart &&
-           isStartOfParagraph(startOfInsertedContent) && 
-           !startOfInsertedContent.deepEquivalent().node()->hasTagName(brTag) &&
-           shouldMerge(startOfInsertedContent, prev);
+    return !selectionStartWasStartOfParagraph
+        && !fragmentHasInterchangeNewlineAtStart
+        && isStartOfParagraph(startOfInsertedContent)
+        && !startOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)
+        && shouldMerge(startOfInsertedContent, prev);
 }
 
 bool ReplaceSelectionCommand::shouldMergeEnd(bool selectionEndWasEndOfParagraph)
@@ -393,10 +393,10 @@ bool ReplaceSelectionCommand::shouldMergeEnd(bool selectionEndWasEndOfParagraph)
     if (next.isNull())
         return false;
 
-    return !selectionEndWasEndOfParagraph &&
-           isEndOfParagraph(endOfInsertedContent) && 
-           !endOfInsertedContent.deepEquivalent().node()->hasTagName(brTag) &&
-           shouldMerge(endOfInsertedContent, next);
+    return !selectionEndWasEndOfParagraph
+        && isEndOfParagraph(endOfInsertedContent)
+        && !endOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)
+        && shouldMerge(endOfInsertedContent, next);
 }
 
 static bool isMailPasteAsQuotationNode(const Node* node)
@@ -453,8 +453,8 @@ bool ReplaceSelectionCommand::shouldMerge(const VisiblePosition& source, const V
     if (source.isNull() || destination.isNull())
         return false;
         
-    Node* sourceNode = source.deepEquivalent().node();
-    Node* destinationNode = destination.deepEquivalent().node();
+    Node* sourceNode = source.deepEquivalent().deprecatedNode();
+    Node* destinationNode = destination.deepEquivalent().deprecatedNode();
     Node* sourceBlock = enclosingBlock(sourceNode);
     Node* destinationBlock = enclosingBlock(destinationNode);
     return !enclosingNodeOfType(source.deepEquivalent(), &isMailPasteAsQuotationNode) &&
@@ -740,7 +740,7 @@ void ReplaceSelectionCommand::mergeEndIfNeeded()
     // To avoid this, we add a placeholder node before the start of the paragraph.
     if (endOfParagraph(startOfParagraphToMove) == destination) {
         RefPtr<Node> placeholder = createBreakElement(document());
-        insertNodeBefore(placeholder, startOfParagraphToMove.deepEquivalent().node());
+        insertNodeBefore(placeholder, startOfParagraphToMove.deepEquivalent().deprecatedNode());
         destination = VisiblePosition(positionBeforeNode(placeholder.get()));
     }
 
@@ -751,9 +751,9 @@ void ReplaceSelectionCommand::mergeEndIfNeeded()
     // only ever used to create positions where inserted content starts/ends.  Also, we sometimes insert content
     // directly into text nodes already in the document, in which case tracking inserted nodes is inadequate.
     if (mergeForward) {
-        m_lastLeafInserted = destination.previous().deepEquivalent().node();
+        m_lastLeafInserted = destination.previous().deepEquivalent().deprecatedNode();
         if (!m_firstNodeInserted->inDocument())
-            m_firstNodeInserted = endingSelection().visibleStart().deepEquivalent().node();
+            m_firstNodeInserted = endingSelection().visibleStart().deepEquivalent().deprecatedNode();
         // If we merged text nodes, m_lastLeafInserted could be null. If this is the case,
         // we use m_firstNodeInserted.
         if (!m_lastLeafInserted)
@@ -780,8 +780,8 @@ void ReplaceSelectionCommand::doApply()
 {
     VisibleSelection selection = endingSelection();
     ASSERT(selection.isCaretOrRange());
-    ASSERT(selection.start().node());
-    if (!selection.isNonOrphanedCaretOrRange() || !selection.start().node())
+    ASSERT(selection.start().deprecatedNode());
+    if (!selection.isNonOrphanedCaretOrRange() || !selection.start().deprecatedNode())
         return;
     
     bool selectionIsPlainText = !selection.isContentRichlyEditable();
@@ -793,8 +793,8 @@ void ReplaceSelectionCommand::doApply()
         return;
     
     // We can skip matching the style if the selection is plain text.
-    if ((selection.start().node()->renderer() && selection.start().node()->renderer()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY) &&
-        (selection.end().node()->renderer() && selection.end().node()->renderer()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY))
+    if ((selection.start().deprecatedNode()->renderer() && selection.start().deprecatedNode()->renderer()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY)
+        && (selection.end().deprecatedNode()->renderer() && selection.end().deprecatedNode()->renderer()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY))
         m_matchStyle = false;
     
     if (m_matchStyle)
@@ -806,10 +806,10 @@ void ReplaceSelectionCommand::doApply()
     bool selectionEndWasEndOfParagraph = isEndOfParagraph(visibleEnd);
     bool selectionStartWasStartOfParagraph = isStartOfParagraph(visibleStart);
     
-    Node* startBlock = enclosingBlock(visibleStart.deepEquivalent().node());
+    Node* startBlock = enclosingBlock(visibleStart.deepEquivalent().deprecatedNode());
     
     Position insertionPos = selection.start();
-    bool startIsInsideMailBlockquote = nearestMailBlockquote(insertionPos.node());
+    bool startIsInsideMailBlockquote = nearestMailBlockquote(insertionPos.deprecatedNode());
     
     if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph && !startIsInsideMailBlockquote) ||
         startBlock == currentRoot || isListItem(startBlock) || selectionIsPlainText)
@@ -862,7 +862,7 @@ void ReplaceSelectionCommand::doApply()
     if (startIsInsideMailBlockquote && m_preventNesting && !(enclosingNodeOfType(insertionPos, &isTableStructureNode))) { 
         applyCommandToComposite(BreakBlockquoteCommand::create(document())); 
         // This will leave a br between the split. 
-        Node* br = endingSelection().start().node(); 
+        Node* br = endingSelection().start().deprecatedNode(); 
         ASSERT(br->hasTagName(brTag)); 
         // Insert content between the two blockquotes, but remove the br (since it was just a placeholder). 
         insertionPos = positionInParentBeforeNode(br);
@@ -873,18 +873,18 @@ void ReplaceSelectionCommand::doApply()
     prepareWhitespaceAtPositionForSplit(insertionPos);
 
     // If the downstream node has been removed there's no point in continuing.
-    if (!insertionPos.downstream().node())
+    if (!insertionPos.downstream().deprecatedNode())
       return;
     
     // NOTE: This would be an incorrect usage of downstream() if downstream() were changed to mean the last position after 
     // p that maps to the same visible position as p (since in the case where a br is at the end of a block and collapsed 
     // away, there are positions after the br which map to the same visible position as [br, 0]).  
-    Node* endBR = insertionPos.downstream().node()->hasTagName(brTag) ? insertionPos.downstream().node() : 0;
+    Node* endBR = insertionPos.downstream().deprecatedNode()->hasTagName(brTag) ? insertionPos.downstream().deprecatedNode() : 0;
     VisiblePosition originalVisPosBeforeEndBR;
     if (endBR)
         originalVisPosBeforeEndBR = VisiblePosition(endBR, 0, DOWNSTREAM).previous();
     
-    startBlock = enclosingBlock(insertionPos.node());
+    startBlock = enclosingBlock(insertionPos.deprecatedNode());
     
     // Adjust insertionPos to prevent nesting.
     // If the start was in a Mail blockquote, we will have already handled adjusting insertionPos above.
@@ -939,7 +939,7 @@ void ReplaceSelectionCommand::doApply()
     
     fragment.removeNode(refNode);
 
-    Node* blockStart = enclosingBlock(insertionPos.node());
+    Node* blockStart = enclosingBlock(insertionPos.deprecatedNode());
     if ((isListElement(refNode.get()) || (isStyleSpan(refNode.get()) && isListElement(refNode->firstChild())))
         && blockStart->renderer()->isListItem())
         refNode = insertAsListItems(refNode, blockStart, insertionPos);
@@ -983,7 +983,7 @@ void ReplaceSelectionCommand::doApply()
     
     // We inserted before the startBlock to prevent nesting, and the content before the startBlock wasn't in its own block and
     // didn't have a br after it, so the inserted content ended up in the same paragraph.
-    if (startBlock && insertionPos.node() == startBlock->parentNode() && (unsigned)insertionPos.deprecatedEditingOffset() < startBlock->nodeIndex() && !isStartOfParagraph(startOfInsertedContent))
+    if (startBlock && insertionPos.deprecatedNode() == startBlock->parentNode() && (unsigned)insertionPos.deprecatedEditingOffset() < startBlock->nodeIndex() && !isStartOfParagraph(startOfInsertedContent))
         insertNodeAt(createBreakElement(document()).get(), startOfInsertedContent.deepEquivalent());
     
     Position lastPositionToSelect;
@@ -1003,7 +1003,7 @@ void ReplaceSelectionCommand::doApply()
         // We need to handle the case where we need to merge the end
         // but our destination node is inside an inline that is the last in the block.
         // We insert a placeholder before the newly inserted content to avoid being merged into the inline.
-        Node* destinationNode = destination.deepEquivalent().node();
+        Node* destinationNode = destination.deepEquivalent().deprecatedNode();
         if (m_shouldMergeEnd && destinationNode != enclosingInline(destinationNode) && enclosingInline(destinationNode)->nextSibling())
             insertNodeBefore(createBreakElement(document()), refNode.get());
         
@@ -1018,16 +1018,16 @@ void ReplaceSelectionCommand::doApply()
         if (startOfParagraph(endOfInsertedContent) == startOfParagraphToMove) {
             insertNodeAt(createBreakElement(document()).get(), endOfInsertedContent.deepEquivalent());
             // Mutation events (bug 22634) triggered by inserting the <br> might have removed the content we're about to move
-            if (!startOfParagraphToMove.deepEquivalent().node()->inDocument())
+            if (!startOfParagraphToMove.deepEquivalent().anchorNode()->inDocument())
                 return;
         }
 
         // FIXME: Maintain positions for the start and end of inserted content instead of keeping nodes.  The nodes are
         // only ever used to create positions where inserted content starts/ends.
         moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination);
-        m_firstNodeInserted = endingSelection().visibleStart().deepEquivalent().downstream().node();
+        m_firstNodeInserted = endingSelection().visibleStart().deepEquivalent().downstream().deprecatedNode();
         if (!m_lastLeafInserted->inDocument())
-            m_lastLeafInserted = endingSelection().visibleEnd().deepEquivalent().upstream().node();
+            m_lastLeafInserted = endingSelection().visibleEnd().deepEquivalent().upstream().deprecatedNode();
     }
             
     endOfInsertedContent = positionAtEndOfInsertedContent();
@@ -1039,7 +1039,7 @@ void ReplaceSelectionCommand::doApply()
         if (selectionEndWasEndOfParagraph || !isEndOfParagraph(endOfInsertedContent) || next.isNull()) {
             if (!isStartOfParagraph(endOfInsertedContent)) {
                 setEndingSelection(endOfInsertedContent);
-                Node* enclosingNode = enclosingBlock(endOfInsertedContent.deepEquivalent().node());
+                Node* enclosingNode = enclosingBlock(endOfInsertedContent.deepEquivalent().deprecatedNode());
                 if (isListItem(enclosingNode)) {
                     RefPtr<Node> newListItem = createListItemElement(document());
                     insertNodeAfter(newListItem, enclosingNode);
@@ -1051,7 +1051,7 @@ void ReplaceSelectionCommand::doApply()
 
                 // Select up to the paragraph separator that was added.
                 lastPositionToSelect = endingSelection().visibleStart().deepEquivalent();
-                updateNodesInserted(lastPositionToSelect.node());
+                updateNodesInserted(lastPositionToSelect.deprecatedNode());
             }
         } else {
             // Select up to the beginning of the next paragraph.
@@ -1079,7 +1079,7 @@ void ReplaceSelectionCommand::doApply()
         if (needsTrailingSpace) {
             RenderObject* renderer = m_lastLeafInserted->renderer();
             bool collapseWhiteSpace = !renderer || renderer->style()->collapseWhiteSpace();
-            Node* endNode = positionAtEndOfInsertedContent().deepEquivalent().upstream().node();
+            Node* endNode = positionAtEndOfInsertedContent().deepEquivalent().upstream().deprecatedNode();
             if (endNode->isTextNode()) {
                 Text* text = static_cast<Text*>(endNode);
                 insertTextIntoNode(text, text->length(), collapseWhiteSpace ? nonBreakingSpaceString() : " ");
@@ -1094,7 +1094,7 @@ void ReplaceSelectionCommand::doApply()
         if (needsLeadingSpace) {
             RenderObject* renderer = m_lastLeafInserted->renderer();
             bool collapseWhiteSpace = !renderer || renderer->style()->collapseWhiteSpace();
-            Node* startNode = positionAtStartOfInsertedContent().deepEquivalent().downstream().node();
+            Node* startNode = positionAtStartOfInsertedContent().deepEquivalent().downstream().deprecatedNode();
             if (startNode->isTextNode()) {
                 Text* text = static_cast<Text*>(startNode);
                 insertTextIntoNode(text, 0, collapseWhiteSpace ? nonBreakingSpaceString() : " ");
@@ -1212,9 +1212,9 @@ Node* ReplaceSelectionCommand::insertAsListItems(PassRefPtr<Node> listElement, N
     // list items and insert these nodes between them.
     if (isMiddle) {
         int textNodeOffset = insertPos.offsetInContainerNode();
-        if (insertPos.node()->isTextNode() && textNodeOffset > 0)
-            splitTextNode(static_cast<Text*>(insertPos.node()), textNodeOffset);
-        splitTreeToNode(insertPos.node(), lastNode, true);
+        if (insertPos.deprecatedNode()->isTextNode() && textNodeOffset > 0)
+            splitTextNode(static_cast<Text*>(insertPos.deprecatedNode()), textNodeOffset);
+        splitTreeToNode(insertPos.deprecatedNode(), lastNode, true);
     }
 
     while (RefPtr<Node> listItem = listElement->firstChild()) {
index 5cf5cb7..f89cb36 100644 (file)
@@ -150,7 +150,7 @@ void SelectionController::setSelection(const VisibleSelection& s, SetSelectionOp
         return;
     }
 
-    Node* baseNode = s.base().node();
+    Node* baseNode = s.base().deprecatedNode();
     Document* document = 0;
     if (baseNode)
         document = baseNode->document();
@@ -204,17 +204,17 @@ void SelectionController::setSelection(const VisibleSelection& s, SetSelectionOp
 
 static bool removingNodeRemovesPosition(Node* node, const Position& position)
 {
-    if (!position.node())
+    if (!position.deprecatedNode())
         return false;
 
-    if (position.node() == node)
+    if (position.deprecatedNode() == node)
         return true;
 
     if (!node->isElementNode())
         return false;
 
     Element* element = static_cast<Element*>(node);
-    return element->contains(position.node()) || element->contains(position.node()->shadowAncestorNode());
+    return element->contains(position.deprecatedNode()) || element->contains(position.deprecatedNode()->shadowAncestorNode());
 }
 
 void SelectionController::nodeWillBeRemoved(Node *node)
@@ -262,7 +262,7 @@ void SelectionController::respondToNodeModification(Node* node, bool baseRemoved
     }
 
     if (clearRenderTreeSelection) {
-        RefPtr<Document> document = m_selection.start().node()->document();
+        RefPtr<Document> document = m_selection.start().anchorNode()->document();
         document->updateStyleIfNeeded();
         if (RenderView* view = toRenderView(document->renderer()))
             view->clearSelection();
@@ -375,7 +375,7 @@ void SelectionController::willBeModified(EAlteration alter, SelectionDirection d
 
 TextDirection SelectionController::directionOfEnclosingBlock()
 {
-    Node* enclosingBlockNode = enclosingBlock(m_selection.extent().node());
+    Node* enclosingBlockNode = enclosingBlock(m_selection.extent().deprecatedNode());
     if (!enclosingBlockNode)
         return LTR;
     RenderObject* renderer = enclosingBlockNode->renderer();
@@ -931,7 +931,7 @@ int SelectionController::xPosForVerticalArrowNavigation(EPositionType type)
         break;
     }
 
-    Frame* frame = pos.node()->document()->frame();
+    Frame* frame = pos.anchorNode()->document()->frame();
     if (!frame)
         return x;
         
@@ -1008,19 +1008,19 @@ void SelectionController::setCaretRectNeedsUpdate(bool flag)
 
 void SelectionController::updateCaretRect()
 {
-    if (isNone() || !m_selection.start().node()->inDocument() || !m_selection.end().node()->inDocument()) {
+    if (isNone() || !m_selection.start().anchorNode()->inDocument() || !m_selection.end().anchorNode()->inDocument()) {
         m_caretRect = IntRect();
         return;
     }
 
-    m_selection.start().node()->document()->updateStyleIfNeeded();
+    m_selection.start().anchorNode()->document()->updateStyleIfNeeded();
     
     m_caretRect = IntRect();
         
     if (isCaret()) {
         VisiblePosition pos(m_selection.start(), m_selection.affinity());
         if (pos.isNotNull()) {
-            ASSERT(pos.deepEquivalent().node()->renderer());
+            ASSERT(pos.deepEquivalent().deprecatedNode()->renderer());
             
             // First compute a rect local to the renderer at the selection start
             RenderObject* renderer;
@@ -1054,7 +1054,7 @@ void SelectionController::updateCaretRect()
 
 RenderObject* SelectionController::caretRenderer() const
 {
-    Node* node = m_selection.start().node();
+    Node* node = m_selection.start().deprecatedNode();
     if (!node)
         return 0;
 
@@ -1161,7 +1161,7 @@ void SelectionController::invalidateCaretRect()
     if (!isCaret())
         return;
 
-    Document* d = m_selection.start().node()->document();
+    Document* d = m_selection.start().anchorNode()->document();
 
     // recomputeCaretRect will always return false for the drag caret,
     // because its m_frame is always 0.
@@ -1239,9 +1239,9 @@ void SelectionController::debugRenderer(RenderObject *r, bool selected) const
         int textLength = text.length();
         if (selected) {
             int offset = 0;
-            if (r->node() == m_selection.start().node())
+            if (r->node() == m_selection.start().deprecatedNode())
                 offset = m_selection.start().deprecatedEditingOffset();
-            else if (r->node() == m_selection.end().node())
+            else if (r->node() == m_selection.end().deprecatedNode())
                 offset = m_selection.end().deprecatedEditingOffset();
                 
             int pos;
@@ -1439,7 +1439,7 @@ bool SelectionController::setSelectedRange(Range* range, EAffinity affinity, boo
 
 bool SelectionController::isInPasswordField() const
 {
-    Node* startNode = start().node();
+    Node* startNode = start().deprecatedNode();
     if (!startNode)
         return false;
 
@@ -1585,8 +1585,8 @@ void SelectionController::updateAppearance()
     // We can get into a state where the selection endpoints map to the same VisiblePosition when a selection is deleted
     // because we don't yet notify the SelectionController of text removal.
     if (startPos.isNotNull() && endPos.isNotNull() && selection.visibleStart() != selection.visibleEnd()) {
-        RenderObject* startRenderer = startPos.node()->renderer();
-        RenderObject* endRenderer = endPos.node()->renderer();
+        RenderObject* startRenderer = startPos.deprecatedNode()->renderer();
+        RenderObject* endRenderer = endPos.deprecatedNode()->renderer();
         view->setSelection(startRenderer, startPos.deprecatedEditingOffset(), endRenderer, endPos.deprecatedEditingOffset());
     }
 }
@@ -1687,7 +1687,7 @@ void SelectionController::paintDragCaret(GraphicsContext* p, int tx, int ty, con
 #if ENABLE(TEXT_CARET)
     SelectionController* dragCaretController = m_frame->page()->dragCaretController();
     ASSERT(dragCaretController->selection().isCaret());
-    if (dragCaretController->selection().start().node()->document()->frame() == m_frame)
+    if (dragCaretController->selection().start().anchorNode()->document()->frame() == m_frame)
         dragCaretController->paintCaret(p, tx, ty, clipRect);
 #else
     UNUSED_PARAM(p);
@@ -1761,7 +1761,7 @@ HTMLFormElement* SelectionController::currentForm() const
     // Start looking either at the active (first responder) node, or where the selection is.
     Node* start = m_frame->document()->focusedNode();
     if (!start)
-        start = this->start().node();
+        start = this->start().deprecatedNode();
 
     // Try walking up the node tree to find a form element.
     Node* node;
@@ -1792,12 +1792,12 @@ void SelectionController::revealSelection(const ScrollAlignment& alignment, bool
     }
 
     Position start = this->start();
-    ASSERT(start.node());
-    if (start.node() && start.node()->renderer()) {
+    ASSERT(start.deprecatedNode());
+    if (start.deprecatedNode() && start.deprecatedNode()->renderer()) {
         // FIXME: This code only handles scrolling the startContainer's layer, but
         // the selection rect could intersect more than just that.
         // See <rdar://problem/4799899>.
-        if (RenderLayer* layer = start.node()->renderer()->enclosingLayer()) {
+        if (RenderLayer* layer = start.deprecatedNode()->renderer()->enclosingLayer()) {
             layer->scrollRectToVisible(rect, false, alignment, alignment);
             updateAppearance();
         }
index 3cdb777..a96e0ad 100644 (file)
@@ -31,7 +31,7 @@
 namespace WebCore {
 
 SetSelectionCommand::SetSelectionCommand(const VisibleSelection& selection, SelectionController::SetSelectionOptions options)
-    : SimpleEditCommand(selection.base().node()->document())
+    : SimpleEditCommand(selection.base().anchorNode()->document())
     , m_options(options)
     , m_selectionToSet(selection)
 {
index b621dc2..d3a6596 100644 (file)
@@ -2346,7 +2346,7 @@ PassRefPtr<Range> TextIterator::rangeFromLocationAndLength(Element* scope, int r
                     Position runEnd = VisiblePosition(runStart).next().deepEquivalent();
                     if (runEnd.isNotNull()) {
                         ExceptionCode ec = 0;
-                        textRunRange->setEnd(runEnd.node(), runEnd.deprecatedEditingOffset(), ec);
+                        textRunRange->setEnd(runEnd.deprecatedNode(), runEnd.deprecatedEditingOffset(), ec);
                         ASSERT(!ec);
                     }
                 }
index 9723c2d..7f2c2e4 100644 (file)
@@ -161,7 +161,7 @@ void TypingCommand::insertText(Document* document, const String& text, const Vis
     VisibleSelection currentSelection = frame->selection()->selection();
     bool changeSelection = currentSelection != selectionForInsertion;
     String newText = text;
-    Node* startNode = selectionForInsertion.start().node();
+    Node* startNode = selectionForInsertion.start().deprecatedNode();
     
     if (startNode && startNode->rootEditableElement() && compositionType != TextCompositionUpdate) {
         // Send BeforeTextInsertedEvent. The event handler will update text if necessary.
@@ -483,7 +483,7 @@ void TypingCommand::deleteKeyPressed(TextGranularity granularity, bool killRing)
 
         VisiblePosition visibleStart(endingSelection().visibleStart());
         // If we have a caret selection on an empty cell, we have nothing to do.
-        if (isEmptyTableCell(visibleStart.deepEquivalent().node()))
+        if (isEmptyTableCell(visibleStart.deepEquivalent().deprecatedNode()))
             return;
 
         // If the caret is at the start of a paragraph after a table, move content into the last table cell.
@@ -502,7 +502,7 @@ void TypingCommand::deleteKeyPressed(TextGranularity granularity, bool killRing)
 
         selectionToDelete = selection.selection();
 
-        if (granularity == CharacterGranularity && selectionToDelete.end().node() == selectionToDelete.start().node() && selectionToDelete.end().deprecatedEditingOffset() - selectionToDelete.start().deprecatedEditingOffset() > 1) {
+        if (granularity == CharacterGranularity && selectionToDelete.end().deprecatedNode() == selectionToDelete.start().deprecatedNode() && selectionToDelete.end().deprecatedEditingOffset() - selectionToDelete.start().deprecatedEditingOffset() > 1) {
             // If there are multiple Unicode code points to be deleted, adjust the range to match platform conventions.
             selectionToDelete.setWithoutValidation(selectionToDelete.end(), selectionToDelete.end().previous(BackwardDeletion));
         }
@@ -570,8 +570,8 @@ void TypingCommand::forwardDeleteKeyPressed(TextGranularity granularity, bool ki
         if (visibleEnd == endOfParagraph(visibleEnd))
             downstreamEnd = visibleEnd.next(true).deepEquivalent().downstream();
         // When deleting tables: Select the table first, then perform the deletion
-        if (downstreamEnd.node() && downstreamEnd.node()->renderer() && downstreamEnd.node()->renderer()->isTable() && !downstreamEnd.deprecatedEditingOffset()) {
-            setEndingSelection(VisibleSelection(endingSelection().end(), lastDeepEditingPositionForNode(downstreamEnd.node()), DOWNSTREAM));
+        if (downstreamEnd.deprecatedNode() && downstreamEnd.deprecatedNode()->renderer() && downstreamEnd.deprecatedNode()->renderer()->isTable() && !downstreamEnd.deprecatedEditingOffset()) {
+            setEndingSelection(VisibleSelection(endingSelection().end(), lastDeepEditingPositionForNode(downstreamEnd.deprecatedNode()), DOWNSTREAM));
             typingAddedToOpenCommand(ForwardDeleteKey);
             return;
         }
@@ -588,15 +588,15 @@ void TypingCommand::forwardDeleteKeyPressed(TextGranularity granularity, bool ki
             // We can't let the VisibleSelection class's validation kick in or it'll adjust for us based on
             // the current state of the document and we'll get the wrong result.
             Position extent = startingSelection().end();
-            if (extent.node() != selectionToDelete.end().node())
+            if (extent.deprecatedNode() != selectionToDelete.end().deprecatedNode())
                 extent = selectionToDelete.extent();
             else {
                 int extraCharacters;
-                if (selectionToDelete.start().node() == selectionToDelete.end().node())
+                if (selectionToDelete.start().deprecatedNode() == selectionToDelete.end().deprecatedNode())
                     extraCharacters = selectionToDelete.end().deprecatedEditingOffset() - selectionToDelete.start().deprecatedEditingOffset();
                 else
                     extraCharacters = selectionToDelete.end().deprecatedEditingOffset();
-                extent = Position(extent.node(), extent.deprecatedEditingOffset() + extraCharacters, Position::PositionIsOffsetInAnchor);
+                extent = Position(extent.deprecatedNode(), extent.deprecatedEditingOffset() + extraCharacters, Position::PositionIsOffsetInAnchor);
             }
             selectionAfterUndo.setWithoutValidation(startingSelection().start(), extent);
         }
index 734e28f..576fcb3 100644 (file)
@@ -106,7 +106,7 @@ VisiblePosition VisiblePosition::previous(bool stayInEditableContent) const
 Position VisiblePosition::leftVisuallyDistinctCandidate() const
 {
     Position p = m_deepPosition;
-    if (!p.node())
+    if (!p.deprecatedNode())
         return Position();
 
     Position downstreamStart = p.downstream();
@@ -242,7 +242,7 @@ VisiblePosition VisiblePosition::left(bool stayInEditableContent) const
 Position VisiblePosition::rightVisuallyDistinctCandidate() const
 {
     Position p = m_deepPosition;
-    if (!p.node())
+    if (!p.deprecatedNode())
         return Position();
 
     Position downstreamStart = p.downstream();
@@ -384,7 +384,7 @@ VisiblePosition VisiblePosition::honorEditableBoundaryAtOrBefore(const VisiblePo
     Node* highestRoot = highestEditableRoot(deepEquivalent());
     
     // Return empty position if pos is not somewhere inside the editable region containing this position
-    if (highestRoot && !pos.deepEquivalent().node()->isDescendantOf(highestRoot))
+    if (highestRoot && !pos.deepEquivalent().deprecatedNode()->isDescendantOf(highestRoot))
         return VisiblePosition();
         
     // Return pos itself if the two are from the very same editable region, or both are non-editable
@@ -410,7 +410,7 @@ VisiblePosition VisiblePosition::honorEditableBoundaryAtOrAfter(const VisiblePos
     Node* highestRoot = highestEditableRoot(deepEquivalent());
     
     // Return empty position if pos is not somewhere inside the editable region containing this position
-    if (highestRoot && !pos.deepEquivalent().node()->isDescendantOf(highestRoot))
+    if (highestRoot && !pos.deepEquivalent().deprecatedNode()->isDescendantOf(highestRoot))
         return VisiblePosition();
     
     // Return pos itself if the two are from the very same editable region, or both are non-editable
@@ -451,7 +451,7 @@ Position VisiblePosition::canonicalPosition(const Position& passedPosition)
     // To fix this, we need to either a) add code to all paintCarets to pass the responsibility off to
     // the appropriate renderer for VisiblePosition's like these, or b) canonicalize to the rightmost candidate
     // unless the affinity is upstream.
-    Node* node = position.node();
+    Node* node = position.deprecatedNode();
     if (!node)
         return Position();
 
@@ -469,8 +469,8 @@ Position VisiblePosition::canonicalPosition(const Position& passedPosition)
     // blocks or enter new ones), we search forward and backward until we find one.
     Position next = canonicalizeCandidate(nextCandidate(position));
     Position prev = canonicalizeCandidate(previousCandidate(position));
-    Node* nextNode = next.node();
-    Node* prevNode = prev.node();
+    Node* nextNode = next.deprecatedNode();
+    Node* prevNode = prev.deprecatedNode();
 
     // 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.
@@ -481,7 +481,7 @@ Position VisiblePosition::canonicalPosition(const Position& passedPosition)
         
     // If the html element is editable, descending into its body will look like a descent 
     // from non-editable to editable content since rootEditableElement() always stops at the body.
-    if ((editingRoot && editingRoot->hasTagName(htmlTag)) || position.node()->isDocumentNode())
+    if ((editingRoot && editingRoot->hasTagName(htmlTag)) || position.deprecatedNode()->isDocumentNode())
         return next.isNotNull() ? next : prev;
         
     bool prevIsInSameEditableElement = prevNode && editableRootForPosition(prev) == editingRoot;
@@ -510,10 +510,10 @@ UChar32 VisiblePosition::characterAfter() const
     // We canonicalize to the first of two equivalent candidates, but the second of the two candidates
     // is the one that will be inside the text node containing the character after this visible position.
     Position pos = m_deepPosition.downstream();
-    Node* node = pos.node();
+    Node* node = pos.deprecatedNode();
     if (!node || !node->isTextNode())
         return 0;
-    Text* textNode = static_cast<Text*>(pos.node());
+    Text* textNode = static_cast<Text*>(pos.deprecatedNode());
     unsigned offset = pos.deprecatedEditingOffset();
     unsigned length = textNode->length();
     if (offset >= length)
@@ -527,7 +527,7 @@ UChar32 VisiblePosition::characterAfter() const
 
 IntRect VisiblePosition::localCaretRect(RenderObject*& renderer) const
 {
-    Node* node = m_deepPosition.node();
+    Node* node = m_deepPosition.deprecatedNode();
     if (!node) {
         renderer = 0;
         return IntRect();
@@ -577,7 +577,7 @@ void VisiblePosition::debugPosition(const char* msg) const
     if (isNull())
         fprintf(stderr, "Position [%s]: null\n", msg);
     else {
-        fprintf(stderr, "Position [%s]: %s, ", msg, m_deepPosition.node()->nodeName().utf8().data());
+        fprintf(stderr, "Position [%s]: %s, ", msg, m_deepPosition.deprecatedNode()->nodeName().utf8().data());
         m_deepPosition.showAnchorTypeAndOffset();
     }
 }
@@ -601,7 +601,7 @@ PassRefPtr<Range> makeRange(const VisiblePosition &start, const VisiblePosition
     
     Position s = start.deepEquivalent().parentAnchoredEquivalent();
     Position e = end.deepEquivalent().parentAnchoredEquivalent();
-    return Range::create(s.node()->document(), s.node(), s.deprecatedEditingOffset(), e.node(), e.deprecatedEditingOffset());
+    return Range::create(s.anchorNode()->document(), s.deprecatedNode(), s.deprecatedEditingOffset(), e.deprecatedNode(), e.deprecatedEditingOffset());
 }
 
 VisiblePosition startVisiblePosition(const Range *r, EAffinity affinity)
@@ -622,7 +622,7 @@ bool setStart(Range *r, const VisiblePosition &visiblePosition)
         return false;
     Position p = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
     int code = 0;
-    r->setStart(p.node(), p.deprecatedEditingOffset(), code);
+    r->setStart(p.deprecatedNode(), p.deprecatedEditingOffset(), code);
     return code == 0;
 }
 
@@ -632,7 +632,7 @@ bool setEnd(Range *r, const VisiblePosition &visiblePosition)
         return false;
     Position p = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
     int code = 0;
-    r->setEnd(p.node(), p.deprecatedEditingOffset(), code);
+    r->setEnd(p.deprecatedNode(), p.deprecatedEditingOffset(), code);
     return code == 0;
 }
 
@@ -641,7 +641,7 @@ Element* enclosingBlockFlowElement(const VisiblePosition &visiblePosition)
     if (visiblePosition.isNull())
         return NULL;
 
-    return visiblePosition.deepEquivalent().node()->enclosingBlockFlowElement();
+    return visiblePosition.deepEquivalent().deprecatedNode()->enclosingBlockFlowElement();
 }
 
 bool isFirstVisiblePositionInNode(const VisiblePosition &visiblePosition, const Node *node)
@@ -649,11 +649,11 @@ bool isFirstVisiblePositionInNode(const VisiblePosition &visiblePosition, const
     if (visiblePosition.isNull())
         return false;
     
-    if (!visiblePosition.deepEquivalent().node()->isDescendantOf(node))
+    if (!visiblePosition.deepEquivalent().deprecatedNode()->isDescendantOf(node))
         return false;
         
     VisiblePosition previous = visiblePosition.previous();
-    return previous.isNull() || !previous.deepEquivalent().node()->isDescendantOf(node);
+    return previous.isNull() || !previous.deepEquivalent().deprecatedNode()->isDescendantOf(node);
 }
 
 bool isLastVisiblePositionInNode(const VisiblePosition &visiblePosition, const Node *node)
@@ -661,11 +661,11 @@ bool isLastVisiblePositionInNode(const VisiblePosition &visiblePosition, const N
     if (visiblePosition.isNull())
         return false;
     
-    if (!visiblePosition.deepEquivalent().node()->isDescendantOf(node))
+    if (!visiblePosition.deepEquivalent().deprecatedNode()->isDescendantOf(node))
         return false;
                 
     VisiblePosition next = visiblePosition.next();
-    return next.isNull() || !next.deepEquivalent().node()->isDescendantOf(node);
+    return next.isNull() || !next.deepEquivalent().deprecatedNode()->isDescendantOf(node);
 }
 
 }  // namespace WebCore
index 2c45f43..47eadf9 100644 (file)
@@ -81,7 +81,7 @@ public:
     UChar32 characterAfter() const;
     UChar32 characterBefore() const { return previous().characterAfter(); }
 
-    Element* rootEditableElement() const { return m_deepPosition.isNotNull() ? m_deepPosition.node()->rootEditableElement() : 0; }
+    Element* rootEditableElement() const { return m_deepPosition.isNotNull() ? m_deepPosition.deprecatedNode()->rootEditableElement() : 0; }
     
     void getInlineBoxAndOffset(InlineBox*& inlineBox, int& caretOffset) const
     {
index f4fe503..75531ca 100644 (file)
@@ -122,7 +122,7 @@ PassRefPtr<Range> VisibleSelection::firstRange() const
         return 0;
     Position start = m_start.parentAnchoredEquivalent();
     Position end = m_end.parentAnchoredEquivalent();
-    return Range::create(start.node()->document(), start, end);
+    return Range::create(start.anchorNode()->document(), start, end);
 }
 
 PassRefPtr<Range> VisibleSelection::toNormalizedRange() const
@@ -134,7 +134,7 @@ PassRefPtr<Range> VisibleSelection::toNormalizedRange() const
     // in the course of running edit commands which modify the DOM.
     // Failing to call this can result in equivalentXXXPosition calls returning
     // incorrect results.
-    m_start.node()->document()->updateLayout();
+    m_start.anchorNode()->document()->updateLayout();
 
     // Check again, because updating layout can clear the selection.
     if (isNone())
@@ -178,7 +178,7 @@ PassRefPtr<Range> VisibleSelection::toNormalizedRange() const
 
     // VisibleSelections are supposed to always be valid.  This constructor will ASSERT
     // if a valid range could not be created, which is fine for this callsite.
-    return Range::create(s.node()->document(), s, e);
+    return Range::create(s.anchorNode()->document(), s, e);
 }
 
 bool VisibleSelection::expandUsingGranularity(TextGranularity granularity)
@@ -192,7 +192,7 @@ bool VisibleSelection::expandUsingGranularity(TextGranularity granularity)
 
 static PassRefPtr<Range> makeSearchRange(const Position& pos)
 {
-    Node* n = pos.node();
+    Node* n = pos.deprecatedNode();
     if (!n)
         return 0;
     Document* d = n->document();
@@ -208,7 +208,7 @@ static PassRefPtr<Range> makeSearchRange(const Position& pos)
 
     Position start(pos.parentAnchoredEquivalent());
     searchRange->selectNodeContents(boundary, ec);
-    searchRange->setStart(start.node(), start.deprecatedEditingOffset(), ec);
+    searchRange->setStart(start.deprecatedNode(), start.deprecatedEditingOffset(), ec);
 
     ASSERT(!ec);
     if (ec)
@@ -296,7 +296,7 @@ void VisibleSelection::setStartAndEndFromBaseAndExtentRespectingGranularity(Text
             VisiblePosition wordEnd(endOfWord(originalEnd, side));
             VisiblePosition end(wordEnd);
             
-            if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.node())) {
+            if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.deprecatedNode())) {
                 // Select the paragraph break (the space from the end of a paragraph to the start of 
                 // the next one) to match TextEdit.
                 end = wordEnd.next();
@@ -457,7 +457,7 @@ void VisibleSelection::adjustSelectionToAvoidCrossingEditingBoundaries()
     Node* startRoot = highestEditableRoot(m_start);
     Node* endRoot = highestEditableRoot(m_end);
     
-    Node* baseEditableAncestor = lowestEditableAncestor(m_base.node());
+    Node* baseEditableAncestor = lowestEditableAncestor(m_base.deprecatedNode());
     
     // The base, start and end are all in the same region.  No adjustment necessary.
     if (baseRoot == startRoot && baseRoot == endRoot)
@@ -492,17 +492,17 @@ void VisibleSelection::adjustSelectionToAvoidCrossingEditingBoundaries()
     
         // The selection ends in editable content or non-editable content inside a different editable ancestor, 
         // move backward until non-editable content inside the same lowest editable ancestor is reached.
-        Node* endEditableAncestor = lowestEditableAncestor(m_end.node());
+        Node* endEditableAncestor = lowestEditableAncestor(m_end.deprecatedNode());
         if (endRoot || endEditableAncestor != baseEditableAncestor) {
             
             Position p = previousVisuallyDistinctCandidate(m_end);
             Node* shadowAncestor = endRoot ? endRoot->shadowAncestorNode() : 0;
             if (p.isNull() && endRoot && (shadowAncestor != endRoot))
                 p = lastDeepEditingPositionForNode(shadowAncestor);
-            while (p.isNotNull() && !(lowestEditableAncestor(p.node()) == baseEditableAncestor && !isEditablePosition(p))) {
+            while (p.isNotNull() && !(lowestEditableAncestor(p.deprecatedNode()) == baseEditableAncestor && !isEditablePosition(p))) {
                 Node* root = editableRootForPosition(p);
                 shadowAncestor = root ? root->shadowAncestorNode() : 0;
-                p = isAtomicNode(p.node()) ? positionInParentBeforeNode(p.node()) : previousVisuallyDistinctCandidate(p);
+                p = isAtomicNode(p.deprecatedNode()) ? positionInParentBeforeNode(p.deprecatedNode()) : previousVisuallyDistinctCandidate(p);
                 if (p.isNull() && (shadowAncestor != root))
                     p = lastDeepEditingPositionForNode(shadowAncestor);
             }
@@ -522,16 +522,16 @@ void VisibleSelection::adjustSelectionToAvoidCrossingEditingBoundaries()
 
         // The selection starts in editable content or non-editable content inside a different editable ancestor, 
         // move forward until non-editable content inside the same lowest editable ancestor is reached.
-        Node* startEditableAncestor = lowestEditableAncestor(m_start.node());      
+        Node* startEditableAncestor = lowestEditableAncestor(m_start.deprecatedNode());      
         if (startRoot || startEditableAncestor != baseEditableAncestor) {
             Position p = nextVisuallyDistinctCandidate(m_start);
             Node* shadowAncestor = startRoot ? startRoot->shadowAncestorNode() : 0;
             if (p.isNull() && startRoot && (shadowAncestor != startRoot))
                 p = positionBeforeNode(shadowAncestor);
-            while (p.isNotNull() && !(lowestEditableAncestor(p.node()) == baseEditableAncestor && !isEditablePosition(p))) {
+            while (p.isNotNull() && !(lowestEditableAncestor(p.deprecatedNode()) == baseEditableAncestor && !isEditablePosition(p))) {
                 Node* root = editableRootForPosition(p);
                 shadowAncestor = root ? root->shadowAncestorNode() : 0;
-                p = isAtomicNode(p.node()) ? positionInParentAfterNode(p.node()) : nextVisuallyDistinctCandidate(p);
+                p = isAtomicNode(p.deprecatedNode()) ? positionInParentAfterNode(p.deprecatedNode()) : nextVisuallyDistinctCandidate(p);
                 if (p.isNull() && (shadowAncestor != root))
                     p = positionBeforeNode(shadowAncestor);
             }
@@ -551,7 +551,7 @@ void VisibleSelection::adjustSelectionToAvoidCrossingEditingBoundaries()
     }
     
     // Correct the extent if necessary.
-    if (baseEditableAncestor != lowestEditableAncestor(m_extent.node()))
+    if (baseEditableAncestor != lowestEditableAncestor(m_extent.deprecatedNode()))
         m_extent = m_baseIsFirst ? m_end : m_start;
 }
 
@@ -572,7 +572,7 @@ Element* VisibleSelection::rootEditableElement() const
 
 Node* VisibleSelection::shadowTreeRootNode() const
 {
-    return start().node() ? start().node()->shadowTreeRootNode() : 0;
+    return start().deprecatedNode() ? start().deprecatedNode()->shadowTreeRootNode() : 0;
 }
 
 #ifndef NDEBUG
index d627d9b..f40134b 100644 (file)
@@ -41,7 +41,7 @@ void SelectionController::notifyAccessibilityForSelectionChange()
     // FIXME: Support editable text in chromium.
     if (AXObjectCache::accessibilityEnabled() && m_selection.start().isNotNull() && m_selection.end().isNotNull()) {
         Document* document = m_frame->document();
-        document->axObjectCache()->postNotification(m_selection.start().node()->renderer(), AXObjectCache::AXSelectedTextChanged, false);
+        document->axObjectCache()->postNotification(m_selection.start().deprecatedNode()->renderer(), AXObjectCache::AXSelectedTextChanged, false);
     }
 }
 
index 19097b2..264bdc3 100644 (file)
@@ -84,7 +84,7 @@ void SelectionController::notifyAccessibilityForSelectionChange()
     if (!m_selection.start().isNotNull() || !m_selection.end().isNotNull())
         return;
 
-    RenderObject* focusedNode = m_selection.end().node()->renderer();
+    RenderObject* focusedNode = m_selection.end().deprecatedNode()->renderer();
     AccessibilityObject* accessibilityObject = m_frame->document()->axObjectCache()->getOrCreate(focusedNode);
 
     // Need to check this as getOrCreate could return 0,
index cb157d2..cd556a5 100644 (file)
@@ -95,9 +95,9 @@ bool canHaveChildrenForEditing(const Node* node)
 // could be inside a shadow tree. Only works for non-null values.
 int comparePositions(const Position& a, const Position& b)
 {
-    Node* nodeA = a.node();
+    Node* nodeA = a.deprecatedNode();
     ASSERT(nodeA);
-    Node* nodeB = b.node();
+    Node* nodeB = b.deprecatedNode();
     ASSERT(nodeB);
     int offsetA = a.deprecatedEditingOffset();
     int offsetB = b.deprecatedEditingOffset();
@@ -134,7 +134,7 @@ int comparePositions(const VisiblePosition& a, const VisiblePosition& b)
 
 Node* highestEditableRoot(const Position& position)
 {
-    Node* node = position.node();
+    Node* node = position.deprecatedNode();
     if (!node)
         return 0;
         
@@ -173,7 +173,7 @@ Node* lowestEditableAncestor(Node* node)
 
 bool isEditablePosition(const Position& p)
 {
-    Node* node = p.node();
+    Node* node = p.deprecatedNode();
     if (!node)
         return false;
         
@@ -185,14 +185,14 @@ bool isEditablePosition(const Position& p)
 
 bool isAtUnsplittableElement(const Position& pos)
 {
-    Node* node = pos.node();
+    Node* node = pos.deprecatedNode();
     return (node == editableRootForPosition(pos) || node == enclosingNodeOfType(pos, &isTableCell));
 }
     
     
 bool isRichlyEditablePosition(const Position& p)
 {
-    Node* node = p.node();
+    Node* node = p.deprecatedNode();
     if (!node)
         return false;
         
@@ -204,7 +204,7 @@ bool isRichlyEditablePosition(const Position& p)
 
 Element* editableRootForPosition(const Position& p)
 {
-    Node* node = p.node();
+    Node* node = p.deprecatedNode();
     if (!node)
         return 0;
         
@@ -282,14 +282,14 @@ VisiblePosition firstEditablePositionAfterPositionInRoot(const Position& positio
 
     Position p = position;
     
-    if (Node* shadowAncestor = p.node()->shadowAncestorNode())
-        if (shadowAncestor != p.node())
+    if (Node* shadowAncestor = p.deprecatedNode()->shadowAncestorNode())
+        if (shadowAncestor != p.deprecatedNode())
             p = lastDeepEditingPositionForNode(shadowAncestor);
     
-    while (p.node() && !isEditablePosition(p) && p.node()->isDescendantOf(highestRoot))
-        p = isAtomicNode(p.node()) ? positionInParentAfterNode(p.node()) : nextVisuallyDistinctCandidate(p);
+    while (p.deprecatedNode() && !isEditablePosition(p) && p.deprecatedNode()->isDescendantOf(highestRoot))
+        p = isAtomicNode(p.deprecatedNode()) ? positionInParentAfterNode(p.deprecatedNode()) : nextVisuallyDistinctCandidate(p);
     
-    if (p.node() && p.node() != highestRoot && !p.node()->isDescendantOf(highestRoot))
+    if (p.deprecatedNode() && p.deprecatedNode() != highestRoot && !p.deprecatedNode()->isDescendantOf(highestRoot))
         return VisiblePosition();
     
     return VisiblePosition(p);
@@ -303,14 +303,14 @@ VisiblePosition lastEditablePositionBeforePositionInRoot(const Position& positio
 
     Position p = position;
     
-    if (Node* shadowAncestor = p.node()->shadowAncestorNode())
-        if (shadowAncestor != p.node())
+    if (Node* shadowAncestor = p.deprecatedNode()->shadowAncestorNode())
+        if (shadowAncestor != p.deprecatedNode())
             p = firstDeepEditingPositionForNode(shadowAncestor);
     
-    while (p.node() && !isEditablePosition(p) && p.node()->isDescendantOf(highestRoot))
-        p = isAtomicNode(p.node()) ? positionInParentBeforeNode(p.node()) : previousVisuallyDistinctCandidate(p);
+    while (p.deprecatedNode() && !isEditablePosition(p) && p.deprecatedNode()->isDescendantOf(highestRoot))
+        p = isAtomicNode(p.deprecatedNode()) ? positionInParentBeforeNode(p.deprecatedNode()) : previousVisuallyDistinctCandidate(p);
     
-    if (p.node() && p.node() != highestRoot && !p.node()->isDescendantOf(highestRoot))
+    if (p.deprecatedNode() && p.deprecatedNode() != highestRoot && !p.deprecatedNode()->isDescendantOf(highestRoot))
         return VisiblePosition();
     
     return VisiblePosition(p);
@@ -421,9 +421,9 @@ bool isSpecialElement(const Node *n)
 
 static Node* firstInSpecialElement(const Position& pos)
 {
-    // FIXME: This begins at pos.node(), which doesn't necessarily contain pos (suppose pos was [img, 0]).  See <rdar://problem/5027702>.
-    Node* rootEditableElement = pos.node()->rootEditableElement();
-    for (Node* n = pos.node(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode())
+    // FIXME: This begins at pos.deprecatedNode(), which doesn't necessarily contain pos (suppose pos was [img, 0]).  See <rdar://problem/5027702>.
+    Node* rootEditableElement = pos.deprecatedNode()->rootEditableElement();
+    for (Node* n = pos.deprecatedNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode())
         if (isSpecialElement(n)) {
             VisiblePosition vPos = VisiblePosition(pos, DOWNSTREAM);
             VisiblePosition firstInElement = VisiblePosition(n, 0, DOWNSTREAM);
@@ -437,9 +437,9 @@ static Node* firstInSpecialElement(const Position& pos)
 
 static Node* lastInSpecialElement(const Position& pos)
 {
-    // FIXME: This begins at pos.node(), which doesn't necessarily contain pos (suppose pos was [img, 0]).  See <rdar://problem/5027702>.
-    Node* rootEditableElement = pos.node()->rootEditableElement();
-    for (Node* n = pos.node(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode())
+    // FIXME: This begins at pos.deprecatedNode(), which doesn't necessarily contain pos (suppose pos was [img, 0]).  See <rdar://problem/5027702>.
+    Node* rootEditableElement = pos.deprecatedNode()->rootEditableElement();
+    for (Node* n = pos.deprecatedNode(); n && n->rootEditableElement() == rootEditableElement; n = n->parentNode())
         if (isSpecialElement(n)) {
             VisiblePosition vPos = VisiblePosition(pos, DOWNSTREAM);
             VisiblePosition lastInElement = VisiblePosition(n, n->childNodeCount(), DOWNSTREAM);
@@ -462,7 +462,7 @@ Position positionBeforeContainingSpecialElement(const Position& pos, Node** cont
     if (!n)
         return pos;
     Position result = positionInParentBeforeNode(n);
-    if (result.isNull() || result.node()->rootEditableElement() != pos.node()->rootEditableElement())
+    if (result.isNull() || result.deprecatedNode()->rootEditableElement() != pos.deprecatedNode()->rootEditableElement())
         return pos;
     if (containingSpecialElement)
         *containingSpecialElement = n;
@@ -480,7 +480,7 @@ Position positionAfterContainingSpecialElement(const Position& pos, Node **conta
     if (!n)
         return pos;
     Position result = positionInParentAfterNode(n);
-    if (result.isNull() || result.node()->rootEditableElement() != pos.node()->rootEditableElement())
+    if (result.isNull() || result.deprecatedNode()->rootEditableElement() != pos.deprecatedNode()->rootEditableElement())
         return pos;
     if (containingSpecialElement)
         *containingSpecialElement = n;
@@ -499,8 +499,8 @@ Position positionOutsideContainingSpecialElement(const Position &pos, Node **con
 Node* isFirstPositionAfterTable(const VisiblePosition& visiblePosition)
 {
     Position upstream(visiblePosition.deepEquivalent().upstream());
-    if (upstream.node() && upstream.node()->renderer() && upstream.node()->renderer()->isTable() && upstream.atLastEditingPositionForNode())
-        return upstream.node();
+    if (upstream.deprecatedNode() && upstream.deprecatedNode()->renderer() && upstream.deprecatedNode()->renderer()->isTable() && upstream.atLastEditingPositionForNode())
+        return upstream.deprecatedNode();
     
     return 0;
 }
@@ -508,8 +508,8 @@ Node* isFirstPositionAfterTable(const VisiblePosition& visiblePosition)
 Node* isLastPositionBeforeTable(const VisiblePosition& visiblePosition)
 {
     Position downstream(visiblePosition.deepEquivalent().downstream());
-    if (downstream.node() && downstream.node()->renderer() && downstream.node()->renderer()->isTable() && downstream.atFirstEditingPositionForNode())
-        return downstream.node();
+    if (downstream.deprecatedNode() && downstream.deprecatedNode()->renderer() && downstream.deprecatedNode()->renderer()->isTable() && downstream.atFirstEditingPositionForNode())
+        return downstream.deprecatedNode();
     
     return 0;
 }
@@ -591,7 +591,7 @@ Node* enclosingNodeWithTag(const Position& p, const QualifiedName& tagName)
         return 0;
         
     Node* root = highestEditableRoot(p);
-    for (Node* n = p.node(); n; n = n->parentNode()) {
+    for (Node* n = p.deprecatedNode(); n; n = n->parentNode()) {
         if (root && !n->isContentEditable())
             continue;
         if (n->hasTagName(tagName))
@@ -609,7 +609,7 @@ Node* enclosingNodeOfType(const Position& p, bool (*nodeIsOfType)(const Node*),
         return 0;
         
     Node* root = highestEditableRoot(p);
-    for (Node* n = p.node(); n; n = n->parentNode()) {
+    for (Node* n = p.deprecatedNode(); n; n = n->parentNode()) {
         // 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->isContentEditable() && onlyReturnEditableNodes)
@@ -627,7 +627,7 @@ Node* highestEnclosingNodeOfType(const Position& p, bool (*nodeIsOfType)(const N
 {
     Node* highest = 0;
     Node* root = highestEditableRoot(p);
-    for (Node* n = p.node(); n; n = n->parentNode()) {
+    for (Node* n = p.deprecatedNode(); n; n = n->parentNode()) {
         if ((*nodeIsOfType)(n))
             highest = n;
         if (n == root)
@@ -647,7 +647,7 @@ Node* enclosingAnchorElement(const Position& p)
     if (p.isNull())
         return 0;
     
-    Node* node = p.node();
+    Node* node = p.deprecatedNode();
     while (node && !(node->isElementNode() && node->isLink()))
         node = node->parentNode();
     return node;
@@ -717,7 +717,7 @@ static Node* appendedSublist(Node* listItem)
 Node* enclosingEmptyListItem(const VisiblePosition& visiblePos)
 {
     // Check that position is on a line by itself inside a list item
-    Node* listChildNode = enclosingListChild(visiblePos.deepEquivalent().node());
+    Node* listChildNode = enclosingListChild(visiblePos.deepEquivalent().deprecatedNode());
     if (!listChildNode || !isStartOfParagraph(visiblePos) || !isEndOfParagraph(visiblePos))
         return 0;
 
@@ -883,7 +883,7 @@ bool isNodeInTextFormControl(Node* node)
     
 Position positionBeforeTabSpan(const Position& pos)
 {
-    Node *node = pos.node();
+    Node* node = pos.deprecatedNode();
     if (isTabSpanTextNode(node))
         node = tabSpanNode(node);
     else if (!isTabSpanNode(node))
@@ -944,7 +944,7 @@ Node *nearestMailBlockquote(const Node *node)
 unsigned numEnclosingMailBlockquotes(const Position& p)
 {
     unsigned num = 0;
-    for (Node* n = p.node(); n; n = n->parentNode())
+    for (Node* n = p.deprecatedNode(); n; n = n->parentNode())
         if (isMailBlockquote(n))
             num++;
     
@@ -1015,7 +1015,7 @@ VisibleSelection selectionForParagraphIteration(const VisibleSelection& original
     // that we'll want modify is the last one inside the table, not the table itself
     // (a table is itself a paragraph).
     if (Node* table = isFirstPositionAfterTable(endOfSelection))
-        if (startOfSelection.deepEquivalent().node()->isDescendantOf(table))
+        if (startOfSelection.deepEquivalent().deprecatedNode()->isDescendantOf(table))
             newSelection = VisibleSelection(startOfSelection, endOfSelection.previous(true));
     
     // If the start of the selection to modify is just before a table,
@@ -1023,7 +1023,7 @@ VisibleSelection selectionForParagraphIteration(const VisibleSelection& original
     // we'll want to modify is the first one inside the table, not the paragraph
     // containing the table itself.
     if (Node* table = isLastPositionBeforeTable(startOfSelection))
-        if (endOfSelection.deepEquivalent().node()->isDescendantOf(table))
+        if (endOfSelection.deepEquivalent().deprecatedNode()->isDescendantOf(table))
             newSelection = VisibleSelection(startOfSelection.next(true), endOfSelection);
     
     return newSelection;
@@ -1035,7 +1035,7 @@ int indexForVisiblePosition(const VisiblePosition& visiblePosition)
     if (visiblePosition.isNull())
         return 0;
     Position p(visiblePosition.deepEquivalent());
-    RefPtr<Range> range = Range::create(p.node()->document(), firstPositionInNode(p.anchorNode()->document()->documentElement()),
+    RefPtr<Range> range = Range::create(p.anchorNode()->document(), firstPositionInNode(p.anchorNode()->document()->documentElement()),
                                         p.parentAnchoredEquivalent());
     return TextIterator::rangeLength(range.get(), true);
 }
@@ -1114,8 +1114,8 @@ VisibleSelection avoidIntersectionWithNode(const VisibleSelection& selection, No
         return VisibleSelection(selection);
 
     VisibleSelection updatedSelection(selection);
-    Node* base = selection.base().node();
-    Node* extent = selection.extent().node();
+    Node* base = selection.base().deprecatedNode();
+    Node* extent = selection.extent().deprecatedNode();
     ASSERT(base);
     ASSERT(extent);
 
index 56b9f71..619f75a 100644 (file)
@@ -158,7 +158,7 @@ NSWritingDirection Editor::baseWritingDirectionForSelectionStart() const
     NSWritingDirection result = NSWritingDirectionLeftToRight;
 
     Position pos = m_frame->selection()->selection().visibleStart().deepEquivalent();
-    Node* node = pos.node();
+    Node* node = pos.deprecatedNode();
     if (!node)
         return result;
 
index 119d406..94199c4 100644 (file)
@@ -51,7 +51,7 @@ void SelectionController::notifyAccessibilityForSelectionChange()
     Document* document = m_frame->document();
 
     if (AXObjectCache::accessibilityEnabled() && m_selection.start().isNotNull() && m_selection.end().isNotNull())
-        document->axObjectCache()->postNotification(m_selection.start().node()->renderer(), AXObjectCache::AXSelectedTextChanged, false);
+        document->axObjectCache()->postNotification(m_selection.start().deprecatedNode()->renderer(), AXObjectCache::AXSelectedTextChanged, false);
 
     // if zoom feature is enabled, insertion point changes should update the zoom
     if (!UAZoomEnabled() || !m_selection.isCaret())
index 34c3ec7..9d97b3f 100644 (file)
@@ -437,8 +437,8 @@ static bool propertyMissingOrEqualToNone(CSSStyleDeclaration* style, int propert
 static bool needInterchangeNewlineAfter(const VisiblePosition& v)
 {
     VisiblePosition next = v.next();
-    Node* upstreamNode = next.deepEquivalent().upstream().node();
-    Node* downstreamNode = v.deepEquivalent().downstream().node();
+    Node* upstreamNode = next.deepEquivalent().upstream().deprecatedNode();
+    Node* downstreamNode = v.deepEquivalent().downstream().deprecatedNode();
     // Add an interchange newline if a paragraph break is selected and a br won't already be added to the markup to represent it.
     return isEndOfParagraph(v) && isStartOfParagraph(next) && !(upstreamNode->hasTagName(brTag) && upstreamNode == downstreamNode);
 }
@@ -571,7 +571,7 @@ String createMarkup(const Range* range, Vector<Node*>* nodes, EAnnotateForInterc
         }
 
         accumulator.appendString(interchangeNewlineString);
-        startNode = visibleStart.next().deepEquivalent().node();
+        startNode = visibleStart.next().deepEquivalent().deprecatedNode();
 
         if (pastEnd && Range::compareBoundaryPoints(startNode, 0, pastEnd, 0) >= 0) {
             if (deleteButton)
@@ -764,7 +764,7 @@ PassRefPtr<DocumentFragment> createFragmentFromText(Range* context, const String
 
     Node* styleNode = context->firstNode();
     if (!styleNode) {
-        styleNode = context->startPosition().node();
+        styleNode = context->startPosition().deprecatedNode();
         if (!styleNode)
             return 0;
     }
index 391d6e6..281bc41 100644 (file)
@@ -68,7 +68,7 @@ static VisiblePosition previousBoundary(const VisiblePosition& c, BoundarySearch
     if (requiresContextForWordBoundary(c.characterBefore())) {
         RefPtr<Range> forwardsScanRange(d->createRange());
         forwardsScanRange->setEndAfter(boundary, ec);
-        forwardsScanRange->setStart(end.node(), end.deprecatedEditingOffset(), ec);
+        forwardsScanRange->setStart(end.deprecatedNode(), end.deprecatedEditingOffset(), ec);
         TextIterator forwardsIterator(forwardsScanRange.get());
         while (!forwardsIterator.atEnd()) {
             const UChar* characters = forwardsIterator.characters();
@@ -82,8 +82,8 @@ static VisiblePosition previousBoundary(const VisiblePosition& c, BoundarySearch
         }
     }
 
-    searchRange->setStart(start.node(), start.deprecatedEditingOffset(), ec);
-    searchRange->setEnd(end.node(), end.deprecatedEditingOffset(), ec);
+    searchRange->setStart(start.deprecatedNode(), start.deprecatedEditingOffset(), ec);
+    searchRange->setEnd(end.deprecatedNode(), end.deprecatedEditingOffset(), ec);
     
     ASSERT(!ec);
     if (ec)
@@ -91,7 +91,7 @@ static VisiblePosition previousBoundary(const VisiblePosition& c, BoundarySearch
 
     SimplifiedBackwardsTextIterator it(searchRange.get(), TextIteratorEndsAtEditingBoundary);
     unsigned next = 0;
-    bool inTextSecurityMode = start.node() && start.node()->renderer() && start.node()->renderer()->style()->textSecurity() != TSNONE;
+    bool inTextSecurityMode = start.deprecatedNode() && start.deprecatedNode()->renderer() && start.deprecatedNode()->renderer()->style()->textSecurity() != TSNONE;
     bool needMoreContext = false;
     while (!it.atEnd()) {
         // iterate to get chunks until the searchFunction returns a non-zero value.
@@ -146,7 +146,7 @@ static VisiblePosition nextBoundary(const VisiblePosition& c, BoundarySearchFunc
     ExceptionCode ec = 0;
     if (requiresContextForWordBoundary(c.characterAfter())) {
         RefPtr<Range> backwardsScanRange(d->createRange());
-        backwardsScanRange->setEnd(start.node(), start.deprecatedEditingOffset(), ec);
+        backwardsScanRange->setEnd(start.deprecatedNode(), start.deprecatedEditingOffset(), ec);
         SimplifiedBackwardsTextIterator backwardsIterator(backwardsScanRange.get());
         while (!backwardsIterator.atEnd()) {
             const UChar* characters = backwardsIterator.characters();
@@ -161,10 +161,10 @@ static VisiblePosition nextBoundary(const VisiblePosition& c, BoundarySearchFunc
     }
 
     searchRange->selectNodeContents(boundary, ec);
-    searchRange->setStart(start.node(), start.deprecatedEditingOffset(), ec);
+    searchRange->setStart(start.deprecatedNode(), start.deprecatedEditingOffset(), ec);
     TextIterator it(searchRange.get(), TextIteratorEmitsCharactersBetweenAllVisiblePositions);
     unsigned next = 0;
-    bool inTextSecurityMode = start.node() && start.node()->renderer() && start.node()->renderer()->style()->textSecurity() != TSNONE;
+    bool inTextSecurityMode = start.deprecatedNode() && start.deprecatedNode()->renderer() && start.deprecatedNode()->renderer()->style()->textSecurity() != TSNONE;
     bool needMoreContext = false;
     while (!it.atEnd()) {
         // Keep asking the iterator for chunks until the search function
@@ -316,7 +316,7 @@ VisiblePosition nextWordPosition(const VisiblePosition &c)
 static RootInlineBox *rootBoxForLine(const VisiblePosition &c)
 {
     Position p = c.deepEquivalent();
-    Node *node = p.node();
+    Node* node = p.deprecatedNode();
     if (!node)
         return 0;
 
@@ -351,7 +351,7 @@ static VisiblePosition startPositionForLine(const VisiblePosition& c)
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.node()->renderer() && p.node()->renderer()->isRenderBlock() && p.deprecatedEditingOffset() == 0)
+        if (p.deprecatedNode()->renderer() && p.deprecatedNode()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
             return positionAvoidingFirstPositionInTable(c);
         
         return VisiblePosition();
@@ -404,7 +404,7 @@ static VisiblePosition endPositionForLine(const VisiblePosition& c)
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.node()->renderer() && p.node()->renderer()->isRenderBlock() && p.deprecatedEditingOffset() == 0)
+        if (p.deprecatedNode()->renderer() && p.deprecatedNode()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
             return c;
         return VisiblePosition();
     }
@@ -501,7 +501,7 @@ static Node* enclosingNodeWithNonInlineRenderer(Node* n)
 VisiblePosition previousLinePosition(const VisiblePosition &visiblePosition, int x)
 {
     Position p = visiblePosition.deepEquivalent();
-    Node *node = p.node();
+    Node* node = p.deprecatedNode();
     Node* highestRoot = highestEditableRoot(p);
     if (!node)
         return VisiblePosition();
@@ -610,7 +610,7 @@ static Node* nextLeafWithSameEditability(Node* node)
 VisiblePosition nextLinePosition(const VisiblePosition &visiblePosition, int x)
 {
     Position p = visiblePosition.deepEquivalent();
-    Node *node = p.node();
+    Node* node = p.deprecatedNode();
     Node* highestRoot = highestEditableRoot(p);
     if (!node)
         return VisiblePosition();
@@ -740,7 +740,7 @@ VisiblePosition nextSentencePosition(const VisiblePosition &c)
 VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     Position p = c.deepEquivalent();
-    Node *startNode = p.node();
+    Node* startNode = p.deprecatedNode();
 
     if (!startNode)
         return VisiblePosition();
@@ -802,7 +802,7 @@ VisiblePosition endOfParagraph(const VisiblePosition &c, EditingBoundaryCrossing
         return VisiblePosition();
 
     Position p = c.deepEquivalent();
-    Node* startNode = p.node();
+    Node* startNode = p.deprecatedNode();
 
     if (isRenderedAsNonInlineTableImageOrHR(startNode))
         return lastDeepEditingPositionForNode(startNode);
@@ -910,7 +910,7 @@ VisiblePosition nextParagraphPosition(const VisiblePosition& p, int x)
 VisiblePosition startOfBlock(const VisiblePosition &c)
 {
     Position p = c.deepEquivalent();
-    Node *startNode = p.node();
+    Node* startNode = p.deprecatedNode();
     if (!startNode)
         return VisiblePosition();
     return VisiblePosition(firstPositionInNode(startNode->enclosingBlockFlowElement()), DOWNSTREAM);
@@ -920,7 +920,7 @@ VisiblePosition endOfBlock(const VisiblePosition &c)
 {
     Position p = c.deepEquivalent();
 
-    Node *startNode = p.node();
+    Node* startNode = p.deprecatedNode();
     if (!startNode)
         return VisiblePosition();
 
@@ -956,7 +956,7 @@ VisiblePosition startOfDocument(const Node* node)
 
 VisiblePosition startOfDocument(const VisiblePosition &c)
 {
-    return startOfDocument(c.deepEquivalent().node());
+    return startOfDocument(c.deepEquivalent().deprecatedNode());
 }
 
 VisiblePosition endOfDocument(const Node* node)
@@ -970,17 +970,17 @@ VisiblePosition endOfDocument(const Node* node)
 
 VisiblePosition endOfDocument(const VisiblePosition &c)
 {
-    return endOfDocument(c.deepEquivalent().node());
+    return endOfDocument(c.deepEquivalent().deprecatedNode());
 }
 
 bool inSameDocument(const VisiblePosition &a, const VisiblePosition &b)
 {
     Position ap = a.deepEquivalent();
-    Node *an = ap.node();
+    Node* an = ap.deprecatedNode();
     if (!an)
         return false;
     Position bp = b.deepEquivalent();
-    Node *bn = bp.node();
+    Node* bn = bp.deprecatedNode();
     if (an == bn)
         return true;
 
@@ -1108,7 +1108,7 @@ static VisiblePosition logicalStartPositionForLine(const VisiblePosition& c)
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.node()->renderer() && p.node()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
+        if (p.deprecatedNode()->renderer() && p.deprecatedNode()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
             return positionAvoidingFirstPositionInTable(c);
         
         return VisiblePosition();
@@ -1146,7 +1146,7 @@ static VisiblePosition logicalEndPositionForLine(const VisiblePosition& c)
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.node()->renderer() && p.node()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
+        if (p.deprecatedNode()->renderer() && p.deprecatedNode()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
             return c;
         return VisiblePosition();
     }
index dbb0944..c28d7de 100644 (file)
@@ -101,7 +101,7 @@ Node* DOMSelection::anchorNode() const
         return 0;
     if (Node* shadowAncestor = selectionShadowAncestor(m_frame))
         return shadowAncestor->parentNodeGuaranteedHostFree();
-    return anchorPosition(visibleSelection()).node();
+    return anchorPosition(visibleSelection()).deprecatedNode();
 }
 
 int DOMSelection::anchorOffset() const
@@ -119,7 +119,7 @@ Node* DOMSelection::focusNode() const
         return 0;
     if (Node* shadowAncestor = selectionShadowAncestor(m_frame))
         return shadowAncestor->parentNodeGuaranteedHostFree();
-    return focusPosition(visibleSelection()).node();
+    return focusPosition(visibleSelection()).deprecatedNode();
 }
 
 int DOMSelection::focusOffset() const
@@ -137,7 +137,7 @@ Node* DOMSelection::baseNode() const
         return 0;
     if (Node* shadowAncestor = selectionShadowAncestor(m_frame))
         return shadowAncestor->parentNodeGuaranteedHostFree();
-    return basePosition(visibleSelection()).node();
+    return basePosition(visibleSelection()).deprecatedNode();
 }
 
 int DOMSelection::baseOffset() const
@@ -155,7 +155,7 @@ Node* DOMSelection::extentNode() const
         return 0;
     if (Node* shadowAncestor = selectionShadowAncestor(m_frame))
         return shadowAncestor->parentNodeGuaranteedHostFree();
-    return extentPosition(visibleSelection()).node();
+    return extentPosition(visibleSelection()).deprecatedNode();
 }
 
 int DOMSelection::extentOffset() const
index c7e6cca..be2b04c 100644 (file)
@@ -753,7 +753,7 @@ bool DragController::startDrag(Frame* src, Clipboard* clipboard, DragOperation s
         doSystemDrag(dragImage, dragLoc, mouseDraggedPoint, clipboard, src, true);
     } else if (isSelected && (m_dragSourceAction & DragSourceActionSelection)) {
         if (!clipboard->hasData()) {
-            if (isNodeInTextFormControl(src->selection()->start().node()))
+            if (isNodeInTextFormControl(src->selection()->start().deprecatedNode()))
                 clipboard->writePlainText(src->editor()->selectedText());
             else {
                 RefPtr<Range> selectionRange = src->selection()->toNormalizedRange();
index 4c3ebb0..1a930e0 100644 (file)
@@ -285,7 +285,7 @@ void EventHandler::selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHit
         VisibleSelection newSelection;
         Element* URLElement = result.hitTestResult().URLElement();
         VisiblePosition pos(innerNode->renderer()->positionForPoint(result.localPoint()));
-        if (pos.isNotNull() && pos.deepEquivalent().node()->isDescendantOf(URLElement))
+        if (pos.isNotNull() && pos.deepEquivalent().deprecatedNode()->isDescendantOf(URLElement))
             newSelection = VisibleSelection::selectionFromContentsOfNode(URLElement);
     
         TextGranularity granularity = CharacterGranularity;
@@ -347,7 +347,7 @@ bool EventHandler::handleMousePressEventTripleClick(const MouseEventWithHitTestR
 
 static int textDistance(const Position& start, const Position& end)
 {
-     RefPtr<Range> range = Range::create(start.node()->document(), start, end);
+     RefPtr<Range> range = Range::create(start.anchorNode()->document(), start, end);
      return TextIterator::rangeLength(range.get(), true);
 }
 
@@ -626,7 +626,7 @@ void EventHandler::updateSelectionForMouseDrag(Node* targetNode, const IntPoint&
 #if ENABLE(SVG)
     // Special case to limit selection to the containing block for SVG text.
     // FIXME: Isn't there a better non-SVG-specific way to do this?
-    if (Node* selectionBaseNode = newSelection.base().node())
+    if (Node* selectionBaseNode = newSelection.base().deprecatedNode())
         if (RenderObject* selectionBaseRenderer = selectionBaseNode->renderer())
             if (selectionBaseRenderer->isSVGText())
                 if (targetNode->renderer()->containingBlock() != selectionBaseRenderer->containingBlock())
@@ -2127,7 +2127,7 @@ bool EventHandler::sendContextMenuEventForKey()
     SelectionController* selectionController = m_frame->selection();
     Position start = selectionController->selection().start();
 
-    if (start.node() && (selectionController->rootEditableElement() || selectionController->isRange())) {
+    if (start.deprecatedNode() && (selectionController->rootEditableElement() || selectionController->isRange())) {
         RefPtr<Range> selection = selectionController->toNormalizedRange();
         IntRect firstRect = m_frame->editor()->firstRectForRange(selection.get());
 
index 3c3199a..57b2c81 100644 (file)
@@ -201,7 +201,7 @@ bool FocusController::advanceFocusInDocumentOrder(FocusDirection direction, Keyb
     bool caretBrowsing = focusedOrMainFrame()->settings()->caretBrowsingEnabled();
 
     if (caretBrowsing && !currentNode)
-        currentNode = frame->selection()->start().node();
+        currentNode = frame->selection()->start().deprecatedNode();
 
     document->updateLayoutIgnorePendingStylesheets();
 
@@ -325,7 +325,7 @@ static void clearSelectionIfNeeded(Frame* oldFocusedFrame, Frame* newFocusedFram
     if (caretBrowsing)
         return;
 
-    Node* selectionStartNode = s->selection().start().node();
+    Node* selectionStartNode = s->selection().start().deprecatedNode();
     if (selectionStartNode == newFocusedNode || selectionStartNode->isDescendantOf(newFocusedNode) || selectionStartNode->shadowAncestorNode() == newFocusedNode)
         return;
         
index 7fc8731..bf9bc02 100644 (file)
@@ -2651,10 +2651,10 @@ VisiblePosition RenderObject::createVisiblePosition(int offset, EAffinity affini
             // If it can be found, we prefer a visually equivalent position that is editable. 
             Position position(node, offset);
             Position candidate = position.downstream(CanCrossEditingBoundary);
-            if (candidate.node()->isContentEditable())
+            if (candidate.deprecatedNode()->isContentEditable())
                 return VisiblePosition(candidate, affinity);
             candidate = position.upstream(CanCrossEditingBoundary);
-            if (candidate.node()->isContentEditable())
+            if (candidate.deprecatedNode()->isContentEditable())
                 return VisiblePosition(candidate, affinity);
         }
         return VisiblePosition(node, offset, affinity);
index c191c29..37deec1 100644 (file)
@@ -249,7 +249,7 @@ void setSelectionRange(Node* node, int start, int end)
     // startPosition and endPosition can be null position for example when
     // "-webkit-user-select: none" style attribute is specified.
     if (startPosition.isNotNull() && endPosition.isNotNull()) {
-        ASSERT(startPosition.deepEquivalent().node()->shadowAncestorNode() == node && endPosition.deepEquivalent().node()->shadowAncestorNode() == node);
+        ASSERT(startPosition.deepEquivalent().deprecatedNode()->shadowAncestorNode() == node && endPosition.deepEquivalent().deprecatedNode()->shadowAncestorNode() == node);
     }
     VisibleSelection newSelection = VisibleSelection(startPosition, endPosition);
 
@@ -338,13 +338,13 @@ VisiblePosition RenderTextControl::visiblePositionForIndex(int index) const
 int RenderTextControl::indexForVisiblePosition(const VisiblePosition& pos) const
 {
     Position indexPosition = pos.deepEquivalent();
-    if (!isSelectableElement(indexPosition.node()))
+    if (!isSelectableElement(indexPosition.deprecatedNode()))
         return 0;
     ExceptionCode ec = 0;
     RefPtr<Range> range = Range::create(document());
     range->setStart(m_innerText.get(), 0, ec);
     ASSERT(!ec);
-    range->setEnd(indexPosition.node(), indexPosition.deprecatedEditingOffset(), ec);
+    range->setEnd(indexPosition.deprecatedNode(), indexPosition.deprecatedEditingOffset(), ec);
     ASSERT(!ec);
     return TextIterator::rangeLength(range.get());
 }
index b54261f..27a6095 100644 (file)
@@ -723,13 +723,13 @@ static void writeSelection(TextStream& ts, const RenderObject* o)
 
     VisibleSelection selection = frame->selection()->selection();
     if (selection.isCaret()) {
-        ts << "caret: position " << selection.start().deprecatedEditingOffset() << " of " << nodePosition(selection.start().node());
+        ts << "caret: position " << selection.start().deprecatedEditingOffset() << " of " << nodePosition(selection.start().deprecatedNode());
         if (selection.affinity() == UPSTREAM)
             ts << " (upstream affinity)";
         ts << "\n";
     } else if (selection.isRange())
-        ts << "selection start: position " << selection.start().deprecatedEditingOffset() << " of " << nodePosition(selection.start().node()) << "\n"
-           << "selection end:   position " << selection.end().deprecatedEditingOffset() << " of " << nodePosition(selection.end().node()) << "\n";
+        ts << "selection start: position " << selection.start().deprecatedEditingOffset() << " of " << nodePosition(selection.start().deprecatedNode()) << "\n"
+           << "selection end:   position " << selection.end().deprecatedEditingOffset() << " of " << nodePosition(selection.end().deprecatedNode()) << "\n";
 }
 
 String externalRepresentation(Frame* frame, RenderAsTextBehavior behavior)
index 3070a6d..3afd186 100644 (file)
@@ -1,3 +1,18 @@
+2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Reviewed by Kent Tamura.
+
+        Rename Position::node() to Position::deprecatedNode()
+        https://bugs.webkit.org/show_bug.cgi?id=54622
+
+        Done the rename. All calls to node() are replaced by calls to deprecatedNode().
+
+        * src/WebViewImpl.cpp:
+        (WebKit::WebViewImpl::setComposition): Check the nullity of startContainer() instead of startPosition()->node().
+        (WebKit::WebViewImpl::confirmComposition): Ditto.
+        (WebKit::WebViewImpl::textInputType):
+        (WebKit::WebViewImpl::caretOrSelectionBounds):
+
 2011-02-19  Brian Ryner  <bryner@chromium.org>
 
         Reviewed by Adam Barth.
index ae97bfa..ae07e5d 100644 (file)
@@ -1276,7 +1276,7 @@ bool WebViewImpl::setComposition(
     // node, which doesn't exist any longer.
     PassRefPtr<Range> range = editor->compositionRange();
     if (range) {
-        const Node* node = range->startPosition().node();
+        const Node* node = range->startContainer();
         if (!node || !node->isContentEditable())
             return false;
     }
@@ -1325,7 +1325,7 @@ bool WebViewImpl::confirmComposition(const WebString& text)
     // node, which doesn't exist any longer.
     PassRefPtr<Range> range = editor->compositionRange();
     if (range) {
-        const Node* node = range->startPosition().node();
+        const Node* node = range->startContainer();
         if (!node || !node->isContentEditable())
             return false;
     }
@@ -1356,7 +1356,7 @@ WebTextInputType WebViewImpl::textInputType()
     if (!controller)
         return type;
 
-    const Node* node = controller->start().node();
+    const Node* node = controller->start().deprecatedNode();
     if (!node)
         return type;
 
@@ -1385,14 +1385,14 @@ WebRect WebViewImpl::caretOrSelectionBounds()
     if (!view)
         return rect;
 
-    const Node* node = controller->start().node();
+    const Node* node = controller->start().deprecatedNode();
     if (!node || !node->renderer())
         return rect;
 
     if (controller->isCaret())
         rect = view->contentsToWindow(controller->absoluteCaretBounds());
     else if (controller->isRange()) {
-        node = controller->end().node();
+        node = controller->end().deprecatedNode();
         if (!node || !node->renderer())
             return rect;
         RefPtr<Range> range = controller->toNormalizedRange();
index deed866..c4ef0e0 100644 (file)
@@ -1,3 +1,15 @@
+2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Reviewed by Kent Tamura.
+
+        Rename Position::node() to Position::deprecatedNode()
+        https://bugs.webkit.org/show_bug.cgi?id=54622
+
+        Done the rename. All calls to node() are replaced by calls to deprecatedNode().
+
+        * webkit/webkitwebview.cpp:
+        (webkit_web_view_popup_menu_handler):
+
 2011-02-19  Ryuan Choi  <ryuan.choi@samsung.com>
 
         Reviewed by Martin Robinson.
index bbf6c24..57eb440 100644 (file)
@@ -397,7 +397,7 @@ static gboolean webkit_web_view_popup_menu_handler(GtkWidget* widget)
     int rightAligned = FALSE;
     IntPoint location;
 
-    if (!start.node() || !end.node()
+    if (!start.deprecatedNode() || !end.deprecatedNode()
         || (frame->selection()->selection().isCaret() && !frame->selection()->selection().isContentEditable())) {
         // If there's a focused elment, use its location.
         if (Node* focusedNode = getFocusedNode(frame)) {
@@ -406,7 +406,7 @@ static gboolean webkit_web_view_popup_menu_handler(GtkWidget* widget)
         } else
             location = IntPoint(rightAligned ? view->contentsWidth() - contextMenuMargin : contextMenuMargin, contextMenuMargin);
     } else {
-        RenderObject* renderer = start.node()->renderer();
+        RenderObject* renderer = start.deprecatedNode()->renderer();
         if (!renderer)
             return FALSE;
 
index 3f4f30d..0fe54ef 100644 (file)
@@ -1,3 +1,17 @@
+2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Reviewed by Kent Tamura.
+
+        Rename Position::node() to Position::deprecatedNode()
+        https://bugs.webkit.org/show_bug.cgi?id=54622
+
+        Replaced the call to node() by a call to containerNode() because the returned node is
+        used to determine whether or not the selected contents are editable and such a check
+        must be done against the container node.
+
+        * WebCoreSupport/EditorClientHaiku.cpp:
+        (WebCore::EditorClientHaiku::handleKeyboardEvent):
+
 2011-02-19  Charlie Reis  <creis@chromium.org>
 
         Reviewed by Mihai Parparita.
index 31e7f58..85d2513 100644 (file)
@@ -256,7 +256,7 @@ void EditorClientHaiku::handleKeyboardEvent(KeyboardEvent* event)
     if (!kevent || kevent->type() == PlatformKeyboardEvent::KeyUp)
         return;
 
-    Node* start = frame->selection()->start().node();
+    Node* start = frame->selection()->start().containerNode();
     if (!start)
         return;
 
index 48aa182..f4debf8 100644 (file)
@@ -1,3 +1,26 @@
+2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Reviewed by Kent Tamura.
+
+        Rename Position::node() to Position::deprecatedNode()
+        https://bugs.webkit.org/show_bug.cgi?id=54622
+
+        * WebView/WebFrame.mm:
+        (-[WebFrame _smartDeleteRangeForProposedRange:]):
+
+2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Reviewed by Kent Tamura.
+
+        Rename Position::node() to Position::deprecatedNode()
+        https://bugs.webkit.org/show_bug.cgi?id=54622
+        
+        Done the rename.
+
+        * WebView/WebFrame.mm:
+        (-[WebFrame _smartDeleteRangeForProposedRange:]): Since newStart and newEnd are parent-anchored,
+        use containerNode() and offsetInContainerNode() instead of deprecated member functions.
+
 2011-02-18  Gavin Barraclough  <barraclough@apple.com>
 
         Reviewed by Sam Weinig.
index 6a0c338..6fc0cd3 100644 (file)
@@ -806,8 +806,8 @@ static inline WebDataSource *dataSource(DocumentLoader* loader)
 
     RefPtr<Range> range = _private->coreFrame->document()->createRange();
     int exception = 0;
-    range->setStart(newStart.node(), newStart.deprecatedEditingOffset(), exception);
-    range->setEnd(newStart.node(), newStart.deprecatedEditingOffset(), exception);
+    range->setStart(newStart.containerNode(), newStart.offsetInContainerNode(), exception);
+    range->setEnd(newStart.containerNode(), newStart.offsetInContainerNode(), exception);
     return kit(range.get());
 }
 
index a957a51..c530f08 100644 (file)
@@ -1,3 +1,17 @@
+2011-02-17  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Reviewed by Kent Tamura.
+
+        Rename Position::node() to Position::deprecatedNode()
+        https://bugs.webkit.org/show_bug.cgi?id=54622
+
+        Replaced the call to node() by a call to containerNode() because the returned node is
+        used to determine whether or not the selected contents are editable and such a check
+        must be done against the container node.
+
+        * WebCoreSupport/EditorClientQt.cpp:
+        (WebCore::EditorClientQt::handleKeyboardEvent):
+
 2011-02-19  Charlie Reis  <creis@chromium.org>
 
         Reviewed by Mihai Parparita.
index fbc5dbc..90c9fb4 100644 (file)
@@ -420,7 +420,7 @@ void EditorClientQt::handleKeyboardEvent(KeyboardEvent* event)
     if (!kevent || kevent->type() == PlatformKeyboardEvent::KeyUp)
         return;
 
-    Node* start = frame->selection()->start().node();
+    Node* start = frame->selection()->start().containerNode();
     if (!start)
         return;