Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/editing/commands/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 65 matching lines @@
     ReplacementFragment(Document*, DocumentFragment*, const VisibleSelection&);
 
     Node* firstChild() const;
     Node* lastChild() const;
 
     bool isEmpty() const;
 
     bool hasInterchangeNewlineAtStart() const { return m_hasInterchangeNewlineAtStart; }
     bool hasInterchangeNewlineAtEnd() const { return m_hasInterchangeNewlineAtEnd; }
 
-    void removeNode(PassRefPtrWillBeRawPtr<Node>);
-    void removeNodePreservingChildren(PassRefPtrWillBeRawPtr<ContainerNode>);
+    void removeNode(RawPtr<Node>);
+    void removeNodePreservingChildren(RawPtr<ContainerNode>);
 
 private:
-    PassRefPtrWillBeRawPtr<HTMLElement> insertFragmentForTestRendering(Element* rootEditableElement);
+    RawPtr<HTMLElement> insertFragmentForTestRendering(Element* rootEditableElement);
     void removeUnrenderedNodes(ContainerNode*);
     void restoreAndRemoveTestRenderingNodesToFragment(Element*);
     void removeInterchangeNodes(ContainerNode*);
 
-    void insertNodeBefore(PassRefPtrWillBeRawPtr<Node>, Node* refNode);
+    void insertNodeBefore(RawPtr<Node>, Node* refNode);
 
-    RefPtrWillBeMember<Document> m_document;
-    RefPtrWillBeMember<DocumentFragment> m_fragment;
+    Member<Document> m_document;
+    Member<DocumentFragment> m_fragment;
     bool m_hasInterchangeNewlineAtStart;
     bool m_hasInterchangeNewlineAtEnd;
 };
 
 static bool isInterchangeHTMLBRElement(const Node* node)
 {
     DEFINE_STATIC_LOCAL(String, interchangeNewlineClassString, (AppleInterchangeNewline));
     if (!isHTMLBRElement(node) || toHTMLBRElement(node)->getAttribute(classAttr) != interchangeNewlineClassString)
         return false;
     UseCounter::count(node->document(), UseCounter::EditingAppleInterchangeNewline);
@@ skipping 39 matching lines @@
     : m_document(document)
     , m_fragment(fragment)
     , m_hasInterchangeNewlineAtStart(false)
     , m_hasInterchangeNewlineAtEnd(false)
 {
     if (!m_document)
         return;
     if (!m_fragment || !m_fragment->hasChildren())
         return;
 
-    RefPtrWillBeRawPtr<Element> editableRoot = selection.rootEditableElement();
+    RawPtr<Element> editableRoot = selection.rootEditableElement();
     ASSERT(editableRoot);
     if (!editableRoot)
         return;
 
     Element* shadowAncestorElement;
     if (editableRoot->isInShadowTree())
         shadowAncestorElement = editableRoot->shadowHost();
     else
         shadowAncestorElement = editableRoot.get();
 
     if (!editableRoot->getAttributeEventListener(EventTypeNames::webkitBeforeTextInserted)
         // FIXME: Remove these checks once textareas and textfields actually register an event handler.
         && !(shadowAncestorElement && shadowAncestorElement->layoutObject() && shadowAncestorElement->layoutObject()->isTextControl())
         && editableRoot->layoutObjectIsRichlyEditable()) {
         removeInterchangeNodes(m_fragment.get());
         return;
     }
 
-    RefPtrWillBeRawPtr<HTMLElement> holder = insertFragmentForTestRendering(editableRoot.get());
+    RawPtr<HTMLElement> holder = insertFragmentForTestRendering(editableRoot.get());
     if (!holder) {
         removeInterchangeNodes(m_fragment.get());
         return;
     }
 
     const EphemeralRange range = VisibleSelection::selectionFromContentsOfNode(holder.get()).toNormalizedEphemeralRange();
     String text = plainText(range, static_cast<TextIteratorBehavior>(TextIteratorEmitsOriginalText | TextIteratorIgnoresStyleVisibility));
 
     removeInterchangeNodes(holder.get());
     removeUnrenderedNodes(holder.get());
     restoreAndRemoveTestRenderingNodesToFragment(holder.get());
 
     // Give the root a chance to change the text.
-    RefPtrWillBeRawPtr<BeforeTextInsertedEvent> evt = BeforeTextInsertedEvent::create(text);
+    RawPtr<BeforeTextInsertedEvent> evt = BeforeTextInsertedEvent::create(text);
     editableRoot->dispatchEvent(evt);
     if (text != evt->text() || !editableRoot->layoutObjectIsRichlyEditable()) {
         restoreAndRemoveTestRenderingNodesToFragment(holder.get());
 
         m_fragment = createFragmentFromText(selection.toNormalizedEphemeralRange(), evt->text());
         if (!m_fragment->hasChildren())
             return;
 
         holder = insertFragmentForTestRendering(editableRoot.get());
         removeInterchangeNodes(holder.get());
@@ skipping 10 matching lines @@
 Node* ReplacementFragment::firstChild() const
 {
     return m_fragment ? m_fragment->firstChild() : 0;
 }
 
 Node* ReplacementFragment::lastChild() const
 {
     return m_fragment ? m_fragment->lastChild() : 0;
 }
 
-void ReplacementFragment::removeNodePreservingChildren(PassRefPtrWillBeRawPtr<ContainerNode> node)
+void ReplacementFragment::removeNodePreservingChildren(RawPtr<ContainerNode> node)
 {
     if (!node)
         return;
 
-    while (RefPtrWillBeRawPtr<Node> n = node->firstChild()) {
+    while (RawPtr<Node> n = node->firstChild()) {
         removeNode(n);
         insertNodeBefore(n.release(), node.get());
     }
     removeNode(node);
 }
 
-void ReplacementFragment::removeNode(PassRefPtrWillBeRawPtr<Node> node)
+void ReplacementFragment::removeNode(RawPtr<Node> node)
 {
     if (!node)
         return;
 
     ContainerNode* parent = node->nonShadowBoundaryParentNode();
     if (!parent)
         return;
 
     parent->removeChild(node.get());
 }
 
-void ReplacementFragment::insertNodeBefore(PassRefPtrWillBeRawPtr<Node> node, Node* refNode)
+void ReplacementFragment::insertNodeBefore(RawPtr<Node> node, Node* refNode)
 {
     if (!node || !refNode)
         return;
 
     ContainerNode* parent = refNode->nonShadowBoundaryParentNode();
     if (!parent)
         return;
 
     parent->insertBefore(node, refNode);
 }
 
-PassRefPtrWillBeRawPtr<HTMLElement> ReplacementFragment::insertFragmentForTestRendering(Element* rootEditableElement)
+RawPtr<HTMLElement> ReplacementFragment::insertFragmentForTestRendering(Element* rootEditableElement)
 {
     ASSERT(m_document);
-    RefPtrWillBeRawPtr<HTMLElement> holder = createDefaultParagraphElement(*m_document.get());
+    RawPtr<HTMLElement> holder = createDefaultParagraphElement(*m_document.get());
 
     holder->appendChild(m_fragment);
     rootEditableElement->appendChild(holder.get());
     m_document->updateLayoutIgnorePendingStylesheets();
 
     return holder.release();
 }
 
 void ReplacementFragment::restoreAndRemoveTestRenderingNodesToFragment(Element* holder)
 {
     if (!holder)
         return;
 
-    while (RefPtrWillBeRawPtr<Node> node = holder->firstChild()) {
+    while (RawPtr<Node> node = holder->firstChild()) {
         holder->removeChild(node.get());
         m_fragment->appendChild(node.get());
     }
 
     removeNode(holder);
 }
 
 void ReplacementFragment::removeUnrenderedNodes(ContainerNode* holder)
 {
-    WillBeHeapVector<RefPtrWillBeMember<Node>> unrendered;
+    HeapVector<Member<Node>> unrendered;
 
     for (Node& node : NodeTraversal::descendantsOf(*holder)) {
         if (!isNodeRendered(node) && !isTableStructureNode(&node))
             unrendered.append(&node);
     }
 
     for (auto& node : unrendered)
         removeNode(node);
 }
 
@@ skipping 22 matching lines @@
         if (isInterchangeHTMLBRElement(node)) {
             m_hasInterchangeNewlineAtEnd = true;
             removeNode(node);
             break;
         }
         node = node->lastChild();
     }
 
     node = container->firstChild();
     while (node) {
-        RefPtrWillBeRawPtr<Node> next = NodeTraversal::next(*node);
+        RawPtr<Node> next = NodeTraversal::next(*node);
         if (isHTMLInterchangeConvertedSpaceSpan(node)) {
             HTMLElement& element = toHTMLElement(*node);
             next = NodeTraversal::nextSkippingChildren(element);
             removeNodePreservingChildren(&element);
         }
         node = next.get();
     }
 }
 
 inline void ReplaceSelectionCommand::InsertedNodes::respondToNodeInsertion(Node& node)
@@ skipping 25 matching lines @@
 }
 
 inline void ReplaceSelectionCommand::InsertedNodes::didReplaceNode(Node& node, Node& newNode)
 {
     if (m_firstNodeInserted.get() == node)
         m_firstNodeInserted = &newNode;
     if (m_lastNodeInserted.get() == node)
         m_lastNodeInserted = &newNode;
 }
 
-ReplaceSelectionCommand::ReplaceSelectionCommand(Document& document, PassRefPtrWillBeRawPtr<DocumentFragment> fragment, CommandOptions options, EditAction editAction)
+ReplaceSelectionCommand::ReplaceSelectionCommand(Document& document, RawPtr<DocumentFragment> fragment, CommandOptions options, EditAction editAction)
     : CompositeEditCommand(document)
     , m_selectReplacement(options & SelectReplacement)
     , m_smartReplace(options & SmartReplace)
     , m_matchStyle(options & MatchStyle)
     , m_documentFragment(fragment)
     , m_preventNesting(options & PreventNesting)
     , m_movingParagraph(options & MovingParagraph)
     , m_editAction(editAction)
     , m_sanitizeFragment(options & SanitizeFragment)
     , m_shouldMergeEnd(false)
@@ skipping 92 matching lines @@
         && (!isHTMLHeaderElement(sourceBlock) || haveSameTagName(sourceBlock, destinationBlock))
         // Don't merge to or from a position before or after a block because it would
         // be a no-op and cause infinite recursion.
         && !isEnclosingBlock(sourceNode) && !isEnclosingBlock(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)
 {
-    RefPtrWillBeRawPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
-    RefPtrWillBeRawPtr<Node> next = nullptr;
-    for (RefPtrWillBeRawPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
+    RawPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
+    RawPtr<Node> next = nullptr;
+    for (RawPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
         // FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance
 
         next = NodeTraversal::next(*node);
         if (!node->isStyledElement())
             continue;
 
         Element* element = toElement(node);
 
         const StylePropertySet* inlineStyle = element->inlineStyle();
-        RefPtrWillBeRawPtr<EditingStyle> newInlineStyle = EditingStyle::create(inlineStyle);
+        RawPtr<EditingStyle> newInlineStyle = EditingStyle::create(inlineStyle);
         if (inlineStyle) {
             if (element->isHTMLElement()) {
                 Vector<QualifiedName> attributes;
                 HTMLElement* htmlElement = toHTMLElement(element);
                 ASSERT(htmlElement);
 
                 if (newInlineStyle->conflictsWithImplicitStyleOfElement(htmlElement)) {
                     // e.g. <b style="font-weight: normal;"> is converted to <span style="font-weight: normal;">
                     element = replaceElementWithSpanPreservingChildrenAndAttributes(htmlElement);
                     inlineStyle = element->inlineStyle();
@@ skipping 118 matching lines @@
         elements.add(theadTag.localName());
         elements.add(trTag.localName());
         elements.add(ulTag.localName());
         elements.add(xmpTag.localName());
     }
     return elements.contains(name);
 }
 
 void ReplaceSelectionCommand::makeInsertedContentRoundTrippableWithHTMLTreeBuilder(const InsertedNodes& insertedNodes)
 {
-    RefPtrWillBeRawPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
-    RefPtrWillBeRawPtr<Node> next = nullptr;
-    for (RefPtrWillBeRawPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
+    RawPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
+    RawPtr<Node> next = nullptr;
+    for (RawPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
         next = NodeTraversal::next(*node);
 
         if (!node->isHTMLElement())
             continue;
         // moveElementOutOfAncestor() in a previous iteration might have failed,
         // and |node| might have been detached from the document tree.
         if (!node->inDocument())
             continue;
 
         HTMLElement& element = toHTMLElement(*node);
         if (isProhibitedParagraphChild(element.localName())) {
             if (HTMLElement* paragraphElement = toHTMLElement(enclosingElementWithTag(positionInParentBeforeNode(element), pTag)))
                 moveElementOutOfAncestor(&element, paragraphElement);
         }
 
         if (isHTMLHeaderElement(&element)) {
             if (HTMLElement* headerElement = toHTMLElement(highestEnclosingNodeOfType(positionInParentBeforeNode(element), isHTMLHeaderElement)))
                 moveElementOutOfAncestor(&element, headerElement);
         }
     }
 }
 
-void ReplaceSelectionCommand::moveElementOutOfAncestor(PassRefPtrWillBeRawPtr<Element> prpElement, PassRefPtrWillBeRawPtr<Element> prpAncestor)
+void ReplaceSelectionCommand::moveElementOutOfAncestor(RawPtr<Element> prpElement, RawPtr<Element> prpAncestor)
 {
-    RefPtrWillBeRawPtr<Element> element = prpElement;
-    RefPtrWillBeRawPtr<Element> ancestor = prpAncestor;
+    RawPtr<Element> element = prpElement;
+    RawPtr<Element> ancestor = prpAncestor;
 
     if (!ancestor->parentNode()->hasEditableStyle())
         return;
 
     VisiblePosition positionAtEndOfNode = createVisiblePosition(lastPositionInOrAfterNode(element.get()));
     VisiblePosition lastPositionInParagraph = createVisiblePosition(lastPositionInNode(ancestor.get()));
     if (positionAtEndOfNode.deepEquivalent() == lastPositionInParagraph.deepEquivalent()) {
         removeNode(element);
         if (ancestor->nextSibling())
             insertNodeBefore(element, ancestor->nextSibling());
         else
             appendNode(element, ancestor->parentNode());
     } else {
-        RefPtrWillBeRawPtr<Node> nodeToSplitTo = splitTreeToNode(element.get(), ancestor.get(), true);
+        RawPtr<Node> nodeToSplitTo = splitTreeToNode(element.get(), ancestor.get(), true);
         removeNode(element);
         insertNodeBefore(element, nodeToSplitTo);
     }
     if (!ancestor->hasChildren())
         removeNode(ancestor.release());
 }
 
 static inline bool nodeHasVisibleLayoutText(Text& text)
 {
     return text.layoutObject() && text.layoutObject()->resolvedTextLength() > 0;
@@ skipping 59 matching lines @@
     // and doesn't receive the optimization.
     if (isMailPasteAsQuotationHTMLBlockQuoteElement(topNode) || enclosingNodeOfType(firstPositionInOrBeforeNode(topNode), isMailHTMLBlockquoteElement, 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 (!isLegacyAppleHTMLSpanElement(topNode))
         return false;
 
     HTMLSpanElement* wrappingStyleSpan = toHTMLSpanElement(topNode);
-    RefPtrWillBeRawPtr<EditingStyle> styleAtInsertionPos = EditingStyle::create(insertionPos.parentAnchoredEquivalent());
+    RawPtr<EditingStyle> styleAtInsertionPos = EditingStyle::create(insertionPos.parentAnchoredEquivalent());
     String styleText = styleAtInsertionPos->style()->asText();
 
     // FIXME: This string comparison is a naive way of comparing two styles.
     // We should be taking the diff and check that the diff is empty.
     if (styleText != wrappingStyleSpan->getAttribute(styleAttr))
         return false;
 
     fragment.removeNodePreservingChildren(wrappingStyleSpan);
     return true;
 }
@@ skipping 18 matching lines @@
             wrappingStyleSpan = toHTMLSpanElement(&node);
             break;
         }
     }
 
     // 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;
 
-    RefPtrWillBeRawPtr<EditingStyle> style = EditingStyle::create(wrappingStyleSpan->inlineStyle());
+    RawPtr<EditingStyle> style = EditingStyle::create(wrappingStyleSpan->inlineStyle());
     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 blockquoteElement are allowed to override those from the source document, see <rdar://problem/4930986> and <rdar://problem/5089327>.
     HTMLQuoteElement* blockquoteElement = isMailPasteAsQuotationHTMLBlockQuoteElement(context) ?
         toHTMLQuoteElement(context) :
         toHTMLQuoteElement(enclosingNodeOfType(firstPositionInNode(context), isMailHTMLBlockquoteElement, CanCrossEditingBoundary));
     if (blockquoteElement)
         context = document().documentElement();
 
@@ skipping 34 matching lines @@
     // include the what was the start of the selection that was pasted into, so that we preserve that paragraph's
     // block styles.
     bool mergeForward = !(inSameParagraph(startOfInsertedContent, endOfInsertedContent) && !isStartOfParagraph(startOfInsertedContent));
 
     VisiblePosition destination = mergeForward ? nextPositionOf(endOfInsertedContent) : endOfInsertedContent;
     VisiblePosition startOfParagraphToMove = mergeForward ? startOfParagraph(endOfInsertedContent) : nextPositionOf(endOfInsertedContent);
 
     // Merging forward could result in deleting the destination anchor node.
     // To avoid this, we add a placeholder node before the start of the paragraph.
     if (endOfParagraph(startOfParagraphToMove).deepEquivalent() == destination.deepEquivalent()) {
-        RefPtrWillBeRawPtr<HTMLBRElement> placeholder = HTMLBRElement::create(document());
+        RawPtr<HTMLBRElement> placeholder = HTMLBRElement::create(document());
         insertNodeBefore(placeholder, startOfParagraphToMove.deepEquivalent().anchorNode());
         destination = createVisiblePosition(positionBeforeNode(placeholder.get()));
     }
 
     moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination);
 
     // Merging forward will remove m_endOfInsertedContent from the document.
     if (mergeForward) {
         if (m_startOfInsertedContent.isOrphan())
             m_startOfInsertedContent = endingSelection().visibleStart().deepEquivalent();
@@ skipping 159 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]).
     HTMLBRElement* endBR = isHTMLBRElement(*mostForwardCaretPosition(insertionPos).anchorNode()) ? toHTMLBRElement(mostForwardCaretPosition(insertionPos).anchorNode()) : 0;
     VisiblePosition originalVisPosBeforeEndBR;
     if (endBR)
         originalVisPosBeforeEndBR = previousPositionOf(createVisiblePosition(positionBeforeNode(endBR)));
 
-    RefPtrWillBeRawPtr<Element> enclosingBlockOfInsertionPos = enclosingBlock(insertionPos.anchorNode());
+    RawPtr<Element> enclosingBlockOfInsertionPos = enclosingBlock(insertionPos.anchorNode());
 
     // Adjust insertionPos to prevent nesting.
     // If the start was in a Mail blockquote, we will have already handled adjusting insertionPos above.
     if (m_preventNesting && enclosingBlockOfInsertionPos && !isTableCell(enclosingBlockOfInsertionPos.get()) && !startIsInsideMailBlockquote) {
         ASSERT(enclosingBlockOfInsertionPos != currentRoot);
         VisiblePosition visibleInsertionPos = createVisiblePosition(insertionPos);
         if (isEndOfBlock(visibleInsertionPos) && !(isStartOfBlock(visibleInsertionPos) && fragment.hasInterchangeNewlineAtEnd()))
             insertionPos = positionInParentAfterNode(*enclosingBlockOfInsertionPos);
         else if (isStartOfBlock(visibleInsertionPos))
             insertionPos = positionInParentBeforeNode(*enclosingBlockOfInsertionPos);
@@ skipping 28 matching lines @@
     // 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.computeContainerNode())) {
         if (insertionPos.computeContainerNode()->isTextNode() && insertionPos.offsetInContainerNode() && !insertionPos.atLastEditingPositionForNode()) {
             splitTextNode(toText(insertionPos.computeContainerNode()), insertionPos.offsetInContainerNode());
             insertionPos = firstPositionInNode(insertionPos.computeContainerNode());
         }
 
-        if (RefPtrWillBeRawPtr<HTMLElement> elementToSplitTo = elementToSplitToAvoidPastingIntoInlineElementsWithStyle(insertionPos)) {
+        if (RawPtr<HTMLElement> elementToSplitTo = elementToSplitToAvoidPastingIntoInlineElementsWithStyle(insertionPos)) {
             if (insertionPos.computeContainerNode() != elementToSplitTo->parentNode()) {
                 Node* splitStart = insertionPos.computeNodeAfterPosition();
                 if (!splitStart)
                     splitStart = insertionPos.computeContainerNode();
-                RefPtrWillBeRawPtr<Node> nodeToSplitTo = splitTreeToNode(splitStart, elementToSplitTo->parentNode()).get();
+                RawPtr<Node> nodeToSplitTo = splitTreeToNode(splitStart, elementToSplitTo->parentNode()).get();
                 insertionPos = positionInParentBeforeNode(*nodeToSplitTo);
             }
         }
     }
 
     // FIXME: When pasting rich content we're often prevented from heading down the fast path by style spans.  Try
     // again here if they've been removed.
 
     // 1) Insert the content.
     // 2) Remove redundant styles and style tags, this inner <b> for example: <b>foo <b>bar</b> baz</b>.
     // 3) Merge the start of the added content with the content before the position being pasted into.
     // 4) Do one of the following: a) expand the last br if the fragment ends with one and it collapsed,
     // b) merge the last paragraph of the incoming fragment with the paragraph that contained the
     // end of the selection that was pasted into, or c) handle an interchange newline at the end of the
     // incoming fragment.
     // 5) Add spaces for smart replace.
     // 6) Select the replacement if requested, and match style if requested.
 
     InsertedNodes insertedNodes;
-    RefPtrWillBeRawPtr<Node> refNode = fragment.firstChild();
+    RawPtr<Node> refNode = fragment.firstChild();
     ASSERT(refNode);
-    RefPtrWillBeRawPtr<Node> node = refNode->nextSibling();
+    RawPtr<Node> node = refNode->nextSibling();
 
     fragment.removeNode(refNode);
 
     Element* blockStart = enclosingBlock(insertionPos.anchorNode());
     if ((isHTMLListElement(refNode.get()) || (isLegacyAppleHTMLSpanElement(refNode.get()) && isHTMLListElement(refNode->firstChild())))
         && blockStart && blockStart->layoutObject()->isListItem() && blockStart->parentNode()->hasEditableStyle()) {
         refNode = insertAsListItems(toHTMLElement(refNode), blockStart, insertionPos, insertedNodes);
     } else {
         insertNodeAt(refNode, insertionPos);
         insertedNodes.respondToNodeInsertion(*refNode);
     }
 
     // Mutation events (bug 22634) may have already removed the inserted content
     if (!refNode->inDocument())
         return;
 
     bool plainTextFragment = isPlainTextMarkup(refNode.get());
 
     while (node) {
-        RefPtrWillBeRawPtr<Node> next = node->nextSibling();
+        RawPtr<Node> next = node->nextSibling();
         fragment.removeNode(node.get());
         insertNodeAfter(node, refNode);
         insertedNodes.respondToNodeInsertion(*node);
 
         // Mutation events (bug 22634) may have already removed the inserted content
         if (!node->inDocument())
             return;
 
         refNode = node;
         if (node && plainTextFragment)
@@ skipping 16 matching lines @@
         enclosingBlockOfInsertionPos = nullptr;
 
     VisiblePosition startOfInsertedContent = createVisiblePosition(firstPositionInOrBeforeNode(insertedNodes.firstNodeInserted()));
 
     // We inserted before the enclosingBlockOfInsertionPos to prevent nesting, and the content before the enclosingBlockOfInsertionPos 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 (!startOfInsertedContent.isNull() && enclosingBlockOfInsertionPos && insertionPos.anchorNode() == enclosingBlockOfInsertionPos->parentNode() && (unsigned)insertionPos.computeEditingOffset() < enclosingBlockOfInsertionPos->nodeIndex() && !isStartOfParagraph(startOfInsertedContent))
         insertNodeAt(HTMLBRElement::create(document()).get(), startOfInsertedContent.deepEquivalent());
 
     if (endBR && (plainTextFragment || (shouldRemoveEndBR(endBR, originalVisPosBeforeEndBR) && !(fragment.hasInterchangeNewlineAtEnd() && selectionIsPlainText)))) {
-        RefPtrWillBeRawPtr<ContainerNode> parent = endBR->parentNode();
+        RawPtr<ContainerNode> parent = endBR->parentNode();
         insertedNodes.willRemoveNode(*endBR);
         removeNode(endBR);
         if (Node* nodeToRemove = highestNodeToRemoveInPruning(parent.get())) {
             insertedNodes.willRemoveNode(*nodeToRemove);
             removeNode(nodeToRemove);
         }
     }
 
     makeInsertedContentRoundTrippableWithHTMLTreeBuilder(insertedNodes);
 
@@ skipping 46 matching lines @@
     Position lastPositionToSelect;
     if (fragment.hasInterchangeNewlineAtEnd()) {
         VisiblePosition endOfInsertedContent = positionAtEndOfInsertedContent();
         VisiblePosition next = nextPositionOf(endOfInsertedContent, CannotCrossEditingBoundary);
 
         if (selectionEndWasEndOfParagraph || !isEndOfParagraph(endOfInsertedContent) || next.isNull()) {
             if (!isStartOfParagraph(endOfInsertedContent)) {
                 setEndingSelection(endOfInsertedContent);
                 Element* enclosingBlockElement = enclosingBlock(endOfInsertedContent.deepEquivalent().anchorNode());
                 if (isListItem(enclosingBlockElement)) {
-                    RefPtrWillBeRawPtr<HTMLLIElement> newListItem = HTMLLIElement::create(document());
+                    RawPtr<HTMLLIElement> newListItem = HTMLLIElement::create(document());
                     insertNodeAfter(newListItem, enclosingBlockElement);
                     setEndingSelection(createVisiblePosition(firstPositionInNode(newListItem.get())));
                 } 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(),
                         isMailHTMLBlockquoteElement, CannotCrossEditingBoundary, insertedNodes.firstNodeInserted()->parentNode()));
                 }
 
                 // Select up to the paragraph separator that was added.
@@ skipping 73 matching lines @@
     }
 
     bool needsTrailingSpace = !isEndOfParagraph(endOfInsertedContent) && !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(characterAfter(endOfInsertedContent), false);
     if (needsTrailingSpace && endNode) {
         bool collapseWhiteSpace = !endNode->layoutObject() || endNode->layoutObject()->style()->collapseWhiteSpace();
         if (endNode->isTextNode()) {
             insertTextIntoNode(toText(endNode), endOffset, collapseWhiteSpace ? nonBreakingSpaceString() : " ");
             if (m_endOfInsertedContent.computeContainerNode() == endNode)
                 m_endOfInsertedContent = Position(endNode, m_endOfInsertedContent.offsetInContainerNode() + 1);
         } else {
-            RefPtrWillBeRawPtr<Text> node = document().createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
+            RawPtr<Text> node = document().createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
             insertNodeAfter(node, endNode);
             updateNodesInserted(node.get());
         }
     }
 
     document().updateLayout();
 
     Position startDownstream = mostForwardCaretPosition(startOfInsertedContent.deepEquivalent());
     Node* startNode = startDownstream.computeNodeAfterPosition();
     unsigned startOffset = 0;
     if (startDownstream.isOffsetInAnchor()) {
         startNode = startDownstream.computeContainerNode();
         startOffset = startDownstream.offsetInContainerNode();
     }
 
     bool needsLeadingSpace = !isStartOfParagraph(startOfInsertedContent) && !isCharacterSmartReplaceExemptConsideringNonBreakingSpace(characterBefore(startOfInsertedContent), true);
     if (needsLeadingSpace && startNode) {
         bool collapseWhiteSpace = !startNode->layoutObject() || startNode->layoutObject()->style()->collapseWhiteSpace();
         if (startNode->isTextNode()) {
             insertTextIntoNode(toText(startNode), startOffset, collapseWhiteSpace ? nonBreakingSpaceString() : " ");
             if (m_endOfInsertedContent.computeContainerNode() == startNode && m_endOfInsertedContent.offsetInContainerNode())
                 m_endOfInsertedContent = Position(startNode, m_endOfInsertedContent.offsetInContainerNode() + 1);
         } else {
-            RefPtrWillBeRawPtr<Text> node = document().createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
+            RawPtr<Text> node = document().createEditingTextNode(collapseWhiteSpace ? nonBreakingSpaceString() : " ");
             // Don't updateNodesInserted. Doing so would set m_endOfInsertedContent to be the node containing the leading space,
             // but m_endOfInsertedContent is supposed to mark the end of pasted content.
             insertNodeBefore(node, startNode);
             m_startOfInsertedContent = firstPositionInNode(node.get());
         }
     }
 }
 
 void ReplaceSelectionCommand::completeHTMLReplacement(const Position &lastPositionToSelect)
 {
@@ skipping 27 matching lines @@
     if (m_selectReplacement)
         setEndingSelection(VisibleSelection(start, end, SelDefaultAffinity, endingSelection().isDirectional()));
     else
         setEndingSelection(VisibleSelection(end, SelDefaultAffinity, endingSelection().isDirectional()));
 }
 
 void ReplaceSelectionCommand::mergeTextNodesAroundPosition(Position& position, Position& positionOnlyToBeUpdated)
 {
     bool positionIsOffsetInAnchor = position.isOffsetInAnchor();
     bool positionOnlyToBeUpdatedIsOffsetInAnchor = positionOnlyToBeUpdated.isOffsetInAnchor();
-    RefPtrWillBeRawPtr<Text> text = nullptr;
+    RawPtr<Text> text = nullptr;
     if (positionIsOffsetInAnchor && position.computeContainerNode() && position.computeContainerNode()->isTextNode()) {
         text = toText(position.computeContainerNode());
     } else {
         Node* before = position.computeNodeBeforePosition();
         if (before && before->isTextNode()) {
             text = toText(before);
         } else {
             Node* after = position.computeNodeAfterPosition();
             if (after && after->isTextNode())
                 text = toText(after);
         }
     }
     if (!text)
         return;
 
     if (text->previousSibling() && text->previousSibling()->isTextNode()) {
-        RefPtrWillBeRawPtr<Text> previous = toText(text->previousSibling());
+        RawPtr<Text> previous = toText(text->previousSibling());
         insertTextIntoNode(text, 0, previous->data());
 
         if (positionIsOffsetInAnchor)
             position = Position(position.computeContainerNode(), previous->length() + position.offsetInContainerNode());
         else
             updatePositionForNodeRemoval(position, *previous);
 
         if (positionOnlyToBeUpdatedIsOffsetInAnchor) {
             if (positionOnlyToBeUpdated.computeContainerNode() == text)
                 positionOnlyToBeUpdated = Position(text, previous->length() + positionOnlyToBeUpdated.offsetInContainerNode());
             else if (positionOnlyToBeUpdated.computeContainerNode() == previous)
                 positionOnlyToBeUpdated = Position(text, positionOnlyToBeUpdated.offsetInContainerNode());
         } else {
             updatePositionForNodeRemoval(positionOnlyToBeUpdated, *previous);
         }
 
         removeNode(previous);
     }
     if (text->nextSibling() && text->nextSibling()->isTextNode()) {
-        RefPtrWillBeRawPtr<Text> next = toText(text->nextSibling());
+        RawPtr<Text> next = toText(text->nextSibling());
         unsigned originalLength = text->length();
         insertTextIntoNode(text, originalLength, next->data());
 
         if (!positionIsOffsetInAnchor)
             updatePositionForNodeRemoval(position, *next);
 
         if (positionOnlyToBeUpdatedIsOffsetInAnchor && positionOnlyToBeUpdated.computeContainerNode() == next)
             positionOnlyToBeUpdated = Position(text, originalLength + positionOnlyToBeUpdated.offsetInContainerNode());
         else
             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(PassRefPtrWillBeRawPtr<HTMLElement> prpListElement, Element* insertionBlock, const Position& insertPos, InsertedNodes& insertedNodes)
+Node* ReplaceSelectionCommand::insertAsListItems(RawPtr<HTMLElement> prpListElement, Element* insertionBlock, const Position& insertPos, InsertedNodes& insertedNodes)
 {
-    RefPtrWillBeRawPtr<HTMLElement> listElement = prpListElement;
+    RawPtr<HTMLElement> listElement = prpListElement;
 
     while (listElement->hasOneChild() && isHTMLListElement(listElement->firstChild()))
         listElement = toHTMLElement(listElement->firstChild());
 
     bool isStart = isStartOfParagraph(createVisiblePosition(insertPos));
     bool isEnd = isEndOfParagraph(createVisiblePosition(insertPos));
     bool isMiddle = !isStart && !isEnd;
     Node* lastNode = 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) {
         int textNodeOffset = insertPos.offsetInContainerNode();
         if (insertPos.anchorNode()->isTextNode() && textNodeOffset > 0)
             splitTextNode(toText(insertPos.anchorNode()), textNodeOffset);
         splitTreeToNode(insertPos.anchorNode(), lastNode, true);
     }
 
-    while (RefPtrWillBeRawPtr<Node> listItem = listElement->firstChild()) {
+    while (RawPtr<Node> listItem = listElement->firstChild()) {
         listElement->removeChild(listItem.get(), ASSERT_NO_EXCEPTION);
         if (isStart || isMiddle) {
             insertNodeBefore(listItem, lastNode);
             insertedNodes.respondToNodeInsertion(*listItem);
         } else if (isEnd) {
             insertNodeAfter(listItem, lastNode);
             insertedNodes.respondToNodeInsertion(*listItem);
             lastNode = listItem.get();
         } else {
             ASSERT_NOT_REACHED();
@@ skipping 27 matching lines @@
         return false;
 
     // FIXME: Would be nice to handle smart replace in the fast path.
     if (m_smartReplace || fragment.hasInterchangeNewlineAtStart() || fragment.hasInterchangeNewlineAtEnd())
         return false;
 
     // e.g. when "bar" is inserted after "foo" in <div><u>foo</u></div>, "bar" should not be underlined.
     if (elementToSplitToAvoidPastingIntoInlineElementsWithStyle(endingSelection().start()))
         return false;
 
-    RefPtrWillBeRawPtr<Node> nodeAfterInsertionPos = mostForwardCaretPosition(endingSelection().end()).anchorNode();
+    RawPtr<Node> nodeAfterInsertionPos = mostForwardCaretPosition(endingSelection().end()).anchorNode();
     Text* textNode = toText(fragment.firstChild());
     // Our fragment creation code handles tabs, spaces, and newlines, so we don't have to worry about those here.
 
     Position start = endingSelection().start();
     Position end = replaceSelectedTextInNode(textNode->data());
     if (end.isNull())
         return false;
 
     if (nodeAfterInsertionPos && nodeAfterInsertionPos->parentNode() && isHTMLBRElement(*nodeAfterInsertionPos)
         && shouldRemoveEndBR(toHTMLBRElement(nodeAfterInsertionPos.get()), createVisiblePosition(positionBeforeNode(nodeAfterInsertionPos.get()))))
@@ skipping 24 matching lines @@
     visitor->trace(m_startOfInsertedContent);
     visitor->trace(m_endOfInsertedContent);
     visitor->trace(m_insertionStyle);
     visitor->trace(m_documentFragment);
     visitor->trace(m_startOfInsertedRange);
     visitor->trace(m_endOfInsertedRange);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink