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