Move DeviceMonitorLinux to //device/core.

device/core/device_monitor_linux.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 "device/hid/device_monitor_linux.h"
+#include "device/core/device_monitor_linux.h"
 
 #include <memory>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
 #include "device/udev_linux/udev.h"
 
 namespace device {
 
@@ skipping 30 matching lines @@
     return;
   }
 
   monitor_fd_ = udev_monitor_get_fd(monitor_.get());
   if (monitor_fd_ <= 0) {
     LOG(ERROR) << "Failed to start udev monitoring.";
     return;
   }
 
   if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          monitor_fd_,
-          true,
-          base::MessageLoopForIO::WATCH_READ,
-          &monitor_watcher_,
-          this)) {
+          monitor_fd_, true /* persistent */,
+          base::MessageLoopForIO::WATCH_READ, &monitor_watcher_, this)) {
     return;
   }
 }
 
 // static
 DeviceMonitorLinux* DeviceMonitorLinux::GetInstance() {
-  if (!HasInstance())
+  if (!g_device_monitor_linux_ptr.Get().get())
     g_device_monitor_linux_ptr.Get().reset(new DeviceMonitorLinux());
   return g_device_monitor_linux_ptr.Get().get();
 }
 
-// static
-bool DeviceMonitorLinux::HasInstance() {
-  return g_device_monitor_linux_ptr.Get().get();
-}
-
 void DeviceMonitorLinux::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (observer)
-    observers_.AddObserver(observer);
+  observers_.AddObserver(observer);
 }
 
 void DeviceMonitorLinux::RemoveObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (observer)
-    observers_.RemoveObserver(observer);
+  observers_.RemoveObserver(observer);
 }
 
 ScopedUdevDevicePtr DeviceMonitorLinux::GetDeviceFromPath(
     const std::string& path) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScopedUdevDevicePtr device(
       udev_device_new_from_syspath(udev_.get(), path.c_str()));
   return device;
 }
 
 void DeviceMonitorLinux::Enumerate(const EnumerateCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev_.get()));
 
   if (!enumerate) {
     LOG(ERROR) << "Failed to enumerate devices.";
     return;
   }
 
   if (udev_enumerate_scan_devices(enumerate.get()) != 0) {
     LOG(ERROR) << "Failed to enumerate devices.";
     return;
   }
 
   // This list is managed by |enumerate|.
   udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
-  for (udev_list_entry* i = devices; i != NULL;
+  for (udev_list_entry* i = devices; i != nullptr;
        i = udev_list_entry_get_next(i)) {
     ScopedUdevDevicePtr device(
         udev_device_new_from_syspath(udev_.get(), udev_list_entry_get_name(i)));
     if (device)
       callback.Run(device.get());
   }
 }
 
 void DeviceMonitorLinux::WillDestroyCurrentMessageLoop() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  g_device_monitor_linux_ptr.Get().reset(NULL);
+  FOR_EACH_OBSERVER(Observer, observers_, WillDestroyMonitorMessageLoop());
+  g_device_monitor_linux_ptr.Get().reset(nullptr);
 }
 
 void DeviceMonitorLinux::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(monitor_fd_, fd);
 
   ScopedUdevDevicePtr device(udev_monitor_receive_device(monitor_.get()));
   if (!device)
     return;
 
   std::string action(udev_device_get_action(device.get()));
   if (action == kUdevActionAdd)
     FOR_EACH_OBSERVER(Observer, observers_, OnDeviceAdded(device.get()));
   else if (action == kUdevActionRemove)
     FOR_EACH_OBSERVER(Observer, observers_, OnDeviceRemoved(device.get()));
 }
 
 void DeviceMonitorLinux::OnFileCanWriteWithoutBlocking(int fd) {}
 
 DeviceMonitorLinux::~DeviceMonitorLinux() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::MessageLoop::current()->RemoveDestructionObserver(this);
   monitor_watcher_.StopWatchingFileDescriptor();
   close(monitor_fd_);
 }
 
 }  // namespace device