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/plugin_dispatcher.h" 6 7#include <map> 8 9#include "base/compiler_specific.h" 10#include "base/debug/trace_event.h" 11#include "base/logging.h" 12#include "base/message_loop/message_loop.h" 13#include "ipc/ipc_message.h" 14#include "ipc/ipc_sync_channel.h" 15#include "ipc/ipc_sync_message_filter.h" 16#include "ppapi/c/pp_errors.h" 17#include "ppapi/c/ppp_instance.h" 18#include "ppapi/proxy/flash_clipboard_resource.h" 19#include "ppapi/proxy/flash_file_resource.h" 20#include "ppapi/proxy/flash_resource.h" 21#include "ppapi/proxy/gamepad_resource.h" 22#include "ppapi/proxy/interface_list.h" 23#include "ppapi/proxy/interface_proxy.h" 24#include "ppapi/proxy/plugin_globals.h" 25#include "ppapi/proxy/plugin_message_filter.h" 26#include "ppapi/proxy/plugin_resource_tracker.h" 27#include "ppapi/proxy/plugin_var_serialization_rules.h" 28#include "ppapi/proxy/ppapi_messages.h" 29#include "ppapi/proxy/ppb_instance_proxy.h" 30#include "ppapi/proxy/ppp_class_proxy.h" 31#include "ppapi/proxy/resource_creation_proxy.h" 32#include "ppapi/proxy/resource_reply_thread_registrar.h" 33#include "ppapi/shared_impl/ppapi_globals.h" 34#include "ppapi/shared_impl/proxy_lock.h" 35#include "ppapi/shared_impl/resource.h" 36 37#if defined(OS_POSIX) && !defined(OS_NACL) 38#include "ipc/ipc_channel_posix.h" 39#endif 40 41namespace ppapi { 42namespace proxy { 43 44namespace { 45 46typedef std::map<PP_Instance, PluginDispatcher*> InstanceToDispatcherMap; 47InstanceToDispatcherMap* g_instance_to_dispatcher = NULL; 48 49typedef std::set<PluginDispatcher*> DispatcherSet; 50DispatcherSet* g_live_dispatchers = NULL; 51 52} // namespace 53 54InstanceData::InstanceData() 55 : is_request_surrounding_text_pending(false), 56 should_do_request_surrounding_text(false) { 57} 58 59InstanceData::~InstanceData() { 60 // Run any pending mouse lock callback to prevent leaks. 61 if (mouse_lock_callback.get()) 62 mouse_lock_callback->Abort(); 63} 64 65PluginDispatcher::PluginDispatcher(PP_GetInterface_Func get_interface, 66 const PpapiPermissions& permissions, 67 bool incognito) 68 : Dispatcher(get_interface, permissions), 69 plugin_delegate_(NULL), 70 received_preferences_(false), 71 plugin_dispatcher_id_(0), 72 incognito_(incognito) { 73 SetSerializationRules(new PluginVarSerializationRules(AsWeakPtr())); 74 75 if (!g_live_dispatchers) 76 g_live_dispatchers = new DispatcherSet; 77 g_live_dispatchers->insert(this); 78} 79 80PluginDispatcher::~PluginDispatcher() { 81 PluginGlobals::Get()->plugin_var_tracker()->DidDeleteDispatcher(this); 82 83 if (plugin_delegate_) 84 plugin_delegate_->Unregister(plugin_dispatcher_id_); 85 86 g_live_dispatchers->erase(this); 87 if (g_live_dispatchers->empty()) { 88 delete g_live_dispatchers; 89 g_live_dispatchers = NULL; 90 } 91} 92 93// static 94PluginDispatcher* PluginDispatcher::GetForInstance(PP_Instance instance) { 95 if (!g_instance_to_dispatcher) 96 return NULL; 97 InstanceToDispatcherMap::iterator found = g_instance_to_dispatcher->find( 98 instance); 99 if (found == g_instance_to_dispatcher->end()) 100 return NULL; 101 return found->second; 102} 103 104// static 105PluginDispatcher* PluginDispatcher::GetForResource(const Resource* resource) { 106 return GetForInstance(resource->pp_instance()); 107} 108 109// static 110const void* PluginDispatcher::GetBrowserInterface(const char* interface_name) { 111 if (!interface_name) { 112 DLOG(WARNING) << "|interface_name| is null. Did you forget to add " 113 "the |interface_name()| template function to the interface's C++ " 114 "wrapper?"; 115 return NULL; 116 } 117 118 return InterfaceList::GetInstance()->GetInterfaceForPPB(interface_name); 119} 120 121// static 122void PluginDispatcher::LogWithSource(PP_Instance instance, 123 PP_LogLevel level, 124 const std::string& source, 125 const std::string& value) { 126 if (!g_live_dispatchers || !g_instance_to_dispatcher) 127 return; 128 129 if (instance) { 130 InstanceToDispatcherMap::iterator found = 131 g_instance_to_dispatcher->find(instance); 132 if (found != g_instance_to_dispatcher->end()) { 133 // Send just to this specific dispatcher. 134 found->second->Send(new PpapiHostMsg_LogWithSource( 135 instance, static_cast<int>(level), source, value)); 136 return; 137 } 138 } 139 140 // Instance 0 or invalid, send to all dispatchers. 141 for (DispatcherSet::iterator i = g_live_dispatchers->begin(); 142 i != g_live_dispatchers->end(); ++i) { 143 (*i)->Send(new PpapiHostMsg_LogWithSource( 144 instance, static_cast<int>(level), source, value)); 145 } 146} 147 148const void* PluginDispatcher::GetPluginInterface( 149 const std::string& interface_name) { 150 InterfaceMap::iterator found = plugin_interfaces_.find(interface_name); 151 if (found == plugin_interfaces_.end()) { 152 const void* ret = local_get_interface()(interface_name.c_str()); 153 plugin_interfaces_.insert(std::make_pair(interface_name, ret)); 154 return ret; 155 } 156 return found->second; 157} 158 159bool PluginDispatcher::InitPluginWithChannel( 160 PluginDelegate* delegate, 161 base::ProcessId peer_pid, 162 const IPC::ChannelHandle& channel_handle, 163 bool is_client) { 164 if (!Dispatcher::InitWithChannel(delegate, peer_pid, channel_handle, 165 is_client)) 166 return false; 167 plugin_delegate_ = delegate; 168 plugin_dispatcher_id_ = plugin_delegate_->Register(this); 169 170 sync_filter_ = new IPC::SyncMessageFilter(delegate->GetShutdownEvent()); 171 channel()->AddFilter(sync_filter_.get()); 172 173 // The message filter will intercept and process certain messages directly 174 // on the I/O thread. 175 channel()->AddFilter( 176 new PluginMessageFilter( 177 delegate->GetGloballySeenInstanceIDSet(), 178 PluginGlobals::Get()->resource_reply_thread_registrar())); 179 return true; 180} 181 182bool PluginDispatcher::IsPlugin() const { 183 return true; 184} 185 186bool PluginDispatcher::SendMessage(IPC::Message* msg) { 187 // Currently we need to choose between two different mechanisms for sending. 188 // On the main thread we use the regular dispatch Send() method, on another 189 // thread we use SyncMessageFilter. 190 if (PpapiGlobals::Get()->GetMainThreadMessageLoop()->BelongsToCurrentThread()) 191 return Dispatcher::Send(msg); 192 return sync_filter_->Send(msg); 193} 194 195bool PluginDispatcher::Send(IPC::Message* msg) { 196 TRACE_EVENT2("ppapi proxy", "PluginDispatcher::Send", 197 "Class", IPC_MESSAGE_ID_CLASS(msg->type()), 198 "Line", IPC_MESSAGE_ID_LINE(msg->type())); 199 // We always want plugin->renderer messages to arrive in-order. If some sync 200 // and some async messages are sent in response to a synchronous 201 // renderer->plugin call, the sync reply will be processed before the async 202 // reply, and everything will be confused. 203 // 204 // Allowing all async messages to unblock the renderer means more reentrancy 205 // there but gives correct ordering. 206 // 207 // We don't want reply messages to unblock however, as they will potentially 208 // end up on the wrong queue - see crbug.com/122443 209 if (!msg->is_reply()) 210 msg->set_unblock(true); 211 if (msg->is_sync()) { 212 // Synchronous messages might be re-entrant, so we need to drop the lock. 213 ProxyAutoUnlock unlock; 214 return SendMessage(msg); 215 } 216 return SendMessage(msg); 217} 218 219bool PluginDispatcher::OnMessageReceived(const IPC::Message& msg) { 220 // We need to grab the proxy lock to ensure that we don't collide with the 221 // plugin making pepper calls on a different thread. 222 ProxyAutoLock lock; 223 TRACE_EVENT2("ppapi proxy", "PluginDispatcher::OnMessageReceived", 224 "Class", IPC_MESSAGE_ID_CLASS(msg.type()), 225 "Line", IPC_MESSAGE_ID_LINE(msg.type())); 226 227 if (msg.routing_id() == MSG_ROUTING_CONTROL) { 228 // Handle some plugin-specific control messages. 229 bool handled = true; 230 IPC_BEGIN_MESSAGE_MAP(PluginDispatcher, msg) 231 IPC_MESSAGE_HANDLER(PpapiMsg_SupportsInterface, OnMsgSupportsInterface) 232 IPC_MESSAGE_HANDLER(PpapiMsg_SetPreferences, OnMsgSetPreferences) 233 IPC_MESSAGE_UNHANDLED(handled = false); 234 IPC_END_MESSAGE_MAP() 235 if (handled) 236 return true; 237 } 238 return Dispatcher::OnMessageReceived(msg); 239} 240 241void PluginDispatcher::OnChannelError() { 242 Dispatcher::OnChannelError(); 243 244 // The renderer has crashed or exited. This channel and all instances 245 // associated with it are no longer valid. 246 ForceFreeAllInstances(); 247 // TODO(brettw) free resources too! 248 delete this; 249} 250 251void PluginDispatcher::DidCreateInstance(PP_Instance instance) { 252 if (!g_instance_to_dispatcher) 253 g_instance_to_dispatcher = new InstanceToDispatcherMap; 254 (*g_instance_to_dispatcher)[instance] = this; 255 instance_map_.set(instance, scoped_ptr<InstanceData>(new InstanceData())); 256} 257 258void PluginDispatcher::DidDestroyInstance(PP_Instance instance) { 259 instance_map_.erase(instance); 260 261 if (g_instance_to_dispatcher) { 262 InstanceToDispatcherMap::iterator found = g_instance_to_dispatcher->find( 263 instance); 264 if (found != g_instance_to_dispatcher->end()) { 265 DCHECK(found->second == this); 266 g_instance_to_dispatcher->erase(found); 267 } else { 268 NOTREACHED(); 269 } 270 } 271} 272 273InstanceData* PluginDispatcher::GetInstanceData(PP_Instance instance) { 274 return instance_map_.get(instance); 275} 276 277thunk::PPB_Instance_API* PluginDispatcher::GetInstanceAPI() { 278 return static_cast<PPB_Instance_Proxy*>( 279 GetInterfaceProxy(API_ID_PPB_INSTANCE)); 280} 281 282thunk::ResourceCreationAPI* PluginDispatcher::GetResourceCreationAPI() { 283 return static_cast<ResourceCreationProxy*>( 284 GetInterfaceProxy(API_ID_RESOURCE_CREATION)); 285} 286 287void PluginDispatcher::ForceFreeAllInstances() { 288 if (!g_instance_to_dispatcher) 289 return; 290 291 // Iterating will remove each item from the map, so we need to make a copy 292 // to avoid things changing out from under is. 293 InstanceToDispatcherMap temp_map = *g_instance_to_dispatcher; 294 for (InstanceToDispatcherMap::iterator i = temp_map.begin(); 295 i != temp_map.end(); ++i) { 296 if (i->second == this) { 297 // Synthesize an "instance destroyed" message, this will notify the 298 // plugin and also remove it from our list of tracked plugins. 299 PpapiMsg_PPPInstance_DidDestroy msg(API_ID_PPP_INSTANCE, i->first); 300 OnMessageReceived(msg); 301 } 302 } 303} 304 305void PluginDispatcher::OnMsgSupportsInterface( 306 const std::string& interface_name, 307 bool* result) { 308 *result = !!GetPluginInterface(interface_name); 309 310 // Do fallback for PPP_Instance. This is a hack here and if we have more 311 // cases like this it should be generalized. The PPP_Instance proxy always 312 // proxies the 1.1 interface, and then does fallback to 1.0 inside the 313 // plugin process (see PPP_Instance_Proxy). So here we return true for 314 // supporting the 1.1 interface if either 1.1 or 1.0 is supported. 315 if (!*result && interface_name == PPP_INSTANCE_INTERFACE) 316 *result = !!GetPluginInterface(PPP_INSTANCE_INTERFACE_1_0); 317} 318 319void PluginDispatcher::OnMsgSetPreferences(const Preferences& prefs) { 320 // The renderer may send us preferences more than once (currently this 321 // happens every time a new plugin instance is created). Since we don't have 322 // a way to signal to the plugin that the preferences have changed, changing 323 // the default fonts and such in the middle of a running plugin could be 324 // confusing to it. As a result, we never allow the preferences to be changed 325 // once they're set. The user will have to restart to get new font prefs 326 // propogated to plugins. 327 if (!received_preferences_) { 328 received_preferences_ = true; 329 preferences_ = prefs; 330 } 331} 332 333} // namespace proxy 334} // namespace ppapi 335