Serialize a subset of WebInputEvents to protobufs.

blimp/common/input/input_event_conversions.cc

Index: blimp/common/input/input_event_conversions.cc
diff --git a/blimp/common/input/input_event_conversions.cc b/blimp/common/input/input_event_conversions.cc
new file mode 100644
index 0000000000000000000000000000000000000000..96ec96e2d6d93787bdc1e900956be3233455e319
--- /dev/null
+++ b/blimp/common/input/input_event_conversions.cc
@@ -0,0 +1,289 @@
+// 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 "blimp/common/input/input_event_conversions.h"
+
+#include "base/logging.h"
+#include "blimp/common/proto/input.pb.h"
+#include "third_party/WebKit/public/platform/WebGestureDevice.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+
+namespace blimp {
+
+namespace {
+
+blink::WebInputEvent::Type ProtoToWebInputEventType(InputMessage::Type type) {
+  switch (type) {
+    case InputMessage::Type_GestureScrollBegin:
+      return blink::WebInputEvent::Type::GestureScrollBegin;
+    case InputMessage::Type_GestureScrollEnd:
+      return blink::WebInputEvent::Type::GestureScrollEnd;
+    case InputMessage::Type_GestureScrollUpdate:
+      return blink::WebInputEvent::Type::GestureScrollUpdate;
+    case InputMessage::Type_GestureFlingStart:
+      return blink::WebInputEvent::Type::GestureFlingStart;
+    case InputMessage::Type_GestureFlingCancel:
+      return blink::WebInputEvent::Type::GestureFlingCancel;
+    case InputMessage::Type_GestureShowPress:
+      return blink::WebInputEvent::Type::GestureShowPress;
+    case InputMessage::Type_GestureTap:
+      return blink::WebInputEvent::Type::GestureTap;
+    case InputMessage::Type_GestureTapUnconfirmed:
+      return blink::WebInputEvent::Type::GestureTapUnconfirmed;
+    case InputMessage::Type_GestureTapDown:
+      return blink::WebInputEvent::Type::GestureTapDown;
+    case InputMessage::Type_GestureTapCancel:
+      return blink::WebInputEvent::Type::GestureTapCancel;
+    case InputMessage::Type_GestureDoubleTap:
+      return blink::WebInputEvent::Type::GestureDoubleTap;
+    case InputMessage::Type_GestureTwoFingerTap:
+      return blink::WebInputEvent::Type::GestureTwoFingerTap;
+    case InputMessage::Type_GestureLongPress:
+      return blink::WebInputEvent::Type::GestureLongPress;
+    case InputMessage::Type_GestureLongTap:
+      return blink::WebInputEvent::Type::GestureLongTap;
+    case InputMessage::Type_GesturePinchBegin:
+      return blink::WebInputEvent::Type::GesturePinchBegin;
+    case InputMessage::Type_GesturePinchEnd:
+      return blink::WebInputEvent::Type::GesturePinchEnd;
+    case InputMessage::Type_GesturePinchUpdate:
+      return blink::WebInputEvent::Type::GesturePinchUpdate;
+    case InputMessage::Type_Undefined:
+    default:
+      return blink::WebInputEvent::Type::Undefined;
+  }
+}
+
+InputMessage::Type WebInputEventTypeToProto(blink::WebInputEvent::Type type) {
+  switch (type) {
+    case blink::WebInputEvent::Type::GestureScrollBegin:
+      return InputMessage::Type_GestureScrollBegin;
+    case blink::WebInputEvent::Type::GestureScrollEnd:
+      return InputMessage::Type_GestureScrollEnd;
+    case blink::WebInputEvent::Type::GestureScrollUpdate:
+      return InputMessage::Type_GestureScrollUpdate;
+    case blink::WebInputEvent::Type::GestureFlingStart:
+      return InputMessage::Type_GestureFlingStart;
+    case blink::WebInputEvent::Type::GestureFlingCancel:
+      return InputMessage::Type_GestureFlingCancel;
+    case blink::WebInputEvent::Type::GestureShowPress:
+      return InputMessage::Type_GestureShowPress;
+    case blink::WebInputEvent::Type::GestureTap:
+      return InputMessage::Type_GestureTap;
+    case blink::WebInputEvent::Type::GestureTapUnconfirmed:
+      return InputMessage::Type_GestureTapUnconfirmed;
+    case blink::WebInputEvent::Type::GestureTapDown:
+      return InputMessage::Type_GestureTapDown;
+    case blink::WebInputEvent::Type::GestureTapCancel:
+      return InputMessage::Type_GestureTapCancel;
+    case blink::WebInputEvent::Type::GestureDoubleTap:
+      return InputMessage::Type_GestureDoubleTap;
+    case blink::WebInputEvent::Type::GestureTwoFingerTap:
+      return InputMessage::Type_GestureTwoFingerTap;
+    case blink::WebInputEvent::Type::GestureLongPress:
+      return InputMessage::Type_GestureLongPress;
+    case blink::WebInputEvent::Type::GestureLongTap:
+      return InputMessage::Type_GestureLongTap;
+    case blink::WebInputEvent::Type::GesturePinchBegin:
+      return InputMessage::Type_GesturePinchBegin;
+    case blink::WebInputEvent::Type::GesturePinchEnd:
+      return InputMessage::Type_GesturePinchEnd;
+    case blink::WebInputEvent::Type::GesturePinchUpdate:
+      return InputMessage::Type_GesturePinchUpdate;
+    case blink::WebInputEvent::Type::Undefined:
+    default:
+      return InputMessage::Type_Undefined;
+  }
+}
+
+blink::WebGestureDevice ProtoToWebGestureDevice(
+    const blimp::WebGestureDevice& type) {
+  switch (type) {
+    case WebGestureDevice::WebGestureDevice_Uninitialized:
+      return blink::WebGestureDevice::WebGestureDeviceUninitialized;
+    case WebGestureDevice::WebGestureDevice_Touchpad:
+      return blink::WebGestureDevice::WebGestureDeviceTouchpad;
+    case WebGestureDevice::WebGestureDevice_Touchscreen:
+      return blink::WebGestureDevice::WebGestureDeviceTouchscreen;
+  }
+  return blink::WebGestureDevice::WebGestureDeviceUninitialized;
+}
+
+blimp::WebGestureDevice WebGestureDeviceToProto(
+    const blink::WebGestureDevice& type) {
+  switch (type) {
+    case blink::WebGestureDevice::WebGestureDeviceUninitialized:
+      return WebGestureDevice::WebGestureDevice_Uninitialized;
+    case blink::WebGestureDevice::WebGestureDeviceTouchpad:
+      return WebGestureDevice::WebGestureDevice_Touchpad;
+    case blink::WebGestureDevice::WebGestureDeviceTouchscreen:
+      return WebGestureDevice::WebGestureDevice_Touchscreen;
+  }
+  return WebGestureDevice::WebGestureDevice_Uninitialized;
+}
+
+void WebGestureEventToProto(const blink::WebGestureEvent& event,
+                            GestureArgs* proto) {
+  proto->set_x(event.x);
+  proto->set_y(event.y);
+  proto->set_global_x(event.globalX);
+  proto->set_global_y(event.globalY);
+  proto->set_source_device(WebGestureDeviceToProto(event.sourceDevice));
+
+  if (event.type == blink::WebInputEvent::GestureTap ||
+      event.type == blink::WebInputEvent::GestureTapUnconfirmed ||
+      event.type == blink::WebInputEvent::GestureDoubleTap) {
+    GestureArgs::Tap* args = proto->mutable_tap();
+    args->set_tap_count(event.data.tap.tapCount);
+    args->set_width(event.data.tap.width);
+    args->set_height(event.data.tap.height);
+  } else if (event.type == blink::WebInputEvent::GestureTapDown) {
+    GestureArgs::TapDown* args = proto->mutable_tap_down();
+    args->set_width(event.data.tapDown.width);
+    args->set_height(event.data.tapDown.height);
+  } else if (event.type == blink::WebInputEvent::GestureShowPress) {
+    GestureArgs::ShowPress* args = proto->mutable_show_press();
+    args->set_width(event.data.showPress.width);
+    args->set_height(event.data.showPress.height);
+  } else if (event.type == blink::WebInputEvent::GestureLongPress) {
+    GestureArgs::LongPress* args = proto->mutable_long_press();
+    args->set_width(event.data.longPress.width);
+    args->set_height(event.data.longPress.height);
+  } else if (event.type == blink::WebInputEvent::GestureTwoFingerTap) {
+    GestureArgs::TwoFingerTap* args = proto->mutable_two_finger_tap();
+    args->set_first_finger_width(event.data.twoFingerTap.firstFingerWidth);
+    args->set_first_finger_height(
+        event.data.twoFingerTap.firstFingerHeight);
+  } else if (event.type == blink::WebInputEvent::GestureScrollBegin) {
+    GestureArgs::ScrollBegin* args = proto->mutable_scroll_begin();
+    args->set_delta_x_hint(event.data.scrollBegin.deltaXHint);
+    args->set_delta_y_hint(event.data.scrollBegin.deltaYHint);
+    args->set_target_viewport(event.data.scrollBegin.targetViewport);
+  } else if (event.type == blink::WebInputEvent::GestureScrollUpdate) {
+    GestureArgs::ScrollUpdate* args = proto->mutable_scroll_update();
+    args->set_delta_x(event.data.scrollUpdate.deltaX);
+    args->set_delta_y(event.data.scrollUpdate.deltaY);
+    args->set_velocity_x(event.data.scrollUpdate.velocityX);
+    args->set_velocity_y(event.data.scrollUpdate.velocityY);
+    args->set_previous_update_in_sequence_prevented(
+        event.data.scrollUpdate.previousUpdateInSequencePrevented);
+    args->set_prevent_propagation(
+        event.data.scrollUpdate.preventPropagation);
+    args->set_inertial(event.data.scrollUpdate.inertial);
+  } else if (event.type == blink::WebInputEvent::GestureFlingStart) {
+    GestureArgs::FlingStart* args = proto->mutable_fling_start();
+    args->set_velocity_x(event.data.flingStart.velocityX);
+    args->set_velocity_y(event.data.flingStart.velocityY);
+    args->set_target_viewport(event.data.flingStart.targetViewport);
+  } else if (event.type == blink::WebInputEvent::GestureFlingCancel) {
+    GestureArgs::FlingCancel* args = proto->mutable_fling_cancel();
+    args->set_prevent_boosting(event.data.flingCancel.preventBoosting);
+  } else if (event.type == blink::WebInputEvent::GesturePinchUpdate) {
+    GestureArgs::PinchUpdate* args = proto->mutable_pinch_update();
+    args->set_zoom_disabled(event.data.pinchUpdate.zoomDisabled);
+    args->set_scale(event.data.pinchUpdate.scale);
+  }
+}
+
+scoped_ptr<blink::WebInputEvent> ProtoToWebGestureEvent(
+    const GestureArgs& proto) {
+  scoped_ptr<blink::WebGestureEvent> event(new blink::WebGestureEvent);
+  event->x = proto.x();
+  event->y = proto.y();
+  event->globalX = proto.global_x();
+  event->globalY = proto.global_y();
+  event->sourceDevice = ProtoToWebGestureDevice(proto.source_device());
+
+  if (proto.has_tap()) {
+    event->data.tap.tapCount = proto.tap().tap_count();
+    event->data.tap.width = proto.tap().width();
+    event->data.tap.height = proto.tap().height();
+  } else if (proto.has_tap_down()) {
+    event->data.tapDown.width = proto.tap_down().width();
+    event->data.tapDown.height = proto.tap_down().height();
+  } else if (proto.has_show_press()) {
+    event->data.showPress.width = proto.show_press().width();
+    event->data.showPress.height = proto.show_press().height();
+  } else if (proto.has_long_press()) {
+    event->data.longPress.width = proto.long_press().width();
+    event->data.longPress.height = proto.long_press().height();
+  } else if (proto.has_two_finger_tap()) {
+    event->data.twoFingerTap.firstFingerWidth =
+        proto.two_finger_tap().first_finger_width();
+    event->data.twoFingerTap.firstFingerHeight =
+        proto.two_finger_tap().first_finger_height();
+  } else if (proto.has_scroll_begin()) {
+    event->data.scrollBegin.deltaXHint = proto.scroll_begin().delta_x_hint();
+    event->data.scrollBegin.deltaYHint = proto.scroll_begin().delta_y_hint();
+    event->data.scrollBegin.targetViewport =
+        proto.scroll_begin().target_viewport();
+  } else if (proto.has_scroll_update()) {
+    event->data.scrollUpdate.deltaX = proto.scroll_update().delta_x();
+    event->data.scrollUpdate.deltaY = proto.scroll_update().delta_y();
+    event->data.scrollUpdate.velocityX = proto.scroll_update().velocity_x();
+    event->data.scrollUpdate.velocityY = proto.scroll_update().velocity_y();
+    event->data.scrollUpdate.previousUpdateInSequencePrevented =
+        proto.scroll_update().previous_update_in_sequence_prevented();
+    event->data.scrollUpdate.preventPropagation =
+        proto.scroll_update().prevent_propagation();
+    event->data.scrollUpdate.inertial = proto.scroll_update().inertial();
+  } else if (proto.has_fling_start()) {
+    event->data.flingStart.velocityX = proto.fling_start().velocity_x();
+    event->data.flingStart.velocityY = proto.fling_start().velocity_y();
+    event->data.flingStart.targetViewport =
+        proto.fling_start().target_viewport();
+  } else if (proto.has_fling_cancel()) {
+    event->data.flingCancel.preventBoosting =
+        proto.fling_cancel().prevent_boosting();
+  } else if (proto.has_pinch_update()) {
+    event->data.pinchUpdate.zoomDisabled = proto.pinch_update().zoom_disabled();
+    event->data.pinchUpdate.scale = proto.pinch_update().scale();
+  }
+
+  return event.Pass();
+}
+
+}  // namespace
+
+void WebInputEventToProto(const blink::WebInputEvent& event,
+                          InputMessage* proto) {
+  // Serialize the common WebInputEvent fields.
+  proto->set_type(WebInputEventTypeToProto(event.type));
+  proto->set_timestamp_seconds(event.timeStampSeconds);
+
+  // Serialize the specific WebInputEvent fields.
+  if (event.type >= blink::WebInputEvent::Type::GestureTypeFirst &&
+      event.type <= blink::WebInputEvent::Type::GestureTypeLast) {
+    WebGestureEventToProto(*static_cast<const blink::WebGestureEvent*>(&event),
+                           proto->mutable_gesture());
+  } else {
+    NOTIMPLEMENTED();
+  }
+}
+
+scoped_ptr<blink::WebInputEvent> ProtoToWebInputEvent(
+    const InputMessage& proto) {
+  blink::WebInputEvent::Type type = ProtoToWebInputEventType(proto.type());
+
+  scoped_ptr<blink::WebInputEvent> event;
+
+  // Build the specific type of WebInputEvent and deserialize the specific
+  // fields.
+  if (type >= blink::WebInputEvent::Type::GestureTypeFirst &&
+      type <= blink::WebInputEvent::Type::GestureTypeLast) {
+    DCHECK(proto.has_gesture());
+    event = ProtoToWebGestureEvent(proto.gesture()).Pass();
+  } else {
+    NOTIMPLEMENTED();
+    return nullptr;
+  }
+
+  // Deserialize the common WebInputEvent fields.
+  event->type = type;
+  event->timeStampSeconds = proto.timestamp_seconds();
+
+  return event;
+}
+
+}  // namespace blimp