Support using TrackedCallbacks as hints to determine the handling thread of resource reply messages

ppapi/proxy/plugin_dispatcher.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/proxy/plugin_dispatcher.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
@@ skipping 12 matching lines @@
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_message_filter.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/plugin_var_serialization_rules.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_instance_proxy.h"
 #include "ppapi/proxy/ppp_class_proxy.h"
 #include "ppapi/proxy/resource_creation_proxy.h"
 #include "ppapi/proxy/resource_message_params.h"
+#include "ppapi/proxy/resource_reply_thread_registrar.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 namespace ppapi {
 namespace proxy {
@@ skipping 123 matching lines @@
     return false;
   plugin_delegate_ = delegate;
   plugin_dispatcher_id_ = plugin_delegate_->Register(this);
 
   sync_filter_ = new IPC::SyncMessageFilter(delegate->GetShutdownEvent());
   channel()->AddFilter(sync_filter_.get());
 
   // The message filter will intercept and process certain messages directly
   // on the I/O thread.
   channel()->AddFilter(
-      new PluginMessageFilter(delegate->GetGloballySeenInstanceIDSet()));
+      new PluginMessageFilter(
+          delegate->GetGloballySeenInstanceIDSet(),
+          PluginGlobals::Get()->resource_reply_thread_registrar()));
   return true;
 }
 
 bool PluginDispatcher::IsPlugin() const {
   return true;
 }
 
 bool PluginDispatcher::SendMessage(IPC::Message* msg) {
   // Currently we need to choose between two different mechanisms for sending.
   // On the main thread we use the regular dispatch Send() method, on another
@@ skipping 32 matching lines @@
   // plugin making pepper calls on a different thread.
   ProxyAutoLock lock;
   TRACE_EVENT2("ppapi proxy", "PluginDispatcher::OnMessageReceived",
                "Class", IPC_MESSAGE_ID_CLASS(msg.type()),
                "Line", IPC_MESSAGE_ID_LINE(msg.type()));
 
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Handle some plugin-specific control messages.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(PluginDispatcher, msg)
-      IPC_MESSAGE_HANDLER(PpapiPluginMsg_ResourceReply, OnMsgResourceReply)
       IPC_MESSAGE_HANDLER(PpapiMsg_SupportsInterface, OnMsgSupportsInterface)
       IPC_MESSAGE_HANDLER(PpapiMsg_SetPreferences, OnMsgSetPreferences)
       IPC_MESSAGE_UNHANDLED(handled = false);
     IPC_END_MESSAGE_MAP()
     if (handled)
       return true;
   }
   return Dispatcher::OnMessageReceived(msg);
 }
 
@@ skipping 40 matching lines @@
 thunk::PPB_Instance_API* PluginDispatcher::GetInstanceAPI() {
   return static_cast<PPB_Instance_Proxy*>(
       GetInterfaceProxy(API_ID_PPB_INSTANCE));
 }
 
 thunk::ResourceCreationAPI* PluginDispatcher::GetResourceCreationAPI() {
   return static_cast<ResourceCreationProxy*>(
       GetInterfaceProxy(API_ID_RESOURCE_CREATION));
 }
 
-// static
-void PluginDispatcher::DispatchResourceReply(
-    const ppapi::proxy::ResourceMessageReplyParams& reply_params,
-    const IPC::Message& nested_msg) {
-  // We need to grab the proxy lock to ensure that we don't collide with the
-  // plugin making pepper calls on a different thread.
-  ProxyAutoLock lock;
-  LockedDispatchResourceReply(reply_params, nested_msg);
-}
-
 void PluginDispatcher::ForceFreeAllInstances() {
   if (!g_instance_to_dispatcher)
     return;
 
   // Iterating will remove each item from the map, so we need to make a copy
   // to avoid things changing out from under is.
   InstanceToDispatcherMap temp_map = *g_instance_to_dispatcher;
   for (InstanceToDispatcherMap::iterator i = temp_map.begin();
        i != temp_map.end(); ++i) {
     if (i->second == this) {
       // Synthesize an "instance destroyed" message, this will notify the
       // plugin and also remove it from our list of tracked plugins.
       PpapiMsg_PPPInstance_DidDestroy msg(API_ID_PPP_INSTANCE, i->first);
       OnMessageReceived(msg);
     }
   }
 }
 
-void PluginDispatcher::OnMsgResourceReply(
-    const ppapi::proxy::ResourceMessageReplyParams& reply_params,
-    const IPC::Message& nested_msg) {
-  LockedDispatchResourceReply(reply_params, nested_msg);
-}
-
 void PluginDispatcher::OnMsgSupportsInterface(
     const std::string& interface_name,
     bool* result) {
   *result = !!GetPluginInterface(interface_name);
 
   // Do fallback for PPP_Instance. This is a hack here and if we have more
   // cases like this it should be generalized. The PPP_Instance proxy always
   // proxies the 1.1 interface, and then does fallback to 1.0 inside the
   // plugin process (see PPP_Instance_Proxy). So here we return true for
   // supporting the 1.1 interface if either 1.1 or 1.0 is supported.
   if (!*result && interface_name == PPP_INSTANCE_INTERFACE)
     *result = !!GetPluginInterface(PPP_INSTANCE_INTERFACE_1_0);
 }
 
 void PluginDispatcher::OnMsgSetPreferences(const Preferences& prefs) {
   // The renderer may send us preferences more than once (currently this
   // happens every time a new plugin instance is created). Since we don't have
   // a way to signal to the plugin that the preferences have changed, changing
   // the default fonts and such in the middle of a running plugin could be
   // confusing to it. As a result, we never allow the preferences to be changed
   // once they're set. The user will have to restart to get new font prefs
   // propogated to plugins.
   if (!received_preferences_) {
     received_preferences_ = true;
     preferences_ = prefs;
   }
 }
 
-// static
-void PluginDispatcher::LockedDispatchResourceReply(
-    const ppapi::proxy::ResourceMessageReplyParams& reply_params,
-    const IPC::Message& nested_msg) {
-  Resource* resource = PpapiGlobals::Get()->GetResourceTracker()->GetResource(
-      reply_params.pp_resource());
-  if (!resource) {
-    DLOG_IF(INFO, reply_params.sequence() != 0)
-        << "Pepper resource reply message received but the resource doesn't "
-           "exist (probably has been destroyed).";
-    return;
-  }
-  resource->OnReplyReceived(reply_params, nested_msg);
-}
-
 }  // namespace proxy
 }  // namespace ppapi