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

remoting/protocol/input_event_tracker.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/protocol/input_event_tracker.h"
 
 #include "base/logging.h"
+#include "base/stl_util.h"
 #include "remoting/proto/event.pb.h"
 
 namespace remoting {
 namespace protocol {
 
 InputEventTracker::InputEventTracker(InputStub* input_stub)
     : input_stub_(input_stub),
       mouse_button_state_(0) {
 }
 
 InputEventTracker::~InputEventTracker() {}
 
 bool InputEventTracker::IsKeyPressed(uint32 usb_keycode) const {
   return pressed_keys_.find(usb_keycode) != pressed_keys_.end();
 }
 
 int InputEventTracker::PressedKeyCount() const {
   return pressed_keys_.size();
 }
 
 void InputEventTracker::ReleaseAll() {

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

Now that this method is longer, I'd suggest a comment before each block, e.g.
"// Release pressed keys.", "// Cancel active touch points." etc

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

Done.

   std::set<uint32>::iterator i;
   for (i = pressed_keys_.begin(); i != pressed_keys_.end(); ++i) {

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

nit: While you're in this file, consider auto-izing this loop, for consistency
with your touch events loop, below.

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

Done.

     KeyEvent event;
     event.set_pressed(false);
     event.set_usb_keycode(*i);
     input_stub_->InjectKeyEvent(event);
   }
   pressed_keys_.clear();
 
   for (int i = MouseEvent::BUTTON_UNDEFINED + 1;
        i < MouseEvent::BUTTON_MAX; ++i) {
     if (mouse_button_state_ & (1 << (i - 1))) {
       MouseEvent mouse;
 
       // TODO(wez): EventInjectors should cope with positionless events by
       // using the current cursor position, and we wouldn't set position here.
       mouse.set_x(mouse_pos_.x());
       mouse.set_y(mouse_pos_.y());
 
       mouse.set_button((MouseEvent::MouseButton)i);
       mouse.set_button_down(false);
       input_stub_->InjectMouseEvent(mouse);
     }
   }
   mouse_button_state_ = 0;
+
+  if (!touch_point_ids_.empty()) {
+    TouchEvent cancel_all_touch_event;
+    cancel_all_touch_event.set_event_type(TouchEvent::TOUCH_POINT_CANCEL);
+    for (uint32 touch_point_id : touch_point_ids_) {
+      TouchEventPoint* point = cancel_all_touch_event.add_touch_points();
+      point->set_id(touch_point_id);
+    }
+    input_stub_->InjectTouchEvent(cancel_all_touch_event);
+    touch_point_ids_.clear();
+  }
+  DCHECK(touch_point_ids_.empty());
 }
 
 void InputEventTracker::InjectKeyEvent(const KeyEvent& event) {
   // We don't need to track the keyboard lock states of key down events.
   // Pressed keys will be released with |lock_states| set to 0.
   // The lock states of auto generated key up events don't matter as long as
   // we release all the pressed keys at blurring/disconnection time.
   if (event.has_pressed()) {
     if (event.has_usb_keycode()) {
       if (event.pressed()) {
@@ skipping 21 matching lines @@
       if (event.button_down()) {
         mouse_button_state_ |= button_change;
       } else {
         mouse_button_state_ &= ~button_change;
       }
     }
   }
   input_stub_->InjectMouseEvent(event);
 }
 
+void InputEventTracker::InjectTouchEvent(const TouchEvent& event) {
+  switch (event.event_type()) {

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

nit: Consider noting (similarly to InjectKeyEvent's comment) that we only need
the touch-point Ids in order to cancel them in ReleaseAll().

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

Done.

+    case TouchEvent::TOUCH_POINT_START:
+      for (const TouchEventPoint& touch_point : event.touch_points()) {
+        DCHECK(touch_point_ids_.find(touch_point.id()) ==
+               touch_point_ids_.end());
+        touch_point_ids_.insert(touch_point.id());
+      }
+      break;
+    case TouchEvent::TOUCH_POINT_END:
+    case TouchEvent::TOUCH_POINT_CANCEL:
+      for (const TouchEventPoint& touch_point : event.touch_points()) {
+        DCHECK(touch_point_ids_.find(touch_point.id()) !=
+               touch_point_ids_.end());
+        touch_point_ids_.erase(touch_point.id());
+      }
+      break;
+    default:
+      break;
+  }
+  input_stub_->InjectTouchEvent(event);
+}
+
 }  // namespace protocol
 }  // namespace remoting