Connect PPAPI IPC channels for non-SFI mode.

components/nacl/loader/nonsfi/nonsfi_main.cc

 // Copyright 2014 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 "components/nacl/loader/nonsfi/nonsfi_main.h"
 
+#include "base/debug/leak_annotations.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/threading/simple_thread.h"
 #include "components/nacl/loader/nonsfi/elf_loader.h"
 #include "components/nacl/loader/nonsfi/irt_interfaces.h"
 #include "native_client/src/include/elf_auxv.h"
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/public/secure_service.h"
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 #include "native_client/src/trusted/desc/nacl_desc_base.h"
 #include "native_client/src/trusted/desc/nacl_desc_imc.h"
 #include "native_client/src/trusted/desc/nrd_all_modules.h"
 #include "native_client/src/trusted/desc/nrd_xfer.h"
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
+#include "ppapi/native_client/src/shared/ppapi_proxy/ppruntime.h"

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

I don't really want us to add stuff to ppapi/native_client or dependencies on
it.

Can we move the stuff in ppruntime? Perhaps to the new ppapi/nacl_irt directory?

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

Moved to ppapi/proxy with renaming it to plugin_main_irt.h. See also my reply to
the plugin_main.cc.

 
 namespace nacl {
 namespace nonsfi {
 namespace {
 
+class PluginMainThread : public base::SimpleThread {
+ public:
+  PluginMainThread(uintptr_t entry_point)

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

nit: explicit

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

Done.

+      : base::SimpleThread("NaClMainThread"),
+        entry_point_(entry_point) {
+  }
+
+  virtual void Run() OVERRIDE {
+    uintptr_t info[] = {
+      0,  // Do not use fini.
+      0,  // envc.
+      0,  // argc.
+      0,  // Null terminate for argv.
+      0,  // Null terminate for envv.
+      AT_SYSINFO,
+      reinterpret_cast<uintptr_t>(&NaClIrtInterface),
+      AT_NULL,
+      0,  // Null terminate for auxv.
+    };
+    reinterpret_cast<void (*)(uintptr_t*)>(entry_point_)(info);
+  }
+
+ private:
+  uintptr_t entry_point_;

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

It seems like it would make more sense to store this as the function pointer
type, since that's the only way you use it. For that matter, it should be passed
to the constructor that way.

Might also be worth having a typedef for void(*)(uintptr_t*). 

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

Done.

+};
+
 struct NaClDescUnrefer {
   void operator()(struct NaClDesc* desc) const {
     NaClDescUnref(desc);
   }
 };
 
 void LoadModuleRpc(struct NaClSrpcRpc* rpc,
                    struct NaClSrpcArg** in_args,
                    struct NaClSrpcArg** out_args,
                    struct NaClSrpcClosure* done_cls) {
   rpc->result = NACL_SRPC_RESULT_INTERNAL;
 
   ::scoped_ptr<struct NaClDesc, NaClDescUnrefer> desc(in_args[0]->u.hval);
   ElfImage image;
   if (image.Read(desc.get()) != LOAD_OK) {
     LOG(ERROR) << "LoadModuleRpc: Failed to read binary.";
     return;
   }
 
   if (image.Load(desc.get()) != LOAD_OK) {
     LOG(ERROR) << "LoadModuleRpc: Failed to load the image";
     return;
   }
 
   uintptr_t entry_point = image.entry_point();
   rpc->result = NACL_SRPC_RESULT_OK;
 
-  // Run for testing. TODO(hidehiko): Remove this.
-  uintptr_t info[] = {
-    0,  // Do not use fini.
-    0,  // envc.
-    0,  // argc.
-    0,  // Null terminate for argv.
-    0,  // Null terminate for envv.
-    AT_SYSINFO,
-    reinterpret_cast<uintptr_t>(&NaClIrtInterface),
-    AT_NULL,
-    0,  // Null terminate for auxv.
-  };
-  reinterpret_cast<void (*)(uintptr_t*)>(entry_point)(info);
+  // We intentionally leak the thread. The plugin runs on the thread, and once
+  // it is completed, this process should be killed so that the memory for
+  // the thread is also collected correctly.
+  // We may want to manage the thread pointer after we switch the
+  // initialization message passing between the renderer from SRPC to IPC.
+  base::SimpleThread* thread = new PluginMainThread(entry_point);
+  ANNOTATE_LEAKING_OBJECT_PTR(thread);
+  thread->Start();
+
+  // Wait until the PPAPI set up is completed on the main thread.
+  ppapi::proxy::WaitForPpapiStartEvent();
+
+  if (done_cls)
+    (*done_cls->Run)(done_cls);
 }
 
 const static struct NaClSrpcHandlerDesc kNonSfiServiceHandlers[] = {
   { NACL_SECURE_SERVICE_LOAD_MODULE, LoadModuleRpc, },
   { static_cast<const char*>(NULL), static_cast<NaClSrpcMethod>(NULL), },
 };
 
 // Creates two socketpairs to communicate with the host process.
 void CreateSecureSocketPair(struct NaClDesc* secure_pair[2],
                             struct NaClDesc* pair[2]) {
@@ skipping 60 matching lines @@
   if (status) {
     LOG(ERROR) << "ServiceAccept: Failed to accept " << status;
     return;
   }
 
   NaClSrpcServerLoop(connected_desc, kNonSfiServiceHandlers, NULL);
 }
 
 }  // namespace
 
+void SetIPCFileDescriptors(int browser_ipc_fd, int renderer_ipc_fd) {
+  ppapi::proxy::SetIPCFileDescriptors(browser_ipc_fd, renderer_ipc_fd);
+}
+
 void MainStart(NaClHandle imc_bootstrap_handle) {
   NaClSrpcModuleInit();
 
   struct NaClDesc* secure_pair[2] = { NULL, NULL };
   struct NaClDesc* pair[2] = { NULL, NULL };
   CreateSecureSocketPair(secure_pair, pair);
   ::scoped_ptr<struct NaClDesc, NaClDescUnrefer> secure_port(secure_pair[0]);
   ::scoped_ptr<struct NaClDesc, NaClDescUnrefer> secure_address(
        secure_pair[1]);
   ::scoped_ptr<struct NaClDesc, NaClDescUnrefer> service_port(pair[0]);
   ::scoped_ptr<struct NaClDesc, NaClDescUnrefer> service_address(pair[1]);
 
   ::scoped_ptr<struct NaClDesc, NaClDescUnrefer> channel(
        SetUpBootstrapChannel(imc_bootstrap_handle,
                              secure_address.get(), service_address.get()));
   if (!channel) {
     LOG(ERROR) << "MainStart: Failed to set up bootstrap channel.";
     return;
   }
 
   // Start the SRPC server loop.
   ServiceAccept(secure_port.get());
 }
 
 }  // namespace nonsfi
 }  // namespace nacl