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;
 }
 
+// Crates protocol::TouchEvent instance from |pp_touch_event|.

[Wez, 2015/01/21 03:08:37]

s/Creates/Creates

[Rintaro Kuroiwa, 2015/01/28 01:12:29]

Done.

+// Note that only the changed touches are added to the instance.

[Wez, 2015/01/21 03:08:37]

s/instance/TouchEvent

[Rintaro Kuroiwa, 2015/01/28 01:12:29]

Done.

+protocol::TouchEvent MakeTouchEvent(const pp::TouchInputEvent& pp_touch_event) {
+  using protocol::TouchEvent;

[Wez, 2015/01/21 03:08:37]

nit: Blank line after this "using", since it's not logically part of the
following code block.

Chromoting code typically uses "using" at file scope, or not at all, FWIW, so
this usage is a little odd; suggest moving to file scope or removing.

[Rintaro Kuroiwa, 2015/01/28 01:12:29]

Not saving any lines, removing :)

+  TouchEvent touch_event;
+  TouchEvent::Point::TouchPointEventType type;
+  switch (pp_touch_event.GetType()) {
+    case PP_INPUTEVENT_TYPE_TOUCHSTART:
+      type = TouchEvent::Point::TOUCH_POINT_START;
+      break;
+    case PP_INPUTEVENT_TYPE_TOUCHMOVE:
+      type = TouchEvent::Point::TOUCH_POINT_MOVE;
+      break;
+    case PP_INPUTEVENT_TYPE_TOUCHEND:
+      type = TouchEvent::Point::TOUCH_POINT_END;
+      break;
+    case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
+      type = TouchEvent::Point::TOUCH_POINT_CANCEL;
+      break;
+    default:
+      NOTIMPLEMENTED() << "Unknown event type: " << pp_touch_event.GetType();
+      return touch_event;
+  }
+
+  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);
+    TouchEvent::Point* point = touch_event.add_touch_points();
+    point->set_event_type(type);
+    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());
+  }
+
+  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 12 matching lines @@
   return mouse_event;
 }
 
 }  // namespace
 
 PepperInputHandler::PepperInputHandler()
     : input_stub_(nullptr),
       has_focus_(false),
       send_mouse_input_when_unfocused_(false),
       send_mouse_move_deltas_(false),
+      send_touch_events_(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 (!send_touch_events_)
+        return false;
+      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