Replace scoped_ptr with std::unique_ptr in //ui

ui/events/ozone/device/udev/device_manager_udev.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/ozone/device/udev/device_manager_udev.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_event_observer.h"
 
 namespace ui {
 
 namespace {
 
 const char* const kSubsystems[] = {
@@ skipping 93 matching lines @@
   struct udev_list_entry* devices =
       device::udev_enumerate_get_list_entry(enumerate.get());
   struct udev_list_entry* entry;
 
   udev_list_entry_foreach(entry, devices) {
     device::ScopedUdevDevicePtr device(device::udev_device_new_from_syspath(
         udev_.get(), device::udev_list_entry_get_name(entry)));
     if (!device)
       continue;
 
-    scoped_ptr<DeviceEvent> event = ProcessMessage(device.get());
+    std::unique_ptr<DeviceEvent> event = ProcessMessage(device.get());
     if (event)
       observer->OnDeviceEvent(*event.get());
   }
 }
 
 void DeviceManagerUdev::AddObserver(DeviceEventObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void DeviceManagerUdev::RemoveObserver(DeviceEventObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void DeviceManagerUdev::OnFileCanReadWithoutBlocking(int fd) {
   // The netlink socket should never become disconnected. There's no need
   // to handle broken connections here.
   TRACE_EVENT1("evdev", "UdevDeviceChange", "socket", fd);
 
   device::ScopedUdevDevicePtr device(
       device::udev_monitor_receive_device(monitor_.get()));
   if (!device)
     return;
 
-  scoped_ptr<DeviceEvent> event = ProcessMessage(device.get());
+  std::unique_ptr<DeviceEvent> event = ProcessMessage(device.get());
   if (event)
     FOR_EACH_OBSERVER(
         DeviceEventObserver, observers_, OnDeviceEvent(*event.get()));
 }
 
 void DeviceManagerUdev::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
-scoped_ptr<DeviceEvent> DeviceManagerUdev::ProcessMessage(udev_device* device) {
+std::unique_ptr<DeviceEvent> DeviceManagerUdev::ProcessMessage(
+    udev_device* device) {
   const char* path = device::udev_device_get_devnode(device);
   const char* action = device::udev_device_get_action(device);
   const char* subsystem =
       device::udev_device_get_property_value(device, "SUBSYSTEM");
 
   if (!path || !subsystem)
     return nullptr;
 
   DeviceEvent::DeviceType device_type;
   if (!strcmp(subsystem, "input") &&
       base::StartsWith(path, "/dev/input/event", base::CompareCase::SENSITIVE))
     device_type = DeviceEvent::INPUT;
   else if (!strcmp(subsystem, "drm") &&
            base::StartsWith(path, "/dev/dri/card",
                             base::CompareCase::SENSITIVE))
     device_type = DeviceEvent::DISPLAY;
   else
     return nullptr;
 
   DeviceEvent::ActionType action_type;
   if (!action || !strcmp(action, "add"))
     action_type = DeviceEvent::ADD;
   else if (!strcmp(action, "remove"))
     action_type = DeviceEvent::REMOVE;
   else if (!strcmp(action, "change"))
     action_type = DeviceEvent::CHANGE;
   else
     return nullptr;
 
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new DeviceEvent(device_type, action_type, base::FilePath(path)));
 }
 
 }  // namespace ui