Connect PPAPI IPC channels for non-SFI mode.

ppapi/proxy/plugin_main.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.
 
+#ifndef __native_client__
+# if OS_LINUX
+#  define NACL_LINUX 1
+# else
+#  error "non-SFI mode is currently supported only on Linux."

[dmichael (off chromium), 2014/02/13 19:00:34]

Why are we changing the name of this file? Are we saying BMM is *not* NaCl? In
Pepper, we also have trusted mode, so this has the potential to get confused
with that. I wasn't sure if we still consider BMM "NaCl" even though it's a
different toolchain and not SFI. If we eventually support PNaCl on BMM, it will
still be "PNaCl" as far as external developers are concerned.


If we move this file to nacl_irt, then the new name is probably fine. If we
leave it here, maybe plugin_main_irt.cc would be clearer?

[hidehiko, 2014/02/14 10:49:05]

The main reason why I changed the file name is that files _nacl.cc suffix is
automatically removed from sources! list for non-untrusted libs.
For BMM, it still is a NaCl, but the code needs to be linked with non-untrusted
code.

I just renamed the file to plugin_main_irt.cc, because according to Mark,
ppapi/nacl_irt is not the appropriate place to put this file. Also, I created
its header file to refer functions from nonsfi_main.cc by refactoring the code
from ppruntime.h.

Also note that I just kept ppruntime.h as is (reverted the change). It is
because that the file is referred from the
native_client/src/untrusted/irt/irt_ppapi.c, so it seems needs to be kept as is
for now. (I.e., to clean it up, we need to change chrome code, NaCl code, NaCl
roll, and then we can clean the files as same as other files, IIUC).

+# endif
+#endif
+
+#include "base/at_exit.h"
 #include "base/command_line.h"
+#include "base/lazy_instance.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/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 ppapi {
+namespace proxy {
+namespace {
+
+// On non-SFI mode, the FDs of IPC channels are different from the hard coded
+// ones. These values will be overwritten by SetIPCFileDescriptors() below.
+// The first FD (based on NACL_CHROME_DESC_BASE) is the IPC channel to the
+// browser, and the second one is to the renderer.
+int g_nacl_ipc_browser_fd = NACL_CHROME_DESC_BASE;
+int g_nacl_ipc_renderer_fd = NACL_CHROME_DESC_BASE + 1;
+
+// We cannot use the default traits for LazyInstance for the
+// base::WaitableEvent, because it doesn't have the default constructor.
+struct WaitableEventLazyInstanceTraits
+    : public base::DefaultLazyInstanceTraits<base::WaitableEvent> {
+  static base::WaitableEvent* New(void* instance) {
+    return new (instance) base::WaitableEvent(true, false);
+  }
+};
+base::LazyInstance<base::WaitableEvent, WaitableEventLazyInstanceTraits>
+    g_ppapi_start_event = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+void SetIPCFileDescriptors(int ipc_browser_fd, int ipc_renderer_fd) {

[dmichael (off chromium), 2014/02/13 19:00:34]

This and WaitForPpapiStartEvent could maybe go in a different namespace; they're
really implementing hooks for the IRT to talk to, and I don't think of it as
part of the proxy. (You might make that argument about this whole file,
really...  it doesn't need to happen for this CL, but it might make sense for us
to move this file to nacl_irt).

[hidehiko, 2014/02/14 10:49:05]

In the new file, I just moved this to the global function as similar to other
exposed functions.

+  // For non-SFI mode, the browser_ipc_fd and renderer_ipc_fd are different
+  // from the hard-coded numbers. So, this overwrites the values directly.
+  g_nacl_ipc_browser_fd = ipc_browser_fd;
+  g_nacl_ipc_renderer_fd = ipc_renderer_fd;
+}
+
+void WaitForPpapiStartEvent() {
+  g_ppapi_start_event.Pointer()->Wait();
+}
+
+}  // namespace proxy
+}  // namespace ppapi
+
 namespace {
 
 // 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 ProxyChannel,
                         public PluginDispatcher::PluginDelegate,
                         public PluginProxyDelegate {
  public:
   explicit PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop);
@@ skipping 36 matching lines @@
   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) {
   // The first FD (based on NACL_CHROME_DESC_BASE) is the IPC channel to the
   // browser.
   IPC::ChannelHandle channel_handle(
-      "NaCl IPC", base::FileDescriptor(NACL_CHROME_DESC_BASE, false));
+      "NaCl IPC",
+      base::FileDescriptor(ppapi::proxy::g_nacl_ipc_browser_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()));
   channel()->AddFilter(
       new tracing::ChildTraceMessageFilter(message_loop_.get()));
 }
 
@@ skipping 104 matching lines @@
   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.
   IPC::ChannelHandle channel_handle(
-      "nacl", base::FileDescriptor(NACL_CHROME_DESC_BASE + 1, false));
+      "nacl",
+      base::FileDescriptor(ppapi::proxy::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.
+  ppapi::proxy::g_ppapi_start_event.Pointer()->Signal();
 }
 
 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;
@@ skipping 13 matching lines @@
     ppapi::proxy::PluginGlobals::Get()->
         set_keepalive_throttle_interval_milliseconds(
             keepalive_throttle_interval_milliseconds);
   }
 }
 
 }  // namespace
 
 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;
 }