Add InputEvent and EventPacket types for batched input delivery

content/common/input/input_param_traits.h

Index: content/common/input/input_param_traits.h
diff --git a/content/common/input/input_param_traits.h b/content/common/input/input_param_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..f82a4c825dfb16e6d0bf761373c1f56fc53488fd
--- /dev/null
+++ b/content/common/input/input_param_traits.h
@@ -0,0 +1,72 @@
+// 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.
+
+// This file defines IPC::ParamTraits<> specializations for several
+// input-related types that require manual serialiation code.
+
+#ifndef CONTENT_COMMON_INPUT_INPUT_PARAM_TRAITS_H_
+#define CONTENT_COMMON_INPUT_INPUT_PARAM_TRAITS_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "content/common/content_param_traits_macros.h"
+#include "content/common/input/input_event.h"
+#include "content/common/input/web_input_event_payload.h"
+
+namespace IPC {
+
+// TODO(jdduke): There should be a common copy of this utility somewhere...
+// Move or remove appropriately.
+template<class P>
+struct ParamTraits<scoped_ptr<P> > {
+  typedef scoped_ptr<P> param_type;
+  static void Write(Message* m, const param_type& p) {
+    bool valid = !!p;
+    WriteParam(m, valid);
+    if (valid)
+      WriteParam(m, *p);
+  }
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
+    bool valid = false;
+    if (!ReadParam(m, iter, &valid))
+      return false;
+
+    if (!valid) {
+      r->reset();
+      return true;
+    }
+
+    param_type temp(new P());

[palmer, 2013/09/03 23:12:47]

Just to make sure I understand: You allocate a new P so that you don't update
|r| in the event that ReadParam fails — you want to leave |r| unchanged in case
of failure. But, for performance, can you change the interface to be, "Dear
caller, if this returns false, don't count on |r| being what it was before." ?

It seems like invoking new potentially often while serializing for IPC could be
slow.

If it is too late to change this or woudl break existing code or if I don't know
what I am talking about, feel free to ignore me. Just a thought I had.

[jdduke (slow), 2013/09/04 17:53:24]

Well, param_type* r is a pointer to any empty scoped_ptr, meaning nothing has
been new'ed or allocated before the call to Read(). That is, we only allocate
the memory once, and we swap the allocated pointer with the empty scoped_ptr
that was passed in. I'm not sure that we can get more optimal than that?

[jdduke (slow), 2013/09/05 00:01:21]

Or perhaps you meant we should go ahead and assign the allocated memory to the
scoped_ptr, and simply return false if ReadParam of the underlying value type
fails?  That seems reasonable. 

[palmer, 2013/09/05 01:20:15]

No, I think you are right. I was trying to figure out if there is a way we can
avoid new-ing if ReadParam fails, but I don't think we can do it in a way that
would really be better. (E.g. we could read into a stack-allocated P, but then
we'd need to copy the value into |*r| anyway, and then what have we gained...)
So, nevermind...

[jdduke (slow), 2013/09/05 19:31:48]

Yeah, that crossed my mind.  This operation *should* be relatively sparse; only
a few input events should be passed around each frame, and even in the
pathological case that's something we can tackle with browser-side coalescing if
need be. Otherwise, I'd share your concerns.

+    if (!ReadParam(m, iter, temp.get()))
+      return false;
+
+    r->swap(temp);
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    if (p)
+      LogParam(*p, l);
+    else
+      l->append("NULL");
+  }
+};
+
+template <>
+struct CONTENT_EXPORT ParamTraits<content::InputEvent> {
+  typedef content::InputEvent param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct CONTENT_EXPORT ParamTraits<content::WebInputEventPayload> {
+  typedef content::WebInputEventPayload param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+}  // namespace IPC
+
+#endif  // CONTENT_COMMON_INPUT_INPUT_PARAM_TRAITS_H_