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 17namespace ppapi { 18namespace proxy { 19 20class ResourceMessageReplyParams; 21 22template <class ObjT, class Method> 23inline void DispatchResourceReply(ObjT* obj, Method method, 24 const ResourceMessageReplyParams& params, 25 const Tuple0& arg) { 26 (obj->*method)(params); 27} 28 29template <class ObjT, class Method, class A> 30inline void DispatchResourceReply(ObjT* obj, Method method, 31 const ResourceMessageReplyParams& params, 32 const Tuple1<A>& arg) { 33 (obj->*method)(params, arg.a); 34} 35 36template<class ObjT, class Method, class A, class B> 37inline 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 43template<class ObjT, class Method, class A, class B, class C> 44inline 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 50template<class ObjT, class Method, class A, class B, class C, class D> 51inline 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 57template<class ObjT, class Method, class A, class B, class C, class D, class E> 58inline 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. 87template<class MsgClass, class ObjT, class Method> 88void 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|. 120template<class MsgClass, class Method> 121void 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