Oilpan: Remove WillBe types (part 9)

third_party/WebKit/Source/core/events/DragEvent.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/events/DragEvent.h"
 
 #include "core/clipboard/DataTransfer.h"
 #include "core/dom/Element.h"
 #include "core/events/EventDispatcher.h"
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<DragEvent> DragEvent::create(const AtomicString& type, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView> view,
+RawPtr<DragEvent> DragEvent::create(const AtomicString& type, bool canBubble, bool cancelable, RawPtr<AbstractView> view,
     int detail, int screenX, int screenY, int windowX, int windowY,
     int movementX, int movementY,
     PlatformEvent::Modifiers modifiers,
     short button, unsigned short buttons,
-    PassRefPtrWillBeRawPtr<EventTarget> relatedTarget,
+    RawPtr<EventTarget> relatedTarget,
     double platformTimeStamp, DataTransfer* dataTransfer,
     PlatformMouseEvent::SyntheticEventType syntheticEventType)
 {
-    return adoptRefWillBeNoop(new DragEvent(type, canBubble, cancelable, view,
+    return new DragEvent(type, canBubble, cancelable, view,
         detail, screenX, screenY, windowX, windowY,
         movementX, movementY,
         modifiers, button, buttons, relatedTarget, platformTimeStamp,
-        dataTransfer, syntheticEventType));
+        dataTransfer, syntheticEventType);
 }
 
 
 DragEvent::DragEvent()
     : m_dataTransfer(nullptr)
 {
 }
 
 DragEvent::DragEvent(DataTransfer* dataTransfer)
     : m_dataTransfer(dataTransfer)
 {
 }
 
-DragEvent::DragEvent(const AtomicString& eventType, bool canBubble, bool cancelable, PassRefPtrWillBeRawPtr<AbstractView> view,
+DragEvent::DragEvent(const AtomicString& eventType, bool canBubble, bool cancelable, RawPtr<AbstractView> view,
     int detail, int screenX, int screenY, int windowX, int windowY,
     int movementX, int movementY,
     PlatformEvent::Modifiers modifiers,
-    short button, unsigned short buttons, PassRefPtrWillBeRawPtr<EventTarget> relatedTarget,
+    short button, unsigned short buttons, RawPtr<EventTarget> relatedTarget,
     double platformTimeStamp, DataTransfer* dataTransfer,
     PlatformMouseEvent::SyntheticEventType syntheticEventType)
     : MouseEvent(eventType, canBubble, cancelable, view, detail, screenX, screenY,
         windowX, windowY, movementX, movementY, modifiers, button, buttons, relatedTarget,
         platformTimeStamp, syntheticEventType,
         // TODO(zino): Should support canvas hit region because the drag event
         // is a kind of mouse event. Please see http://crbug.com/594073
         String())
     , m_dataTransfer(dataTransfer)
 
 {
 }
 
 DragEvent::DragEvent(const AtomicString& type, const DragEventInit& initializer)
     : MouseEvent(type, initializer)
     , m_dataTransfer(initializer.getDataTransfer())
 {
 }
 
 bool DragEvent::isDragEvent() const
 {
     return true;
 }
 
 bool DragEvent::isMouseEvent() const
 {
     return false;
 }
 
-PassRefPtrWillBeRawPtr<EventDispatchMediator> DragEvent::createMediator()
+RawPtr<EventDispatchMediator> DragEvent::createMediator()
 {
     return DragEventDispatchMediator::create(this);
 }
 
 DEFINE_TRACE(DragEvent)
 {
     visitor->trace(m_dataTransfer);
     MouseEvent::trace(visitor);
 }
 
-PassRefPtrWillBeRawPtr<DragEventDispatchMediator> DragEventDispatchMediator::create(PassRefPtrWillBeRawPtr<DragEvent> dragEvent)
+RawPtr<DragEventDispatchMediator> DragEventDispatchMediator::create(RawPtr<DragEvent> dragEvent)
 {
-    return adoptRefWillBeNoop(new DragEventDispatchMediator(dragEvent));
+    return new DragEventDispatchMediator(dragEvent);
 }
 
-DragEventDispatchMediator::DragEventDispatchMediator(PassRefPtrWillBeRawPtr<DragEvent> dragEvent)
+DragEventDispatchMediator::DragEventDispatchMediator(RawPtr<DragEvent> dragEvent)
     : EventDispatchMediator(dragEvent)
 {
 }
 
 DragEvent& DragEventDispatchMediator::event() const
 {
     return toDragEvent(EventDispatchMediator::event());
 }
 
 DispatchEventResult DragEventDispatchMediator::dispatchEvent(EventDispatcher& dispatcher) const
 {
     if (event().relatedTargetScoped())
         event().eventPath().adjustForRelatedTarget(dispatcher.node(), event().relatedTarget());
     return EventDispatchMediator::dispatchEvent(dispatcher);
 }
 
 } // namespace blink