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