Add InputEvent and EventPacket types for batched input delivery

content/common/input/input_param_traits.cc

Index: content/common/input/input_param_traits.cc
diff --git a/content/common/input/input_param_traits.cc b/content/common/input/input_param_traits.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e6eec647ef86824c63387f0ac583dce4675307b7
--- /dev/null
+++ b/content/common/input/input_param_traits.cc
@@ -0,0 +1,183 @@
+// 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 "content/common/input/input_param_traits.h"
+
+#include "content/common/content_param_traits.h"
+#include "content/common/input/generic_event.h"
+#include "content/common/input/input_event_state.h"
+
+namespace IPC {
+
+void ParamTraits<content::EventPacket>::Write(
+    Message* m, const param_type& p) {
+  DCHECK_EQ(p.events.size(), p.event_states.size());
+
+  WriteParam(m, p.id);
+  WriteParam(m, p.event_states);
+  WriteParam(m, p.events.size());
+
+  for (size_t i = 0; i < p.events.size(); ++i) {
+    const content::InputEvent* event = p.events[i];
+    switch (event->type) {
+      case content::InputEvent::GENERIC:
+        WriteParam(m, *content::GenericEvent::EventCast(event));
+        break;
+      case content::InputEvent::WEB:
+        WriteParam(m, *content::WebEvent::EventCast(event));
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+template<typename InputEventType>
+static scoped_ptr<content::InputEvent> ReadInputEvent(const Message* m,
+                                                      PickleIterator* iter) {
+  scoped_ptr<InputEventType> event = InputEventType::Create();
+  if (!ReadParam(m, iter, event.get()))
+    return scoped_ptr<InputEventType>().template PassAs<content::InputEvent>();
+  return event.template PassAs<content::InputEvent>();
+}
+
+bool ParamTraits<content::EventPacket>::Read(
+    const Message* m, PickleIterator* iter, param_type* p) {
+  int64 id;
+  std::vector<content::InputEventState> event_states;
+  size_t event_list_size;
+  if (!ReadParam(m, iter, &id) ||
+      !ReadParam(m, iter, &event_states) ||
+      !ReadParam(m, iter, &event_list_size))
+    return false;
+
+  if (event_states.size() != event_list_size)
+    return false;
+
+  ScopedVector<content::InputEvent> events;
+  for (size_t i = 0; i < event_list_size; ++i) {
+    content::InputEvent::Type type;
+    PickleIterator temp_iter = *iter;
+    if (!ReadParam(m, &temp_iter, &type))
+      return false;
+
+    scoped_ptr<content::InputEvent> event;
+    switch (type) {
+      case content::InputEvent::GENERIC:
+        event = ReadInputEvent<content::GenericEvent>(m, iter);
+        break;
+      case content::InputEvent::WEB:
+        event = ReadInputEvent<content::WebEvent>(m, iter);
+        break;
+      default:
+        break;
+    }
+    if (!event)
+      return false;
+
+    events.push_back(event.release());
+  }
+
+  p->id = id;
+  p->events.swap(events);
+  p->event_states.swap(event_states);
+  return true;
+}
+
+void ParamTraits<content::EventPacket>::Log(
+    const param_type& p, std::string* l) {
+  l->append("EventPacket((");
+  LogParam(p.id, l);
+  l->append("), ");
+  LogParam(p.event_states, l);
+  l->append("[");
+  for (size_t i = 0; i < p.events.size(); ++i) {
+    if (i)
+      l->append(", ");
+    const content::InputEvent* event = p.events[i];
+    switch (event->type) {
+      case content::InputEvent::GENERIC:
+        LogParam(*content::GenericEvent::EventCast(event), l);
+        break;
+      case content::InputEvent::WEB:
+        LogParam(*content::WebEvent::EventCast(event), l);
+        break;
+      default:
+        break;
+    }
+  }
+  l->append("])");
+}
+
+void ParamTraits<content::WebEvent>::Write(
+    Message* m, const param_type& p) {
+  ParamTraits<content::InputEvent>::Write(m, p);
+  WriteParam(m, static_cast<WebInputEventPointer>(p.event.get()));
+  WriteParam(m, p.latency_info);
+  WriteParam(m, p.is_keyboard_shortcut);
+  WriteParam(m, p.creates_followup_events);
+}
+
+
+bool ParamTraits<content::WebEvent>::Read(
+    const Message* m, PickleIterator* iter, param_type* p) {
+  if (!ParamTraits<content::InputEvent>::Read(m, iter, p))
+    return false;
+  if (p->type != content::InputEvent::WEB)
+    return false;
+
+  WebInputEventPointer web_input_event_pointer;
+  ui::LatencyInfo latency_info;
+  bool is_keyboard_shortcut;
+  bool creates_followup_events;
+  if (!ReadParam(m, iter, &web_input_event_pointer) ||
+      !ReadParam(m, iter, &latency_info) ||
+      !ReadParam(m, iter, &is_keyboard_shortcut) ||
+      !ReadParam(m, iter, &creates_followup_events))
+    return false;
+
+  p->SetAll(*web_input_event_pointer,
+            latency_info,
+            is_keyboard_shortcut,
+            creates_followup_events);
+  return true;
+}
+
+void ParamTraits<content::WebEvent>::Log(
+    const param_type& p, std::string* l) {
+  l->append("(");
+  ParamTraits<content::InputEvent>::Log(p, l);
+  l->append(", WebEvent(");
+  LogParam(static_cast<WebInputEventPointer>(p.event.get()), l);
+  l->append(", ");
+  LogParam(p.latency_info, l);
+  l->append(", ");
+  LogParam(p.is_keyboard_shortcut, l);
+  l->append(", ");
+  LogParam(p.creates_followup_events, l);
+  l->append("))");
+}
+
+}  // namespace IPC
+
+// Generate param traits write methods.
+#include "ipc/param_traits_write_macros.h"
+namespace IPC {
+#undef CONTENT_COMMON_INPUT_INPUT_PARAM_TRAITS_MACROS_H_
+#include "content/common/input/input_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits read methods.
+#include "ipc/param_traits_read_macros.h"
+namespace IPC {
+#undef CONTENT_COMMON_INPUT_INPUT_PARAM_TRAITS_MACROS_H_
+#include "content/common/input/input_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits log methods.
+#include "ipc/param_traits_log_macros.h"
+namespace IPC {
+#undef CONTENT_COMMON_INPUT_INPUT_PARAM_TRAITS_MACROS_H_
+#include "content/common/input/input_param_traits_macros.h"
+}  // namespace IPC