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..f1869440fa0b85200e43c8af3c800fce3f777780
--- /dev/null
+++ b/content/common/input/input_param_traits.cc
@@ -0,0 +1,134 @@
+// 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/content_param_traits.h"
+#include "content/common/input/input_event_disposition.h"
+#include "content/common/input/ipc_input_event_payload.h"
+#include "content/common/input/web_input_event_payload.h"
+#include "content/common/input_messages.h"
+
+namespace IPC {
+namespace {
+template<typename PayloadType>
+scoped_ptr<content::InputEvent::Payload> ReadPayload(const Message* m,
+                                                     PickleIterator* iter) {
+  scoped_ptr<PayloadType> event = PayloadType::Create();
+  if (!ReadParam(m, iter, event.get()))
+    return scoped_ptr<content::InputEvent::Payload>();
+  return event.template PassAs<content::InputEvent::Payload>();
+}
+}  // namespace
+
+void ParamTraits<content::InputEvent>::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, p.id());
+  WriteParam(m, !!p.payload());
+  if (!p.payload())
+    return;
+
+  content::InputEvent::Payload::Type payload_type = p.payload()->GetType();
+  WriteParam(m, payload_type);
+  switch (payload_type) {
+    case content::InputEvent::Payload::IPC_MESSAGE:
+      WriteParam(m, *content::IPCInputEventPayload::Cast(p.payload()));
+      break;
+    case content::InputEvent::Payload::WEB_INPUT_EVENT:
+      WriteParam(m, *content::WebInputEventPayload::Cast(p.payload()));
+      break;
+    default:
+      break;
+  }
+}
+
+bool ParamTraits<content::InputEvent>::Read(
+    const Message* m, PickleIterator* iter, param_type* p) {
+  int64 id;
+  bool has_payload = false;
+  content::InputEvent::Payload::Type payload_type;
+  if (!ReadParam(m, iter, &id) ||
+      !ReadParam(m, iter, &has_payload) ||
+      !has_payload ||
+      !ReadParam(m, iter, &payload_type))
+    return false;
+
+  scoped_ptr<content::InputEvent::Payload> payload;
+  switch (payload_type) {
+    case content::InputEvent::Payload::IPC_MESSAGE:
+      payload = ReadPayload<content::IPCInputEventPayload>(m, iter);
+      break;
+    case content::InputEvent::Payload::WEB_INPUT_EVENT:
+      payload = ReadPayload<content::WebInputEventPayload>(m, iter);
+      break;
+    default:
+      break;
+  }
+  if (!payload)
+    return false;
+
+  p->Initialize(id, payload.Pass());
+  return true;
+}
+
+void ParamTraits<content::InputEvent>::Log(
+    const param_type& p, std::string* l) {
+  l->append("InputEvent((");
+  LogParam(p.id(), l);
+  l->append("), Payload (");
+  const content::InputEvent::Payload* payload = p.payload();
+  switch (payload->GetType()) {
+    case content::InputEvent::Payload::IPC_MESSAGE:
+      LogParam(*content::IPCInputEventPayload::Cast(payload), l);
+      break;
+    case content::InputEvent::Payload::WEB_INPUT_EVENT:
+      LogParam(*content::WebInputEventPayload::Cast(payload), l);
+      break;
+    default:
+      break;
+  }
+  l->append("))");

[aelias_OOO_until_Jul13, 2013/09/03 22:31:10]

Nit: unbalanced parens

[jdduke (slow), 2013/09/03 22:52:14]

Hmm, I think this is balanced, we just have Payload nested inside InputEvent.

+}
+
+void ParamTraits<content::WebInputEventPayload>::Write(
+    Message* m, const param_type& p) {
+  bool valid_web_event = !!p.web_event();
+  WriteParam(m, valid_web_event);
+  if (valid_web_event)
+    WriteParam(m, p.web_event());
+  WriteParam(m, p.latency_info());
+  WriteParam(m, p.is_keyboard_shortcut());
+}
+
+bool ParamTraits<content::WebInputEventPayload>::Read(
+    const Message* m, PickleIterator* iter, param_type* p) {
+  bool valid_web_event;
+  WebInputEventPointer web_input_event_pointer;
+  ui::LatencyInfo latency_info;
+  bool is_keyboard_shortcut;
+  if (!ReadParam(m, iter, &valid_web_event) ||
+      !valid_web_event ||
+      !ReadParam(m, iter, &web_input_event_pointer) ||
+      !ReadParam(m, iter, &latency_info) ||
+      !ReadParam(m, iter, &is_keyboard_shortcut))
+    return false;
+
+  p->Initialize(*web_input_event_pointer,
+                latency_info,
+                is_keyboard_shortcut);
+  return true;
+}
+
+void ParamTraits<content::WebInputEventPayload>::Log(
+    const param_type& p, std::string* l) {
+  l->append("WebInputEventPayload(");
+  LogParam(p.web_event(), l);
+  l->append(", ");
+  LogParam(p.latency_info(), l);
+  l->append(", ");
+  LogParam(p.is_keyboard_shortcut(), l);
+  l->append(")");
+}
+
+}  // namespace IPC