[PATCH 8/11] ozone: evdev: Plumb device changes to EventFactoryEvdev

ui/events/ozone/evdev/input_device_factory_evdev.cc

 // Copyright 2015 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/evdev/input_device_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_util_linux.h"
+#include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
 #include "ui/events/ozone/evdev/event_converter_evdev_impl.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 
 #if defined(USE_EVDEV_GESTURES)
 #include "ui/events/ozone/evdev/libgestures_glue/event_reader_libevdev_cros.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 #endif
@@ skipping 91 matching lines @@
       return DumpArrayProperty(property->GetDoubleValue(), "%lf");
       break;
     default:
       NOTREACHED();
       break;
   }
   return std::string();
 }
 
 // Dump touch device property values to a string.
-void DumpTouchDeviceStatus(InputDeviceFactoryEvdev* device_factory,
-                           GesturePropertyProvider* provider,
+void DumpTouchDeviceStatus(GesturePropertyProvider* provider,
                            std::string* status) {
   // We use DT_ALL since we want gesture property values for all devices that
   // run with the gesture library, not just mice or touchpads.
   std::vector<int> ids;
-  device_factory->GetDeviceIdsByType(DT_ALL, &ids);
+  provider->GetDeviceIdsByType(DT_ALL, &ids);
 
   // Dump the property names and values for each device.
   for (size_t i = 0; i < ids.size(); ++i) {
     std::vector<std::string> names = provider->GetPropertyNamesById(ids[i]);
     status->append("\n");
     status->append(base::StringPrintf("ID %d:\n", ids[i]));
     status->append(base::StringPrintf(
         "Device \'%s\':\n", provider->GetDeviceNameById(ids[i]).c_str()));
 
     // Note that, unlike X11, we don't maintain the "atom" concept here.
@@ skipping 222 matching lines @@
 void InputDeviceFactoryEvdev::EnableInternalKeyboard() {
   for (const auto& it : converters_) {
     EventConverterEvdev* converter = it.second;
     if (converter->type() == InputDeviceType::INPUT_DEVICE_INTERNAL &&
         converter->HasKeyboard()) {
       converter->AllowAllKeys();
     }
   }
 }
 
-bool InputDeviceFactoryEvdev::HasMouse() {
-  return GetDeviceIdsByType(DT_MOUSE, NULL);
-}
-
-bool InputDeviceFactoryEvdev::HasTouchpad() {
-  return GetDeviceIdsByType(DT_TOUCHPAD, NULL);
-}
-
 void InputDeviceFactoryEvdev::SetTouchpadSensitivity(int value) {
   SetIntPropertyForOneType(DT_TOUCHPAD, "Pointer Sensitivity", value);
   SetIntPropertyForOneType(DT_TOUCHPAD, "Scroll Sensitivity", value);
 }
 
 void InputDeviceFactoryEvdev::SetTapToClick(bool enabled) {
   SetBoolPropertyForOneType(DT_TOUCHPAD, "Tap Enable", enabled);
 }
 
 void InputDeviceFactoryEvdev::SetThreeFingerClick(bool enabled) {
@@ skipping 15 matching lines @@
 }
 
 void InputDeviceFactoryEvdev::SetTapToClickPaused(bool state) {
   SetBoolPropertyForOneType(DT_TOUCHPAD, "Tap Paused", state);
 }
 
 void InputDeviceFactoryEvdev::GetTouchDeviceStatus(
     const GetTouchDeviceStatusReply& reply) {
   scoped_ptr<std::string> status(new std::string);
 #if defined(USE_EVDEV_GESTURES)
-  DumpTouchDeviceStatus(this, gesture_property_provider_.get(), status.get());
+  DumpTouchDeviceStatus(gesture_property_provider_.get(), status.get());
 #endif
   reply.Run(status.Pass());
 }
 
 void InputDeviceFactoryEvdev::NotifyDeviceChange(
     const EventConverterEvdev& converter) {
   if (converter.HasTouchscreen())
     NotifyTouchscreensUpdated();
 
   if (converter.HasKeyboard())
     NotifyKeyboardsUpdated();
+
+  if (converter.HasMouse())
+    NotifyMouseDevicesUpdated();
+
+  if (converter.HasTouchpad())
+    NotifyMouseDevicesUpdated();
 }
 
 void InputDeviceFactoryEvdev::NotifyTouchscreensUpdated() {
-  DeviceHotplugEventObserver* observer = DeviceDataManager::GetInstance();
   std::vector<TouchscreenDevice> touchscreens;
   for (auto it = converters_.begin(); it != converters_.end(); ++it) {
     if (it->second->HasTouchscreen()) {
       // TODO(spang): Extract the number of touch-points supported by the
       // device.
       const int touch_points = 11;
       touchscreens.push_back(TouchscreenDevice(
           it->second->id(), it->second->type(), std::string() /* Device name */,
           it->second->GetTouchscreenSize(), touch_points));
     }
   }
 
-  observer->OnTouchscreenDevicesUpdated(touchscreens);
+  dispatcher_->DispatchTouchscreenDevicesUpdated(touchscreens);
 }
 
 void InputDeviceFactoryEvdev::NotifyKeyboardsUpdated() {
-  DeviceHotplugEventObserver* observer = DeviceDataManager::GetInstance();
   std::vector<KeyboardDevice> keyboards;
   for (auto it = converters_.begin(); it != converters_.end(); ++it) {
     if (it->second->HasKeyboard()) {
       keyboards.push_back(KeyboardDevice(it->second->id(), it->second->type(),
                                          std::string() /* Device name */));
     }
   }
 
-  observer->OnKeyboardDevicesUpdated(keyboards);
+  dispatcher_->DispatchKeyboardDevicesUpdated(keyboards);
 }
 
-bool InputDeviceFactoryEvdev::GetDeviceIdsByType(const EventDeviceType type,
-                                                 std::vector<int>* device_ids) {
-  if (device_ids)
-    device_ids->clear();
-  std::vector<int> ids;
+void InputDeviceFactoryEvdev::NotifyMouseDevicesUpdated() {
+  std::vector<InputDevice> mice;
+  for (auto it = converters_.begin(); it != converters_.end(); ++it) {
+    if (it->second->HasMouse()) {
+      mice.push_back(InputDevice(it->second->id(), it->second->type(),
+                                 std::string() /* Device name */));
+    }
+  }
 
-#if defined(USE_EVDEV_GESTURES)
-  // Ask GesturePropertyProvider for matching devices.
-  gesture_property_provider_->GetDeviceIdsByType(type, &ids);
-#endif
-  // In the future we can add other device matching logics here.
+  dispatcher_->DispatchMouseDevicesUpdated(mice);
+}
 
-  if (device_ids)
-    device_ids->assign(ids.begin(), ids.end());
-  return !ids.empty();
+void InputDeviceFactoryEvdev::NotifyTouchpadDevicesUpdated() {
+  std::vector<InputDevice> touchpads;
+  for (auto it = converters_.begin(); it != converters_.end(); ++it) {
+    if (it->second->HasTouchpad()) {
+      touchpads.push_back(InputDevice(it->second->id(), it->second->type(),
+                                      std::string() /* Device name */));
+    }
+  }
+
+  dispatcher_->DispatchTouchpadDevicesUpdated(touchpads);
 }
 
 void InputDeviceFactoryEvdev::SetIntPropertyForOneType(
     const EventDeviceType type,
     const std::string& name,
     int value) {
 #if defined(USE_EVDEV_GESTURES)
   std::vector<int> ids;
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
   for (size_t i = 0; i < ids.size(); ++i) {
@@ skipping 14 matching lines @@
   std::vector<int> ids;
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
   for (size_t i = 0; i < ids.size(); ++i) {
     SetGestureBoolProperty(gesture_property_provider_.get(), ids[i], name,
                            value);
   }
 #endif
 }
 
 }  // namespace ui