ppapi/proxy/message_handler.cc

   1 // Copyright 2014 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 #include "ppapi/proxy/message_handler.h"
   6
   7 #include "ipc/ipc_message.h"
   8 #include "ppapi/proxy/plugin_dispatcher.h"
   9 #include "ppapi/proxy/ppapi_messages.h"
  10 #include "ppapi/proxy/ppb_message_loop_proxy.h"
  11 #include "ppapi/shared_impl/proxy_lock.h"
  12 #include "ppapi/shared_impl/scoped_pp_var.h"
  13 #include "ppapi/thunk/enter.h"
  14
  15 namespace ppapi {
  16 namespace proxy {
  17 namespace {
  18
  19 typedef void (*HandleMessageFunc)(PP_Instance, void*, const PP_Var*);
  20 typedef void (*HandleBlockingMessageFunc)(
  21     PP_Instance, void*, const PP_Var*, PP_Var*);
  22 typedef void (*HandleMessageFunc_0_1)(PP_Instance, void*, PP_Var);
  23 typedef PP_Var (*HandleBlockingMessageFunc_0_1)(PP_Instance, void*, PP_Var);
  24
  25 void HandleMessageWrapper(HandleMessageFunc function,
  26                           PP_Instance instance,
  27                           void* user_data,
  28                           ScopedPPVar message_data) {
  29   CallWhileUnlocked(function, instance, user_data,
  30                     &message_data.get());
  31 }
  32
  33 void HandleBlockingMessageWrapper(HandleBlockingMessageFunc function,
  34                                   PP_Instance instance,
  35                                   void* user_data,
  36                                   ScopedPPVar message_data,
  37                                   scoped_ptr<IPC::Message> reply_msg) {
  38   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
  39   if (!dispatcher)
  40     return;
  41   PP_Var result = PP_MakeUndefined();
  42   MessageLoopResource::GetCurrent()->
  43       set_currently_handling_blocking_message(true);
  44   CallWhileUnlocked(
  45       function, instance, user_data, &message_data.get(), &result);
  46   MessageLoopResource::GetCurrent()->
  47       set_currently_handling_blocking_message(false);
  48   PpapiMsg_PPPMessageHandler_HandleBlockingMessage::WriteReplyParams(
  49       reply_msg.get(),
  50       SerializedVarReturnValue::Convert(dispatcher, result),
  51       true /* was_handled */);
  52   dispatcher->Send(reply_msg.release());
  53 }
  54
  55 // TODO(dmichael): Remove the 0_1 verions; crbug.com/414398
  56 void HandleMessageWrapper_0_1(HandleMessageFunc_0_1 function,
  57                               PP_Instance instance,
  58                               void* user_data,
  59                               ScopedPPVar message_data) {
  60   CallWhileUnlocked(function, instance, user_data, message_data.get());
  61 }
  62
  63 void HandleBlockingMessageWrapper_0_1(HandleBlockingMessageFunc_0_1 function,
  64                                       PP_Instance instance,
  65                                       void* user_data,
  66                                       ScopedPPVar message_data,
  67                                       scoped_ptr<IPC::Message> reply_msg) {
  68   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
  69   if (!dispatcher)
  70     return;
  71   MessageLoopResource::GetCurrent()->
  72       set_currently_handling_blocking_message(true);
  73   PP_Var return_value = CallWhileUnlocked(function,
  74                                           instance,
  75                                           user_data,
  76                                           message_data.get());
  77   MessageLoopResource::GetCurrent()->
  78       set_currently_handling_blocking_message(false);
  79   PpapiMsg_PPPMessageHandler_HandleBlockingMessage::WriteReplyParams(
  80       reply_msg.get(),
  81       SerializedVarReturnValue::Convert(dispatcher, return_value),
  82       true /* was_handled */);
  83   dispatcher->Send(reply_msg.release());
  84 }
  85
  86 }  // namespace
  87
  88 // static
  89 scoped_ptr<MessageHandler> MessageHandler::Create(
  90       PP_Instance instance,
  91       const PPP_MessageHandler_0_2* handler_if,
  92       void* user_data,
  93       PP_Resource message_loop,
  94       int32_t* error) {
  95   scoped_ptr<MessageHandler> result;
  96   // The interface and all function pointers must be valid.
  97   if (!handler_if ||
  98       !handler_if->HandleMessage ||
  99       !handler_if->HandleBlockingMessage ||
 100       !handler_if->Destroy) {
 101     *error = PP_ERROR_BADARGUMENT;
 102     return result.Pass();
 103   }
 104   thunk::EnterResourceNoLock<thunk::PPB_MessageLoop_API>
 105       enter_loop(message_loop, true);
 106   if (enter_loop.failed()) {
 107     *error = PP_ERROR_BADRESOURCE;
 108     return result.Pass();
 109   }
 110   scoped_refptr<MessageLoopResource> message_loop_resource(
 111       static_cast<MessageLoopResource*>(enter_loop.object()));
 112   if (message_loop_resource->is_main_thread_loop()) {
 113     *error = PP_ERROR_WRONG_THREAD;
 114     return result.Pass();
 115   }
 116
 117   result.reset(new MessageHandler(
 118       instance, handler_if, user_data, message_loop_resource));
 119   *error = PP_OK;
 120   return result.Pass();
 121 }
 122
 123 // CreateDeprecated is a near-exact copy of Create, but we'll just delete it
 124 // when 0.1 is deprecated, so need to get fancy to avoid code duplication.
 125 // TODO(dmichael) crbug.com/414398
 126 // static
 127 scoped_ptr<MessageHandler> MessageHandler::CreateDeprecated(
 128       PP_Instance instance,
 129       const PPP_MessageHandler_0_1_Deprecated* handler_if,
 130       void* user_data,
 131       PP_Resource message_loop,
 132       int32_t* error) {
 133   scoped_ptr<MessageHandler> result;
 134   // The interface and all function pointers must be valid.
 135   if (!handler_if ||
 136       !handler_if->HandleMessage ||
 137       !handler_if->HandleBlockingMessage ||
 138       !handler_if->Destroy) {
 139     *error = PP_ERROR_BADARGUMENT;
 140     return result.Pass();
 141   }
 142   thunk::EnterResourceNoLock<thunk::PPB_MessageLoop_API>
 143       enter_loop(message_loop, true);
 144   if (enter_loop.failed()) {
 145     *error = PP_ERROR_BADRESOURCE;
 146     return result.Pass();
 147   }
 148   scoped_refptr<MessageLoopResource> message_loop_resource(
 149       static_cast<MessageLoopResource*>(enter_loop.object()));
 150   if (message_loop_resource->is_main_thread_loop()) {
 151     *error = PP_ERROR_WRONG_THREAD;
 152     return result.Pass();
 153   }
 154
 155   result.reset(new MessageHandler(
 156       instance, handler_if, user_data, message_loop_resource));
 157   *error = PP_OK;
 158   return result.Pass();
 159 }
 160
 161 MessageHandler::~MessageHandler() {
 162   // It's possible the message_loop_proxy is NULL if that loop has been quit.
 163   // In that case, we unfortunately just can't call Destroy.
 164   if (message_loop_->message_loop_proxy().get()) {
 165     // The posted task won't have the proxy lock, but that's OK, it doesn't
 166     // touch any internal state; it's a direct call on the plugin's function.
 167     if (handler_if_0_1_) {
 168       message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
 169           base::Bind(handler_if_0_1_->Destroy,
 170                      instance_,
 171                      user_data_));
 172       return;
 173     }
 174     message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
 175         base::Bind(handler_if_->Destroy,
 176                    instance_,
 177                    user_data_));
 178   }
 179 }
 180
 181 bool MessageHandler::LoopIsValid() const {
 182   return !!message_loop_->message_loop_proxy().get();
 183 }
 184
 185 void MessageHandler::HandleMessage(ScopedPPVar var) {
 186   if (handler_if_0_1_) {
 187     // TODO(dmichael): Remove this code path. crbug.com/414398
 188     message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
 189         RunWhileLocked(base::Bind(&HandleMessageWrapper_0_1,
 190                                   handler_if_0_1_->HandleMessage,
 191                                   instance_,
 192                                   user_data_,
 193                                   var)));
 194     return;
 195   }
 196   message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
 197       RunWhileLocked(base::Bind(&HandleMessageWrapper,
 198                                 handler_if_->HandleMessage,
 199                                 instance_,
 200                                 user_data_,
 201                                 var)));
 202 }
 203
 204 void MessageHandler::HandleBlockingMessage(ScopedPPVar var,
 205                                            scoped_ptr<IPC::Message> reply_msg) {
 206   if (handler_if_0_1_) {
 207     // TODO(dmichael): Remove this code path. crbug.com/414398
 208     message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
 209         RunWhileLocked(base::Bind(&HandleBlockingMessageWrapper_0_1,
 210                                   handler_if_0_1_->HandleBlockingMessage,
 211                                   instance_,
 212                                   user_data_,
 213                                   var,
 214                                   base::Passed(reply_msg.Pass()))));
 215     return;
 216   }
 217   message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
 218       RunWhileLocked(base::Bind(&HandleBlockingMessageWrapper,
 219                                 handler_if_->HandleBlockingMessage,
 220                                 instance_,
 221                                 user_data_,
 222                                 var,
 223                                 base::Passed(reply_msg.Pass()))));
 224 }
 225
 226 MessageHandler::MessageHandler(
 227     PP_Instance instance,
 228     const PPP_MessageHandler_0_2* handler_if,
 229     void* user_data,
 230     scoped_refptr<MessageLoopResource> message_loop)
 231     : instance_(instance),
 232       handler_if_(handler_if),
 233       handler_if_0_1_(NULL),
 234       user_data_(user_data),
 235       message_loop_(message_loop) {
 236 }
 237
 238 MessageHandler::MessageHandler(
 239     PP_Instance instance,
 240     const PPP_MessageHandler_0_1_Deprecated* handler_if,
 241     void* user_data,
 242     scoped_refptr<MessageLoopResource> message_loop)
 243     : instance_(instance),
 244       handler_if_(NULL),
 245       handler_if_0_1_(handler_if),
 246       user_data_(user_data),
 247       message_loop_(message_loop) {
 248 }
 249
 250 }  // namespace proxy
 251 }  // namespace ppapi