Add touch events to the protocol, the stub layer, and to the client plugin.

remoting/client/plugin/pepper_input_handler.cc

 // Copyright (c) 2012 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 "remoting/client/plugin/pepper_input_handler.h"
 
 #include "base/logging.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/mouse_cursor.h"
 #include "ppapi/cpp/point.h"
+#include "ppapi/cpp/touch_point.h"
 #include "ppapi/cpp/var.h"
 #include "remoting/proto/event.pb.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
 
 namespace remoting {
 
 namespace {
 
 // Builds the Chromotocol lock states flags for the PPAPI |event|.
 uint32_t MakeLockStates(const pp::InputEvent& event) {
   uint32_t modifiers = event.GetModifiers();
   uint32_t lock_states = 0;
 
   if (modifiers & PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY)
     lock_states |= protocol::KeyEvent::LOCK_STATES_CAPSLOCK;
 
   if (modifiers & PP_INPUTEVENT_MODIFIER_NUMLOCKKEY)
     lock_states |= protocol::KeyEvent::LOCK_STATES_NUMLOCK;
 
   return lock_states;
 }
 
+// Creates protocol::TouchEvent instance from |pp_touch_event|.

[Wez, 2015/02/05 02:09:06]

"Creates a protocol::TouchEvent..."

[Rintaro Kuroiwa, 2015/02/06 23:35:00]

Done.

+// Note that only the changed touches are added to the TouchEvent.
+protocol::TouchEvent MakeTouchEvent(const pp::TouchInputEvent& pp_touch_event) {
+  protocol::TouchEvent touch_event;
+  protocol::TouchEvent::TouchEventType type;
+  switch (pp_touch_event.GetType()) {
+    case PP_INPUTEVENT_TYPE_TOUCHSTART:
+      type = protocol::TouchEvent::TOUCH_POINT_START;
+      break;
+    case PP_INPUTEVENT_TYPE_TOUCHMOVE:
+      type = protocol::TouchEvent::TOUCH_POINT_MOVE;
+      break;
+    case PP_INPUTEVENT_TYPE_TOUCHEND:
+      type = protocol::TouchEvent::TOUCH_POINT_END;
+      break;
+    case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
+      type = protocol::TouchEvent::TOUCH_POINT_CANCEL;
+      break;
+    default:
+      NOTREACHED() << "Unknown event type: " << pp_touch_event.GetType();
+      return touch_event;
+  }
+  touch_event.set_event_type(type);
+
+  for (uint32_t i = 0;
+       i < pp_touch_event.GetTouchCount(PP_TOUCHLIST_TYPE_CHANGEDTOUCHES);
+       ++i) {
+    pp::TouchPoint pp_point =
+        pp_touch_event.GetTouchByIndex(PP_TOUCHLIST_TYPE_CHANGEDTOUCHES, i);
+    protocol::TouchEventPoint* point = touch_event.add_touch_points();
+    point->set_id(pp_point.id());
+    point->set_x(pp_point.position().x());
+    point->set_y(pp_point.position().y());
+    point->set_radius_x(pp_point.radii().x());
+    point->set_radius_y(pp_point.radii().y());
+    point->set_angle(pp_point.rotation_angle());
+  }
+
+  return touch_event;
+}
+
 // Builds a protocol::KeyEvent from the supplied PPAPI event.
 protocol::KeyEvent MakeKeyEvent(const pp::KeyboardInputEvent& pp_key_event) {
   protocol::KeyEvent key_event;
   std::string dom_code = pp_key_event.GetCode().AsString();
   key_event.set_usb_keycode(
       ui::KeycodeConverter::CodeToUsbKeycode(dom_code.c_str()));
   key_event.set_pressed(pp_key_event.GetType() == PP_INPUTEVENT_TYPE_KEYDOWN);
   key_event.set_lock_states(MakeLockStates(pp_key_event));
   return key_event;
 }
@@ skipping 20 matching lines @@
       send_mouse_input_when_unfocused_(false),
       send_mouse_move_deltas_(false),
       wheel_delta_x_(0),
       wheel_delta_y_(0),
       wheel_ticks_x_(0),
       wheel_ticks_y_(0) {
 }
 
 bool PepperInputHandler::HandleInputEvent(const pp::InputEvent& event) {
   switch (event.GetType()) {
+    // Touch input cases.
+    case PP_INPUTEVENT_TYPE_TOUCHSTART:
+    case PP_INPUTEVENT_TYPE_TOUCHMOVE:
+    case PP_INPUTEVENT_TYPE_TOUCHEND:
+    case PP_INPUTEVENT_TYPE_TOUCHCANCEL: {
+      if (!input_stub_)
+        return true;
+      pp::TouchInputEvent pp_touch_event(event);
+      input_stub_->InjectTouchEvent(MakeTouchEvent(pp_touch_event));
+      return true;
+    }
+
     case PP_INPUTEVENT_TYPE_CONTEXTMENU: {
       // We need to return true here or else we'll get a local (plugin) context
       // menu instead of the mouseup event for the right click.
       return true;
     }
 
     case PP_INPUTEVENT_TYPE_KEYDOWN:
     case PP_INPUTEVENT_TYPE_KEYUP: {
       if (!input_stub_)
         return true;
@@ skipping 109 matching lines @@
   }
 
   return false;
 }
 
 void PepperInputHandler::DidChangeFocus(bool has_focus) {
   has_focus_ = has_focus;
 }
 
 }  // namespace remoting