ppapi/proxy/ppp_messaging_proxy.cc

   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 #include "ppapi/proxy/ppp_messaging_proxy.h"
   6
   7 #include <algorithm>
   8
   9 #include "ppapi/c/ppp_messaging.h"
  10 #include "ppapi/proxy/host_dispatcher.h"
  11 #include "ppapi/proxy/message_handler.h"
  12 #include "ppapi/proxy/plugin_dispatcher.h"
  13 #include "ppapi/proxy/plugin_resource_tracker.h"
  14 #include "ppapi/proxy/plugin_var_tracker.h"
  15 #include "ppapi/proxy/ppapi_messages.h"
  16 #include "ppapi/proxy/serialized_var.h"
  17 #include "ppapi/shared_impl/ppapi_globals.h"
  18 #include "ppapi/shared_impl/proxy_lock.h"
  19 #include "ppapi/shared_impl/scoped_pp_var.h"
  20 #include "ppapi/shared_impl/var_tracker.h"
  21
  22 namespace ppapi {
  23 namespace proxy {
  24
  25 namespace {
  26
  27 MessageHandler* GetMessageHandler(Dispatcher* dispatcher,
  28                                   PP_Instance instance) {
  29   if (!dispatcher || !dispatcher->IsPlugin()) {
  30     NOTREACHED();
  31     return NULL;
  32   }
  33   PluginDispatcher* plugin_dispatcher =
  34       static_cast<PluginDispatcher*>(dispatcher);
  35   InstanceData* instance_data = plugin_dispatcher->GetInstanceData(instance);
  36   if (!instance_data)
  37     return NULL;
  38
  39   return instance_data->message_handler.get();
  40 }
  41
  42 void ResetMessageHandler(Dispatcher* dispatcher, PP_Instance instance) {
  43   if (!dispatcher || !dispatcher->IsPlugin()) {
  44     NOTREACHED();
  45     return;
  46   }
  47   PluginDispatcher* plugin_dispatcher =
  48       static_cast<PluginDispatcher*>(dispatcher);
  49   InstanceData* instance_data = plugin_dispatcher->GetInstanceData(instance);
  50   if (!instance_data)
  51     return;
  52
  53   instance_data->message_handler.reset();
  54 }
  55
  56 }  // namespace
  57
  58 PPP_Messaging_Proxy::PPP_Messaging_Proxy(Dispatcher* dispatcher)
  59     : InterfaceProxy(dispatcher),
  60       ppp_messaging_impl_(NULL) {
  61   if (dispatcher->IsPlugin()) {
  62     ppp_messaging_impl_ = static_cast<const PPP_Messaging*>(
  63         dispatcher->local_get_interface()(PPP_MESSAGING_INTERFACE));
  64   }
  65 }
  66
  67 PPP_Messaging_Proxy::~PPP_Messaging_Proxy() {
  68 }
  69
  70 bool PPP_Messaging_Proxy::OnMessageReceived(const IPC::Message& msg) {
  71   if (!dispatcher()->IsPlugin())
  72     return false;
  73
  74   bool handled = true;
  75   IPC_BEGIN_MESSAGE_MAP(PPP_Messaging_Proxy, msg)
  76     IPC_MESSAGE_HANDLER(PpapiMsg_PPPMessaging_HandleMessage,
  77                         OnMsgHandleMessage)
  78     IPC_MESSAGE_HANDLER_DELAY_REPLY(
  79         PpapiMsg_PPPMessageHandler_HandleBlockingMessage,
  80         OnMsgHandleBlockingMessage)
  81     IPC_MESSAGE_UNHANDLED(handled = false)
  82   IPC_END_MESSAGE_MAP()
  83   return handled;
  84 }
  85
  86 void PPP_Messaging_Proxy::OnMsgHandleMessage(
  87     PP_Instance instance, SerializedVarReceiveInput message_data) {
  88   PP_Var received_var(message_data.GetForInstance(dispatcher(), instance));
  89   MessageHandler* message_handler = GetMessageHandler(dispatcher(), instance);
  90   if (message_handler) {
  91     if (message_handler->LoopIsValid()) {
  92       message_handler->HandleMessage(ScopedPPVar(received_var));
  93       return;
  94     } else {
  95       // If the MessageHandler's loop has been quit, then we should treat it as
  96       // though it has been unregistered and start sending messages to the
  97       // default handler. This might mean the plugin has lost messages, but
  98       // there's not really anything sane we can do about it. They should have
  99       // used UnregisterMessageHandler.
 100       ResetMessageHandler(dispatcher(), instance);
 101     }
 102   }
 103   // If we reach this point, then there's no message handler registered, so
 104   // we send to the default PPP_Messaging one for the instance.
 105
 106   // SerializedVarReceiveInput will decrement the reference count, but we want
 107   // to give the recipient a reference in the legacy API.
 108   PpapiGlobals::Get()->GetVarTracker()->AddRefVar(received_var);
 109   CallWhileUnlocked(ppp_messaging_impl_->HandleMessage,
 110                     instance,
 111                     received_var);
 112 }
 113
 114 void PPP_Messaging_Proxy::OnMsgHandleBlockingMessage(
 115     PP_Instance instance,
 116     SerializedVarReceiveInput message_data,
 117     IPC::Message* reply_msg) {
 118   ScopedPPVar received_var(message_data.GetForInstance(dispatcher(), instance));
 119   MessageHandler* message_handler = GetMessageHandler(dispatcher(), instance);
 120   if (message_handler) {
 121     if (message_handler->LoopIsValid()) {
 122       message_handler->HandleBlockingMessage(
 123           received_var, scoped_ptr<IPC::Message>(reply_msg));
 124       return;
 125     } else {
 126       // If the MessageHandler's loop has been quit, then we should treat it as
 127       // though it has been unregistered. Also see the note for PostMessage.
 128       ResetMessageHandler(dispatcher(), instance);
 129     }
 130   }
 131   // We have no handler, but we still need to respond to unblock the renderer
 132   // and inform the JavaScript caller.
 133   PpapiMsg_PPPMessageHandler_HandleBlockingMessage::WriteReplyParams(
 134       reply_msg,
 135       SerializedVarReturnValue::Convert(dispatcher(), PP_MakeUndefined()),
 136       false /* was_handled */);
 137   dispatcher()->Send(reply_msg);
 138 }
 139
 140
 141 }  // namespace proxy
 142 }  // namespace ppapi