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

ppapi/proxy/plugin_main_nacl.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 <map>
 #include <set>
 
 #include "build/build_config.h"
 // Need to include this before most other files because it defines
 // IPC_MESSAGE_LOG_ENABLED. We need to use it to define
 // IPC_MESSAGE_MACROS_LOG_ENABLED so ppapi_messages.h will generate the
 // ViewMsgLog et al. functions.
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "components/tracing/child_trace_message_filter.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message.h"
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 #include "native_client/src/untrusted/irt/irt_ppapi.h"
 #include "ppapi/c/ppp.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/native_client/src/shared/ppapi_proxy/ppruntime.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
+#include "ppapi/proxy/plugin_message_filter.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
+#include "ppapi/proxy/resource_reply_thread_registrar.h"
 #include "ppapi/shared_impl/ppb_audio_shared.h"
 
 #if defined(IPC_MESSAGE_LOG_ENABLED)
 #include "base/containers/hash_tables.h"
 
 LogFunctionMap g_log_function_mapping;
 
 #define IPC_MESSAGE_MACROS_LOG_ENABLED
 #define IPC_LOG_TABLE_ADD_ENTRY(msg_id, logger) \
   g_log_function_mapping[msg_id] = logger
@@ skipping 44 matching lines @@
       const PP_BrowserFont_Trusted_Description& desc,
       const ppapi::Preferences& prefs) OVERRIDE;
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
  private:
   void OnMsgCreateNaClChannel(int renderer_id,
                               const ppapi::PpapiNaClChannelArgs& args,
                               SerializedHandle handle);
-  void OnMsgResourceReply(
-      const ppapi::proxy::ResourceMessageReplyParams& reply_params,
-      const IPC::Message& nested_msg);
   void OnPluginDispatcherMessageReceived(const IPC::Message& msg);
 
   std::set<PP_Instance> instances_;
   std::map<uint32, PluginDispatcher*> plugin_dispatchers_;
   uint32 next_plugin_dispatcher_id_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   base::WaitableEvent shutdown_event_;
 };
 
 PpapiDispatcher::PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop)
     : next_plugin_dispatcher_id_(0),
       message_loop_(io_loop),
       shutdown_event_(true, false) {
   IPC::ChannelHandle channel_handle(
       "NaCl IPC", base::FileDescriptor(NACL_IPC_FD, false));
   // We don't have/need a PID since handle sharing happens outside of the
   // NaCl sandbox.
   InitWithChannel(this, base::kNullProcessId, channel_handle,
                   false);  // Channel is server.
+  channel()->AddFilter(new ppapi::proxy::PluginMessageFilter(
+      NULL, PluginGlobals::Get()->resource_reply_thread_registrar()));

[dmichael (off chromium), 2013/12/11 21:30:36]

Why do we need this *and* the one that PluginDispatcher registers?

[yzshen1, 2013/12/11 22:22:07]

Please see my comment in ppapi_thread.cc.

   channel()->AddFilter(
       new tracing::ChildTraceMessageFilter(message_loop_.get()));
 }
 
 base::MessageLoopProxy* PpapiDispatcher::GetIPCMessageLoop() {
   return message_loop_.get();
 }
 
 base::WaitableEvent* PpapiDispatcher::GetShutdownEvent() {
   return &shutdown_event_;
@@ skipping 53 matching lines @@
     PP_Instance instance,
     const PP_BrowserFont_Trusted_Description& desc,
     const ppapi::Preferences& prefs) {
   NOTIMPLEMENTED();
   return 0;
 }
 
 bool PpapiDispatcher::OnMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(PpapiDispatcher, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_CreateNaClChannel, OnMsgCreateNaClChannel)
-    IPC_MESSAGE_HANDLER(PpapiPluginMsg_ResourceReply, OnMsgResourceReply)
     // All other messages are simply forwarded to a PluginDispatcher.
     IPC_MESSAGE_UNHANDLED(OnPluginDispatcherMessageReceived(msg))
   IPC_END_MESSAGE_MAP()
   return true;
 }
 
 void PpapiDispatcher::OnMsgCreateNaClChannel(
     int renderer_id,
     const ppapi::PpapiNaClChannelArgs& args,
     SerializedHandle handle) {
@@ skipping 28 matching lines @@
   IPC::ChannelHandle channel_handle("nacl", handle.descriptor());
   if (!dispatcher->InitPluginWithChannel(this, base::kNullProcessId,
                                          channel_handle, false)) {
     delete dispatcher;
     return;
   }
   // From here, the dispatcher will manage its own lifetime according to the
   // lifetime of the attached channel.
 }
 
-void PpapiDispatcher::OnMsgResourceReply(
-    const ppapi::proxy::ResourceMessageReplyParams& reply_params,
-    const IPC::Message& nested_msg) {
-  ppapi::proxy::PluginDispatcher::DispatchResourceReply(reply_params,
-                                                        nested_msg);
-}
-
 void PpapiDispatcher::OnPluginDispatcherMessageReceived(
     const IPC::Message& msg) {
   // The first parameter should be a plugin dispatcher ID.
   PickleIterator iter(msg);
   uint32 id = 0;
   if (!msg.ReadUInt32(&iter, &id)) {
     NOTREACHED();
     return;
   }
   std::map<uint32, ppapi::proxy::PluginDispatcher*>::iterator dispatcher =
@@ skipping 31 matching lines @@
     return 1;
   }
 
   PpapiDispatcher ppapi_dispatcher(io_thread.message_loop_proxy());
   plugin_globals.set_plugin_proxy_delegate(&ppapi_dispatcher);
 
   loop.Run();
 
   return 0;
 }