ozone: evdev: Add libgestures bindings for touchpad & mouse support

ui/events/ozone/evdev/event_factory_evdev.cc

Index: ui/events/ozone/evdev/event_factory_evdev.cc
diff --git a/ui/events/ozone/evdev/event_factory_evdev.cc b/ui/events/ozone/evdev/event_factory_evdev.cc
index 9e66505f3b20dd705cc37e0e106ff2f672fc1c3c..1b566de125538431c322590b2ada4e0124d13626 100644
--- a/ui/events/ozone/evdev/event_factory_evdev.cc
+++ b/ui/events/ozone/evdev/event_factory_evdev.cc
@@ -20,20 +20,56 @@
 #include "ui/events/ozone/evdev/device_manager_udev.h"
 #endif
 
+#if defined(USE_EVDEV_GESTURES)

[rjkroege, 2014/03/11 12:58:47]

do we ever not want to use evdev_gestures?

[spang, 2014/03/11 16:38:11]

It is only present on chromeos.

My suspicion is that we should choose our battles with respect to moving code
around. Let's use the one from the system, and keep an ifdef. Only bona fide
ChromeOS builds have any use for this code.

If we want it everywhere, it obviously must go into third_party, but I am not
sure doing that is really worth the effort at this time.

+#include "ui/events/ozone/evdev/gestures/event_reader_libevdev_cros.h"
+#include "ui/events/ozone/evdev/gestures/gesture_interpreter_libevdev_cros.h"
+#endif
+
 namespace ui {
 
 namespace {
 
-bool IsTouchPad(const EventDeviceInfo& devinfo) {
-  if (!devinfo.HasEventType(EV_ABS))
-    return false;
+bool UseGesturesLibraryForDevice(const EventDeviceInfo& devinfo) {
+  if (devinfo.HasAbsXY() && !devinfo.IsMappedToScreen())
+    return true;  // touchpad
 
-  return devinfo.HasKeyEvent(BTN_LEFT) || devinfo.HasKeyEvent(BTN_MIDDLE) ||
-         devinfo.HasKeyEvent(BTN_RIGHT) || devinfo.HasKeyEvent(BTN_TOOL_FINGER);
+  if (devinfo.HasRelXY())
+    return true;  // mouse
+
+  return false;
 }
 
-bool IsTouchScreen(const EventDeviceInfo& devinfo) {
-  return devinfo.HasEventType(EV_ABS) && !IsTouchPad(devinfo);
+scoped_ptr<EventConverterEvdev> CreateConverter(int fd,
+                                                const base::FilePath& path,
+                                                const EventDeviceInfo& devinfo,
+                                                EventModifiersEvdev* modifiers,
+                                                CursorDelegateEvdev* cursor) {
+#if defined(USE_EVDEV_GESTURES)
+  // Touchpad: use gestures library.
+  // EventReaderLibevdevCros -> GestureInterpreterLibevdevCros -> DispatchEvent
+  if (UseGesturesLibraryForDevice(devinfo)) {
+    EventDispatchCallback dispatch =
+        base::Bind(&EventFactoryOzone::DispatchEvent);
+    scoped_ptr<GestureInterpreterLibevdevCros> gesture_interp = make_scoped_ptr(
+        new GestureInterpreterLibevdevCros(modifiers, cursor, dispatch));
+    scoped_ptr<EventReaderLibevdevCros> libevdev_reader =
+        make_scoped_ptr(new EventReaderLibevdevCros(
+            fd,
+            path,
+            gesture_interp.PassAs<EventReaderLibevdevCros::Delegate>()));
+    return libevdev_reader.PassAs<EventConverterEvdev>();
+  }
+#endif
+
+  // Touchscreen: use TouchEventConverterEvdev.
+  scoped_ptr<EventConverterEvdev> converter;
+  if (devinfo.HasAbsXY())
+    return make_scoped_ptr<EventConverterEvdev>(
+        new TouchEventConverterEvdev(fd, path, devinfo));
+
+  // Everything else: use KeyEventConverterEvdev.
+  return make_scoped_ptr<EventConverterEvdev>(
+      new KeyEventConverterEvdev(fd, path, modifiers));
 }
 
 // Open an input device. Opening may put the calling thread to sleep, and
@@ -63,26 +99,12 @@ void OpenInputDevice(
     return;
   }
 
-  if (IsTouchPad(devinfo)) {
-    LOG(WARNING) << "touchpad device not supported: " << path.value();
-    close(fd);
-    return;
-  }
-
-  // TODO(spang) Add more device types.
-  scoped_ptr<EventConverterEvdev> converter;
-  if (IsTouchScreen(devinfo))
-    converter.reset(new TouchEventConverterEvdev(fd, path, devinfo));
-  else if (devinfo.HasEventType(EV_KEY))
-    converter.reset(new KeyEventConverterEvdev(fd, path, modifiers));
+  scoped_ptr<EventConverterEvdev> converter =
+      CreateConverter(fd, path, devinfo, modifiers, cursor);
 
-  if (converter) {
-    // Reply with the constructed converter.
-    reply_runner->PostTask(
-        FROM_HERE, base::Bind(reply_callback, base::Passed(&converter)));
-  } else {
-    close(fd);
-  }
+  // Reply with the constructed converter.
+  reply_runner->PostTask(FROM_HERE,
+                         base::Bind(reply_callback, base::Passed(&converter)));
 }
 
 // Close an input device. Closing may put the calling thread to sleep, and