ozone: evdev: Populate keyboard list on DeviceDataManager

ui/events/ozone/evdev/event_factory_evdev.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 "ui/events/ozone/evdev/event_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 
 #include "base/debug/trace_event.h"
@@ skipping 70 matching lines @@
 #if defined(USE_EVDEV_GESTURES)
   // Touchpad or mouse: use gestures library.
   // EventReaderLibevdevCros -> GestureInterpreterLibevdevCros -> DispatchEvent
   if (UseGesturesLibraryForDevice(devinfo)) {
     scoped_ptr<GestureInterpreterLibevdevCros> gesture_interp =
         make_scoped_ptr(new GestureInterpreterLibevdevCros(
             params.id, params.modifiers, params.button_map, params.cursor,
             params.keyboard, params.gesture_property_provider,
             params.dispatch_callback));
     return make_scoped_ptr(new EventReaderLibevdevCros(
-        fd, params.path, params.id, type, gesture_interp.Pass()));
+        fd, params.path, params.id, type, devinfo, gesture_interp.Pass()));
   }
 #endif
 
   // Touchscreen: use TouchEventConverterEvdev.
   if (devinfo.HasMTAbsXY()) {
     scoped_ptr<TouchEventConverterEvdev> converter(new TouchEventConverterEvdev(
         fd, params.path, params.id, type, params.dispatch_callback));
     converter->Initialize(devinfo);
     return converter.Pass();
   }
 
   // Graphics tablet
   if (devinfo.HasAbsXY())
     return make_scoped_ptr<EventConverterEvdev>(new TabletEventConverterEvdev(
         fd, params.path, params.id, type, params.modifiers, params.cursor,
         devinfo, params.dispatch_callback));
 
   // Everything else: use EventConverterEvdevImpl.
   return make_scoped_ptr<EventConverterEvdevImpl>(new EventConverterEvdevImpl(
-      fd, params.path, params.id, type, params.modifiers,
+      fd, params.path, params.id, type, devinfo, params.modifiers,
       params.button_map, params.cursor, params.keyboard,
       params.dispatch_callback));
 }
 
 // Open an input device. Opening may put the calling thread to sleep, and
 // therefore should be run on a thread where latency is not critical. We
 // run it on a thread from the worker pool.
 //
 // This takes a TaskRunner and runs the reply on that thread, so that we
 // can hop threads if necessary (back to the UI thread).
@@ skipping 95 matching lines @@
 
   // If we have an existing device, detach it. We don't want two
   // devices with the same name open at the same time.
   if (converters_[path])
     DetachInputDevice(path);
 
   // Add initialized device to map.
   converters_[path] = converter.release();
   converters_[path]->Start();
 
-  NotifyHotplugEventObserver(*converters_[path]);
+  NotifyDeviceChange(*converters_[path]);
 }
 
 void EventFactoryEvdev::OnDeviceEvent(const DeviceEvent& event) {
   if (event.device_type() != DeviceEvent::INPUT)
     return;
 
   switch (event.action_type()) {
     case DeviceEvent::ADD:
     case DeviceEvent::CHANGE: {
       TRACE_EVENT1("ozone", "OnDeviceAdded", "path", event.path().value());
@@ skipping 46 matching lines @@
 
   // Remove device from map.
   scoped_ptr<EventConverterEvdev> converter(converters_[path]);
   converters_.erase(path);
 
   if (converter) {
     // Cancel libevent notifications from this converter. This part must be
     // on UI since the polling happens on UI.
     converter->Stop();
 
-    NotifyHotplugEventObserver(*converter);
+    NotifyDeviceChange(*converter);
 
     // Dispatch task to close from the worker pool, since close may block.
     base::WorkerPool::PostTask(
         FROM_HERE,
         base::Bind(&CloseInputDevice, path, base::Passed(&converter)),
         true);
   }
 }
 
 void EventFactoryEvdev::WarpCursorTo(gfx::AcceleratedWidget widget,
                                      const gfx::PointF& location) {
   if (cursor_) {
     cursor_->MoveCursorTo(widget, location);
     PostUiEvent(make_scoped_ptr(new MouseEvent(ET_MOUSE_MOVED,
                                                cursor_->GetLocation(),
                                                cursor_->GetLocation(),
                                                modifiers_.GetModifierFlags(),
                                                /* changed_button_flags */ 0)));
   }
 }
 
-void EventFactoryEvdev::NotifyHotplugEventObserver(
+void EventFactoryEvdev::NotifyDeviceChange(
     const EventConverterEvdev& converter) {
-  // For now the only information propagated is related to touchscreens. Ignore
-  // events for everything but touchscreens.
-  if (!converter.HasTouchscreen())
-    return;
+  if (converter.HasTouchscreen())
+    NotifyTouchscreensUpdated();
 
+  if (converter.HasKeyboard())
+    NotifyKeyboardsUpdated();
+}
+
+void EventFactoryEvdev::NotifyTouchscreensUpdated() {
   DeviceHotplugEventObserver* observer = DeviceDataManager::GetInstance();
   std::vector<TouchscreenDevice> touchscreens;
   for (auto it = converters_.begin(); it != converters_.end(); ++it) {
     if (it->second->HasTouchscreen()) {
-      touchscreens.push_back(
-          TouchscreenDevice(it->second->id(),
-                            it->second->type(),
-                            std::string(), /* Device name */
-                            it->second->GetTouchscreenSize()));
+      touchscreens.push_back(TouchscreenDevice(
+          it->second->id(), it->second->type(), std::string() /* Device name */,
+          it->second->GetTouchscreenSize()));
     }
   }
 
   observer->OnTouchscreenDevicesUpdated(touchscreens);
 }
 
+void EventFactoryEvdev::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);
+}
+
 int EventFactoryEvdev::NextDeviceId() {
   return ++last_device_id_;
 }
 
 bool EventFactoryEvdev::GetDeviceIdsByType(const EventDeviceType type,
                                            std::vector<int>* device_ids) {
   if (device_ids)
     device_ids->clear();
   std::vector<int> ids;
 
 #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.
 
   if (device_ids)
     device_ids->assign(ids.begin(), ids.end());
   return !ids.empty();
 }
 
 }  // namespace ui