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

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/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)

[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
 // therefore should be run on a thread where latency is not critical. We
 // run it on the FILE thread.
 //
 // This takes a TaskRunner and runs the reply on that thread, so that we
 // can hop threads if necessary (back to the UI thread).
 void OpenInputDevice(
     const base::FilePath& path,
     EventModifiersEvdev* modifiers,
     CursorDelegateEvdev* cursor,
     scoped_refptr<base::TaskRunner> reply_runner,
     base::Callback<void(scoped_ptr<EventConverterEvdev>)> reply_callback) {
   TRACE_EVENT1("ozone", "OpenInputDevice", "path", path.value());
 
   int fd = open(path.value().c_str(), O_RDONLY | O_NONBLOCK);
   if (fd < 0) {
     PLOG(ERROR) << "Cannot open '" << path.value();
     return;
   }
 
   EventDeviceInfo devinfo;
   if (!devinfo.Initialize(fd)) {
     LOG(ERROR) << "failed to get device information for " << path.value();
     close(fd);
     return;
   }
 
-  if (IsTouchPad(devinfo)) {
-    LOG(WARNING) << "touchpad device not supported: " << path.value();
-    close(fd);
-    return;
-  }
+  scoped_ptr<EventConverterEvdev> converter =
+      CreateConverter(fd, path, devinfo, modifiers, cursor);
 
-  // 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));
-
-  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
 // therefore should be run on a thread where latency is not critical. We
 // 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();
 }
@@ skipping 99 matching lines @@
     cursor_->MoveCursorTo(widget, location);
   scoped_ptr<Event> ev(new MouseEvent(ET_MOUSE_MOVED,
                                       cursor_->location(),
                                       cursor_->location(),
                                       modifiers_.GetModifierFlags(),
                                       /* changed_button_flags */ 0));
   DispatchEvent(ev.Pass());
 }
 
 }  // namespace ui