Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/editing/Editor.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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 103 matching lines @@
 VisibleSelection Editor::selectionForCommand(Event* event)
 {
     VisibleSelection selection = frame().selection().selection();
     if (!event)
         return selection;
     // If the target is a text control, and the current selection is outside of its shadow tree,
     // then use the saved selection for that text control.
     HTMLTextFormControlElement* textFormControlOfSelectionStart = enclosingTextFormControl(selection.start());
     HTMLTextFormControlElement* textFromControlOfTarget = isHTMLTextFormControlElement(*event->target()->toNode()) ? toHTMLTextFormControlElement(event->target()->toNode()) : 0;
     if (textFromControlOfTarget && (selection.start().isNull() || textFromControlOfTarget != textFormControlOfSelectionStart)) {
-        if (RefPtrWillBeRawPtr<Range> range = textFromControlOfTarget->selection())
+        if (RawPtr<Range> range = textFromControlOfTarget->selection())
             return VisibleSelection(EphemeralRange(range.get()), TextAffinity::Downstream, selection.isDirectional());
     }
     return selection;
 }
 
 // Function considers Mac editing behavior a fallback when Page or Settings is not available.
 EditingBehavior Editor::behavior() const
 {
     if (!frame().settings())
         return EditingBehavior(EditingMacBehavior);
@@ skipping 207 matching lines @@
 }
 
 void Editor::pasteAsPlainText(const String& pastingText, bool smartReplace)
 {
     Element* target = findEventTargetFromSelection();
     if (!target)
         return;
     target->dispatchEvent(TextEvent::createForPlainTextPaste(frame().domWindow(), pastingText, smartReplace));
 }
 
-void Editor::pasteAsFragment(PassRefPtrWillBeRawPtr<DocumentFragment> pastingFragment, bool smartReplace, bool matchStyle)
+void Editor::pasteAsFragment(RawPtr<DocumentFragment> pastingFragment, bool smartReplace, bool matchStyle)
 {
     Element* target = findEventTargetFromSelection();
     if (!target)
         return;
     target->dispatchEvent(TextEvent::createForFragmentPaste(frame().domWindow(), pastingFragment, smartReplace, matchStyle));
 }
 
 bool Editor::tryDHTMLCopy()
 {
     if (frame().selection().isInPasswordField())
@@ skipping 16 matching lines @@
 }
 
 void Editor::pasteAsPlainTextWithPasteboard(Pasteboard* pasteboard)
 {
     String text = pasteboard->plainText();
     pasteAsPlainText(text, canSmartReplaceWithPasteboard(pasteboard));
 }
 
 void Editor::pasteWithPasteboard(Pasteboard* pasteboard)
 {
-    RefPtrWillBeRawPtr<DocumentFragment> fragment = nullptr;
+    RawPtr<DocumentFragment> fragment = nullptr;
     bool chosePlainText = false;
 
     if (pasteboard->isHTMLAvailable()) {
         unsigned fragmentStart = 0;
         unsigned fragmentEnd = 0;
         KURL url;
         String markup = pasteboard->readHTML(url, fragmentStart, fragmentEnd);
         if (!markup.isEmpty()) {
             ASSERT(frame().document());
             fragment = createFragmentFromMarkupWithContext(*frame().document(), markup, fragmentStart, fragmentEnd, url, DisallowScriptingAndPluginContent);
@@ skipping 74 matching lines @@
     if (!target)
         return true;
 
     DataTransfer* dataTransfer = DataTransfer::create(
         DataTransfer::CopyAndPaste,
         policy,
         policy == DataTransferWritable
             ? DataObject::create()
             : DataObject::createFromPasteboard(pasteMode));
 
-    RefPtrWillBeRawPtr<Event> evt = ClipboardEvent::create(eventType, true, true, dataTransfer);
+    RawPtr<Event> evt = ClipboardEvent::create(eventType, true, true, dataTransfer);
     target->dispatchEvent(evt);
     bool noDefaultProcessing = evt->defaultPrevented();
     if (noDefaultProcessing && policy == DataTransferWritable)
         Pasteboard::generalPasteboard()->writeDataObject(dataTransfer->dataObject());
 
     // invalidate clipboard here for security
     dataTransfer->setAccessPolicy(DataTransferNumb);
 
     return !noDefaultProcessing;
 }
 
 bool Editor::canSmartReplaceWithPasteboard(Pasteboard* pasteboard)
 {
     return smartInsertDeleteEnabled() && pasteboard->canSmartReplace();
 }
 
-void Editor::replaceSelectionWithFragment(PassRefPtrWillBeRawPtr<DocumentFragment> fragment, bool selectReplacement, bool smartReplace, bool matchStyle)
+void Editor::replaceSelectionWithFragment(RawPtr<DocumentFragment> fragment, bool selectReplacement, bool smartReplace, bool matchStyle)
 {
     if (frame().selection().isNone() || !frame().selection().isContentEditable() || !fragment)
         return;
 
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::PreventNesting | ReplaceSelectionCommand::SanitizeFragment;
     if (selectReplacement)
         options |= ReplaceSelectionCommand::SelectReplacement;
     if (smartReplace)
         options |= ReplaceSelectionCommand::SmartReplace;
     if (matchStyle)
         options |= ReplaceSelectionCommand::MatchStyle;
     ASSERT(frame().document());
     ReplaceSelectionCommand::create(*frame().document(), fragment, options, EditActionPaste)->apply();
     revealSelectionAfterEditingOperation();
 }
 
 void Editor::replaceSelectionWithText(const String& text, bool selectReplacement, bool smartReplace)
 {
     replaceSelectionWithFragment(createFragmentFromText(selectedRange(), text), selectReplacement, smartReplace, true);
 }
 
 // TODO(xiaochengh): Merge it with |replaceSelectionWithFragment()|.
-void Editor::replaceSelectionAfterDragging(PassRefPtrWillBeRawPtr<DocumentFragment> fragment, bool smartReplace, bool plainText)
+void Editor::replaceSelectionAfterDragging(RawPtr<DocumentFragment> fragment, bool smartReplace, bool plainText)
 {
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::SelectReplacement | ReplaceSelectionCommand::PreventNesting;
     if (smartReplace)
         options |= ReplaceSelectionCommand::SmartReplace;
     if (plainText)
         options |= ReplaceSelectionCommand::MatchStyle;
     ASSERT(frame().document());
     ReplaceSelectionCommand::create(*frame().document(), fragment, options, EditActionDrag)->apply();
 }
 
-void Editor::moveSelectionAfterDragging(PassRefPtrWillBeRawPtr<DocumentFragment> fragment, const Position& pos, bool smartInsert, bool smartDelete)
+void Editor::moveSelectionAfterDragging(RawPtr<DocumentFragment> fragment, const Position& pos, bool smartInsert, bool smartDelete)
 {
     MoveSelectionCommand::create(fragment, pos, smartInsert, smartDelete)->apply();
 }
 
 EphemeralRange Editor::selectedRange()
 {
     return frame().selection().selection().toNormalizedEphemeralRange();
 }
 
 bool Editor::shouldDeleteRange(const EphemeralRange& range) const
@@ skipping 95 matching lines @@
         EditingStyle::styleAtSelectionStart(frame().selection().selection(), propertyID == CSSPropertyBackgroundColor).get());
 }
 
 TriState Editor::selectionHasStyle(CSSPropertyID propertyID, const String& value) const
 {
     return EditingStyle::create(propertyID, value)->triStateOfStyle(frame().selection().selection());
 }
 
 String Editor::selectionStartCSSPropertyValue(CSSPropertyID propertyID)
 {
-    RefPtrWillBeRawPtr<EditingStyle> selectionStyle = EditingStyle::styleAtSelectionStart(frame().selection().selection(),
+    RawPtr<EditingStyle> selectionStyle = EditingStyle::styleAtSelectionStart(frame().selection().selection(),
         propertyID == CSSPropertyBackgroundColor);
     if (!selectionStyle || !selectionStyle->style())
         return String();
 
     if (propertyID == CSSPropertyFontSize)
         return String::number(selectionStyle->legacyFontSize(frame().document()));
     return selectionStyle->style()->getPropertyValue(propertyID);
 }
 
-static void dispatchEditableContentChangedEvents(PassRefPtrWillBeRawPtr<Element> startRoot, PassRefPtrWillBeRawPtr<Element> endRoot)
+static void dispatchEditableContentChangedEvents(RawPtr<Element> startRoot, RawPtr<Element> endRoot)
 {
     if (startRoot)
         startRoot->dispatchEvent(Event::create(EventTypeNames::webkitEditableContentChanged));
     if (endRoot && endRoot != startRoot)
         endRoot->dispatchEvent(Event::create(EventTypeNames::webkitEditableContentChanged));
 }
 
 void Editor::requestSpellcheckingAfterApplyingCommand(CompositeEditCommand* cmd)
 {
     // Note: Request spell checking for and only for |ReplaceSelectionCommand|s
     // created in |Editor::replaceSelectionWithFragment()|.
     // TODO(xiaochengh): May also need to do this after dragging crbug.com/298046.
     if (cmd->editingAction() != EditActionPaste)
         return;
     if (frame().selection().isInPasswordField() || !spellChecker().isContinuousSpellCheckingEnabled())
         return;
     ASSERT(cmd->isReplaceSelectionCommand());
     const EphemeralRange& insertedRange = toReplaceSelectionCommand(cmd)->insertedRange();
     if (insertedRange.isNull())
         return;
     spellChecker().chunkAndMarkAllMisspellingsAndBadGrammar(cmd->endingSelection().rootEditableElement(), insertedRange);
 }
 
-void Editor::appliedEditing(PassRefPtrWillBeRawPtr<CompositeEditCommand> cmd)
+void Editor::appliedEditing(RawPtr<CompositeEditCommand> cmd)
 {
     EventQueueScope scope;
     frame().document()->updateLayout();
 
     // Request spell checking after pasting before any further DOM change.
     requestSpellcheckingAfterApplyingCommand(cmd.get());
 
     EditCommandComposition* composition = cmd->composition();
     ASSERT(composition);
     dispatchEditableContentChangedEvents(composition->startingRootEditableElement(), composition->endingRootEditableElement());
@@ skipping 12 matching lines @@
         // Only register a new undo command if the command passed in is
         // different from the last command
         m_lastEditCommand = cmd;
         if (UndoStack* undoStack = this->undoStack())
             undoStack->registerUndoStep(m_lastEditCommand->ensureComposition());
     }
 
     respondToChangedContents(newSelection);
 }
 
-void Editor::unappliedEditing(PassRefPtrWillBeRawPtr<EditCommandComposition> cmd)
+void Editor::unappliedEditing(RawPtr<EditCommandComposition> cmd)
 {
     EventQueueScope scope;
     frame().document()->updateLayout();
 
     dispatchEditableContentChangedEvents(cmd->startingRootEditableElement(), cmd->endingRootEditableElement());
 
     VisibleSelection newSelection(cmd->startingSelection());
     newSelection.validatePositionsIfNeeded();
     if (newSelection.start().document() == frame().document() && newSelection.end().document() == frame().document())
         changeSelectionAfterCommand(newSelection, FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle);
 
     m_lastEditCommand = nullptr;
     if (UndoStack* undoStack = this->undoStack())
         undoStack->registerRedoStep(cmd);
     respondToChangedContents(newSelection);
 }
 
-void Editor::reappliedEditing(PassRefPtrWillBeRawPtr<EditCommandComposition> cmd)
+void Editor::reappliedEditing(RawPtr<EditCommandComposition> cmd)
 {
     EventQueueScope scope;
     frame().document()->updateLayout();
 
     dispatchEditableContentChangedEvents(cmd->startingRootEditableElement(), cmd->endingRootEditableElement());
 
     VisibleSelection newSelection(cmd->endingSelection());
     changeSelectionAfterCommand(newSelection, FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle);
 
     m_lastEditCommand = nullptr;
     if (UndoStack* undoStack = this->undoStack())
         undoStack->registerUndoStep(cmd);
     respondToChangedContents(newSelection);
 }
 
-PassOwnPtrWillBeRawPtr<Editor> Editor::create(LocalFrame& frame)
+RawPtr<Editor> Editor::create(LocalFrame& frame)
 {
-    return adoptPtrWillBeNoop(new Editor(frame));
+    return (new Editor(frame));
 }
 
 Editor::Editor(LocalFrame& frame)
     : m_frame(&frame)
     , m_preventRevealSelection(0)
     , m_shouldStartNewKillRingSequence(false)
     // This is off by default, since most editors want this behavior (this matches IE but not FF).
     , m_shouldStyleWithCSS(false)
     , m_killRing(adoptPtr(new KillRing))
     , m_areMarkedTextMatchesHighlighted(false)
@@ skipping 28 matching lines @@
         return false;
 
     spellChecker().updateMarkersForWordsAffectedByEditing(isSpaceOrNewline(text[0]));
 
     // Get the selection to use for the event that triggered this insertText.
     // If the event handler changed the selection, we may want to use a different selection
     // that is contained in the event target.
     selection = selectionForCommand(triggeringEvent);
     if (selection.isContentEditable()) {
         if (Node* selectionStart = selection.start().anchorNode()) {
-            RefPtrWillBeRawPtr<Document> document(selectionStart->document());
+            RawPtr<Document> document(selectionStart->document());
 
             // Insert the text
             TypingCommand::Options options = 0;
             if (selectInsertedText)
                 options |= TypingCommand::SelectInsertedText;
             TypingCommand::insertText(*document.get(), text, selection, options, triggeringEvent && triggeringEvent->isComposition() ? TypingCommand::TextCompositionConfirm : TypingCommand::TextCompositionNone);
 
             // Reveal the current selection
             if (LocalFrame* editedFrame = document->frame()) {
                 if (Page* page = editedFrame->page())
@@ skipping 213 matching lines @@
     Element* focusedElement = frame().document()->focusedElement();
     if (isHTMLTextFormControlElement(focusedElement)) {
         if (direction == NaturalWritingDirection)
             return;
         focusedElement->setAttribute(dirAttr, direction == LeftToRightWritingDirection ? "ltr" : "rtl");
         focusedElement->dispatchInputEvent();
         frame().document()->updateLayoutTreeIfNeeded();
         return;
     }
 
-    RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create(HTMLQuirksMode);
+    RawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create(HTMLQuirksMode);
     style->setProperty(CSSPropertyDirection, direction == LeftToRightWritingDirection ? "ltr" : direction == RightToLeftWritingDirection ? "rtl" : "inherit", false);
     applyParagraphStyleToSelection(style.get(), EditActionSetWritingDirection);
 }
 
 void Editor::revealSelectionAfterEditingOperation(const ScrollAlignment& alignment, RevealExtentOption revealExtentOption)
 {
     if (m_preventRevealSelection)
         return;
 
     frame().selection().revealSelection(alignment, revealExtentOption);
@@ skipping 102 matching lines @@
 }
 
 void Editor::computeAndSetTypingStyle(StylePropertySet* style, EditAction editingAction)
 {
     if (!style || style->isEmpty()) {
         frame().selection().clearTypingStyle();
         return;
     }
 
     // Calculate the current typing style.
-    RefPtrWillBeRawPtr<EditingStyle> typingStyle = nullptr;
+    RawPtr<EditingStyle> typingStyle = nullptr;
     if (frame().selection().typingStyle()) {
         typingStyle = frame().selection().typingStyle()->copy();
         typingStyle->overrideWithStyle(style);
     } else {
         typingStyle = EditingStyle::create(style);
     }
 
     typingStyle->prepareToApplyAt(frame().selection().selection().visibleStart().deepEquivalent(), EditingStyle::PreserveWritingDirection);
 
     // Handle block styles, substracting these from the typing style.
-    RefPtrWillBeRawPtr<EditingStyle> blockStyle = typingStyle->extractAndRemoveBlockProperties();
+    RawPtr<EditingStyle> blockStyle = typingStyle->extractAndRemoveBlockProperties();
     if (!blockStyle->isEmpty()) {
         ASSERT(frame().document());
         ApplyStyleCommand::create(*frame().document(), blockStyle.get(), editingAction)->apply();
     }
 
     // Set the remaining style as the typing style.
     frame().selection().setTypingStyle(typingStyle);
 }
 
 bool Editor::findString(const String& target, FindOptions options)
 {
     VisibleSelection selection = frame().selection().selection();
 
     // TODO(yosin) We should make |findRangeOfString()| to return
     // |EphemeralRange| rather than|Range| object.
-    RefPtrWillBeRawPtr<Range> resultRange = findRangeOfString(target, EphemeralRange(selection.start(), selection.end()), static_cast<FindOptions>(options | FindAPICall));
+    RawPtr<Range> resultRange = findRangeOfString(target, EphemeralRange(selection.start(), selection.end()), static_cast<FindOptions>(options | FindAPICall));
 
     if (!resultRange)
         return false;
 
     frame().selection().setSelection(VisibleSelection(EphemeralRange(resultRange.get())));
     frame().selection().revealSelection();
     return true;
 }
 
 template <typename Strategy>
-static PassRefPtrWillBeRawPtr<Range> findStringAndScrollToVisibleAlgorithm(Editor& editor, const String& target, const EphemeralRangeTemplate<Strategy>& previousMatch, FindOptions options)
+static RawPtr<Range> findStringAndScrollToVisibleAlgorithm(Editor& editor, const String& target, const EphemeralRangeTemplate<Strategy>& previousMatch, FindOptions options)
 {
-    RefPtrWillBeRawPtr<Range> nextMatch = editor.findRangeOfString(target, previousMatch, options);
+    RawPtr<Range> nextMatch = editor.findRangeOfString(target, previousMatch, options);
     if (!nextMatch)
         return nullptr;
 
     nextMatch->firstNode()->layoutObject()->scrollRectToVisible(LayoutRect(nextMatch->boundingBox()),
         ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded, UserScroll);
 
     return nextMatch.release();
 }
 
-PassRefPtrWillBeRawPtr<Range> Editor::findStringAndScrollToVisible(const String& target, Range* range, FindOptions options)
+RawPtr<Range> Editor::findStringAndScrollToVisible(const String& target, Range* range, FindOptions options)
 {
     if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
         return findStringAndScrollToVisibleAlgorithm<EditingInFlatTreeStrategy>(*this, target, EphemeralRangeInFlatTree(range), options);
     return findStringAndScrollToVisibleAlgorithm<EditingStrategy>(*this, target, EphemeralRange(range), options);
 }
 
 // TODO(yosin) We should return |EphemeralRange| rather than |Range|. We use
 // |Range| object for checking whether start and end position crossing shadow
 // boundaries, however we can do it without |Range| object.
 template <typename Strategy>
-static PassRefPtrWillBeRawPtr<Range> findStringBetweenPositions(const String& target, const EphemeralRangeTemplate<Strategy>& referenceRange, FindOptions options)
+static RawPtr<Range> findStringBetweenPositions(const String& target, const EphemeralRangeTemplate<Strategy>& referenceRange, FindOptions options)
 {
     EphemeralRangeTemplate<Strategy> searchRange(referenceRange);
 
     bool forward = !(options & Backwards);
 
     while (true) {
         EphemeralRangeTemplate<Strategy> resultRange = findPlainText(searchRange, target, options);
         if (resultRange.isCollapsed())
             return nullptr;
 
-        RefPtrWillBeRawPtr<Range> rangeObject = Range::create(resultRange.document(), toPositionInDOMTree(resultRange.startPosition()), toPositionInDOMTree(resultRange.endPosition()));
+        RawPtr<Range> rangeObject = Range::create(resultRange.document(), toPositionInDOMTree(resultRange.startPosition()), toPositionInDOMTree(resultRange.endPosition()));
         if (!rangeObject->collapsed())
             return rangeObject.release();
 
         // Found text spans over multiple TreeScopes. Since it's impossible to
         // return such section as a Range, we skip this match and seek for the
         // next occurrence.
         // TODO(yosin) Handle this case.
         if (forward) {
             // TODO(yosin) We should use |PositionMoveType::Character|
             // for |nextPositionOf()|.
             searchRange = EphemeralRangeTemplate<Strategy>(nextPositionOf(resultRange.startPosition(), PositionMoveType::CodePoint), searchRange.endPosition());
         } else {
             // TODO(yosin) We should use |PositionMoveType::Character|
             // for |previousPositionOf()|.
             searchRange = EphemeralRangeTemplate<Strategy>(searchRange.startPosition(), previousPositionOf(resultRange.endPosition(), PositionMoveType::CodePoint));
         }
     }
 
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 template <typename Strategy>
-static PassRefPtrWillBeRawPtr<Range> findRangeOfStringAlgorithm(Document& document, const String& target, const EphemeralRangeTemplate<Strategy>& referenceRange, FindOptions options)
+static RawPtr<Range> findRangeOfStringAlgorithm(Document& document, const String& target, const EphemeralRangeTemplate<Strategy>& referenceRange, FindOptions options)
 {
     if (target.isEmpty())
         return nullptr;
 
     // Start from an edge of the reference range. Which edge is used depends on
     // whether we're searching forward or backward, and whether startInSelection
     // is set.
     EphemeralRangeTemplate<Strategy> documentRange = EphemeralRangeTemplate<Strategy>::rangeOfContents(document);
     EphemeralRangeTemplate<Strategy> searchRange(documentRange);
 
     bool forward = !(options & Backwards);
     bool startInReferenceRange = false;
     if (referenceRange.isNotNull()) {
         startInReferenceRange = options & StartInSelection;
         if (forward && startInReferenceRange)
             searchRange = EphemeralRangeTemplate<Strategy>(referenceRange.startPosition(), documentRange.endPosition());
         else if (forward)
             searchRange = EphemeralRangeTemplate<Strategy>(referenceRange.endPosition(), documentRange.endPosition());
         else if (startInReferenceRange)
             searchRange = EphemeralRangeTemplate<Strategy>(documentRange.startPosition(), referenceRange.endPosition());
         else
             searchRange = EphemeralRangeTemplate<Strategy>(documentRange.startPosition(), referenceRange.startPosition());
     }
 
-    RefPtrWillBeRawPtr<Range> resultRange = findStringBetweenPositions(target, searchRange, options);
+    RawPtr<Range> resultRange = findStringBetweenPositions(target, searchRange, options);
 
     // If we started in the reference range and the found range exactly matches
     // the reference range, find again. Build a selection with the found range
     // to remove collapsed whitespace. Compare ranges instead of selection
     // objects to ignore the way that the current selection was made.
     if (resultRange && startInReferenceRange && normalizeRange(EphemeralRangeTemplate<Strategy>(resultRange.get())) == referenceRange) {
         if (forward)
             searchRange = EphemeralRangeTemplate<Strategy>(fromPositionInDOMTree<Strategy>(resultRange->endPosition()), searchRange.endPosition());
         else
             searchRange = EphemeralRangeTemplate<Strategy>(searchRange.startPosition(), fromPositionInDOMTree<Strategy>(resultRange->startPosition()));
         resultRange = findStringBetweenPositions(target, searchRange, options);
     }
 
     if (!resultRange && options & WrapAround)
         return findStringBetweenPositions(target, documentRange, options);
 
     return resultRange.release();
 }
 
-PassRefPtrWillBeRawPtr<Range> Editor::findRangeOfString(const String& target, const EphemeralRange& reference, FindOptions options)
+RawPtr<Range> Editor::findRangeOfString(const String& target, const EphemeralRange& reference, FindOptions options)
 {
     return findRangeOfStringAlgorithm<EditingStrategy>(*frame().document(), target, reference, options);
 }
 
-PassRefPtrWillBeRawPtr<Range> Editor::findRangeOfString(const String& target, const EphemeralRangeInFlatTree& reference, FindOptions options)
+RawPtr<Range> Editor::findRangeOfString(const String& target, const EphemeralRangeInFlatTree& reference, FindOptions options)
 {
     return findRangeOfStringAlgorithm<EditingInFlatTreeStrategy>(*frame().document(), target, reference, options);
 }
 
 void Editor::setMarkedTextMatchesAreHighlighted(bool flag)
 {
     if (flag == m_areMarkedTextMatchesHighlighted)
         return;
 
     m_areMarkedTextMatchesHighlighted = flag;
@@ skipping 18 matching lines @@
     frame().selection().setShouldShowBlockCursor(m_overwriteModeEnabled);
 }
 
 void Editor::tidyUpHTMLStructure(Document& document)
 {
     // hasEditableStyle() needs up-to-date ComputedStyle.
     document.updateLayoutTreeIfNeeded();
     bool needsValidStructure = document.hasEditableStyle() || (document.documentElement() && document.documentElement()->hasEditableStyle());
     if (!needsValidStructure)
         return;
-    RefPtrWillBeRawPtr<Element> existingHead = nullptr;
-    RefPtrWillBeRawPtr<Element> existingBody = nullptr;
+    RawPtr<Element> existingHead = nullptr;
+    RawPtr<Element> existingBody = nullptr;
     Element* currentRoot = document.documentElement();
     if (currentRoot) {
         if (isHTMLHtmlElement(currentRoot))
             return;
         if (isHTMLHeadElement(currentRoot))
             existingHead = currentRoot;
         else if (isHTMLBodyElement(currentRoot))
             existingBody = currentRoot;
         else if (isHTMLFrameSetElement(currentRoot))
             existingBody = currentRoot;
     }
     // We ensure only "the root is <html>."
     // documentElement as rootEditableElement is problematic.  So we move
     // non-<html> root elements under <body>, and the <body> works as
     // rootEditableElement.
     document.addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, "document.execCommand() doesn't work with an invalid HTML structure. It is corrected automatically."));
 
-    RefPtrWillBeRawPtr<Element> root = HTMLHtmlElement::create(document);
+    RawPtr<Element> root = HTMLHtmlElement::create(document);
     if (existingHead)
         root->appendChild(existingHead.release());
-    RefPtrWillBeRawPtr<Element> body = nullptr;
+    RawPtr<Element> body = nullptr;
     if (existingBody)
         body = existingBody.release();
     else
         body = HTMLBodyElement::create(document);
     if (document.documentElement())
         body->appendChild(document.documentElement());
     root->appendChild(body.release());
     ASSERT(!document.documentElement());
     document.appendChild(root.release());
 
     // TODO(tkent): Should we check and move Text node children of <html>?
 }
 
 DEFINE_TRACE(Editor)
 {
     visitor->trace(m_frame);
     visitor->trace(m_lastEditCommand);
     visitor->trace(m_mark);
 }
 
 } // namespace blink