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 143