Add template SyncCall() to PluginResource.

ppapi/proxy/ppapi_message_utils.h

+// 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.
+
+#ifndef PPAPI_PROXY_PPAPI_MESSAGE_UTILS_H_

[raymes, 2012/10/11 04:45:54]

Optional: combine this with ppapi/proxy/dispatch_reply_message.h? I'm not really
sure whether or not it's better though and I'm fine keeping them separate.

[yzshen1, 2012/10/12 16:47:03]

I think it is better to keep it as a separate file. Because
dispatch_reply_message.h is only used by the proxy; while this file is used by
both the host and the proxy.


On 2012/10/11 04:45:54, raymes wrote:

+#define PPAPI_PROXY_PPAPI_MESSAGE_UTILS_H_
+
+#include "base/basictypes.h"
+#include "base/pickle.h"
+#include "base/tuple.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_message_utils.h"
+
+namespace ppapi {
+
+// TupleTypeMatch* check whether a tuple type contains elements of the specified

[brettw, 2012/10/10 21:58:23]

Can you put the TupleTypeMatch in a nested "internal" namespace? I've done that
in a few other places for these internal implementation stuff.

[yzshen1, 2012/10/10 22:24:22]

Done.

[yzshen1, 2012/10/10 22:24:22]

Done.

+// types. They are used to make sure the output parameters of UnpackMessage()
+// match the corresponding message type.
+template <class TupleType, class A>
+struct TupleTypeMatch1 {
+  static const bool kValue = false;
+};
+template <class A>
+struct TupleTypeMatch1<Tuple1<A>, A> {
+  static const bool kValue = true;
+};
+
+template <class TupleType, class A, class B>
+struct TupleTypeMatch2 {
+  static const bool kValue = false;
+};
+template <class A, class B>
+struct TupleTypeMatch2<Tuple2<A, B>, A, B> {
+  static const bool kValue = true;
+};
+
+template <class TupleType, class A, class B, class C>
+struct TupleTypeMatch3 {
+  static const bool kValue = false;
+};
+template <class A, class B, class C>
+struct TupleTypeMatch3<Tuple3<A, B, C>, A, B, C> {
+  static const bool kValue = true;
+};
+
+template <class TupleType, class A, class B, class C, class D>
+struct TupleTypeMatch4 {
+  static const bool kValue = false;
+};
+template <class A, class B, class C, class D>
+struct TupleTypeMatch4<Tuple4<A, B, C, D>, A, B, C, D> {
+  static const bool kValue = true;
+};
+
+template <class TupleType, class A, class B, class C, class D, class E>
+struct TupleTypeMatch5 {
+  static const bool kValue = false;
+};
+template <class A, class B, class C, class D, class E>
+struct TupleTypeMatch5<Tuple5<A, B, C, D, E>, A, B, C, D, E> {
+  static const bool kValue = true;
+};
+
+template <class MsgClass, class A>
+bool UnpackMessage(const IPC::Message& msg, A* a) {
+  COMPILE_ASSERT((TupleTypeMatch1<typename MsgClass::Param, A>::kValue),
+                 tuple_type_not_match);
+
+  PickleIterator iter(msg);
+  return IPC::ReadParam(&msg, &iter, a);
+}
+
+template <class MsgClass, class A, class B>
+bool UnpackMessage(const IPC::Message& msg, A* a, B* b) {
+  COMPILE_ASSERT((TupleTypeMatch2<typename MsgClass::Param, A, B>::kValue),
+                 tuple_type_not_match);
+
+  PickleIterator iter(msg);
+  return IPC::ReadParam(&msg, &iter, a) && IPC::ReadParam(&msg, &iter, b);
+}
+
+template <class MsgClass, class A, class B, class C>
+bool UnpackMessage(const IPC::Message& msg, A* a, B* b, C* c) {
+  COMPILE_ASSERT((TupleTypeMatch3<typename MsgClass::Param, A, B, C>::kValue),
+                 tuple_type_not_match);
+
+  PickleIterator iter(msg);
+  return IPC::ReadParam(&msg, &iter, a) &&
+         IPC::ReadParam(&msg, &iter, b) &&
+         IPC::ReadParam(&msg, &iter, c);
+}
+
+template <class MsgClass, class A, class B, class C, class D>
+bool UnpackMessage(const IPC::Message& msg, A* a, B* b, C* c, D* d) {
+  COMPILE_ASSERT(
+      (TupleTypeMatch4<typename MsgClass::Param, A, B, C, D>::kValue),
+      tuple_type_not_match);
+
+  PickleIterator iter(msg);
+  return IPC::ReadParam(&msg, &iter, a) &&
+         IPC::ReadParam(&msg, &iter, b) &&
+         IPC::ReadParam(&msg, &iter, c) &&
+         IPC::ReadParam(&msg, &iter, d);
+}
+
+template <class MsgClass, class A, class B, class C, class D, class E>
+bool UnpackMessage(const IPC::Message& msg, A* a, B* b, C* c, D* d, E* e) {
+  COMPILE_ASSERT(
+      (TupleTypeMatch5<typename MsgClass::Param, A, B, C, D, E>::kValue),
+      tuple_type_not_match);
+
+  PickleIterator iter(msg);
+  return IPC::ReadParam(&msg, &iter, a) &&
+         IPC::ReadParam(&msg, &iter, b) &&
+         IPC::ReadParam(&msg, &iter, c) &&
+         IPC::ReadParam(&msg, &iter, d) &&
+         IPC::ReadParam(&msg, &iter, e);
+}
+
+}  // namespace ppapi
+
+#endif  // PPAPI_PROXY_PPAPI_MESSAGE_UTILS_H_
+