ppapi/proxy/dispatch_reply_message.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file provides infrastructure for dispatching messasges from host
   6 // resource, inlcuding reply messages or unsolicited replies. Normal IPC Reply
   7 // handlers can't take extra parameters. We want to take a
   8 // ResourceMessageReplyParams as a parameter.
   9
  10 #ifndef PPAPI_PROXY_DISPATCH_REPLY_MESSAGE_H_
  11 #define PPAPI_PROXY_DISPATCH_REPLY_MESSAGE_H_
  12
  13 #include "base/callback.h"
  14 #include "base/profiler/scoped_profile.h"  // For TRACK_RUN_IN_IPC_HANDLER.
  15 #include "ipc/ipc_message_macros.h"
  16 #include "ppapi/c/pp_errors.h"
  17
  18 namespace ppapi {
  19 namespace proxy {
  20
  21 class ResourceMessageReplyParams;
  22
  23 template <class ObjT, class Method>
  24 inline void DispatchResourceReply(ObjT* obj, Method method,
  25                                   const ResourceMessageReplyParams& params,
  26                                   const Tuple0& arg) {
  27   (obj->*method)(params);
  28 }
  29
  30 template <class ObjT, class Method, class A>
  31 inline void DispatchResourceReply(ObjT* obj, Method method,
  32                                   const ResourceMessageReplyParams& params,
  33                                   const Tuple1<A>& arg) {
  34   (obj->*method)(params, arg.a);
  35 }
  36
  37 template<class ObjT, class Method, class A, class B>
  38 inline void DispatchResourceReply(ObjT* obj, Method method,
  39                                   const ResourceMessageReplyParams& params,
  40                                   const Tuple2<A, B>& arg) {
  41   (obj->*method)(params, arg.a, arg.b);
  42 }
  43
  44 template<class ObjT, class Method, class A, class B, class C>
  45 inline void DispatchResourceReply(ObjT* obj, Method method,
  46                                   const ResourceMessageReplyParams& params,
  47                                   const Tuple3<A, B, C>& arg) {
  48   (obj->*method)(params, arg.a, arg.b, arg.c);
  49 }
  50
  51 template<class ObjT, class Method, class A, class B, class C, class D>
  52 inline void DispatchResourceReply(ObjT* obj, Method method,
  53                                   const ResourceMessageReplyParams& params,
  54                                   const Tuple4<A, B, C, D>& arg) {
  55   (obj->*method)(params, arg.a, arg.b, arg.c, arg.d);
  56 }
  57
  58 template<class ObjT, class Method, class A, class B, class C, class D, class E>
  59 inline void DispatchResourceReply(ObjT* obj, Method method,
  60                                   const ResourceMessageReplyParams& params,
  61                                   const Tuple5<A, B, C, D, E>& arg) {
  62   (obj->*method)(params, arg.a, arg.b, arg.c, arg.d, arg.e);
  63 }
  64
  65 // Used to dispatch resource replies. In most cases, you should not call this
  66 // function to dispatch a resource reply manually, but instead use
  67 // |PluginResource::CallBrowser|/|PluginResource::CallRenderer| with a
  68 // |base::Callback| which will be called when a reply message is received
  69 // (see plugin_resource.h).
  70 //
  71 // This function will call your callback with the nested reply message's
  72 // parameters on success. On failure, your callback will be called with each
  73 // parameter having its default constructed value.
  74 //
  75 // Resource replies are a bit weird in that the host will automatically
  76 // generate a reply in error cases (when the call handler returns error rather
  77 // than returning "completion pending"). This makes it more convenient to write
  78 // the call message handlers. But this also means that the reply handler has to
  79 // handle both the success case (when all of the reply message paramaters are
  80 // specified) and the error case (when the nested reply message is empty).
  81 // In both cases the resource will want to issue completion callbacks to the
  82 // plugin.
  83 //
  84 // This function handles the error case by calling your reply handler with the
  85 // default value for each paramater in the error case. In most situations this
  86 // will be the right thing. You should always dispatch completion callbacks
  87 // using the result code present in the ResourceMessageReplyParams.
  88 template<class MsgClass, class ObjT, class Method>
  89 void DispatchResourceReplyOrDefaultParams(
  90     ObjT* obj,
  91     Method method,
  92     const ResourceMessageReplyParams& reply_params,
  93     const IPC::Message& msg) {
  94   typename MsgClass::Schema::Param msg_params;
  95   // We either expect the nested message type to match, or that there is no
  96   // nested message. No nested message indicates a default reply sent from
  97   // the host: when the resource message handler returns an error, a reply
  98   // is implicitly sent with no nested message.
  99   DCHECK(msg.type() == MsgClass::ID || msg.type() == 0)
 100       << "Resource reply message of unexpected type.";
 101   if (msg.type() == MsgClass::ID && MsgClass::Read(&msg, &msg_params)) {
 102     // Message type matches and the parameters were successfully read.
 103     DispatchResourceReply(obj, method, reply_params, msg_params);
 104   } else {
 105     // The nested message is empty because the host handler didn't explicitly
 106     // send a reply (likely), or you screwed up and didn't use the correct
 107     // message type when calling this function (you should have hit the
 108     // assertion above, Einstein).
 109     //
 110     // Dispatch the reply function with the default parameters. We explicitly
 111     // use a new Params() structure since if the Read failed due to an invalid
 112     // message, the params could have been partially filled in.
 113     DispatchResourceReply(obj, method, reply_params,
 114         typename MsgClass::Schema::Param());
 115   }
 116 }
 117
 118 // Template specialization for |Callback|s that only accept a
 119 // |ResourceMessageReplyParams|. In this case |msg| shouldn't contain any
 120 // arguments, so just call the |method| with the |reply_params|.
 121 template<class MsgClass, class Method>
 122 void DispatchResourceReplyOrDefaultParams(
 123     base::Callback<void(const ResourceMessageReplyParams&)>* obj,
 124     Method method,
 125     const ResourceMessageReplyParams& reply_params,
 126     const IPC::Message& msg) {
 127   DCHECK(msg.type() == MsgClass::ID || msg.type() == 0)
 128       << "Resource reply message of unexpected type.";
 129   (obj->*method)(reply_params);
 130 }
 131
 132 // Note that this only works for message with 1 or more parameters. For
 133 // 0-parameter messages you need to use the _0 version below (since there are
 134 // no params in the message).
 135 #define PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(msg_class, member_func) \
 136     case msg_class::ID: { \
 137       msg_class::Schema::Param p; \
 138       if (msg_class::Read(&ipc_message__, &p)) { \
 139         ppapi::proxy::DispatchResourceReply( \
 140             this, \
 141             &_IpcMessageHandlerClass::member_func, \
 142             params, p); \
 143       } else { \
 144         NOTREACHED(); \
 145       } \
 146       break; \
 147     }
 148
 149 #define PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_0(msg_class, member_func) \
 150   case msg_class::ID: { \
 151     member_func(params); \
 152     break; \
 153   }
 154
 155 #define PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(code) \
 156     default: { \
 157         code; \
 158     } \
 159     break;
 160
 161 }  // namespace proxy
 162 }  // namespace ppapi
 163
 164 #endif  // PPAPI_PROXY_DISPATCH_REPLY_MESSAGE_H_