[oilpan] Handlify Nodes in htmlediting

Source/core/editing/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 338 matching lines @@
 
 void CompositeEditCommand::insertNodeAt(const Handle<Node>& insertChild, const Position& editingPosition)
 {
     ASSERT(isEditablePosition(editingPosition));
     // For editing positions like [table, 0], insert before the table,
     // likewise for replaced elements, brs, etc.
     Position p = editingPosition.parentAnchoredEquivalent();
     Handle<Node> refChild = p.deprecatedNode();
     int offset = p.deprecatedEditingOffset();
     
-    if (canHaveChildrenForEditing(refChild.raw())) {
+    if (canHaveChildrenForEditing(refChild)) {
         Handle<Node> child = refChild->firstChild();
         for (int i = 0; child && i < offset; i++)
             child = child->nextSibling();
         if (child)
             insertNodeBefore(insertChild, child);
         else
             appendNode(insertChild, toContainerNode(refChild));
-    } else if (caretMinOffset(refChild.raw()) >= offset)
+    } else if (caretMinOffset(refChild) >= offset)
         insertNodeBefore(insertChild, refChild);
-    else if (refChild->isTextNode() && caretMaxOffset(refChild.raw()) > offset) {
-        splitTextNode(toText(refChild.raw()), offset);
+    else if (refChild->isTextNode() && caretMaxOffset(refChild) > offset) {
+        splitTextNode(toText(refChild), offset);
 
         // Mutation events (bug 22634) from the text node insertion may have removed the refChild
         if (!refChild->inDocument())
             return;
         insertNodeBefore(insertChild, refChild);
     } else
         insertNodeAfter(insertChild, refChild);
 }
 
 void CompositeEditCommand::appendNode(const Handle<Node>& node, const Handle<ContainerNode>& parent)
 {
-    ASSERT(canHaveChildrenForEditing(parent.raw()));
+    ASSERT(canHaveChildrenForEditing(parent));
     applyCommandToComposite(AppendNodeCommand::create(parent, node));
 }
 
 void CompositeEditCommand::removeChildrenInRange(const Handle<Node>& node, unsigned from, unsigned to)
 {
     CollectionRoot<Vector<Member<Node> > > children;
     Handle<Node> child = node->childNode(from);
     for (unsigned i = from; child && i < to; i++, child = child->nextSibling()) {
         NoHandleScope scope;
         children->append(child);
@@ skipping 40 matching lines @@
     for (unsigned i = 0; i < nodesToRemove->size(); i++) {
         HandleScope scope;
         removeNode(nodesToRemove[i]);
         appendNode(nodesToRemove[i], newParent);
     }
 }
 
 void CompositeEditCommand::updatePositionForNodeRemovalPreservingChildren(Position& position, const Handle<Node>& node)
 {
     int offset = (position.anchorType() == Position::PositionIsOffsetInAnchor) ? position.offsetInContainerNode() : 0;
-    updatePositionForNodeRemoval(position, node.raw());
+    updatePositionForNodeRemoval(position, node);
     if (offset)
         position.moveToOffset(offset);    
 }
 
 Result<HTMLElement> CompositeEditCommand::replaceElementWithSpanPreservingChildrenAndAttributes(const Handle<HTMLElement>& node)
 {
     // It would also be possible to implement all of ReplaceNodeWithSpanCommand
     // as a series of existing smaller edit commands.  Someone who wanted to
     // reduce the number of edit commands could do so here.
     RefPtr<ReplaceNodeWithSpanCommand> command = ReplaceNodeWithSpanCommand::create(node);
     applyCommandToComposite(command);
     // Returning a raw pointer here is OK because the command is retained by
     // applyCommandToComposite (thus retaining the span), and the span is also
     // in the DOM tree, and thus alive whie it has a parent.
     ASSERT(command->spanElement()->inDocument());
     return command->spanElement();
 }
 
 void CompositeEditCommand::prune(const Handle<Node>& node)
 {
-    if (Handle<Node> highestNodeToRemove = adoptRawResult(highestNodeToRemoveInPruning(node.raw())))
+    if (Handle<Node> highestNodeToRemove = highestNodeToRemoveInPruning(node))
         removeNode(highestNodeToRemove);
 }
 
 void CompositeEditCommand::splitTextNode(const Handle<Text>& node, unsigned offset)
 {
     applyCommandToComposite(SplitTextNodeCommand::create(node, offset));
 }
 
 void CompositeEditCommand::splitElement(const Handle<Element>& element, const Handle<Node>& atChild)
 {
@@ skipping 39 matching lines @@
     Handle<Text> node(prpNode);
     applyCommandToComposite(DeleteFromTextNodeCommand::create(node, offset, count));
     if (!replacementText.isEmpty())
         applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, replacementText));
 }
 
 Position CompositeEditCommand::replaceSelectedTextInNode(const String& text)
 {
     Position start = endingSelection().start();
     Position end = endingSelection().end();
-    if (start.containerNode() != end.containerNode() || !start.containerNode()->isTextNode() || isTabSpanTextNode(start.containerNode().handle().raw()))
+    if (start.containerNode() != end.containerNode() || !start.containerNode()->isTextNode() || isTabSpanTextNode(start.containerNode()))
         return Position();
 
     Handle<Text> textNode = start.containerText();
     replaceTextInNode(textNode, start.offsetInContainerNode(), end.offsetInContainerNode() - start.offsetInContainerNode(), text);
 
     return Position(textNode, start.offsetInContainerNode() + text.length());
 }
 
 static void copyMarkers(const Vector<DocumentMarker*>& markerPointers, Vector<DocumentMarker>& markers)
 {
@@ skipping 12 matching lines @@
     replaceTextInNode(node, offset, count, replacementText);
     Handle<Range> newRange = Range::create(document(), node, offset, node, offset + replacementText.length());
     for (size_t i = 0; i < markers.size(); ++i) {
         HandleScope scope;
         markerController->addMarker(newRange, markers[i].type(), markers[i].description());
     }
 }
 
 Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos)
 {
-    if (!isTabSpanTextNode(pos.anchorNode().handle().raw()))
+    if (!isTabSpanTextNode(pos.anchorNode()))
         return pos;
 
     switch (pos.anchorType()) {
     case Position::PositionIsBeforeChildren:
     case Position::PositionIsAfterChildren:
         ASSERT_NOT_REACHED();
         return pos;
     case Position::PositionIsOffsetInAnchor:
         break;
     case Position::PositionIsBeforeAnchor:
         return positionInParentBeforeNode(pos.anchorNode());
     case Position::PositionIsAfterAnchor:
         return positionInParentAfterNode(pos.anchorNode());
     }
 
-    Handle<Node> tabSpan = adoptRawResult(tabSpanNode(pos.containerNode().handle().raw()));
+    Handle<Node> tabSpan = tabSpanNode(pos.containerNode());
 
-    if (pos.offsetInContainerNode() <= caretMinOffset(pos.containerNode().handle().raw()))
+    if (pos.offsetInContainerNode() <= caretMinOffset(pos.containerNode()))
         return positionInParentBeforeNode(tabSpan);
 
-    if (pos.offsetInContainerNode() >= caretMaxOffset(pos.containerNode().handle().raw()))
+    if (pos.offsetInContainerNode() >= caretMaxOffset(pos.containerNode()))
         return positionInParentAfterNode(tabSpan);
 
-    splitTextNodeContainingElement(toText(pos.containerNode().handle().raw()), pos.offsetInContainerNode());
+    splitTextNodeContainingElement(toText(pos.containerNode()), pos.offsetInContainerNode());
     return positionInParentBeforeNode(tabSpan);
 }
 
 void CompositeEditCommand::insertNodeAtTabSpanPosition(const Handle<Node>& node, const Position& pos)
 {
     // insert node before, after, or at split of tab span
     insertNodeAt(node, positionOutsideTabSpan(pos));
 }
 
 void CompositeEditCommand::deleteSelection(bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements, bool sanitizeMarkup)
@@ skipping 348 matching lines @@
     
     Position upstreamStart = visibleParagraphStart.deepEquivalent().upstream();
     Position upstreamEnd = visibleEnd.deepEquivalent().upstream();
 
     // If there are no VisiblePositions in the same block as pos then 
     // upstreamStart will be outside the paragraph
     if (comparePositions(pos, upstreamStart) < 0)
         return nullptr;
 
     // Perform some checks to see if we need to perform work in this function.
-    if (isBlock(upstreamStart.deprecatedNode().handle().raw())) {
+    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.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.deprecatedNode()->renderer()))
                 return insertNewDefaultParagraphElementAt(upstreamStart);
-        } else if (isBlock(upstreamEnd.deprecatedNode().handle().raw())) {
+        } else if (isBlock(upstreamEnd.deprecatedNode())) {
             if (!upstreamEnd.deprecatedNode()->isDescendantOf(upstreamStart.deprecatedNode().handle().raw())) {
                 // 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 nullptr;
             }
-        } else if (enclosingBlock(upstreamEnd.deprecatedNode().handle().raw()) != upstreamStart.deprecatedNode().handle().raw()) {
+        } 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.deprecatedNode()->isDescendantOf(enclosingBlock(upstreamEnd.deprecatedNode().handle().raw()).handle().raw()));
+            ASSERT(upstreamStart.deprecatedNode()->isDescendantOf(enclosingBlock(upstreamEnd.deprecatedNode()).handle().raw()));
             return nullptr;
         } else if (isEndOfEditableOrNonEditableContent(visibleEnd)) {
             // At the end of the editable region. We can bail here as well.
             return nullptr;
         }
     }
 
     Handle<Node> newBlock = insertNewDefaultParagraphElementAt(upstreamStart);
 
     bool endWasBr = visibleParagraphEnd.deepEquivalent().deprecatedNode()->hasTagName(brTag);
@@ skipping 25 matching lines @@
 
 void CompositeEditCommand::cloneParagraphUnderNewElement(Position& start, Position& end, const Handle<Node>& passedOuterNode, const Handle<Element>& blockElement)
 {
     // First we clone the outerNode
     Handle<Node> lastNode;
     Handle<Node> outerNode = passedOuterNode;
 
     if (outerNode->isRootEditableElement()) {
         lastNode = blockElement;
     } else {
-        lastNode = outerNode->cloneNode(isTableElement(outerNode.raw()));
+        lastNode = outerNode->cloneNode(isTableElement(outerNode));
         appendNode(lastNode, blockElement);
     }
 
     if (start.deprecatedNode() != outerNode && lastNode->isElementNode()) {
         CollectionRoot<Vector<Member<Node> > > ancestors;
         
         // Insert each node from innerNode to outerNode (excluded) in a list.
         for (Handle<Node> n = start.deprecatedNode(); n && n != outerNode; n = n->parentNode()) {
             NoHandleScope scope;
             ancestors->append(n);
         }
 
         // Clone every node between start.deprecatedNode() and outerBlock.
 
         for (size_t i = ancestors->size(); i != 0; --i) {
             HandleScope scope;
             Handle<Node> item = ancestors[i - 1];
-            Handle<Node> child = item->cloneNode(isTableElement(item.raw()));
+            Handle<Node> child = item->cloneNode(isTableElement(item));
             appendNode(child, Handle<Element>::cast(lastNode));
             lastNode = child;
         }
     }
 
     // Handle the case of paragraphs with more than one node,
     // cloning all the siblings until end.deprecatedNode() is reached.
     
     if (start.deprecatedNode() != end.deprecatedNode() && !start.deprecatedNode()->isDescendantOf(end.deprecatedNode().handle().raw())) {
         // If end is not a descendant of outerNode we need to
@@ skipping 38 matching lines @@
         // Note: We want the rightmost candidate.
         Position position = caretAfterDelete.deepEquivalent().downstream();
         Handle<Node> node = position.deprecatedNode();
         // Normally deletion will leave a br as a placeholder.
         if (node->hasTagName(brTag))
             removeNodeAndPruneAncestors(node);
         // If the selection to move was empty and in an empty block that 
         // doesn't require a placeholder to prop itself open (like a bordered
         // div or an li), remove it during the move (the list removal code
         // expects this behavior).
-        else if (isBlock(node.raw())) {
+        else if (isBlock(node)) {
             // If caret position after deletion and destination position coincides,
             // node should not be removed.
             if (!position.rendersInDifferentPosition(destination.deepEquivalent())) {
                 prune(node);
                 return;
             }
             removeNodeAndPruneAncestors(node);
         }
         else if (lineBreakExistsAtPosition(position)) {
             // There is a preserved '\n' at caretAfterDelete.
@@ skipping 40 matching lines @@
     // Add a br if pruning an empty block level element caused a collapse.  For example:
     // foo^
     // <div>bar</div>
     // baz
     // Imagine moving 'bar' to ^.  'bar' will be deleted and its div pruned.  That would
     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
     // Must recononicalize these two VisiblePositions after the pruning above.
     beforeParagraph = VisiblePosition(beforeParagraph.deepEquivalent());
     afterParagraph = VisiblePosition(afterParagraph.deepEquivalent());
 
-    if (beforeParagraph.isNotNull() && !isTableElement(beforeParagraph.deepEquivalent().deprecatedNode().handle().raw())
+    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());
     }
 }
 
 void CompositeEditCommand::moveParagraph(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, bool preserveSelection, bool preserveStyle, const Handle<Node>& constrainingAncestor)
 {
     ASSERT(isStartOfParagraph(startOfParagraphToMove));
     ASSERT(isEndOfParagraph(endOfParagraphToMove));
@@ skipping 117 matching lines @@
         Handle<Range> start = TextIterator::rangeFromLocationAndLength(adoptRawResult(document()->documentElement().handle().raw()), destinationIndex + startIndex, 0, true);
         Handle<Range> end = TextIterator::rangeFromLocationAndLength(adoptRawResult(document()->documentElement().handle().raw()), destinationIndex + endIndex, 0, true);
         if (start && end)
             setEndingSelection(VisibleSelection(start->startPosition(), end->startPosition(), DOWNSTREAM, originalIsDirectional));
     }
 }
 
 // FIXME: Send an appropriate shouldDeleteRange call.
 bool CompositeEditCommand::breakOutOfEmptyListItem()
 {
-    Handle<Node> emptyListItem = adoptRawResult(enclosingEmptyListItem(endingSelection().visibleStart()));
+    Handle<Node> emptyListItem = enclosingEmptyListItem(endingSelection().visibleStart());
     if (!emptyListItem)
         return false;
 
     RefPtr<EditingStyle> style = EditingStyle::create(endingSelection().start());
     style->mergeTypingStyle(document());
 
     Handle<ContainerNode> listNode = emptyListItem->parentNode();
     // FIXME: Can't we do something better when the immediate parent wasn't a list node?
     if (!listNode
         || (!listNode->hasTagName(ulTag) && !listNode->hasTagName(olTag))
         || !listNode->rendererIsEditable()
         || listNode == emptyListItem->rootEditableElement())
         return false;
 
     Handle<Element> newBlock;
     if (Handle<ContainerNode> blockEnclosingList = listNode->parentNode()) {
         if (blockEnclosingList->hasTagName(liTag)) { // listNode is inside another list item
-            if (visiblePositionAfterNode(blockEnclosingList.raw()) == visiblePositionAfterNode(listNode.raw())) {
+            if (visiblePositionAfterNode(blockEnclosingList) == visiblePositionAfterNode(listNode)) {
                 // If listNode appears at the end of the outer list item, then move listNode outside of this list item
                 // e.g. <ul><li>hello <ul><li><br></li></ul> </li></ul> should become <ul><li>hello</li> <ul><li><br></li></ul> </ul> after this section
                 // If listNode does NOT appear at the end, then we should consider it as a regular paragraph.
                 // e.g. <ul><li> <ul><li><br></li></ul> hello</li></ul> should become <ul><li> <div><br></div> hello</li></ul> at the end
                 splitElement(toElement(blockEnclosingList), listNode);
                 removeNodePreservingChildren(listNode->parentNode());
                 newBlock = createListItemElement(document());
             }
             // If listNode does NOT appear at the end of the outer list item, then behave as if in a regular paragraph.
         } else if (blockEnclosingList->hasTagName(olTag) || blockEnclosingList->hasTagName(ulTag))
             newBlock = createListItemElement(document());
     }
     if (!newBlock)
         newBlock = createDefaultParagraphElement(document());
 
     Handle<Node> previousListNode = emptyListItem->isElementNode() ? Result<Node>(toElement(emptyListItem)->previousElementSibling()) : emptyListItem->previousSibling();
     Handle<Node> nextListNode = emptyListItem->isElementNode() ? Result<Node>(toElement(emptyListItem)->nextElementSibling()) : emptyListItem->nextSibling();
-    if (isListItem(nextListNode.raw()) || isListElement(nextListNode.raw())) {
+    if (isListItem(nextListNode) || isListElement(nextListNode)) {
         // If emptyListItem follows another list item or nested list, split the list node.
-        if (isListItem(previousListNode.raw()) || isListElement(previousListNode.raw()))
+        if (isListItem(previousListNode) || isListElement(previousListNode))
             splitElement(toElement(listNode), emptyListItem);
 
         // If emptyListItem is followed by other list item or nested list, then insert newBlock before the list node.
         // Because we have splitted the element, emptyListItem is the first element in the list node.
         // i.e. insert newBlock before ul or ol whose first element is emptyListItem
         insertNodeBefore(newBlock, listNode);
         removeNode(emptyListItem);
     } else {
         // When emptyListItem does not follow any list item or nested list, insert newBlock after the enclosing list node.
         // Remove the enclosing node if emptyListItem is the only child; otherwise just remove emptyListItem.
         insertNodeAfter(newBlock, listNode);
-        removeNode(isListItem(previousListNode.raw()) || isListElement(previousListNode.raw()) ? emptyListItem : Handle<Node>(listNode));
+        removeNode(isListItem(previousListNode) || isListElement(previousListNode) ? emptyListItem : Handle<Node>(listNode));
     }
 
     appendBlockPlaceholder(newBlock);
     setEndingSelection(VisibleSelection(firstPositionInNode(newBlock), DOWNSTREAM, endingSelection().isDirectional()));
 
     style->prepareToApplyAt(endingSelection().start());
     if (!style->isEmpty())
         applyStyle(style.get());
 
     return true;
 }
 
 // If the caret is in an empty quoted paragraph, and either there is nothing before that
 // paragraph, or what is before is unquoted, and the user presses delete, unquote that paragraph.
 bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph()
 {
     if (!endingSelection().isCaret())
         return false;
         
     VisiblePosition caret(endingSelection().visibleStart());
-    Node* highestBlockquote = highestEnclosingNodeOfType(caret.deepEquivalent(), &isMailBlockquote);
+    Handle<Node> highestBlockquote = highestEnclosingNodeOfType(caret.deepEquivalent(), &isMailBlockquote);
     if (!highestBlockquote)
         return false;
         
     if (!isStartOfParagraph(caret) || !isEndOfParagraph(caret))
         return false;
     
     VisiblePosition previous(caret.previous(CannotCrossEditingBoundary));
     // Only move forward if there's nothing before the caret, or if there's unquoted content before it.
     if (enclosingNodeOfType(previous.deepEquivalent(), &isMailBlockquote))
         return false;
     
     Handle<Node> br = createBreakElement(document());
     // We want to replace this quoted paragraph with an unquoted one, so insert a br
     // to hold the caret before the highest blockquote.
-    insertNodeBefore(br, adoptRawResult(highestBlockquote));
+    insertNodeBefore(br, highestBlockquote);
     VisiblePosition atBR(positionBeforeNode(br));
     // If the br we inserted collapsed, for example foo<br><blockquote>...</blockquote>, insert
     // a second one.
     if (!isStartOfParagraph(atBR))
         insertNodeBefore(createBreakElement(document()), br);
     setEndingSelection(VisibleSelection(atBR, endingSelection().isDirectional()));
     
     // If this is an empty paragraph there must be a line break here.
     if (!lineBreakExistsAtVisiblePosition(caret))
         return false;
@@ skipping 20 matching lines @@
 // Operations use this function to avoid inserting content into an anchor when at the start or the end of
 // that anchor, as in NSTextView.
 // FIXME: This is only an approximation of NSTextViews insertion behavior, which varies depending on how
 // the caret was made. 
 Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(const Position& original)
 {
     if (original.isNull())
         return original;
         
     VisiblePosition visiblePos(original);
-    Handle<Node> enclosingAnchor = adoptRawResult(enclosingAnchorElement(original));
+    Handle<Node> enclosingAnchor = enclosingAnchorElement(original);
     Position result = original;
 
     if (!enclosingAnchor)
         return result;
 
     // Don't avoid block level anchors, because that would insert content into the wrong paragraph.
-    if (enclosingAnchor && !isBlock(enclosingAnchor.raw())) {
+    if (enclosingAnchor && !isBlock(enclosingAnchor)) {
         VisiblePosition firstInAnchor(firstPositionInNode(enclosingAnchor));
         VisiblePosition lastInAnchor(lastPositionInNode(enclosingAnchor));
         // If visually just after the anchor, insert *inside* the anchor unless it's the last
         // VisiblePosition in the document, to match NSTextView.
         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.deprecatedNode() != enclosingAnchor && original.deprecatedNode()->parentNode() != enclosingAnchor) {
                 pushAnchorElementDown(enclosingAnchor);
-                enclosingAnchor = adoptRawResult(enclosingAnchorElement(original));
+                enclosingAnchor = enclosingAnchorElement(original);
                 if (!enclosingAnchor)
                     return original;
             }
             // 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.deprecatedNode()->isDescendantOf(enclosingAnchor.raw()))
                 return original;
             
             result = positionInParentAfterNode(enclosingAnchor);
         }
         // If visually just before an anchor, insert *outside* the anchor unless it's the first
         // VisiblePosition in a paragraph, to match NSTextView.
         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.deprecatedNode() != enclosingAnchor && original.deprecatedNode()->parentNode() != enclosingAnchor) {
                 pushAnchorElementDown(enclosingAnchor);
-                enclosingAnchor = adoptRawResult(enclosingAnchorElement(original));
+                enclosingAnchor = enclosingAnchorElement(original);
             }
             if (!enclosingAnchor)
                 return original;
 
             result = positionInParentBeforeNode(enclosingAnchor);
         }
     }
         
     if (result.isNull() || !editableRootForPosition(result))
         result = original;
@@ skipping 13 matching lines @@
     Handle<Node> endNode = end;
     if (shouldSplitAncestor && endNode->parentNode())
         endNode = endNode->parentNode();
 
     for (node = start; node && node->parentNode() != endNode; node = node->parentNode()) {
         HandleScope scope;
         if (!node->parentNode()->isElementNode())
             break;
         // Do not split a node when doing so introduces an empty node.
         VisiblePosition positionInParent = firstPositionInNode(node->parentNode());
-        VisiblePosition positionInNode = firstPositionInOrBeforeNode(node.raw());
+        VisiblePosition positionInNode = firstPositionInOrBeforeNode(node);
         if (positionInParent != positionInNode)
             splitElement(toElement(node->parentNode()), node);
     }
 
     return node;
 }
 
 Result<Element> createBlockPlaceholderElement(const Handle<Document>& document)
 {
     return document->createElement(brTag, false);
 }
 
 } // namespace WebCore