Add resource message call and reply infrastructure.

ppapi/proxy/resource_message_params.cc

Index: ppapi/proxy/resource_message_params.cc
diff --git a/ppapi/proxy/resource_message_params.cc b/ppapi/proxy/resource_message_params.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6a76581be69ad19f7a0db9df6d10018247132583
--- /dev/null
+++ b/ppapi/proxy/resource_message_params.cc
@@ -0,0 +1,91 @@
+// 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 "ppapi/proxy/resource_message_params.h"
+
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/proxy/ppapi_messages.h"
+
+namespace ppapi {
+namespace proxy {
+
+ResourceMessageParams::ResourceMessageParams()
+    : pp_resource_(0),
+      sequence_(0) {
+}
+
+ResourceMessageParams::ResourceMessageParams(PP_Resource resource,
+                                             int32_t sequence)
+    : pp_resource_(resource),
+      sequence_(sequence) {
+}
+
+ResourceMessageParams::~ResourceMessageParams() {
+}
+
+void ResourceMessageParams::Serialize(IPC::Message* msg) const {
+  IPC::ParamTraits<PP_Resource>::Write(msg, pp_resource_);
+  IPC::ParamTraits<int32_t>::Write(msg, sequence_);
+}
+
+bool ResourceMessageParams::Deserialize(const IPC::Message* msg,
+                                        PickleIterator* iter) {
+  return IPC::ParamTraits<PP_Resource>::Read(msg, iter, &pp_resource_) &&
+         IPC::ParamTraits<int32_t>::Read(msg, iter, &sequence_);
+}
+
+ResourceMessageCallParams::ResourceMessageCallParams()
+    : ResourceMessageParams(),
+      has_callback_(0) {
+}
+
+ResourceMessageCallParams::ResourceMessageCallParams(PP_Resource resource,
+                                                     int32_t sequence)
+    : ResourceMessageParams(resource, sequence),
+      has_callback_(0) {
+}
+
+ResourceMessageCallParams::~ResourceMessageCallParams() {
+}
+
+void ResourceMessageCallParams::Serialize(IPC::Message* msg) const {
+  ResourceMessageParams::Serialize(msg);
+  IPC::ParamTraits<bool>::Write(msg, has_callback_);
+}
+
+bool ResourceMessageCallParams::Deserialize(const IPC::Message* msg,
+                                            PickleIterator* iter) {
+  if (!ResourceMessageParams::Deserialize(msg, iter))
+    return false;
+  return IPC::ParamTraits<bool>::Read(msg, iter, &has_callback_);

[bbudge, 2012/06/20 16:58:41]

Could be:
return ResourceMessageParams::Deserialize(msg, iter) &&
          IPC::ParamTraits<bool>::Read(msg, iter, &has_callback_);

also below.

+}
+
+ResourceMessageReplyParams::ResourceMessageReplyParams()
+    : ResourceMessageParams(),
+      result_(PP_OK) {
+}
+
+ResourceMessageReplyParams::ResourceMessageReplyParams(PP_Resource resource,
+                                                       int32_t sequence)
+    : ResourceMessageParams(resource, sequence),
+      result_(PP_OK) {
+}
+
+ResourceMessageReplyParams::~ResourceMessageReplyParams() {
+}
+
+void ResourceMessageReplyParams::Serialize(IPC::Message* msg) const {
+  ResourceMessageParams::Serialize(msg);
+  IPC::ParamTraits<int32_t>::Write(msg, result_);
+}
+
+bool ResourceMessageReplyParams::Deserialize(const IPC::Message* msg,
+                                             PickleIterator* iter) {
+  if (!ResourceMessageParams::Deserialize(msg, iter))
+    return false;
+  return IPC::ParamTraits<int32_t>::Read(msg, iter, &result_);
+}
+
+}  // namespace proxy
+}  // namespace ppapi