[oilpan] Handlify Nodes in htmlediting

Source/core/editing/ReplaceSelectionCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010, 2011 Google 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
@@ skipping 98 matching lines @@
 static bool isInterchangeConvertedSpaceSpan(const Node *node)
 {
     DEFINE_STATIC_LOCAL(String, convertedSpaceSpanClassString, (AppleConvertedSpace));
     return node->isHTMLElement() && 
            static_cast<const HTMLElement *>(node)->getAttribute(classAttr) == convertedSpaceSpanClassString;
 }
 
 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 (editingIgnoresContent(pos.deprecatedNode().handle().raw()))
+    if (editingIgnoresContent(pos.deprecatedNode()))
         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.
-    Handle<Node> enclosingBlockNode = enclosingBlock(pos.containerNode().handle().raw());
+    Handle<Node> enclosingBlockNode = enclosingBlock(pos.containerNode());
     for (Position nextPosition = pos; nextPosition.containerNode() != enclosingBlockNode; pos = nextPosition) {
         HandleScope scope;
         if (lineBreakExistsAtPosition(pos))
             break;
 
         if (pos.containerNode()->nonShadowBoundaryParentNode())
             nextPosition = positionInParentAfterNode(pos.containerNode());
         
         if (nextPosition == pos 
-            || enclosingBlock(nextPosition.containerNode().handle().raw()) != enclosingBlockNode
+            || enclosingBlock(nextPosition.containerNode()) != enclosingBlockNode
             || VisiblePosition(pos) != VisiblePosition(nextPosition))
             break;
     }
     return pos;
 }
 
 ReplacementFragment::ReplacementFragment(const Handle<Document>& document, DocumentFragment* fragment, bool, const VisibleSelection& selection)
     : m_document(document),
       m_fragment(fragment),
       m_hasInterchangeNewlineAtStart(false), 
@@ skipping 127 matching lines @@
 
     removeNode(holder.raw());
 }
 
 void ReplacementFragment::removeUnrenderedNodes(Node* holder)
 {
     Vector<RefPtr<Node> > unrendered;
 
     for (Handle<Node> node = holder->firstChild(); node; node = NodeTraversal::next(node, adoptRawResult(holder))) {
         HandleScope scope;
-        if (!isNodeRendered(node.raw()) && !isTableStructureNode(node.raw()))
+        if (!isNodeRendered(node) && !isTableStructureNode(node))
             unrendered.append(node.raw());
     }
 
     size_t n = unrendered.size();
     for (size_t i = 0; i < n; ++i) {
         HandleScope scope;
         removeNode(unrendered[i]);
     }
 }
 
@@ skipping 130 matching lines @@
     VisiblePosition next = endOfInsertedContent.next(CannotCrossEditingBoundary);
     if (next.isNull())
         return false;
 
     return !selectionEndWasEndOfParagraph
         && isEndOfParagraph(endOfInsertedContent)
         && !endOfInsertedContent.deepEquivalent().deprecatedNode()->hasTagName(brTag)
         && shouldMerge(endOfInsertedContent, next);
 }
 
-static bool isMailPasteAsQuotationNode(const Node* node)
+static bool isMailPasteAsQuotationNode(const Handle<const Node>& node)
 {
-    return node && node->hasTagName(blockquoteTag) && node->isElementNode() && toElement(node)->getAttribute(classAttr) == ApplePasteAsQuotation;
+    return node && node->hasTagName(blockquoteTag) && node->isElementNode() && toConstElement(node)->getAttribute(classAttr) == ApplePasteAsQuotation;
 }
 
-static bool isHeaderElement(const Node* a)
+static bool isHeaderElement(const Handle<const Node>& a)
 {
     if (!a)
         return false;
         
     return a->hasTagName(h1Tag)
         || a->hasTagName(h2Tag)
         || a->hasTagName(h3Tag)
         || a->hasTagName(h4Tag)
         || a->hasTagName(h5Tag)
         || a->hasTagName(h6Tag);
 }
 
 static bool haveSameTagName(Node* a, Node* b)
 {
     return a && b && a->isElementNode() && b->isElementNode() && toElement(a)->tagName() == toElement(b)->tagName();
 }
 
 bool ReplaceSelectionCommand::shouldMerge(const VisiblePosition& source, const VisiblePosition& destination)
 {
     if (source.isNull() || destination.isNull())
         return false;
         
     Handle<Node> sourceNode = source.deepEquivalent().deprecatedNode();
     Handle<Node> destinationNode = destination.deepEquivalent().deprecatedNode();
-    Handle<Node> sourceBlock = enclosingBlock(sourceNode.raw());
-    Handle<Node> destinationBlock = enclosingBlock(destinationNode.raw());
+    Handle<Node> sourceBlock = enclosingBlock(sourceNode);
+    Handle<Node> destinationBlock = enclosingBlock(destinationNode);
     return !enclosingNodeOfType(source.deepEquivalent(), &isMailPasteAsQuotationNode)
-        && sourceBlock && (!sourceBlock->hasTagName(blockquoteTag) || isMailBlockquote(sourceBlock.raw()))
-        && enclosingListChild(sourceBlock.raw()) == enclosingListChild(destinationNode.raw())
+        && sourceBlock && (!sourceBlock->hasTagName(blockquoteTag) || isMailBlockquote(sourceBlock))
+        && enclosingListChild(sourceBlock) == enclosingListChild(destinationNode)
         && enclosingTableCell(source.deepEquivalent()) == enclosingTableCell(destination.deepEquivalent())
-        && (!isHeaderElement(sourceBlock.raw()) || haveSameTagName(sourceBlock.raw(), destinationBlock.raw()))
+        && (!isHeaderElement(sourceBlock) || haveSameTagName(sourceBlock.raw(), destinationBlock.raw()))
         // Don't merge to or from a position before or after a block because it would
         // be a no-op and cause infinite recursion.
-        && !isBlock(sourceNode.raw()) && !isBlock(destinationNode.raw());
+        && !isBlock(sourceNode) && !isBlock(destinationNode);
 }
 
 // Style rules that match just inserted elements could change their appearance, like
 // a div inserted into a document with div { display:inline; }.
 void ReplaceSelectionCommand::removeRedundantStylesAndKeepStyleSpanInline(InsertedNodes& insertedNodes)
 {
     Handle<Node> pastEndNode = adoptRawResult(insertedNodes.pastLastLeaf());
     Handle<Node> next;
     for (Handle<Node> node = adoptRawResult(insertedNodes.firstNodeInserted()); node && node != pastEndNode; node = next) {
         // FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance
@@ skipping 21 matching lines @@
                     // e.g. <font size="3" style="font-size: 20px;"> is converted to <font style="font-size: 20px;">
                     for (size_t i = 0; i < attributes.size(); i++)
                         removeNodeAttribute(element, attributes[i]);
                 }
             }
 
             Handle<ContainerNode> context = element->parentNode();
 
             // If Mail wraps the fragment with a Paste as Quotation blockquote, or if you're pasting into a quoted region,
             // styles from blockquoteNode are allowed to override those from the source document, see <rdar://problem/4930986> and <rdar://problem/5089327>.
-            Node* blockquoteNode = isMailPasteAsQuotationNode(context.raw()) ? context.raw() : enclosingNodeOfType(firstPositionInNode(context), isMailBlockquote, CanCrossEditingBoundary);
+            Handle<Node> blockquoteNode = isMailPasteAsQuotationNode(context) ? Handle<Node>(context) : Handle<Node>(enclosingNodeOfType(firstPositionInNode(context), isMailBlockquote, CanCrossEditingBoundary));
             if (blockquoteNode)
                 newInlineStyle->removeStyleFromRulesAndContext(element, document()->documentElement());
 
             newInlineStyle->removeStyleFromRulesAndContext(element, context);
         }
 
         if (!inlineStyle || newInlineStyle->isEmpty()) {
             if (isStyleSpanOrSpanWithOnlyStyleAttribute(element) || isEmptyFontTag(element, AllowNonEmptyStyleAttribute)) {
                 insertedNodes.willRemoveNodePreservingChildren(element.raw());
                 removeNodePreservingChildren(element);
                 continue;
             }
             removeNodeAttribute(element, styleAttr);
         } else if (newInlineStyle->style()->propertyCount() != inlineStyle->propertyCount())
             setNodeAttribute(element, styleAttr, newInlineStyle->style()->asText());
 
         // FIXME: Tolerate differences in id, class, and style attributes.
-        if (isNonTableCellHTMLBlockElement(element.raw()) && areIdenticalElements(element.raw(), element->parentNode().handle().raw())
+        if (isNonTableCellHTMLBlockElement(element) && areIdenticalElements(element, element->parentNode())
             && VisiblePosition(firstPositionInNode(element->parentNode())) == VisiblePosition(firstPositionInNode(element))
             && VisiblePosition(lastPositionInNode(element->parentNode())) == VisiblePosition(lastPositionInNode(element))) {
             insertedNodes.willRemoveNodePreservingChildren(element.raw());
             removeNodePreservingChildren(element);
             continue;
         }
 
         if (element->parentNode()->rendererIsRichlyEditable())
             removeNodeAttribute(element, contenteditableAttr);
 
         // WebKit used to not add display: inline and float: none on copy.
         // Keep this code around for backward compatibility
         if (isLegacyAppleStyleSpan(element)) {
             if (!element->firstChild()) {
                 insertedNodes.willRemoveNodePreservingChildren(element.raw());
                 removeNodePreservingChildren(element);
                 continue;
             }
             // There are other styles that style rules can give to style spans,
             // but these are the two important ones because they'll prevent
             // inserted content from appearing in the right paragraph.
             // FIXME: Hyatt is concerned that selectively using display:inline will give inconsistent
             // results. We already know one issue because td elements ignore their display property
             // in quirks mode (which Mail.app is always in). We should look for an alternative.
 
             // Mutate using the CSSOM wrapper so we get the same event behavior as a script.
-            if (isBlock(element.raw()))
+            if (isBlock(element))
                 element->style()->setPropertyInternal(CSSPropertyDisplay, "inline", false, IGNORE_EXCEPTION);
             if (element->renderer() && element->renderer()->style()->isFloating())
                 element->style()->setPropertyInternal(CSSPropertyFloat, "none", false, IGNORE_EXCEPTION);
         }
     }
 }
 
 static bool isProhibitedParagraphChild(const AtomicString& name)
 {
     // https://dvcs.w3.org/hg/editing/raw-file/57abe6d3cb60/editing.html#prohibited-paragraph-child
@@ skipping 55 matching lines @@
 {
     RefPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
     Handle<Node> next;
     for (RefPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next.passRefPtr()) {
         next = NodeTraversal::next(adoptRawResult(node.get()));
 
         if (!node->isHTMLElement())
             continue;
 
         if (isProhibitedParagraphChild(toHTMLElement(adoptRawResult(node.get()))->localName())) {
-            if (Handle<HTMLElement> paragraphElement = toHTMLElement(adoptRawResult(enclosingNodeWithTag(positionInParentBeforeNode(adoptRawResult(node.get())), pTag))))
+            if (Handle<HTMLElement> paragraphElement = toHTMLElement(enclosingNodeWithTag(positionInParentBeforeNode(adoptRawResult(node.get())), pTag)))
                 moveNodeOutOfAncestor(node, paragraphElement.passRefPtr());
         }
 
-        if (isHeaderElement(node.get())) {
-            if (Handle<HTMLElement> headerElement = toHTMLElement(adoptRawResult(highestEnclosingNodeOfType(positionInParentBeforeNode(adoptRawResult(node.get())), isHeaderElement))))
+        if (isHeaderElement(adoptRawResult(node.get()))) {
+            if (Handle<HTMLElement> headerElement = toHTMLElement(highestEnclosingNodeOfType(positionInParentBeforeNode(adoptRawResult(node.get())), isHeaderElement)))
                 moveNodeOutOfAncestor(node, headerElement.passRefPtr());
         }
     }
 }
 
 void ReplaceSelectionCommand::moveNodeOutOfAncestor(PassRefPtr<Node> prpNode, PassRefPtr<Node> prpAncestor)
 {
     Handle<Node> node = adoptRawResult(prpNode.get());
     Handle<Node> ancestor = adoptRawResult(prpAncestor.get());
 
-    VisiblePosition positionAtEndOfNode = lastPositionInOrAfterNode(node.raw());
+    VisiblePosition positionAtEndOfNode = lastPositionInOrAfterNode(node);
     VisiblePosition lastPositionInParagraph = lastPositionInNode(ancestor);
     if (positionAtEndOfNode == lastPositionInParagraph) {
         removeNode(node);
         if (ancestor->nextSibling())
             insertNodeBefore(node, ancestor->nextSibling());
         else
             appendNode(node, ancestor->parentNode());
     } else {
         Handle<Node> nodeToSplitTo = splitTreeToNode(node, ancestor, true);
         removeNode(node);
         insertNodeBefore(node, nodeToSplitTo);
     }
     if (!ancestor->firstChild())
         removeNode(ancestor);
 }
 
 static inline bool nodeHasVisibleRenderText(const Handle<Text>& text)
 {
     return text->renderer() && toRenderText(text->renderer())->renderedTextLength() > 0;
 }
 
 void ReplaceSelectionCommand::removeUnrenderedTextNodesAtEnds(InsertedNodes& insertedNodes)
 {
     document()->updateLayoutIgnorePendingStylesheets();
 
     Handle<Node> lastLeafInserted = adoptRawResult(insertedNodes.lastLeafInserted());
     if (lastLeafInserted && lastLeafInserted->isTextNode() && !nodeHasVisibleRenderText(toText(lastLeafInserted))
-        && !enclosingNodeWithTag(firstPositionInOrBeforeNode(lastLeafInserted.raw()), selectTag)
-        && !enclosingNodeWithTag(firstPositionInOrBeforeNode(lastLeafInserted.raw()), scriptTag)) {
+        && !enclosingNodeWithTag(firstPositionInOrBeforeNode(lastLeafInserted), selectTag)
+        && !enclosingNodeWithTag(firstPositionInOrBeforeNode(lastLeafInserted), scriptTag)) {
         insertedNodes.willRemoveNode(lastLeafInserted.raw());
         removeNode(lastLeafInserted);
     }
 
     // We don't have to make sure that firstNodeInserted isn't inside a select or script element, because
     // it is a top level node in the fragment and the user can't insert into those elements.
     Handle<Node> firstNodeInserted = adoptRawResult(insertedNodes.firstNodeInserted());
     lastLeafInserted = adoptRawResult(insertedNodes.lastLeafInserted());
     if (firstNodeInserted && firstNodeInserted->isTextNode() && !nodeHasVisibleRenderText(toText(firstNodeInserted.raw()))) {
         insertedNodes.willRemoveNode(firstNodeInserted.raw());
         removeNode(firstNodeInserted);
     }
 }
 
 VisiblePosition ReplaceSelectionCommand::positionAtEndOfInsertedContent() const
 {
     // FIXME: Why is this hack here?  What's special about <select> tags?
-    Node* enclosingSelect = enclosingNodeWithTag(m_endOfInsertedContent, selectTag);
+    Handle<Node> enclosingSelect = enclosingNodeWithTag(m_endOfInsertedContent, selectTag);
     return enclosingSelect ? lastPositionInOrAfterNode(enclosingSelect) : m_endOfInsertedContent;
 }
 
 VisiblePosition ReplaceSelectionCommand::positionAtStartOfInsertedContent() const
 {
     return m_startOfInsertedContent;
 }
 
 static void removeHeadContents(ReplacementFragment& fragment)
 {
@@ skipping 13 matching lines @@
 }
 
 // Remove style spans before insertion if they are unnecessary.  It's faster because we'll 
 // avoid doing a layout.
 static bool handleStyleSpansBeforeInsertion(ReplacementFragment& fragment, const Position& insertionPos)
 {
     Handle<Node> topNode = adoptRawResult(fragment.firstChild());
 
     // Handling the case where we are doing Paste as Quotation or pasting into quoted content is more complicated (see handleStyleSpans)
     // and doesn't receive the optimization.
-    if (isMailPasteAsQuotationNode(topNode.raw()) || enclosingNodeOfType(firstPositionInOrBeforeNode(topNode.raw()), isMailBlockquote, CanCrossEditingBoundary))
+    if (isMailPasteAsQuotationNode(topNode) || enclosingNodeOfType(firstPositionInOrBeforeNode(topNode), isMailBlockquote, CanCrossEditingBoundary))
         return false;
 
     // Either there are no style spans in the fragment or a WebKit client has added content to the fragment
     // before inserting it.  Look for and handle style spans after insertion.
     if (!isLegacyAppleStyleSpan(topNode))
         return false;
 
     Handle<Node> wrappingStyleSpan = topNode;
     RefPtr<EditingStyle> styleAtInsertionPos = EditingStyle::create(insertionPos.parentAnchoredEquivalent());
     String styleText = styleAtInsertionPos->style()->asText();
@@ skipping 32 matching lines @@
     // There might not be any style spans if we're pasting from another application or if 
     // we are here because of a document.execCommand("InsertHTML", ...) call.
     if (!wrappingStyleSpan)
         return;
 
     RefPtr<EditingStyle> style = EditingStyle::createFromPropertySet(wrappingStyleSpan->inlineStyle());
     Handle<ContainerNode> context = wrappingStyleSpan->parentNode();
 
     // If Mail wraps the fragment with a Paste as Quotation blockquote, or if you're pasting into a quoted region,
     // styles from blockquoteNode are allowed to override those from the source document, see <rdar://problem/4930986> and <rdar://problem/5089327>.
-    Node* blockquoteNode = isMailPasteAsQuotationNode(context.raw()) ? context.raw() : enclosingNodeOfType(firstPositionInNode(context), isMailBlockquote, CanCrossEditingBoundary);
+    Handle<Node> blockquoteNode = isMailPasteAsQuotationNode(context) ? Handle<Node>(context) : Handle<Node>(enclosingNodeOfType(firstPositionInNode(context), isMailBlockquote, CanCrossEditingBoundary));
     if (blockquoteNode)
         context = document()->documentElement();
 
     // This operation requires that only editing styles to be removed from sourceDocumentStyle.
     style->prepareToApplyAt(firstPositionInNode(context));
 
     // Remove block properties in the span's style. This prevents properties that probably have no effect 
     // currently from affecting blocks later if the style is cloned for a new block element during a future 
     // editing operation.
     // FIXME: They *can* have an effect currently if blocks beneath the style span aren't individually marked
@@ skipping 60 matching lines @@
         // Stop if any previous sibling is a block.
         for (Handle<Node> sibling = node->previousSibling(); sibling; sibling = sibling->previousSibling()) {
             if (sibling->isBlockFlowElement())
                 return node;
         }
         node = parent.raw();
     }
     return node;
 }
 
-static bool isInlineNodeWithStyle(const Node* node)
+static bool isInlineNodeWithStyle(const Handle<const Node>& node)
 {
     // We don't want to skip over any block elements.
     if (isBlock(node))
         return false;
 
     if (!node->isHTMLElement())
         return false;
 
     // We can skip over elements whose class attribute is
     // one of our internal classes.
-    Handle<const HTMLElement> element = toConstHTMLElement(adoptRawResult(node));
+    Handle<const HTMLElement> element = toConstHTMLElement(node);
     const AtomicString& classAttributeValue = element->getAttribute(classAttr);
     if (classAttributeValue == AppleTabSpanClass
         || classAttributeValue == AppleConvertedSpace
         || classAttributeValue == ApplePasteAsQuotation)
         return true;
 
     return EditingStyle::elementIsStyledSpanOrHTMLEquivalent(element);
 }
 
 inline Node* nodeToSplitToAvoidPastingIntoInlineNodesWithStyle(const Position& insertionPos)

[Mads Ager (chromium), 2013/09/24 06:36:20]

I believe this is only used in a couple of places and I think the code will be
even nicer if we just make this return a Result<Node> as well. :-)

 {
-    Handle<Node> containgBlock = enclosingBlock(insertionPos.containerNode().handle().raw());
-    return highestEnclosingNodeOfType(insertionPos, isInlineNodeWithStyle, CannotCrossEditingBoundary, containgBlock.raw());
+    Handle<Node> containgBlock = enclosingBlock(insertionPos.containerNode());
+    return highestEnclosingNodeOfType(insertionPos, isInlineNodeWithStyle, CannotCrossEditingBoundary, containgBlock).handle().raw();
 }
 
 void ReplaceSelectionCommand::doApply()
 {
     VisibleSelection selection = endingSelection();
     ASSERT(selection.isCaretOrRange());
     ASSERT(selection.start().deprecatedNode());
     if (!selection.isNonOrphanedCaretOrRange() || !selection.start().deprecatedNode())
         return;
 
@@ skipping 13 matching lines @@
         m_insertionStyle = EditingStyle::create(selection.start());
         m_insertionStyle->mergeTypingStyle(document());
     }
 
     VisiblePosition visibleStart = selection.visibleStart();
     VisiblePosition visibleEnd = selection.visibleEnd();
     
     bool selectionEndWasEndOfParagraph = isEndOfParagraph(visibleEnd);
     bool selectionStartWasStartOfParagraph = isStartOfParagraph(visibleStart);
     
-    Handle<Node> startBlock = enclosingBlock(visibleStart.deepEquivalent().deprecatedNode().handle().raw());
+    Handle<Node> startBlock = enclosingBlock(visibleStart.deepEquivalent().deprecatedNode());
     
     Position insertionPos = selection.start();
     bool startIsInsideMailBlockquote = enclosingNodeOfType(insertionPos, isMailBlockquote, CanCrossEditingBoundary);
     bool selectionIsPlainText = !selection.isContentRichlyEditable();
     Handle<Element> currentRoot = selection.rootEditableElement();
 
     if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph && !startIsInsideMailBlockquote) ||
-        startBlock == currentRoot || isListItem(startBlock.raw()) || selectionIsPlainText)
+        startBlock == currentRoot || isListItem(startBlock) || selectionIsPlainText)
         m_preventNesting = false;
     
     if (selection.isRange()) {
         // When the end of the selection being pasted into is at the end of a paragraph, and that selection
         // spans multiple blocks, not merging may leave an empty line.
         // When the start of the selection being pasted into is at the start of a block, not merging 
         // will leave hanging block(s).
         // Merge blocks if the start of the selection was in a Mail blockquote, since we handle  
         // that case specially to prevent nesting. 
         bool mergeBlocksAfterDelete = startIsInsideMailBlockquote || isEndOfParagraph(visibleEnd) || isStartOfBlock(visibleStart);
@@ skipping 53 matching lines @@
       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]).  
     Handle<Node> endBR = insertionPos.downstream().deprecatedNode()->hasTagName(brTag) ? insertionPos.downstream().deprecatedNode() : nullptr;
     VisiblePosition originalVisPosBeforeEndBR;
     if (endBR)
         originalVisPosBeforeEndBR = VisiblePosition(positionBeforeNode(endBR), DOWNSTREAM).previous();
     
-    startBlock = enclosingBlock(insertionPos.deprecatedNode().handle().raw());
+    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.
-    if (m_preventNesting && startBlock && !isTableCell(startBlock.raw()) && !startIsInsideMailBlockquote) {
+    if (m_preventNesting && startBlock && !isTableCell(startBlock) && !startIsInsideMailBlockquote) {
         ASSERT(startBlock != currentRoot);
         VisiblePosition visibleInsertionPos(insertionPos);
         if (isEndOfBlock(visibleInsertionPos) && !(isStartOfBlock(visibleInsertionPos) && fragment.hasInterchangeNewlineAtEnd()))
             insertionPos = positionInParentAfterNode(startBlock);
         else if (isStartOfBlock(visibleInsertionPos))
             insertionPos = positionInParentBeforeNode(startBlock);
     }
     
     // Paste at start or end of link goes outside of link.
     insertionPos = positionAvoidingSpecialElementBoundary(insertionPos);
@@ skipping 18 matching lines @@
     // We're finished if there is nothing to add.
     if (fragment.isEmpty() || !fragment.firstChild())
         return;
 
     // If we are not trying to match the destination style we prefer a position
     // that is outside inline elements that provide style.
     // This way we can produce a less verbose markup.
     // We can skip this optimization for fragments not wrapped in one of
     // our style spans and for positions inside list items
     // since insertAsListItems already does the right thing.
-    if (!m_matchStyle && !enclosingList(insertionPos.containerNode().handle().raw())) {
+    if (!m_matchStyle && !enclosingList(insertionPos.containerNode())) {
         if (insertionPos.containerNode()->isTextNode() && insertionPos.offsetInContainerNode() && !insertionPos.atLastEditingPositionForNode()) {
             splitTextNode(insertionPos.containerText(), insertionPos.offsetInContainerNode());
             insertionPos = firstPositionInNode(insertionPos.containerNode());
         }
 
         if (RefPtr<Node> nodeToSplitTo = nodeToSplitToAvoidPastingIntoInlineNodesWithStyle(insertionPos)) {
             if (insertionPos.containerNode() != nodeToSplitTo->parentNode()) {
                 Handle<Node> splitStart = insertionPos.computeNodeAfterPosition();
                 if (!splitStart)
                     splitStart = insertionPos.containerNode();
@@ skipping 15 matching lines @@
     // incoming fragment.
     // 5) Add spaces for smart replace.
     // 6) Select the replacement if requested, and match style if requested.
 
     InsertedNodes insertedNodes;
     Handle<Node> refNode = adoptRawResult(fragment.firstChild());
     Handle<Node> node = refNode->nextSibling();
     
     fragment.removeNode(refNode.raw());
 
-    Handle<Node> blockStart = enclosingBlock(insertionPos.deprecatedNode().handle().raw());
-    if ((isListElement(refNode.raw()) || (isLegacyAppleStyleSpan(refNode) && isListElement(refNode->firstChild().handle().raw())))
+    Handle<Node> blockStart = enclosingBlock(insertionPos.deprecatedNode());
+    if ((isListElement(refNode) || (isLegacyAppleStyleSpan(refNode) && isListElement(refNode->firstChild())))
         && blockStart && blockStart->renderer()->isListItem())
         refNode = adoptRawResult(insertAsListItems(toHTMLElement(refNode), blockStart.raw(), insertionPos, insertedNodes));
     else {
         insertNodeAt(refNode, insertionPos);
         insertedNodes.respondToNodeInsertion(refNode.raw());
     }
 
     // Mutation events (bug 22634) may have already removed the inserted content
     if (!refNode->inDocument())
         return;
@@ skipping 19 matching lines @@
 
     removeUnrenderedTextNodesAtEnds(insertedNodes);
 
     if (!handledStyleSpans)
         handleStyleSpans(insertedNodes);
 
     // Mutation events (bug 20161) may have already removed the inserted content
     if (!insertedNodes.firstNodeInserted() || !insertedNodes.firstNodeInserted()->inDocument())
         return;
 
-    VisiblePosition startOfInsertedContent = firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted());
+    VisiblePosition startOfInsertedContent = firstPositionInOrBeforeNode(adoptRawResult(insertedNodes.firstNodeInserted()));
 
     // 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.deprecatedNode() == startBlock->parentNode() && (unsigned)insertionPos.deprecatedEditingOffset() < startBlock->nodeIndex() && !isStartOfParagraph(startOfInsertedContent))
         insertNodeAt(createBreakElement(document()), startOfInsertedContent.deepEquivalent());
 
     if (endBR && (plainTextFragment || shouldRemoveEndBR(endBR.raw(), originalVisPosBeforeEndBR))) {
-        RefPtr<Node> parent = endBR->parentNode().passRefPtr();
+        Handle<Node> parent = endBR->parentNode();
         insertedNodes.willRemoveNode(endBR.raw());
         removeNode(endBR);
-        if (Handle<Node> nodeToRemove = adoptRawResult(highestNodeToRemoveInPruning(parent.get()))) {
+        if (Handle<Node> nodeToRemove = highestNodeToRemoveInPruning(parent)) {
             insertedNodes.willRemoveNode(nodeToRemove.raw());
             removeNode(nodeToRemove);
         }
     }
     
     makeInsertedContentRoundTrippableWithHTMLTreeBuilder(insertedNodes);
 
     removeRedundantStylesAndKeepStyleSpanInline(insertedNodes);
 
     if (m_sanitizeFragment)
         applyCommandToComposite(SimplifyMarkupCommand::create(document(), insertedNodes.firstNodeInserted(), insertedNodes.pastLastLeaf()));
 
     // Setup m_startOfInsertedContent and m_endOfInsertedContent. This should be the last two lines of code that access insertedNodes.
-    m_startOfInsertedContent = firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted());
-    m_endOfInsertedContent = lastPositionInOrAfterNode(insertedNodes.lastLeafInserted());
+    m_startOfInsertedContent = firstPositionInOrBeforeNode(adoptRawResult(insertedNodes.firstNodeInserted()));
+    m_endOfInsertedContent = lastPositionInOrAfterNode(adoptRawResult(insertedNodes.lastLeafInserted()));
 
     // Determine whether or not we should merge the end of inserted content with what's after it before we do
     // the start merge so that the start merge doesn't effect our decision.
     m_shouldMergeEnd = shouldMergeEnd(selectionEndWasEndOfParagraph);
     
     if (shouldMergeStart(selectionStartWasStartOfParagraph, fragment.hasInterchangeNewlineAtStart(), startIsInsideMailBlockquote)) {
         VisiblePosition startOfParagraphToMove = positionAtStartOfInsertedContent();
         VisiblePosition destination = startOfParagraphToMove.previous();
         // 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.
@@ skipping 26 matching lines @@
     }
 
     Position lastPositionToSelect;
     if (fragment.hasInterchangeNewlineAtEnd()) {
         VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
         VisiblePosition next = endOfInsertedContent.next(CannotCrossEditingBoundary);
 
         if (selectionEndWasEndOfParagraph || !isEndOfParagraph(endOfInsertedContent) || next.isNull()) {
             if (!isStartOfParagraph(endOfInsertedContent)) {
                 setEndingSelection(endOfInsertedContent);
-                Handle<Node> enclosingNode = enclosingBlock(endOfInsertedContent.deepEquivalent().deprecatedNode().handle().raw());
-                if (isListItem(enclosingNode.raw())) {
+                Handle<Node> enclosingNode = enclosingBlock(endOfInsertedContent.deepEquivalent().deprecatedNode());
+                if (isListItem(enclosingNode)) {
                     Handle<Node> newListItem = createListItemElement(document());
                     insertNodeAfter(newListItem, enclosingNode);
                     setEndingSelection(VisiblePosition(firstPositionInNode(newListItem)));
                 } else {
                     // Use a default paragraph element (a plain div) for the empty paragraph, using the last paragraph
                     // block's style seems to annoy users.
                     insertParagraphSeparator(true, !startIsInsideMailBlockquote && highestEnclosingNodeOfType(endOfInsertedContent.deepEquivalent(),
-                        isMailBlockquote, CannotCrossEditingBoundary, insertedNodes.firstNodeInserted()->parentNode().handle().raw()));
+                        isMailBlockquote, CannotCrossEditingBoundary, insertedNodes.firstNodeInserted()->parentNode()));
                 }
 
                 // Select up to the paragraph separator that was added.
                 lastPositionToSelect = endingSelection().visibleStart().deepEquivalent();
                 updateNodesInserted(lastPositionToSelect.deprecatedNode().handle().raw());
             }
         } else {
             // Select up to the beginning of the next paragraph.
             lastPositionToSelect = next.deepEquivalent().downstream();
         }
         
     } else
         mergeEndIfNeeded();
 
-    if (Node* mailBlockquote = enclosingNodeOfType(positionAtStartOfInsertedContent().deepEquivalent(), isMailPasteAsQuotationNode))
-        removeNodeAttribute(adoptRawResult(toElement(mailBlockquote)), classAttr);
+    if (Handle<Node> mailBlockquote = enclosingNodeOfType(positionAtStartOfInsertedContent().deepEquivalent(), isMailPasteAsQuotationNode))
+        removeNodeAttribute(toElement(mailBlockquote), classAttr);
 
     if (shouldPerformSmartReplace())
         addSpacesForSmartReplace();
 
     // If we are dealing with a fragment created from plain text
     // no style matching is necessary.
     if (plainTextFragment)
         m_matchStyle = false;
         
     completeHTMLReplacement(lastPositionToSelect);
@@ skipping 141 matching lines @@
     if (!text)
         return;
 
     if (text->previousSibling() && text->previousSibling()->isTextNode()) {
         Handle<Text> previous = toText(text->previousSibling());
         insertTextIntoNode(text, 0, previous->data());
 
         if (positionIsOffsetInAnchor)
             position.moveToOffset(previous->length() + position.offsetInContainerNode());
         else
-            updatePositionForNodeRemoval(position, previous.raw());
+            updatePositionForNodeRemoval(position, previous);
 
         if (positionOnlyToBeUpdatedIsOffsetInAnchor) {
             if (positionOnlyToBeUpdated.containerNode() == text)
                 positionOnlyToBeUpdated.moveToOffset(previous->length() + positionOnlyToBeUpdated.offsetInContainerNode());
             else if (positionOnlyToBeUpdated.containerNode() == previous)
                 positionOnlyToBeUpdated.moveToPosition(text, positionOnlyToBeUpdated.offsetInContainerNode());
         } else
-            updatePositionForNodeRemoval(positionOnlyToBeUpdated, previous.raw());
+            updatePositionForNodeRemoval(positionOnlyToBeUpdated, previous);
 
         removeNode(previous);
     }
     if (text->nextSibling() && text->nextSibling()->isTextNode()) {
         Handle<Text> next = toText(text->nextSibling());
         unsigned originalLength = text->length();
         insertTextIntoNode(text, originalLength, next->data());
 
         if (!positionIsOffsetInAnchor)
-            updatePositionForNodeRemoval(position, next.raw());
+            updatePositionForNodeRemoval(position, next);
 
         if (positionOnlyToBeUpdatedIsOffsetInAnchor && positionOnlyToBeUpdated.containerNode() == next)
             positionOnlyToBeUpdated.moveToPosition(text, originalLength + positionOnlyToBeUpdated.offsetInContainerNode());
         else
-            updatePositionForNodeRemoval(positionOnlyToBeUpdated, next.raw());
+            updatePositionForNodeRemoval(positionOnlyToBeUpdated, next);
 
         removeNode(next);
     }
 }
 
 EditAction ReplaceSelectionCommand::editingAction() const
 {
     return m_editAction;
 }
 
 // If the user is inserting a list into an existing list, instead of nesting the list,
 // we put the list items into the existing list.
 Node* ReplaceSelectionCommand::insertAsListItems(const Handle<HTMLElement>& prpListElement, Node* insertionBlock, const Position& insertPos, InsertedNodes& insertedNodes)
 {
     Handle<HTMLElement> listElement = prpListElement;
 
-    while (listElement->hasChildNodes() && isListElement(listElement->firstChild().handle().raw()) && listElement->childNodeCount() == 1)
+    while (listElement->hasChildNodes() && isListElement(listElement->firstChild()) && listElement->childNodeCount() == 1)
         listElement = toHTMLElement(listElement->firstChild());
 
     bool isStart = isStartOfParagraph(insertPos);
     bool isEnd = isEndOfParagraph(insertPos);
     bool isMiddle = !isStart && !isEnd;
     Handle<Node> lastNode = adoptRawResult(insertionBlock);
 
     // If we're in the middle of a list item, we should split it into two separate
     // list items and insert these nodes between them.
     if (isMiddle) {
@@ skipping 20 matching lines @@
         lastNode = lastNode->previousSibling();
     return lastNode.raw();
 }
 
 void ReplaceSelectionCommand::updateNodesInserted(Node *node)
 {
     if (!node)
         return;
 
     if (m_startOfInsertedContent.isNull())
-        m_startOfInsertedContent = firstPositionInOrBeforeNode(node);
+        m_startOfInsertedContent = firstPositionInOrBeforeNode(adoptRawResult(node));
 
-    m_endOfInsertedContent = lastPositionInOrAfterNode(node->lastDescendant().handle().raw());
+    m_endOfInsertedContent = lastPositionInOrAfterNode(node->lastDescendant());
 }
 
 // During simple pastes, where we're just pasting a text node into a run of text, we insert the text node
 // directly into the text node that holds the selection.  This is much faster than the generalized code in
 // ReplaceSelectionCommand, and works around <https://bugs.webkit.org/show_bug.cgi?id=6148> since we don't 
 // split text nodes.
 bool ReplaceSelectionCommand::performTrivialReplace(const ReplacementFragment& fragment)
 {
     if (!fragment.firstChild() || fragment.firstChild() != fragment.lastChild() || !fragment.firstChild()->isTextNode())
         return false;
@@ skipping 20 matching lines @@
         removeNodeAndPruneAncestors(nodeAfterInsertionPos);
 
     VisibleSelection selectionAfterReplace(m_selectReplacement ? start : end, end);
 
     setEndingSelection(selectionAfterReplace);
 
     return true;
 }
 
 } // namespace WebCore