Refactor Udev device support in Ozone and add a DRM hotplug monitor

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"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
+#include "ui/events/ozone/device/device_event.h"
+#include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/cursor_delegate_evdev.h"
-#include "ui/events/ozone/evdev/device_manager_evdev.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/key_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 
-#if defined(USE_UDEV)
-#include "ui/events/ozone/evdev/device_manager_udev.h"
-#endif
-
 #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"
 #endif
 
 #ifndef EVIOCSCLOCKID
 #define EVIOCSCLOCKID  _IOW('E', 0xa0, int)
 #endif
 
 namespace ui {
@@ skipping 93 matching lines @@
 // run it on the FILE thread.
 void CloseInputDevice(const base::FilePath& path,
                       scoped_ptr<EventConverterEvdev> converter) {
   TRACE_EVENT1("ozone", "CloseInputDevice", "path", path.value());
   converter.reset();
 }
 
 }  // namespace
 
 EventFactoryEvdev::EventFactoryEvdev()
-    : ui_task_runner_(base::MessageLoopProxy::current()),
+    : device_manager_(NULL),
+      has_started_processing_events_(false),
+      ui_task_runner_(base::MessageLoopProxy::current()),
       file_task_runner_(base::MessageLoopProxy::current()),
       cursor_(NULL),
       dispatch_callback_(
           base::Bind(base::IgnoreResult(&EventFactoryEvdev::DispatchUiEvent),
                      base::Unretained(this))),
       weak_ptr_factory_(this) {}
 
-EventFactoryEvdev::EventFactoryEvdev(CursorDelegateEvdev* cursor)
-    : ui_task_runner_(base::MessageLoopProxy::current()),
+EventFactoryEvdev::EventFactoryEvdev(
+    CursorDelegateEvdev* cursor,
+    DeviceManager* device_manager)
+    : device_manager_(device_manager),
+      has_started_processing_events_(false),
+      ui_task_runner_(base::MessageLoopProxy::current()),
       file_task_runner_(base::MessageLoopProxy::current()),
       cursor_(cursor),
       dispatch_callback_(
           base::Bind(base::IgnoreResult(&EventFactoryEvdev::DispatchUiEvent),
                      base::Unretained(this))),
       weak_ptr_factory_(this) {}
 
 EventFactoryEvdev::~EventFactoryEvdev() { STLDeleteValues(&converters_); }
 
 void EventFactoryEvdev::DispatchUiEvent(Event* event) {
   EventFactoryOzone::DispatchEvent(event);
 }
 
 void EventFactoryEvdev::AttachInputDevice(
     const base::FilePath& path,
     scoped_ptr<EventConverterEvdev> converter) {
   TRACE_EVENT1("ozone", "AttachInputDevice", "path", path.value());
   CHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   // 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();
 }
 
-void EventFactoryEvdev::OnDeviceAdded(const base::FilePath& path) {
-  TRACE_EVENT1("ozone", "OnDeviceAdded", "path", path.value());
+void EventFactoryEvdev::OnDeviceEvent(const DeviceEvent& event) {
+  if (event.device_type() != DeviceEvent::INPUT)
+    return;
 
-  // Dispatch task to open on FILE thread, since open may block.
-  file_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&OpenInputDevice,
-                 path,
-                 &modifiers_,
-                 cursor_,
-                 ui_task_runner_,
-                 dispatch_callback_,
-                 base::Bind(&EventFactoryEvdev::AttachInputDevice,
-                            weak_ptr_factory_.GetWeakPtr(),
-                            path)));
+  switch (event.action_type()) {
+    case DeviceEvent::ADD:
+    case DeviceEvent::CHANGE: {
+      TRACE_EVENT1("ozone", "OnDeviceAdded", "path", event.path().value());
+
+      // Dispatch task to open on FILE thread, since open may block.
+      file_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&OpenInputDevice,
+                     event.path(),
+                     &modifiers_,
+                     cursor_,
+                     ui_task_runner_,
+                     dispatch_callback_,
+                     base::Bind(&EventFactoryEvdev::AttachInputDevice,
+                                weak_ptr_factory_.GetWeakPtr(),
+                                event.path())));
+    }
+      break;
+    case DeviceEvent::REMOVE: {
+      TRACE_EVENT1("ozone", "OnDeviceRemoved", "path", event.path().value());
+      DetachInputDevice(event.path());
+    }
+      break;
+  }
 }
 
 void EventFactoryEvdev::DetachInputDevice(const base::FilePath& path) {
   TRACE_EVENT1("ozone", "DetachInputDevice", "path", path.value());
   CHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   // 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();
 
     // Dispatch task to close on FILE thread, since close may block.
     file_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&CloseInputDevice, path, base::Passed(&converter)));
   }
 }
 
-void EventFactoryEvdev::OnDeviceRemoved(const base::FilePath& path) {
-  TRACE_EVENT1("ozone", "OnDeviceRemoved", "path", path.value());
-  DetachInputDevice(path);
-}
-
 void EventFactoryEvdev::StartProcessingEvents() {
   CHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
-#if defined(USE_UDEV)
-  // Scan for input devices using udev.
-  device_manager_ = CreateDeviceManagerUdev();
-#else
-  // No udev support. Scan devices manually in /dev/input.
-  device_manager_ = CreateDeviceManagerManual();
-#endif
-
-  // Scan & monitor devices.
-  device_manager_->ScanAndStartMonitoring(
-      base::Bind(&EventFactoryEvdev::OnDeviceAdded, base::Unretained(this)),
-      base::Bind(&EventFactoryEvdev::OnDeviceRemoved, base::Unretained(this)));
+  if (device_manager_ && !has_started_processing_events_) {
+    has_started_processing_events_ = true;
+    // Scan & monitor devices.
+    device_manager_->AddObserver(this);
+    device_manager_->ScanDevices(this);
+  }
 }
 
 void EventFactoryEvdev::SetFileTaskRunner(
     scoped_refptr<base::TaskRunner> task_runner) {
   file_task_runner_ = task_runner;
 }
 
 void EventFactoryEvdev::WarpCursorTo(gfx::AcceleratedWidget widget,
                                      const gfx::PointF& location) {
   if (cursor_) {
     cursor_->MoveCursorTo(widget, location);
     MouseEvent mouse_event(ET_MOUSE_MOVED,
                            cursor_->location(),
                            cursor_->location(),
                            modifiers_.GetModifierFlags(),
                            /* changed_button_flags */ 0);
     DispatchEvent(&mouse_event);
   }
 }
 
 }  // namespace ui