Add InputEvent and EventPacket types for batched input delivery

content/common/input/input_param_traits_unittest.cc

Index: content/common/input/input_param_traits_unittest.cc
diff --git a/content/common/input/input_param_traits_unittest.cc b/content/common/input/input_param_traits_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5e826cbfc3f23d7c49986d024f86542bbf6291cd
--- /dev/null
+++ b/content/common/input/input_param_traits_unittest.cc
@@ -0,0 +1,207 @@
+// Copyright (c) 2013 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 "content/common/input/input_param_traits.h"
+
+#include "content/common/input/event_packet.h"
+#include "content/common/input/generic_input_event.h"
+#include "content/common/input/input_event.h"
+#include "content/common/input_messages.h"
+#include "ipc/ipc_message.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+
+namespace content {
+namespace {
+
+class InputParamTraitsTest : public testing::Test {
+ protected:
+  void Compare(const WebPlatformInputEvent* a, const WebPlatformInputEvent* b) {
+    EXPECT_EQ(!!a->event, !!b->event);
+    if (a->event && b->event) {
+      ASSERT_EQ(a->event->size, b->event->size);
+      EXPECT_EQ(0, memcmp(a->event.get(), b->event.get(), a->event->size));
+    }
+    EXPECT_EQ(a->latency_info.latency_components.size(),
+              b->latency_info.latency_components.size());
+    EXPECT_EQ(a->is_keyboard_shortcut, b->is_keyboard_shortcut);
+  }
+
+  void Compare(const GenericInputEvent* a, const GenericInputEvent* b) {
+    EXPECT_EQ(!!a->message, !!b->message);
+    if (a->message && b->message) {
+      EXPECT_EQ(a->message->type(), b->message->type());
+      EXPECT_EQ(a->message->routing_id(), b->message->routing_id());
+    }
+  }
+
+  void Compare(const InputEvent* a, const InputEvent* b) {
+    ASSERT_EQ(a->type, b->type);
+    EXPECT_EQ(a->ack_type, b->ack_type);
+    EXPECT_EQ(a->id, b->id);
+    switch (a->type) {
+      case InputEvent::GENERIC:
+        Compare(GenericInputEvent::EventCast(a),
+                GenericInputEvent::EventCast(b));
+        break;
+      case InputEvent::WEB_PLATFORM:
+        Compare(WebPlatformInputEvent::EventCast(a),
+                WebPlatformInputEvent::EventCast(b));
+      default:
+        break;
+    }
+  }
+
+  void Compare(const EventPacket* a, const EventPacket* b) {
+    EXPECT_EQ(a->id, b->id);
+    EXPECT_EQ(a->dispositions, b->dispositions);
+    ASSERT_EQ(a->events.size(), b->events.size());
+    for (size_t i = 0; i < a->events.size(); ++i)
+      Compare(a->events[i], b->events[i]);
+  }
+
+  void Verify(const EventPacket& packet_in) {
+    ASSERT_EQ(packet_in.events.size(), packet_in.dispositions.size());
+
+    IPC::Message msg;
+    IPC::ParamTraits<EventPacket>::Write(&msg, packet_in);
+
+    EventPacket packet_out;
+    PickleIterator iter(msg);
+    EXPECT_TRUE(IPC::ParamTraits<EventPacket>::Read(&msg, &iter, &packet_out));
+
+    Compare(&packet_in, &packet_out);
+
+    // Perform a sanity check that logging doesn't explode.
+    std::string packet_in_string;
+    IPC::ParamTraits<EventPacket>::Log(packet_in, &packet_in_string);
+    std::string packet_out_string;
+    IPC::ParamTraits<EventPacket>::Log(packet_out, &packet_out_string);
+    ASSERT_FALSE(packet_in_string.empty());
+    EXPECT_EQ(packet_in_string, packet_out_string);
+  }
+};
+
+TEST_F(InputParamTraitsTest, EventPacketEmpty) {
+  EventPacket packet_in;
+  IPC::Message msg;
+  IPC::ParamTraits<EventPacket>::Write(&msg, packet_in);
+
+  EventPacket packet_out;
+  PickleIterator iter(msg);
+  EXPECT_TRUE(IPC::ParamTraits<EventPacket>::Read(&msg, &iter, &packet_out));
+
+  Compare(&packet_in, &packet_out);
+}
+
+#ifdef NDEBUG  // This test triggers a DCHECK.
+TEST_F(InputParamTraitsTest, EventPacketUninitializedEvents) {
+  EventPacket packet_in;
+  packet_in.id = 1;
+  packet_in.Add(GenericInputEvent::Create(), INPUT_EVENT_UNHANDLED);
+  packet_in.Add(WebPlatformInputEvent::Create(), INPUT_EVENT_UNHANDLED);
+
+  IPC::Message msg;
+  IPC::ParamTraits<EventPacket>::Write(&msg, packet_in);
+
+  EventPacket packet_out;
+  PickleIterator iter(msg);
+  EXPECT_FALSE(IPC::ParamTraits<EventPacket>::Read(&msg, &iter, &packet_out));
+}
+#endif
+
+TEST_F(InputParamTraitsTest, EventPacketGenericEvents) {
+  EventPacket packet_in;
+  packet_in.id = 1;
+
+  packet_in.Add(
+      GenericInputEvent::Create(
+          1, scoped_ptr<IPC::Message>(new InputMsg_Undo(1))),
+      INPUT_EVENT_UNHANDLED);
+
+  Verify(packet_in);
+}
+
+TEST_F(InputParamTraitsTest, EventPacketWebPlatformEvents) {
+  EventPacket packet_in;
+  packet_in.id = 1;
+
+  ui::LatencyInfo latency;
+
+  WebKit::WebKeyboardEvent key_event;
+  key_event.type = WebKit::WebInputEvent::RawKeyDown;
+  key_event.nativeKeyCode = 5;
+  packet_in.Add(
+      WebPlatformInputEvent::Create(1, key_event, latency, true, false),
+      INPUT_EVENT_UNHANDLED);
+
+  WebKit::WebMouseWheelEvent wheel_event;
+  wheel_event.type = WebKit::WebInputEvent::MouseWheel;
+  wheel_event.deltaX = 10;
+  latency.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_RWH_COMPONENT, 1, 1);
+  packet_in.Add(
+      WebPlatformInputEvent::Create(2, wheel_event, latency, false, false),
+      INPUT_EVENT_UNHANDLED);
+
+  WebKit::WebMouseEvent mouse_event;
+  mouse_event.type = WebKit::WebInputEvent::MouseDown;
+  mouse_event.x = 10;
+  latency.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 2, 2);
+  packet_in.Add(
+      WebPlatformInputEvent::Create(3, mouse_event, latency, false, false),
+      INPUT_EVENT_UNHANDLED);
+
+  WebKit::WebGestureEvent gesture_event;
+  gesture_event.type = WebKit::WebInputEvent::GestureScrollBegin;
+  gesture_event.x = -1;
+  packet_in.Add(
+      WebPlatformInputEvent::Create(4, gesture_event, latency, false, false),
+      INPUT_EVENT_UNHANDLED);
+
+  WebKit::WebTouchEvent touch_event;
+  touch_event.type = WebKit::WebInputEvent::TouchStart;
+  touch_event.touchesLength = 1;
+  touch_event.touches[0].radiusX = 1;
+  packet_in.Add(
+      WebPlatformInputEvent::Create(5, touch_event, latency, false, false),
+      INPUT_EVENT_COULD_NOT_DELIVER);
+
+  Verify(packet_in);
+}
+
+TEST_F(InputParamTraitsTest, EventPacketMixedEvents) {
+  EventPacket packet_in;
+  packet_in.id = 1;
+
+  // Add some valid GenericEvents.
+  packet_in.Add(
+      GenericInputEvent::Create(
+          1, scoped_ptr<IPC::Message>(new InputMsg_Undo(1))),
+      INPUT_EVENT_UNHANDLED);
+
+  ui::LatencyInfo latency;
+
+  WebKit::WebKeyboardEvent key_event;
+  key_event.type = WebKit::WebInputEvent::RawKeyDown;
+  key_event.nativeKeyCode = 5;
+  packet_in.Add(
+      WebPlatformInputEvent::Create(2, key_event, latency, true, false),
+      INPUT_EVENT_UNHANDLED);
+
+  packet_in.Add(GenericInputEvent::Create(
+          3, scoped_ptr<IPC::Message>(new InputMsg_SetFocus(2, true))),
+      INPUT_EVENT_UNHANDLED);
+
+  WebKit::WebMouseWheelEvent wheel_event;
+  wheel_event.type = WebKit::WebInputEvent::MouseWheel;
+  wheel_event.deltaX = 10;
+  packet_in.Add(
+      WebPlatformInputEvent::Create(4, wheel_event, latency, false, false),
+      INPUT_EVENT_UNHANDLED);
+
+  Verify(packet_in);
+}
+
+}  // namespace
+}  // namespace content