Remove DeviceMonitorLinux::WillDestroyCurrentMessageLoop().

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/base/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";
 const char kTypeUsb[] = "usb";
 const char kTypeSerio[] = "serio";
 const char kIdInputAccelerometer[] = "ID_INPUT_ACCELEROMETER";
 const char kIdInputJoystick[] = "ID_INPUT_JOYSTICK";
 const char kIdInputKey[] = "ID_INPUT_KEY";
 const char kIdInputKeyboard[] = "ID_INPUT_KEYBOARD";
 const char kIdInputMouse[] = "ID_INPUT_MOUSE";
 const char kIdInputTablet[] = "ID_INPUT_TABLET";
 const char kIdInputTouchpad[] = "ID_INPUT_TOUCHPAD";
 const char kIdInputTouchscreen[] = "ID_INPUT_TOUCHSCREEN";
 
-// The instance will be reset when message loop destroys.
-base::LazyInstance<std::unique_ptr<InputServiceLinux>>::Leaky
-    g_input_service_linux_ptr = LAZY_INSTANCE_INITIALIZER;
+InputServiceLinux* g_input_service_linux = nullptr;
 
 bool GetBoolProperty(udev_device* device, const char* key) {
   CHECK(device);
   CHECK(key);
   const char* property = udev_device_get_property_value(device, key);
   if (!property)
     return false;
   int value;
   if (!base::StringToInt(property, &value)) {
     LOG(ERROR) << "Not an integer value for " << key << " property";
@@ skipping 32 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() : observer_(this) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   DeviceMonitorLinux* monitor = DeviceMonitorLinux::GetInstance();
   observer_.Add(monitor);
   monitor->Enumerate(base::Bind(&InputServiceLinuxImpl::OnDeviceAdded,
                                 base::Unretained(this)));
 }
 
 InputServiceLinuxImpl::~InputServiceLinuxImpl() {
+  // Never destroyed.
+  NOTREACHED();
 }
 
 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),
       is_tablet(false),
       is_touchpad(false),
       is_touchscreen(false) {}
 
 InputServiceLinux::InputDeviceInfo::InputDeviceInfo(
     const InputDeviceInfo& other) = default;
 
 InputServiceLinux::InputServiceLinux() {
 }
 
 InputServiceLinux::~InputServiceLinux() {
   DCHECK(CalledOnValidThread());
 }
 
 // static
 InputServiceLinux* InputServiceLinux::GetInstance() {
   if (!HasInstance())
-    g_input_service_linux_ptr.Get().reset(new InputServiceLinuxImpl());
-  return g_input_service_linux_ptr.Get().get();
+    g_input_service_linux = new InputServiceLinuxImpl();
+  return g_input_service_linux;
 }
 
 // static
 bool InputServiceLinux::HasInstance() {
-  return g_input_service_linux_ptr.Get().get();
+  return !!g_input_service_linux;
 }
 
 // static
-void InputServiceLinux::SetForTesting(InputServiceLinux* service) {
-  g_input_service_linux_ptr.Get().reset(service);
+void InputServiceLinux::SetForTesting(
+    std::unique_ptr<InputServiceLinux> service) {
+  DCHECK(!HasInstance());
+  DCHECK(service);
+  // |service| will never be destroyed.
+  g_input_service_linux = service.release();
 }
 
 void InputServiceLinux::AddObserver(Observer* observer) {
   DCHECK(CalledOnValidThread());
   if (observer)
     observers_.AddObserver(observer);
 }
 
 void InputServiceLinux::RemoveObserver(Observer* observer) {
   DCHECK(CalledOnValidThread());
@@ skipping 29 matching lines @@
   devices_.erase(id);
   for (auto& observer : observers_)
     observer.OnInputDeviceRemoved(id);
 }
 
 bool InputServiceLinux::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace device