Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/editing/InputMethodController.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 38 matching lines @@
 {
 }
 
 InputMethodController::SelectionOffsetsScope::~SelectionOffsetsScope()
 {
     m_inputMethodController->setSelectionOffsets(m_offsets);
 }
 
 // ----------------------------
 
-PassOwnPtrWillBeRawPtr<InputMethodController> InputMethodController::create(LocalFrame& frame)
+RawPtr<InputMethodController> InputMethodController::create(LocalFrame& frame)
 {
-    return adoptPtrWillBeNoop(new InputMethodController(frame));
+    return new InputMethodController(frame);
 }
 
 InputMethodController::InputMethodController(LocalFrame& frame)
     : m_frame(&frame)
     , m_isDirty(false)
     , m_hasComposition(false)
 {
 }
 
 InputMethodController::~InputMethodController()
@@ skipping 51 matching lines @@
 }
 
 static void dispatchCompositionEndEvent(LocalFrame& frame, const String& text)
 {
     // We should send this event before sending a TextEvent as written in
     // Section 6.2.2 and 6.2.3 of the DOM Event specification.
     Element* target = frame.document()->focusedElement();
     if (!target)
         return;
 
-    RefPtrWillBeRawPtr<CompositionEvent> event =
+    RawPtr<CompositionEvent> event =
         CompositionEvent::create(EventTypeNames::compositionend, frame.domWindow(), text);
     target->dispatchEvent(event);
 }
 
 bool InputMethodController::confirmComposition(const String& text)
 {
     if (!hasComposition())
         return false;
 
     Editor::RevealSelectionScope revealSelectionScope(&editor());
@@ skipping 110 matching lines @@
         //    a new composition node, i.e.
         //    !hasComposition() && !text.isEmpty().
         //    Sending a compositionupdate event at this time ensures that at least one
         //    compositionupdate event is dispatched.
         // 2. Updating the existing composition node.
         //    Send a compositionupdate event when this function updates the existing composition
         //    node, i.e. hasComposition() && !text.isEmpty().
         // 3. Canceling the ongoing composition.
         //    Send a compositionend event when function deletes the existing composition node, i.e.
         //    !hasComposition() && test.isEmpty().
-        RefPtrWillBeRawPtr<CompositionEvent> event = nullptr;
+        RawPtr<CompositionEvent> event = nullptr;
         if (!hasComposition()) {
             // We should send a compositionstart event only when the given text is not empty because this
             // function doesn't create a composition node when the text is empty.
             if (!text.isEmpty()) {
                 target->dispatchEvent(CompositionEvent::create(EventTypeNames::compositionstart, frame().domWindow(), frame().selectedText()));
                 event = CompositionEvent::create(EventTypeNames::compositionupdate, frame().domWindow(), text);
             }
         } else {
             if (!text.isEmpty())
                 event = CompositionEvent::create(EventTypeNames::compositionupdate, frame().domWindow(), text);
@@ skipping 39 matching lines @@
     if (!m_compositionRange)
         m_compositionRange = Range::create(baseNode->document());
     m_compositionRange->setStart(baseNode, baseOffset);
     m_compositionRange->setEnd(baseNode, extentOffset);
 
     if (baseNode->layoutObject())
         baseNode->layoutObject()->setShouldDoFullPaintInvalidation();
 
     unsigned start = std::min(baseOffset + selectionStart, extentOffset);
     unsigned end = std::min(std::max(start, baseOffset + selectionEnd), extentOffset);
-    RefPtrWillBeRawPtr<Range> selectedRange = Range::create(baseNode->document(), baseNode, start, baseNode, end);
+    RawPtr<Range> selectedRange = Range::create(baseNode->document(), baseNode, start, baseNode, end);
     frame().selection().setSelectedRange(selectedRange.get(), TextAffinity::Downstream, SelectionDirectionalMode::NonDirectional, NotUserTriggered);
 
     if (underlines.isEmpty()) {
         frame().document()->markers().addCompositionMarker(m_compositionRange->startPosition(), m_compositionRange->endPosition(), Color::black, false, LayoutTheme::theme().platformDefaultCompositionBackgroundColor());
         return;
     }
     for (const auto& underline : underlines) {
         unsigned underlineStart = baseOffset + underline.startOffset;
         unsigned underlineEnd = baseOffset + underline.endOffset;
         EphemeralRange ephemeralLineRange = EphemeralRange(Position(baseNode, underlineStart), Position(baseNode, underlineEnd));
@@ skipping 39 matching lines @@
     m_compositionRange->setEnd(range.endPosition());
 }
 
 EphemeralRange InputMethodController::compositionEphemeralRange() const
 {
     if (!hasComposition())
         return EphemeralRange();
     return EphemeralRange(m_compositionRange.get());
 }
 
-PassRefPtrWillBeRawPtr<Range> InputMethodController::compositionRange() const
+RawPtr<Range> InputMethodController::compositionRange() const
 {
     return hasComposition() ? m_compositionRange : nullptr;
 }
 
 String InputMethodController::composingText() const
 {
     return plainText(compositionEphemeralRange(), TextIteratorEmitsOriginalText);
 }
 
 PlainTextRange InputMethodController::getSelectionOffsets() const
@@ skipping 58 matching lines @@
     TypingCommand::deleteSelection(*frame().document());
 }
 
 DEFINE_TRACE(InputMethodController)
 {
     visitor->trace(m_frame);
     visitor->trace(m_compositionRange);
 }
 
 } // namespace blink