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

remoting/protocol/touch_input_filter.cc

Index: remoting/protocol/touch_input_filter.cc
diff --git a/remoting/protocol/touch_input_filter.cc b/remoting/protocol/touch_input_filter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..39f9708788f4fedaadf10fd64dae20860a28e12c
--- /dev/null
+++ b/remoting/protocol/touch_input_filter.cc
@@ -0,0 +1,65 @@
+// Copyright (c) 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 "remoting/protocol/touch_input_filter.h"
+
+#include "remoting/proto/event.pb.h"
+
+namespace remoting {
+namespace protocol {
+
+namespace {
+// |value| is the number to be scaled. |output_max| is the output desktop's max
+// height or width. |input_max| is the input desktop's max height or width.
+float ScaleAndClamp(float value, int output_max, int input_max) {
+  float scale = static_cast<float>(output_max) / input_max;
+  float new_value = value * scale;
+  return std::max(0.0f, std::min(static_cast<float>(output_max), new_value));

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

This seems a convoluted way to get the effect you want!

You can do the following:

value *= output_max
value /= input_max

Since value is float that shouldn't lose you any precision with the sorts of
values we're dealing with.

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

Done.

+}
+}  // namespace
+
+TouchInputFilter::TouchInputFilter() {

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

You can use c++11 default constructor here (i.e. =default syntax)

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

wow, C++11 :)
Done

+}
+
+TouchInputFilter::TouchInputFilter(InputStub* input_stub)
+    : InputFilter(input_stub) {
+}
+
+TouchInputFilter::~TouchInputFilter() {
+}
+
+void TouchInputFilter::InjectTouchEvent(const TouchEvent& event) {
+  if (input_max_.is_empty() || output_max_.is_empty())
+    return;
+
+  // We scale based on the maximum input & output coordinates, rather than the
+  // input and output sizes, so that it's possible to reach the edge of the
+  // output when up-scaling.  We also take care to round up or down correctly,
+  // which is important when down-scaling.

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

Thinking Out Loud: It does seem a shame to be constructing a new TouchEvent even
when the two sizes match, and the original event has valid contents; probably
not worth optimizing, though.

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

Since I'm implementing the client side atm, WDYT about only scaling in this
class? Then if the desktop sizes match, I can immediately delegate to
InputFilter::InjectTouchEvent() without making a copy?
Clamping would have to happen on host if the coordinates are outside the range.

+  TouchEvent out_event(event);
+  for (int i = 0; i < out_event.touch_points().size(); ++i) {
+    TouchEvent::Point* point = out_event.mutable_touch_points(i);
+    if (point->has_x()) {

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

Is it possible for events to have an X coordinate but not Y, or vice versa? If
not then consider checking those fields in a single if() here, and ignoring the
event entirely if it's malformed.

Alternatively, you might consider sanity-checking the event for the presence of
X & Y fields in the HostEventDispatcher, so that this code needn't bother
(though we typically don't use that approach for the other input types).

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

No, there is X iff Y. Making this || and DCHECKing to make sure it is &&.

Actually, none of the fields, except the ID, are necessary for END and CANCEL
events because the host should have all the other information from the previous
events. Realized this when changing InputEventTracker.

+      point->set_x(
+          ScaleAndClamp(point->x(), output_max_.width(), input_max_.width()));
+    }
+    if (point->has_y()) {
+      point->set_y(
+          ScaleAndClamp(point->y(), output_max_.height(), input_max_.height()));
+    }
+  }
+
+  InputFilter::InjectTouchEvent(out_event);
+}
+
+void TouchInputFilter::set_input_size(const webrtc::DesktopSize& size) {
+  input_max_.set(size.width() - 1, size.height() - 1);
+}
+
+void TouchInputFilter::set_output_size(const webrtc::DesktopSize& size) {
+  output_max_.set(size.width() - 1, size.height() - 1);
+}
+
+}  // namespace protocol
+}  // namespace remoting