arc-bridge: Move most methods to Mojo interfaces

components/arc/input/arc_input_bridge_impl.cc

 // 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_impl.h"
 
 #include <linux/input.h>
 #include <fcntl.h>
 
+#include <string>
+
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/arc/arc_bridge_service.h"
+#include "third_party/mojo/src/mojo/edk/embedder/embedder.h"
 #include "ui/aura/env.h"
 #include "ui/aura/env_observer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 
 namespace {
@@ skipping 34 matching lines @@
 namespace arc {
 
 ArcInputBridgeImpl::ArcInputBridgeImpl(ArcBridgeService* arc_bridge_service)
     : arc_bridge_service_(arc_bridge_service),
       offset_x_acc_(0.5f),
       offset_y_acc_(0.5f),
       current_slot_(-1),
       current_slot_tracking_ids_(kMaxSlots, kEmptySlot),
       origin_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_factory_(this) {
-  DCHECK(arc_bridge_service->state() == ArcBridgeService::State::STOPPED);
   arc_bridge_service->AddObserver(this);
+  if (arc_bridge_service->input_instance())
+    OnInputInstanceReady();
 
   aura::Env* env = aura::Env::GetInstanceDontCreate();
   if (env)
     env->AddObserver(this);
 }
 
 ArcInputBridgeImpl::~ArcInputBridgeImpl() {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   arc_bridge_service_->RemoveObserver(this);
 
   aura::Env* env = aura::Env::GetInstanceDontCreate();
   if (env)
     env->RemoveObserver(this);
 
   for (aura::Window* window : arc_windows_.windows()) {
     window->RemovePreTargetHandler(this);
   }
 }
 
-void ArcInputBridgeImpl::OnInstanceBootPhase(InstanceBootPhase phase) {
+void ArcInputBridgeImpl::OnInputInstanceReady() {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
-  if (phase != INSTANCE_BOOT_PHASE_SYSTEM_SERVICES_READY)
-    return;
 
   keyboard_fd_ = CreateBridgeInputDevice("ChromeOS Keyboard", "keyboard");
   mouse_fd_ = CreateBridgeInputDevice("ChromeOS Mouse", "mouse");
   touchscreen_fd_ =
       CreateBridgeInputDevice("ChromeOS Touchscreen", "touchscreen");
 }
 
 // Translates and sends a ui::Event to the appropriate bridge device of the
 // ARC instance. If the devices have not yet been initialized, the event
 // will be ignored.
@@ skipping 15 matching lines @@
     new_window->AddPreTargetHandler(this);
   }
 }
 
 void ArcInputBridgeImpl::SendKeyEvent(ui::KeyEvent* event) {
   if (keyboard_fd_.get() < 0) {
     VLOG(2) << "No keyboard bridge device available.";
     return;
   }
 
-  unsigned short evdev_code = DomCodeToEvdevCode(event->code());
+  uint16_t evdev_code = DomCodeToEvdevCode(event->code());
   int evdev_value = 0;
   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;
   } else {
@@ skipping 101 matching lines @@
       SendKernelEvent(mouse_fd_, time_stamp, EV_REL, REL_HWHEEL, hwheel);
       offset_x_acc_ -= static_cast<float>(hwheel);
     }
   }
 
   SendSynReport(mouse_fd_, time_stamp);
 }
 
 void ArcInputBridgeImpl::SendKernelEvent(const base::ScopedFD& fd,
                                          base::TimeDelta time_stamp,
-                                         unsigned short type,
-                                         unsigned short code,
+                                         uint16_t type,
+                                         uint16_t code,
                                          int value) {
   DCHECK(fd.is_valid());
 
   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;
@@ skipping 33 matching lines @@
 
 int ArcInputBridgeImpl::FindTouchSlot(int tracking_id) {
   for (int i = 0; i < kMaxSlots; ++i) {
     if (current_slot_tracking_ids_[i] == tracking_id) {
       return i;
     }
   }
   return -1;
 }
 
-unsigned short ArcInputBridgeImpl::DomCodeToEvdevCode(ui::DomCode dom_code) {
+uint16_t ArcInputBridgeImpl::DomCodeToEvdevCode(ui::DomCode dom_code) {
   int native_code = ui::KeycodeConverter::DomCodeToNativeKeycode(dom_code);
   if (native_code == ui::KeycodeConverter::InvalidNativeKeycode())
     return KEY_RESERVED;
 
   return native_code - kXkbKeycodeOffset;
 }
 
 base::ScopedFD ArcInputBridgeImpl::CreateBridgeInputDevice(
     const std::string& name,
     const std::string& device_type) {
   if (!arc_bridge_service_) {
     VLOG(1) << "ArcBridgeService disappeared.";
     return base::ScopedFD();
   }
 
   // Create file descriptor pair for communication
   int fd[2];
   int res = HANDLE_EINTR(pipe(fd));
   if (res < 0) {
     VPLOG(1) << "Cannot create pipe";
     return base::ScopedFD();
   }
   base::ScopedFD read_fd(fd[0]);
   base::ScopedFD write_fd(fd[1]);
 
   // The read end is sent to the instance, ownership of fd transfers.
-  if (!arc_bridge_service_->RegisterInputDevice(name, device_type,
-                                                std::move(read_fd))) {
-    VLOG(1) << "Cannot create bridge input device";
+  InputInstance* input_instance = arc_bridge_service_->input_instance();
+  if (!input_instance) {
+    VLOG(1) << "ArcBridgeService InputInstance disappeared.";
     return base::ScopedFD();
   }
+  MojoHandle wrapped_handle;
+  MojoResult wrap_result = mojo::embedder::CreatePlatformHandleWrapper(
+      mojo::embedder::ScopedPlatformHandle(
+          mojo::embedder::PlatformHandle(read_fd.release())),
+      &wrapped_handle);
+  if (wrap_result != MOJO_RESULT_OK) {
+    LOG(WARNING) << "Pipe failed to wrap handles. Closing: " << wrap_result;
+    return base::ScopedFD();
+  }
+  input_instance->RegisterInputDevice(
+      name, device_type, mojo::ScopedHandle(mojo::Handle(wrapped_handle)));
 
   // setup write end as non blocking
   int flags = HANDLE_EINTR(fcntl(write_fd.get(), F_GETFL, 0));
   if (res < 0) {
     VPLOG(1) << "Cannot get file descriptor flags";
     return base::ScopedFD();
   }
 
   res = HANDLE_EINTR(fcntl(write_fd.get(), F_SETFL, flags | O_NONBLOCK));
   if (res < 0) {
     VPLOG(1) << "Cannot set file descriptor flags";
     return base::ScopedFD();
   }
   return write_fd;
 }
 
 scoped_ptr<ArcInputBridge> ArcInputBridge::Create(
     ArcBridgeService* arc_bridge_service) {
   return make_scoped_ptr(new ArcInputBridgeImpl(arc_bridge_service));
 }
 
 }  // namespace arc