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/proxy/plugin_main_irt.h"
 
 namespace nacl {
 namespace nonsfi {
 namespace {
 
+typedef void (*EntryPointType)(uintptr_t *);
+
+class PluginMainThread : public base::SimpleThread {
+ public:
+  explicit PluginMainThread(EntryPointType entry_point)
+      : 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.
+    };
+    entry_point_(info);
+  }
+
+ private:
+  EntryPointType entry_point_;
+};
+
 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

[Mark Seaborn, 2014/02/15 03:00:52]

Do you mean the SimpleThread pointer?

[hidehiko, 2014/02/19 13:05:02]

Acknowledged.

+  // initialization message passing between the renderer from SRPC to IPC.
+  base::SimpleThread* thread =
+      new PluginMainThread(reinterpret_cast<EntryPointType>(entry_point));
+  ANNOTATE_LEAKING_OBJECT_PTR(thread);

[Mark Seaborn, 2014/02/15 03:00:52]

Maybe use base::PlatformThread::CreateNonJoinable()?  It has less baggage: it
has no need for a separate Start() or for declaring a leak.

[hidehiko, 2014/02/19 13:05:02]

Great to know. Done.

+  thread->Start();
+
+  if (done_cls)

[Mark Seaborn, 2014/02/15 03:00:52]

I don't think you need a NULL check here

[hidehiko, 2014/02/19 13:05:02]

Done.

+    (*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) {
+  ::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