Linux: Unify udev scopers.

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 <libudev.h>
 
 #include "base/debug/trace_event.h"
 #include "base/strings/stringprintf.h"
@@ skipping 32 matching lines @@
              va_list args) {
   if (priority <= SYS_LOG_ERR)
     LOG(ERROR) << "libudev: " << fn << ": " << base::StringPrintV(format, args);
   else if (priority <= SYS_LOG_INFO)
     VLOG(1) << "libudev: " << fn << ": " << base::StringPrintV(format, args);
   else  // SYS_LOG_DEBUG
     VLOG(2) << "libudev: " << fn << ": " << base::StringPrintV(format, args);
 }
 
 // Create libudev context.
-scoped_udev UdevCreate() {
+device::ScopedUdevPtr UdevCreate() {
   struct udev* udev = udev_new();
   if (udev) {
     udev_set_log_fn(udev, UdevLog);
     udev_set_log_priority(udev, SYS_LOG_DEBUG);
   }
-  return scoped_udev(udev);
+  return device::ScopedUdevPtr(udev);
 }
 
 // Start monitoring input device changes.
-scoped_udev_monitor UdevCreateMonitor(struct udev* udev) {
+device::ScopedUdevMonitorPtr UdevCreateMonitor(struct udev* udev) {
   struct udev_monitor* monitor = udev_monitor_new_from_netlink(udev, "udev");
   if (monitor) {
     for (size_t i = 0; i < arraysize(kSubsystems); ++i)
       udev_monitor_filter_add_match_subsystem_devtype(
           monitor, kSubsystems[i], NULL);
 
     if (udev_monitor_enable_receiving(monitor))
       LOG(ERROR) << "Failed to start receiving events from udev";
   } else {
     LOG(ERROR) << "Failed to create udev monitor";
   }
 
-  return scoped_udev_monitor(monitor);
+  return device::ScopedUdevMonitorPtr(monitor);
 }
 
 }  // namespace
 
 DeviceManagerUdev::DeviceManagerUdev() : udev_(UdevCreate()) {
 }
 
 DeviceManagerUdev::~DeviceManagerUdev() {
 }
 
 void DeviceManagerUdev::CreateMonitor() {
   if (monitor_)
     return;
   monitor_ = UdevCreateMonitor(udev_.get());
   if (monitor_) {
     int fd = udev_monitor_get_fd(monitor_.get());
     CHECK_GT(fd, 0);
     base::MessageLoopForUI::current()->WatchFileDescriptor(
         fd, true, base::MessagePumpLibevent::WATCH_READ, &controller_, this);
   }
 }
 
 void DeviceManagerUdev::ScanDevices(DeviceEventObserver* observer) {
   CreateMonitor();
 
-  scoped_udev_enumerate enumerate(udev_enumerate_new(udev_.get()));
+  device::ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev_.get()));
   if (!enumerate)
     return;
 
   for (size_t i = 0; i < arraysize(kSubsystems); ++i)
     udev_enumerate_add_match_subsystem(enumerate.get(), kSubsystems[i]);
   udev_enumerate_scan_devices(enumerate.get());
 
   struct udev_list_entry* devices =
       udev_enumerate_get_list_entry(enumerate.get());
   struct udev_list_entry* entry;
 
   udev_list_entry_foreach(entry, devices) {
-    scoped_udev_device device(udev_device_new_from_syspath(
+    device::ScopedUdevDevicePtr device(udev_device_new_from_syspath(
         udev_.get(), udev_list_entry_get_name(entry)));
     if (!device)
       continue;
 
     scoped_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("ozone", "UdevDeviceChange", "socket", fd);
 
-  scoped_udev_device device(udev_monitor_receive_device(monitor_.get()));
+  device::ScopedUdevDevicePtr device(
+      udev_monitor_receive_device(monitor_.get()));
   if (!device)
     return;
 
   scoped_ptr<DeviceEvent> event = ProcessMessage(device.get());
   if (event)
     FOR_EACH_OBSERVER(
         DeviceEventObserver, observers_, OnDeviceEvent(*event.get()));
 }
 
 void DeviceManagerUdev::OnFileCanWriteWithoutBlocking(int fd) {
@@ skipping 26 matching lines @@
   else if (!strcmp(action, "change"))
     action_type = DeviceEvent::CHANGE;
   else
     return scoped_ptr<DeviceEvent>();
 
   return scoped_ptr<DeviceEvent>(
       new DeviceEvent(device_type, action_type, base::FilePath(path)));
 }
 
 }  // namespace ui