Replace scoped_ptr with std::unique_ptr in //ui

ui/events/ozone/evdev/input_device_factory_evdev.cc

 // 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 "ui/events/ozone/evdev/input_device_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 #include <stddef.h>
+
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_util_linux.h"
 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
 #include "ui/events/ozone/evdev/event_converter_evdev_impl.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 
 #if defined(USE_EVDEV_GESTURES)
 #include "ui/events/ozone/evdev/libgestures_glue/event_reader_libevdev_cros.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_feedback.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 #endif
 
 #ifndef EVIOCSCLOCKID
 #define EVIOCSCLOCKID _IOW('E', 0xa0, int)
 #endif
 
 namespace ui {
 
 namespace {
 
-typedef base::Callback<void(scoped_ptr<EventConverterEvdev>)>
+typedef base::Callback<void(std::unique_ptr<EventConverterEvdev>)>
     OpenInputDeviceReplyCallback;
 
 struct OpenInputDeviceParams {
   // Unique identifier for the new device.
   int id;
 
   // Device path to open.
   base::FilePath path;
 
   // Dispatcher for events. Call on UI thread only.
@@ skipping 24 matching lines @@
                             bool value) {
   GesturesProp* property = provider->GetProperty(id, name);
   if (property) {
     std::vector<bool> values(1, value);
     property->SetBoolValue(values);
   }
 }
 
 #endif
 
-scoped_ptr<EventConverterEvdev> CreateConverter(
+std::unique_ptr<EventConverterEvdev> CreateConverter(
     const OpenInputDeviceParams& params,
     int fd,
     const EventDeviceInfo& devinfo) {
 #if defined(USE_EVDEV_GESTURES)
   // Touchpad or mouse: use gestures library.
   // EventReaderLibevdevCros -> GestureInterpreterLibevdevCros -> DispatchEvent
   if (devinfo.HasTouchpad() || devinfo.HasMouse()) {
-    scoped_ptr<GestureInterpreterLibevdevCros> gesture_interp =
-        make_scoped_ptr(new GestureInterpreterLibevdevCros(
+    std::unique_ptr<GestureInterpreterLibevdevCros> gesture_interp =
+        base::WrapUnique(new GestureInterpreterLibevdevCros(
             params.id, params.cursor, params.gesture_property_provider,
             params.dispatcher));
-    return make_scoped_ptr(new EventReaderLibevdevCros(
+    return base::WrapUnique(new EventReaderLibevdevCros(
         fd, params.path, params.id, devinfo, std::move(gesture_interp)));
   }
 #endif
 
   // Touchscreen: use TouchEventConverterEvdev.
   if (devinfo.HasTouchscreen()) {
-    scoped_ptr<TouchEventConverterEvdev> converter(new TouchEventConverterEvdev(
-        fd, params.path, params.id, devinfo, params.dispatcher));
+    std::unique_ptr<TouchEventConverterEvdev> converter(
+        new TouchEventConverterEvdev(fd, params.path, params.id, devinfo,
+                                     params.dispatcher));
     converter->Initialize(devinfo);
     return std::move(converter);
   }
 
   // Graphics tablet
   if (devinfo.HasTablet())
-    return make_scoped_ptr<EventConverterEvdev>(new TabletEventConverterEvdev(
+    return base::WrapUnique<EventConverterEvdev>(new TabletEventConverterEvdev(
         fd, params.path, params.id, params.cursor, devinfo, params.dispatcher));
 
   // Everything else: use EventConverterEvdevImpl.
-  return make_scoped_ptr<EventConverterEvdevImpl>(new EventConverterEvdevImpl(
+  return base::WrapUnique<EventConverterEvdevImpl>(new EventConverterEvdevImpl(
       fd, params.path, params.id, devinfo, params.cursor, params.dispatcher));
 }
 
 // Open an input device. Opening may put the calling thread to sleep, and
 // therefore should be run on a thread where latency is not critical. We
 // run it on a thread from the worker pool.
 //
 // This takes a TaskRunner and runs the reply on that thread, so that we
 // can hop threads if necessary (back to the UI thread).
-void OpenInputDevice(scoped_ptr<OpenInputDeviceParams> params,
+void OpenInputDevice(std::unique_ptr<OpenInputDeviceParams> params,
                      scoped_refptr<base::TaskRunner> reply_runner,
                      const OpenInputDeviceReplyCallback& reply_callback) {
   const base::FilePath& path = params->path;
-  scoped_ptr<EventConverterEvdev> converter;
+  std::unique_ptr<EventConverterEvdev> converter;
 
   TRACE_EVENT1("evdev", "OpenInputDevice", "path", path.value());
 
   int fd = open(path.value().c_str(), O_RDWR | O_NONBLOCK);
   if (fd < 0) {
     PLOG(ERROR) << "Cannot open '" << path.value();
     reply_runner->PostTask(
         FROM_HERE, base::Bind(reply_callback, base::Passed(&converter)));
     return;
   }
@@ skipping 18 matching lines @@
 
   // Reply with the constructed converter.
   reply_runner->PostTask(FROM_HERE,
                          base::Bind(reply_callback, base::Passed(&converter)));
 }
 
 // Close an input device. Closing may put the calling thread to sleep, and
 // therefore should be run on a thread where latency is not critical. We
 // run it on the FILE thread.
 void CloseInputDevice(const base::FilePath& path,
-                      scoped_ptr<EventConverterEvdev> converter) {
+                      std::unique_ptr<EventConverterEvdev> converter) {
   TRACE_EVENT1("evdev", "CloseInputDevice", "path", path.value());
   converter.reset();
 }
 
 }  // namespace
 
 InputDeviceFactoryEvdev::InputDeviceFactoryEvdev(
-    scoped_ptr<DeviceEventDispatcherEvdev> dispatcher,
+    std::unique_ptr<DeviceEventDispatcherEvdev> dispatcher,
     CursorDelegateEvdev* cursor)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       cursor_(cursor),
 #if defined(USE_EVDEV_GESTURES)
       gesture_property_provider_(new GesturePropertyProvider),
 #endif
       dispatcher_(std::move(dispatcher)),
       weak_ptr_factory_(this) {
 }
 
 InputDeviceFactoryEvdev::~InputDeviceFactoryEvdev() {
   STLDeleteValues(&converters_);
 }
 
 void InputDeviceFactoryEvdev::AddInputDevice(int id,
                                              const base::FilePath& path) {
-  scoped_ptr<OpenInputDeviceParams> params(new OpenInputDeviceParams);
+  std::unique_ptr<OpenInputDeviceParams> params(new OpenInputDeviceParams);
   params->id = id;
   params->path = path;
   params->cursor = cursor_;
   params->dispatcher = dispatcher_.get();
 
 #if defined(USE_EVDEV_GESTURES)
   params->gesture_property_provider = gesture_property_provider_.get();
 #endif
 
   OpenInputDeviceReplyCallback reply_callback =
@@ skipping 12 matching lines @@
 void InputDeviceFactoryEvdev::RemoveInputDevice(const base::FilePath& path) {
   DetachInputDevice(path);
 }
 
 void InputDeviceFactoryEvdev::OnStartupScanComplete() {
   startup_devices_enumerated_ = true;
   NotifyDevicesUpdated();
 }
 
 void InputDeviceFactoryEvdev::AttachInputDevice(
-    scoped_ptr<EventConverterEvdev> converter) {
+    std::unique_ptr<EventConverterEvdev> converter) {
   if (converter.get()) {
     const base::FilePath& path = converter->path();
 
     TRACE_EVENT1("evdev", "AttachInputDevice", "path", path.value());
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
     // If we have an existing device, detach it. We don't want two
     // devices with the same name open at the same time.
     if (converters_[path])
       DetachInputDevice(path);
@@ skipping 10 matching lines @@
 
   --pending_device_changes_;
   NotifyDevicesUpdated();
 }
 
 void InputDeviceFactoryEvdev::DetachInputDevice(const base::FilePath& path) {
   TRACE_EVENT1("evdev", "DetachInputDevice", "path", path.value());
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   // Remove device from map.
-  scoped_ptr<EventConverterEvdev> converter(converters_[path]);
+  std::unique_ptr<EventConverterEvdev> converter(converters_[path]);
   converters_.erase(path);
 
   if (converter) {
     // Disable the device (to release keys/buttons/etc).
     converter->SetEnabled(false);
 
     // Cancel libevent notifications from this converter. This part must be
     // on UI since the polling happens on UI.
     converter->Stop();
 
@@ skipping 13 matching lines @@
 }
 
 void InputDeviceFactoryEvdev::UpdateInputDeviceSettings(
     const InputDeviceSettingsEvdev& settings) {
   input_device_settings_ = settings;
   ApplyInputDeviceSettings();
 }
 
 void InputDeviceFactoryEvdev::GetTouchDeviceStatus(
     const GetTouchDeviceStatusReply& reply) {
-  scoped_ptr<std::string> status(new std::string);
+  std::unique_ptr<std::string> status(new std::string);
 #if defined(USE_EVDEV_GESTURES)
   DumpTouchDeviceStatus(gesture_property_provider_.get(), status.get());
 #endif
   reply.Run(std::move(status));
 }
 
 void InputDeviceFactoryEvdev::GetTouchEventLog(
     const base::FilePath& out_dir,
     const GetTouchEventLogReply& reply) {
-  scoped_ptr<std::vector<base::FilePath>> log_paths(
+  std::unique_ptr<std::vector<base::FilePath>> log_paths(
       new std::vector<base::FilePath>);
 #if defined(USE_EVDEV_GESTURES)
   DumpTouchEventLog(converters_, gesture_property_provider_.get(), out_dir,
                     std::move(log_paths), reply);
 #else
   reply.Run(std::move(log_paths));
 #endif
 }
 
 base::WeakPtr<InputDeviceFactoryEvdev> InputDeviceFactoryEvdev::GetWeakPtr() {
@@ skipping 169 matching lines @@
   std::vector<int> ids;
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
   for (size_t i = 0; i < ids.size(); ++i) {
     SetGestureBoolProperty(gesture_property_provider_.get(), ids[i], name,
                            value);
   }
 #endif
 }
 
 }  // namespace ui