Add InputEvent and EventPacket types for batched input delivery

content/common/input/input_param_traits.cc

+// 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/generic_input_event.h"
+#include "content/common/input/input_event_disposition.h"
+
+namespace IPC {
+
+void ParamTraits<content::EventPacket>::Write(
+    Message* m, const param_type& p) {
+  DCHECK_EQ(p.events.size(), p.dispositions.size());
+
+  WriteParam(m, p.id);
+  WriteParam(m, p.dispositions);
+  WriteParam(m, p.events.size());
+
+  for (size_t i = 0; i < p.events.size(); ++i) {
+    const content::InputEvent* event = p.events[i];
+    WriteParam(m, event->type);
+    switch (event->type) {
+      case content::InputEvent::GENERIC:
+        WriteParam(m, *content::GenericInputEvent::EventCast(event));
+        break;
+      case content::InputEvent::WEB_PLATFORM:
+        WriteParam(m, *content::WebPlatformInputEvent::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<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::InputEventDisposition> dispositions;
+  size_t event_count;
+  if (!ReadParam(m, iter, &id) ||
+      !ReadParam(m, iter, &dispositions) ||
+      !ReadParam(m, iter, &event_count))
+    return false;
+
+  if (dispositions.size() != event_count)
+    return false;
+
+  ScopedVector<content::InputEvent> events;
+  for (size_t i = 0; i < event_count; ++i) {
+    content::InputEvent::Type type;
+    if (!ReadParam(m, iter, &type))
+      return false;
+
+    scoped_ptr<content::InputEvent> event;
+    switch (type) {
+      case content::InputEvent::GENERIC:
+        event = ReadInputEvent<content::GenericInputEvent>(m, iter);
+        break;
+      case content::InputEvent::WEB_PLATFORM:
+        event = ReadInputEvent<content::WebPlatformInputEvent>(m, iter);
+        break;
+      default:
+        break;
+    }
+    if (!event)
+      return false;
+
+    events.push_back(event.release());
+  }
+
+  p->id = id;
+  p->events.swap(events);
+  p->dispositions.swap(dispositions);
+  return true;
+}
+
+void ParamTraits<content::EventPacket>::Log(
+    const param_type& p, std::string* l) {
+  l->append("EventPacket((");
+  LogParam(p.id, l);
+  l->append("), Dispositions [");
+  LogParam(p.dispositions, l);
+  l->append("], Events [");
+  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::GenericInputEvent::EventCast(event), l);
+        break;
+      case content::InputEvent::WEB_PLATFORM:
+        LogParam(*content::WebPlatformInputEvent::EventCast(event), l);
+        break;
+      default:
+        break;
+    }
+  }
+  l->append("])");
+}
+
+void ParamTraits<content::WebPlatformInputEvent>::Write(
+    Message* m, const param_type& p) {
+  ParamTraits<content::InputEvent>::Write(m, p);
+  bool valid_web_event = !!p.event;
+  DCHECK(valid_web_event);
+  WriteParam(m, valid_web_event);
+  if (valid_web_event)
+    WriteParam(m, static_cast<WebInputEventPointer>(p.event.get()));
+  WriteParam(m, p.latency_info);
+  WriteParam(m, p.is_keyboard_shortcut);
+}
+
+bool ParamTraits<content::WebPlatformInputEvent>::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_PLATFORM)
+    return false;
+
+  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::WebPlatformInputEvent>::Log(
+    const param_type& p, std::string* l) {
+  l->append("(");
+  ParamTraits<content::InputEvent>::Log(p, l);
+  l->append(", WebPlatformInputEvent(");
+  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("))");
+}
+
+}  // 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