Move DeviceMonitorLinux to //device/core.

device/hid/input_service_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/input_service_linux.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/scoped_observer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
+#include "device/core/device_monitor_linux.h"
 #include "device/udev_linux/udev.h"
 
 namespace device {
 
 namespace {
 
 const char kSubsystemHid[] = "hid";
 const char kSubsystemInput[] = "input";
 const char kSubsystemMisc[] = "misc";
 const char kTypeBluetooth[] = "bluetooth";
@@ skipping 56 matching lines @@
   base::TrimString(name, "\"", &result);
   return result;
 }
 
 class InputServiceLinuxImpl : public InputServiceLinux,
                               public DeviceMonitorLinux::Observer {
  public:
   // Implements DeviceMonitorLinux::Observer:
   void OnDeviceAdded(udev_device* device) override;
   void OnDeviceRemoved(udev_device* device) override;
+  void WillDestroyMonitorMessageLoop() override;
 
  private:
   friend class InputServiceLinux;
 
   InputServiceLinuxImpl();
   ~InputServiceLinuxImpl() override;
 
+  ScopedObserver<DeviceMonitorLinux, DeviceMonitorLinux::Observer> observer_;
+
   DISALLOW_COPY_AND_ASSIGN(InputServiceLinuxImpl);
 };
 
-InputServiceLinuxImpl::InputServiceLinuxImpl() {
+InputServiceLinuxImpl::InputServiceLinuxImpl() : observer_(this) {
   base::ThreadRestrictions::AssertIOAllowed();
-  base::MessageLoop::current()->AddDestructionObserver(this);
 
-  DeviceMonitorLinux::GetInstance()->AddObserver(this);
-  DeviceMonitorLinux::GetInstance()->Enumerate(base::Bind(
-      &InputServiceLinuxImpl::OnDeviceAdded, base::Unretained(this)));
+  DeviceMonitorLinux* monitor = DeviceMonitorLinux::GetInstance();
+  observer_.Add(monitor);
+  monitor->Enumerate(base::Bind(&InputServiceLinuxImpl::OnDeviceAdded,
+                                base::Unretained(this)));
 }
 
 InputServiceLinuxImpl::~InputServiceLinuxImpl() {
-  if (DeviceMonitorLinux::HasInstance())
-    DeviceMonitorLinux::GetInstance()->RemoveObserver(this);
-  base::MessageLoop::current()->RemoveDestructionObserver(this);
 }
 
 void InputServiceLinuxImpl::OnDeviceAdded(udev_device* device) {
   DCHECK(CalledOnValidThread());
   if (!device)
     return;
   const char* devnode = udev_device_get_devnode(device);
   if (!devnode)
     return;
 
@@ skipping 29 matching lines @@
 
 void InputServiceLinuxImpl::OnDeviceRemoved(udev_device* device) {
   DCHECK(CalledOnValidThread());
   if (!device)
     return;
   const char* devnode = udev_device_get_devnode(device);
   if (devnode)
     RemoveDevice(devnode);
 }
 
+void InputServiceLinuxImpl::WillDestroyMonitorMessageLoop() {
+  DCHECK(CalledOnValidThread());
+  g_input_service_linux_ptr.Get().reset(nullptr);
+}
+
 }  // namespace
 
 InputServiceLinux::InputDeviceInfo::InputDeviceInfo()
     : subsystem(SUBSYSTEM_UNKNOWN),
       type(TYPE_UNKNOWN),
       is_accelerometer(false),
       is_joystick(false),
       is_key(false),
       is_keyboard(false),
       is_mouse(false),
@@ skipping 51 matching lines @@
 bool InputServiceLinux::GetDeviceInfo(const std::string& id,
                                       InputDeviceInfo* info) const {
   DCHECK(CalledOnValidThread());
   DeviceMap::const_iterator it = devices_.find(id);
   if (it == devices_.end())
     return false;
   *info = it->second;
   return true;
 }
 
-void InputServiceLinux::WillDestroyCurrentMessageLoop() {
-  DCHECK(CalledOnValidThread());
-  g_input_service_linux_ptr.Get().reset(NULL);
-}
-
 void InputServiceLinux::AddDevice(const InputDeviceInfo& info) {
   devices_[info.id] = info;
   FOR_EACH_OBSERVER(Observer, observers_, OnInputDeviceAdded(info));
 }
 
 void InputServiceLinux::RemoveDevice(const std::string& id) {
   devices_.erase(id);
   FOR_EACH_OBSERVER(Observer, observers_, OnInputDeviceRemoved(id));
 }
 
 bool InputServiceLinux::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace device