Replace scoped_ptr with std::unique_ptr in //ui

ui/events/platform/x11/x11_event_source_libevent.cc

 // Copyright 2014 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 "ui/events/platform/x11/x11_event_source_libevent.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/XInput2.h>
 
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/x/events_x_utils.h"
 
 namespace ui {
 
 namespace {
 
 // Translates XI2 XEvent into a ui::Event.
-scoped_ptr<ui::Event> TranslateXI2EventToEvent(const XEvent& xev) {
+std::unique_ptr<ui::Event> TranslateXI2EventToEvent(const XEvent& xev) {
   EventType event_type = EventTypeFromXEvent(xev);
   switch (event_type) {
     case ET_KEY_PRESSED:
     case ET_KEY_RELEASED:
-      return make_scoped_ptr(new KeyEvent(event_type,
-                                          KeyboardCodeFromXKeyEvent(&xev),
-                                          EventFlagsFromXEvent(xev)));
+      return base::WrapUnique(new KeyEvent(event_type,
+                                           KeyboardCodeFromXKeyEvent(&xev),
+                                           EventFlagsFromXEvent(xev)));
     case ET_MOUSE_PRESSED:
     case ET_MOUSE_MOVED:
     case ET_MOUSE_DRAGGED:
     case ET_MOUSE_RELEASED:
-      return make_scoped_ptr(
+      return base::WrapUnique(
           new MouseEvent(event_type, EventLocationFromXEvent(xev),
                          EventSystemLocationFromXEvent(xev),
                          EventTimeFromXEvent(xev), EventFlagsFromXEvent(xev),
                          GetChangedMouseButtonFlagsFromXEvent(xev)));
     case ET_MOUSEWHEEL:
-      return make_scoped_ptr(new MouseWheelEvent(
+      return base::WrapUnique(new MouseWheelEvent(
           GetMouseWheelOffsetFromXEvent(xev), EventLocationFromXEvent(xev),
           EventSystemLocationFromXEvent(xev), EventTimeFromXEvent(xev),
           EventFlagsFromXEvent(xev),
           GetChangedMouseButtonFlagsFromXEvent(xev)));
     case ET_SCROLL_FLING_START:
     case ET_SCROLL_FLING_CANCEL: {
       float x_offset, y_offset, x_offset_ordinal, y_offset_ordinal;
       GetFlingDataFromXEvent(xev, &x_offset, &y_offset, &x_offset_ordinal,
                              &y_offset_ordinal, nullptr);
-      return make_scoped_ptr(new ScrollEvent(
+      return base::WrapUnique(new ScrollEvent(
           event_type, EventLocationFromXEvent(xev), EventTimeFromXEvent(xev),
           EventFlagsFromXEvent(xev), x_offset, y_offset, x_offset_ordinal,
           y_offset_ordinal, 0));
     }
     case ET_SCROLL: {
       float x_offset, y_offset, x_offset_ordinal, y_offset_ordinal;
       int finger_count;
       GetScrollOffsetsFromXEvent(xev, &x_offset, &y_offset, &x_offset_ordinal,
                                  &y_offset_ordinal, &finger_count);
-      return make_scoped_ptr(new ScrollEvent(
+      return base::WrapUnique(new ScrollEvent(
           event_type, EventLocationFromXEvent(xev), EventTimeFromXEvent(xev),
           EventFlagsFromXEvent(xev), x_offset, y_offset, x_offset_ordinal,
           y_offset_ordinal, finger_count));
     }
     case ET_TOUCH_MOVED:
     case ET_TOUCH_PRESSED:
     case ET_TOUCH_CANCELLED:
     case ET_TOUCH_RELEASED:
-      return make_scoped_ptr(
+      return base::WrapUnique(
           new TouchEvent(event_type, EventLocationFromXEvent(xev),
                          GetTouchIdFromXEvent(xev), EventTimeFromXEvent(xev)));
     case ET_UNKNOWN:
       return nullptr;
     default:
       break;
   }
   return nullptr;
 }
 
 // Translates a XEvent into a ui::Event.
-scoped_ptr<ui::Event> TranslateXEventToEvent(const XEvent& xev) {
+std::unique_ptr<ui::Event> TranslateXEventToEvent(const XEvent& xev) {
   int flags = EventFlagsFromXEvent(xev);
   switch (xev.type) {
     case LeaveNotify:
     case EnterNotify:
       // EnterNotify creates ET_MOUSE_MOVED. Mark as synthesized as this is
       // not real mouse move event.
       if (xev.type == EnterNotify)
         flags |= EF_IS_SYNTHESIZED;
-      return make_scoped_ptr(
+      return base::WrapUnique(
           new MouseEvent(ET_MOUSE_MOVED, EventLocationFromXEvent(xev),
                          EventSystemLocationFromXEvent(xev),
                          EventTimeFromXEvent(xev), flags, 0));
 
     case KeyPress:
     case KeyRelease:
-      return make_scoped_ptr(new KeyEvent(
+      return base::WrapUnique(new KeyEvent(
           EventTypeFromXEvent(xev), KeyboardCodeFromXKeyEvent(&xev), flags));
 
     case ButtonPress:
     case ButtonRelease: {
       switch (EventTypeFromXEvent(xev)) {
         case ET_MOUSEWHEEL:
-          return make_scoped_ptr(new MouseWheelEvent(
+          return base::WrapUnique(new MouseWheelEvent(
               GetMouseWheelOffsetFromXEvent(xev), EventLocationFromXEvent(xev),
               EventSystemLocationFromXEvent(xev), EventTimeFromXEvent(xev),
               flags, 0));
         case ET_MOUSE_PRESSED:
         case ET_MOUSE_RELEASED:
-          return make_scoped_ptr(new MouseEvent(
+          return base::WrapUnique(new MouseEvent(
               EventTypeFromXEvent(xev), EventLocationFromXEvent(xev),
               EventSystemLocationFromXEvent(xev), EventTimeFromXEvent(xev),
               flags, GetChangedMouseButtonFlagsFromXEvent(xev)));
         case ET_UNKNOWN:
           // No event is created for X11-release events for mouse-wheel
           // buttons.
           break;
         default:
           NOTREACHED();
       }
@@ skipping 18 matching lines @@
 void X11EventSourceLibevent::AddXEventDispatcher(XEventDispatcher* dispatcher) {
   dispatchers_xevent_.AddObserver(dispatcher);
 }
 
 void X11EventSourceLibevent::RemoveXEventDispatcher(
     XEventDispatcher* dispatcher) {
   dispatchers_xevent_.RemoveObserver(dispatcher);
 }
 
 void X11EventSourceLibevent::ProcessXEvent(XEvent* xevent) {
-  scoped_ptr<ui::Event> translated_event = TranslateXEventToEvent(*xevent);
+  std::unique_ptr<ui::Event> translated_event = TranslateXEventToEvent(*xevent);
   if (translated_event) {
     DispatchEvent(translated_event.get());
   } else {
     // Only if we can't translate XEvent into ui::Event, try to dispatch XEvent
     // directly to XEventDispatchers.
     DispatchXEventToXEventDispatchers(xevent);
   }
 }
 
 void X11EventSourceLibevent::AddEventWatcher() {
@@ skipping 30 matching lines @@
 
 void X11EventSourceLibevent::OnFileCanReadWithoutBlocking(int fd) {
   event_source_.DispatchXEvents();
 }
 
 void X11EventSourceLibevent::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
 }  // namespace ui