Connect PPAPI IPC channels for non-SFI mode.

ppapi/proxy/plugin_main_irt.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_main_irt.h"
+
 #include <unistd.h>
-
 #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/at_exit.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.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/public/chrome_main.h"
-#include "native_client/src/shared/srpc/nacl_srpc.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/ppapi_switches.h"
 #include "ppapi/shared_impl/ppb_audio_shared.h"
 
+#if defined(__native_client__)
+#include "native_client/src/public/chrome_main.h"
+#include "native_client/src/shared/srpc/nacl_srpc.h"
+#endif
+
 #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
 
 #endif
 #include "ppapi/proxy/ppapi_messages.h"
 
 using ppapi::proxy::PluginDispatcher;
 using ppapi::proxy::PluginGlobals;
 using ppapi::proxy::PluginProxyDelegate;
 using ppapi::proxy::ProxyChannel;
 using ppapi::proxy::SerializedHandle;
 
 namespace {
 
+#if defined(__native_client__)
+// In SFI mode, the FDs of IPC channels are NACL_CHROME_DESC_BASE and its
+// successor, which is set in nacl_listener.cc.
+int g_nacl_ipc_browser_fd = NACL_CHROME_DESC_BASE;
+int g_nacl_ipc_renderer_fd = NACL_CHROME_DESC_BASE + 1;
+#else
+// In non-SFI mode, the FDs of IPC channels are different from the hard coded
+// ones. These values will be set by SetIPCFileDescriptors() below.
+// At first, both are initialized to invalid FD number (-1).
+int g_nacl_ipc_browser_fd = -1;
+int g_nacl_ipc_renderer_fd = -1;
+#endif
+
 // This class manages communication between the plugin and the browser, and
 // manages the PluginDispatcher instances for communication between the plugin
 // and the renderer.
 class PpapiDispatcher : public PluginDispatcher::PluginDelegate,
                         public PluginProxyDelegate,
                         public IPC::Listener,
                         public IPC::Sender {
  public:
   explicit PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop);
 
@@ skipping 37 matching lines @@
   uint32 next_plugin_dispatcher_id_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   base::WaitableEvent shutdown_event_;
   scoped_ptr<IPC::SyncChannel> channel_;
 };
 
 PpapiDispatcher::PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop)
     : next_plugin_dispatcher_id_(0),
       message_loop_(io_loop),
       shutdown_event_(true, false) {
-  // The first FD (based on NACL_CHROME_DESC_BASE) is the IPC channel to the
-  // browser.
+  DCHECK_NE(g_nacl_ipc_browser_fd, -1)
+      << "g_nacl_ipc_browser_fd must be initialized before the plugin starts";
   IPC::ChannelHandle channel_handle(
-      "NaCl IPC", base::FileDescriptor(NACL_CHROME_DESC_BASE, false));
+      "NaCl IPC", base::FileDescriptor(g_nacl_ipc_browser_fd, false));
 
   // Delay initializing the SyncChannel until after we add filters. This
   // ensures that the filters won't miss any messages received by
   // the channel.
   channel_.reset(new IPC::SyncChannel(
       this, GetIPCMessageLoop(), GetShutdownEvent()));
   channel_->AddFilter(new ppapi::proxy::PluginMessageFilter(
       NULL, PluginGlobals::Get()->resource_reply_thread_registrar()));
   channel_->AddFilter(
       new tracing::ChildTraceMessageFilter(message_loop_.get()));
@@ skipping 112 matching lines @@
   int32_t error = ::PPP_InitializeModule(
       0 /* module */,
       &ppapi::proxy::PluginDispatcher::GetBrowserInterface);
   if (error)
     ::exit(error);
 
   PluginDispatcher* dispatcher =
       new PluginDispatcher(::PPP_GetInterface, args.permissions,
                            args.off_the_record);
   // The channel handle's true name is not revealed here.
-  // The second FD (based on NACL_CHROME_DESC_BASE) is the IPC channel to the
-  // renderer.
+  DCHECK_NE(g_nacl_ipc_renderer_fd, -1)
+      << "g_nacl_ipc_renderer_fd must be initialized before the plugin starts";
   IPC::ChannelHandle channel_handle(
-      "nacl", base::FileDescriptor(NACL_CHROME_DESC_BASE + 1, false));
+      "nacl", base::FileDescriptor(g_nacl_ipc_renderer_fd, false));
   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::OnPluginDispatcherMessageReceived(
@@ skipping 18 matching lines @@
               switches::kPpapiKeepAliveThrottle),
           &keepalive_throttle_interval_milliseconds)) {
     ppapi::proxy::PluginGlobals::Get()->
         set_keepalive_throttle_interval_milliseconds(
             keepalive_throttle_interval_milliseconds);
   }
 }
 
 }  // namespace
 
+void SetIPCFileDescriptors(int ipc_browser_fd, int ipc_renderer_fd) {
+  g_nacl_ipc_browser_fd = ipc_browser_fd;
+  g_nacl_ipc_renderer_fd = ipc_renderer_fd;
+}
+
 void PpapiPluginRegisterThreadCreator(
     const struct PP_ThreadFunctions* thread_functions) {
+#if defined(__native_client__)
+  // TODO(hidehiko): The thread creation for the PPB_Audio is not yet
+  // implemented on non-SFI mode. Support this. Now, this function invocation
+  // is just ignored.
+
   // Initialize all classes that need to create threads that call back into
   // user code.
   ppapi::PPB_Audio_Shared::SetThreadFunctions(thread_functions);
+#endif
 }
 
 int PpapiPluginMain() {
   // Though it isn't referenced here, we must instantiate an AtExitManager.
   base::AtExitManager exit_manager;
   base::MessageLoop loop;
+#if defined(IPC_MESSAGE_LOG_ENABLED)
   IPC::Logging::set_log_function_map(&g_log_function_mapping);
+#endif
   ppapi::proxy::PluginGlobals plugin_globals;
   base::Thread io_thread("Chrome_NaClIOThread");
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread.StartWithOptions(options);
 
+#if defined(__native_client__)
+  // Currently on non-SFI mode, we don't use SRPC server on plugin.
+  // TODO(hidehiko): Make sure this SRPC is actually used on SFI-mode.
+
   // Start up the SRPC server on another thread. Otherwise, when it blocks
   // on an RPC, the PPAPI proxy will hang. Do this before we initialize the
   // module and start the PPAPI proxy so that the NaCl plugin can continue
   // loading the app.
   static struct NaClSrpcHandlerDesc srpc_methods[] = { { NULL, NULL } };
   if (!NaClSrpcAcceptClientOnThread(srpc_methods)) {
     return 1;
   }
+#endif
 
   PpapiDispatcher ppapi_dispatcher(io_thread.message_loop_proxy());
   plugin_globals.set_plugin_proxy_delegate(&ppapi_dispatcher);
 
   loop.Run();
 
   return 0;
 }