Created fakes for HID-detection screen testing. Initial browsertest added.

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 "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 62 matching lines @@
   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;
 
+  // InputServiceLinux overrides:
+  void AddObserver(InputServiceLinux::Observer* observer) override;
+  void RemoveObserver(InputServiceLinux::Observer* observer) override;
+  void GetDevices(std::vector<InputDeviceInfo>* devices) override;
+  bool GetDeviceInfo(
+      const std::string& id, InputDeviceInfo* info) const override;
+  void WillDestroyCurrentMessageLoop() override;
+
+ protected:
+  bool CalledOnValidThread() const;
+
  private:
   friend class InputServiceLinux;
 
   InputServiceLinuxImpl();
   ~InputServiceLinuxImpl() override;
 
+  base::ThreadChecker thread_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(InputServiceLinuxImpl);
 };
 
 InputServiceLinuxImpl::InputServiceLinuxImpl() {
+  base::ThreadRestrictions::AssertIOAllowed();
+  base::MessageLoop::current()->AddDestructionObserver(this);
+
   DeviceMonitorLinux::GetInstance()->AddObserver(this);
   DeviceMonitorLinux::GetInstance()->Enumerate(base::Bind(
       &InputServiceLinuxImpl::OnDeviceAdded, base::Unretained(this)));
 }
 
 InputServiceLinuxImpl::~InputServiceLinuxImpl() {
-  if (DeviceMonitorLinux::HasInstance())
-    DeviceMonitorLinux::GetInstance()->RemoveObserver(this);
+  DCHECK(CalledOnValidThread());
+  base::MessageLoop::current()->RemoveDestructionObserver(this);
+}
+
+void InputServiceLinuxImpl::AddObserver(InputServiceLinux::Observer* observer) {
+  DCHECK(CalledOnValidThread());
+  InputServiceLinux::AddObserver(observer);
+}
+
+void InputServiceLinuxImpl::RemoveObserver(
+    InputServiceLinux::Observer* observer) {
+  DCHECK(CalledOnValidThread());
+  InputServiceLinux::RemoveObserver(observer);
+}
+
+void InputServiceLinuxImpl::GetDevices(std::vector<InputDeviceInfo>* devices) {
+  DCHECK(CalledOnValidThread());
+  InputServiceLinux::GetDevices(devices);
+}
+
+bool InputServiceLinuxImpl::GetDeviceInfo(const std::string& id,
+                                          InputDeviceInfo* info) const {
+  DCHECK(CalledOnValidThread());
+  return InputServiceLinux::GetDeviceInfo(id, info);
 }
 
 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::WillDestroyCurrentMessageLoop() {
+  DCHECK(CalledOnValidThread());
+  InputServiceLinux::WillDestroyCurrentMessageLoop();
+}
+
+bool InputServiceLinuxImpl::CalledOnValidThread() const {
+  return thread_checker_.CalledOnValidThread();
+}
+
 }  // 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::InputServiceLinux() {
-  base::ThreadRestrictions::AssertIOAllowed();
-  base::MessageLoop::current()->AddDestructionObserver(this);
 }
 
 InputServiceLinux::~InputServiceLinux() {
-  DCHECK(CalledOnValidThread());
-  base::MessageLoop::current()->RemoveDestructionObserver(this);
 }
 
 // static
 InputServiceLinux* InputServiceLinux::GetInstance() {
   if (!HasInstance())
     g_input_service_linux_ptr.Get().reset(new InputServiceLinuxImpl());
   return g_input_service_linux_ptr.Get().get();
 }
 
 // static
 bool InputServiceLinux::HasInstance() {
   return g_input_service_linux_ptr.Get().get();
 }
 
 // static
 void InputServiceLinux::SetForTesting(InputServiceLinux* service) {
   g_input_service_linux_ptr.Get().reset(service);
 }
 
 void InputServiceLinux::AddObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
   if (observer)
     observers_.AddObserver(observer);
 }
 
 void InputServiceLinux::RemoveObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
   if (observer)
     observers_.RemoveObserver(observer);
 }
 
 void InputServiceLinux::GetDevices(std::vector<InputDeviceInfo>* devices) {
-  DCHECK(CalledOnValidThread());
   for (DeviceMap::iterator it = devices_.begin(), ie = devices_.end(); it != ie;
        ++it) {
     devices->push_back(it->second);
   }
 }
 
 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