chromeos: Add ArcInputBridge to components/arc

components/arc/input/arc_input_bridge.cc

Index: components/arc/input/arc_input_bridge.cc
diff --git a/components/arc/input/arc_input_bridge.cc b/components/arc/input/arc_input_bridge.cc
new file mode 100644
index 0000000000000000000000000000000000000000..64e16c3ed474bb6bf175d575a780674d55bc9c0d
--- /dev/null
+++ b/components/arc/input/arc_input_bridge.cc
@@ -0,0 +1,327 @@
+// 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 "components/arc/input/arc_input_bridge.h"
+
+#include <linux/input.h>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/sequenced_task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/time/time.h"
+#include "components/arc/arc_bridge_service.h"
+#include "ui/events/event_utils.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
+#include "ui/events/ozone/evdev/keyboard_util_evdev.h"
+
+namespace {
+
+// input_event values for keyboard events
+const int kKeyReleased = 0;
+const int kKeyPressed = 1;
+const int kKeyRepeated = 2;
+
+// maximum number of supported multi-touch slots (simultaneous fingers)
+const int kMaxSlots = 64;
+
+// tracking id of an empty slot
+const int kEmptySlot = -1;
+
+// maximum possible pressure as defined in EventHubARC.
+// todo(denniskempin): communicate maximum during initialization.
+const int kMaxPressure = 65536;
+
+struct MouseButtonMapping {
+  int ui_flag;
+  int evdev_code;
+};
+
+MouseButtonMapping kMouseButtonMap[] = {
+    {ui::EF_LEFT_MOUSE_BUTTON, BTN_LEFT},
+    {ui::EF_RIGHT_MOUSE_BUTTON, BTN_RIGHT},
+    {ui::EF_MIDDLE_MOUSE_BUTTON, BTN_MIDDLE},
+};
+
+// Weak pointer.  This class is owned by ChromeBrowserMainPartsChromeos.
+arc::ArcInputBridge* g_arc_input_bridge = nullptr;
+
+}  // namespace
+
+namespace arc {
+
+ArcInputBridge::ArcInputBridge(
+    base::WeakPtr<ArcBridgeService> arc_bridge_service,
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
+    : arc_bridge_service_(arc_bridge_service),
+      current_slot_(-1),
+      current_slot_tracking_ids_(kMaxSlots, kEmptySlot),
+      origin_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      io_task_runner_(io_task_runner),
+      weak_factory_(this) {
+  DCHECK(arc_bridge_service);
+  DCHECK(arc_bridge_service->state() == ArcBridgeService::State::STOPPED);
+  arc_bridge_service->AddObserver(this);
+  g_arc_input_bridge = this;
+}
+
+ArcInputBridge::~ArcInputBridge() {
+  if (arc_bridge_service_)
+    arc_bridge_service_->RemoveObserver(this);
+}
+
+// static
+ArcInputBridge* ArcInputBridge::Get() {
+  DCHECK(g_arc_input_bridge);
+  DCHECK(g_arc_input_bridge->origin_task_runner_->RunsTasksOnCurrentThread());
+  return g_arc_input_bridge;
+}
+
+void ArcInputBridge::OnInstanceBootPhase(InstanceBootPhase phase) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  if (phase != InstanceBootPhase::SYSTEM_SERVICES_READY)
+    return;
+
+  keyboard_fd_ = CreateBridgeInputDevice("ChromeOS Keyboard", "keyboard");
+  mouse_fd_ = CreateBridgeInputDevice("ChromeOS Mouse", "mouse");
+  touchscreen_fd_ =
+      CreateBridgeInputDevice("ChromeOS Touchscreen", "touchscreen");
+}
+
+void ArcInputBridge::SendInputEvent(ui::Event* event) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  scoped_ptr<ui::Event> copy = ui::Event::Clone(*event);
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&ArcInputBridge::SendInputEventIO,

[elijahtaylor1, 2015/12/03 06:35:19]

just wondering if you know the average thread switch and dispatch time for these
events and what it does for input latency.  Not super critical as we really just
need something functional, but unfortunate that each event incurs this cost. 
This is also a frequent event,are there any implications of dispatching them
individually over batch processing them?

[denniskempin, 2015/12/03 15:43:40]

I don't feel too comfortable about this either. Maybe we could get an Exception
for the input bridge doing IO on the UI thread. But I do not know what the
latency implications are, what I am mostly worried about is that we might get
stutter when there is something big working on the IO thread that's blocking
input from being delivered. 
It is at least not noticeable when using the device so far. We could set up some
latency comparisons later, but considering this version of the input bridge
won't last long it's probably not worth the effort.

+                            weak_factory_.GetWeakPtr(), base::Passed(&copy)));
+}
+
+void ArcInputBridge::SendInputEventIO(scoped_ptr<ui::Event> event) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+
+  if (event->IsKeyEvent()) {
+    SendKeyEventIO(static_cast<ui::KeyEvent*>(event.get()));
+  } else if (event->IsMouseEvent()) {
+    SendMouseEventIO(static_cast<ui::MouseEvent*>(event.get()));
+  } else if (event->IsTouchEvent()) {
+    SendTouchEventIO(static_cast<ui::TouchEvent*>(event.get()));
+  }
+}
+
+void ArcInputBridge::SendKeyEventIO(ui::KeyEvent* event) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+
+  if (keyboard_fd_.get() < 0) {
+    LOG(WARNING) << "No keyboard bridge device available.";
+    return;
+  }
+
+  int native_code = ui::KeycodeConverter::DomCodeToNativeKeycode(event->code());
+
+  unsigned short evdev_code = ui::NativeCodeToEvdevCode(native_code);
+  int evdev_value;
+  if (event->type() == ui::ET_KEY_PRESSED) {
+    if (event->flags() & ui::EF_IS_REPEAT) {
+      evdev_value = kKeyRepeated;
+    } else {
+      evdev_value = kKeyPressed;
+    }
+  } else if (event->type() == ui::ET_KEY_RELEASED) {
+    evdev_value = kKeyReleased;
+  }
+
+  base::TimeDelta time_stamp = event->time_stamp();
+  SendKernelEventIO(keyboard_fd_, time_stamp, EV_KEY, evdev_code, evdev_value);
+  SendSynReportIO(keyboard_fd_, time_stamp);
+}
+
+void ArcInputBridge::SendTouchEventIO(ui::TouchEvent* event) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+
+  if (touchscreen_fd_.get() < 0) {
+    LOG(WARNING) << "No touchscreen bridge device available.";
+    return;
+  }
+
+  ui::PointerDetails details = event->pointer_details();
+  base::TimeDelta time_stamp = event->time_stamp();
+
+  // find or assing a slot for this tracking id
+  int slot_id = AcquireTouchSlotIO(event);
+  if (slot_id < 0) {
+    LOG(ERROR) << "Ran out of slot IDs.";
+    return;
+  }
+
+  // we only need to send the slot ID when it has changed.
+  if (slot_id != current_slot_) {
+    current_slot_ = slot_id;
+    SendKernelEventIO(touchscreen_fd_, time_stamp, EV_ABS, ABS_MT_SLOT,
+                      current_slot_);
+  }
+
+  // update tracking id
+  if (event->type() == ui::ET_TOUCH_PRESSED) {
+    SendKernelEventIO(touchscreen_fd_, time_stamp, EV_ABS, ABS_MT_TRACKING_ID,
+                      event->touch_id());
+  } else if (event->type() == ui::ET_TOUCH_RELEASED) {
+    SendKernelEventIO(touchscreen_fd_, time_stamp, EV_ABS, ABS_MT_TRACKING_ID,
+                      kEmptySlot);
+  }
+
+  // update touch information
+  if (event->type() == ui::ET_TOUCH_MOVED ||
+      event->type() == ui::ET_TOUCH_PRESSED) {
+    SendKernelEventIO(touchscreen_fd_, time_stamp, EV_ABS, ABS_MT_POSITION_X,
+                      event->x());
+    SendKernelEventIO(touchscreen_fd_, time_stamp, EV_ABS, ABS_MT_POSITION_Y,
+                      event->y());
+    SendKernelEventIO(touchscreen_fd_, time_stamp, EV_ABS, ABS_MT_TOUCH_MAJOR,
+                      details.radius_x());
+    SendKernelEventIO(touchscreen_fd_, time_stamp, EV_ABS, ABS_MT_TOUCH_MINOR,
+                      details.radius_y());
+    SendKernelEventIO(touchscreen_fd_, time_stamp, EV_ABS, ABS_MT_PRESSURE,
+                      details.force() * kMaxPressure);
+  }
+  SendSynReportIO(touchscreen_fd_, time_stamp);
+}
+
+void ArcInputBridge::SendMouseEventIO(ui::MouseEvent* event) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+
+  if (mouse_fd_.get() < 0) {
+    LOG(WARNING) << "No mouse bridge device available.";
+    return;
+  }
+
+  base::TimeDelta time_stamp = event->time_stamp();
+
+  // update location
+  if (event->type() == ui::ET_MOUSE_MOVED) {
+    SendKernelEventIO(mouse_fd_, time_stamp, EV_ABS, ABS_X, event->x());
+    SendKernelEventIO(mouse_fd_, time_stamp, EV_ABS, ABS_Y, event->y());
+  }
+
+  // update buttons
+  if (event->type() == ui::ET_MOUSE_PRESSED ||
+      event->type() == ui::ET_MOUSE_RELEASED) {
+    int evdev_value = static_cast<int>(event->type() == ui::ET_MOUSE_PRESSED);
+    for (MouseButtonMapping mapping : kMouseButtonMap) {
+      if (event->changed_button_flags() & mapping.ui_flag) {
+        SendKernelEventIO(mouse_fd_, time_stamp, EV_KEY, mapping.evdev_code,
+                          evdev_value);
+      }
+    }
+  }
+
+  // update scroll wheel
+  if (event->IsMouseWheelEvent()) {
+    ui::MouseWheelEvent* wheel_event = static_cast<ui::MouseWheelEvent*>(event);
+    SendKernelEventIO(mouse_fd_, time_stamp, EV_REL, REL_WHEEL,
+                      wheel_event->y_offset());
+    SendKernelEventIO(mouse_fd_, time_stamp, EV_REL, REL_HWHEEL,
+                      wheel_event->x_offset());
+  }
+
+  SendSynReportIO(mouse_fd_, time_stamp);
+}
+
+void ArcInputBridge::SendKernelEventIO(const base::ScopedFD& fd,
+                                       base::TimeDelta time_stamp,
+                                       unsigned short type,
+                                       unsigned short code,
+                                       int value) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK_GE(fd.get(), 0);
+
+  // Chrome does not always use the monotonic system time for event times.
+  // For now always force the event time to the current system time.
+  // todo(denniskempin): To enable performance tracing of events we will want
+  // to use the kernel-provided monotonic time stamps of events.
+  time_stamp = ui::EventTimeForNow();

[elijahtaylor1, 2015/12/03 06:35:19]

I wonder if this might cause problems because you're generating lots of events
per ui::Event with different timestamps.  If this is temporary this is probably
ok as it seems to work.

[denniskempin, 2015/12/03 15:43:40]

As far as I can tell from the low level stuff we did on CrOS it does not really
matter. Usually it's the timestamp of the SYN event that counts for ui purposes.

+
+  struct input_event event;
+  event.time.tv_sec = time_stamp.InSeconds();
+  base::TimeDelta remainder =
+      time_stamp - base::TimeDelta::FromSeconds(event.time.tv_sec);
+  event.time.tv_usec = remainder.InMicroseconds();
+  event.type = type;
+  event.code = code;
+  event.value = value;
+
+  // Write event to file descriptor
+  int num_written = write(fd.get(), reinterpret_cast<void*>(&event),
+                          sizeof(struct input_event));
+  if (num_written != sizeof(struct input_event))
+    LOG(ERROR) << "Can't write to file descriptor";
+}
+
+void ArcInputBridge::SendSynReportIO(const base::ScopedFD& fd,
+                                     base::TimeDelta time) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+
+  SendKernelEventIO(fd, time, EV_SYN, SYN_REPORT, 0);

[elijahtaylor1, 2015/12/03 06:35:19]

you should probably use ui::EventTimeForNow here too while you're doing it above

[denniskempin, 2015/12/03 15:43:40]

it is calling the method above, so it's using the now timestamp.

[elijahtaylor1, 2015/12/04 01:38:29]

doh, code comprehension failure!

+}
+
+int ArcInputBridge::AcquireTouchSlotIO(ui::TouchEvent* event) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+
+  int slot_id;
+  if (event->type() == ui::ET_TOUCH_PRESSED) {
+    slot_id = FindTouchSlotIO(kEmptySlot);
+  } else {
+    slot_id = FindTouchSlotIO(event->touch_id());
+  }
+  if (slot_id < 0) {
+    return -1;
+  }
+
+  if (event->type() == ui::ET_TOUCH_RELEASED) {
+    current_slot_tracking_ids_[slot_id] = kEmptySlot;
+  } else if (event->type() == ui::ET_TOUCH_PRESSED) {
+    current_slot_tracking_ids_[slot_id] = event->touch_id();
+  }
+  return slot_id;
+}
+
+int ArcInputBridge::FindTouchSlotIO(int tracking_id) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+
+  for (int i = 0; i < kMaxSlots; ++i) {
+    if (current_slot_tracking_ids_[i] == tracking_id) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+base::ScopedFD ArcInputBridge::CreateBridgeInputDevice(
+    const std::string& name,
+    const std::string& device_type) {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+
+  if (!arc_bridge_service_) {
+    LOG(ERROR) << "ArcBridgeService disappeared.";
+    return base::ScopedFD();
+  }
+
+  // Create file descriptor pair for communication
+  int fd[2];
+  int res = HANDLE_EINTR(pipe(fd));
+  if (res < 0)
+    PLOG(ERROR) << "Cannot create pipe";
+
+  // The read end is sent to the instance, ownership of fd transfers.
+  if (!arc_bridge_service_->RegisterInputDevice(name, device_type,
+                                                base::ScopedFD(fd[0]))) {
+    close(fd[1]);  // close write end.
+    LOG(ERROR) << "Cannot create bridge input device";
+    return base::ScopedFD();
+  }
+
+  // return the write end
+  return base::ScopedFD(fd[1]).Pass();
+}
+
+}  // namespace arc