Adding nonsfi content handler

mojo/nacl/mojo_interface_nacl_nonsfi.cc

 // Copyright 2015 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 <fcntl.h>
-#include <iostream>
-
-#include "mojo/edk/embedder/embedder.h"
-#include "mojo/edk/embedder/simple_platform_support.h"
-#include "mojo/public/platform/nacl/mojo_irt.h"
-#include "native_client/src/public/irt_core.h"
-#include "native_client/src/public/nonsfi/elf_loader.h"
+#include "mojo_interface_nacl_nonsfi.h"
 
 namespace {
 
+MojoHandle g_mojo_handle = MOJO_HANDLE_INVALID;

[Sean Klein, 2015/09/01 20:24:48]

Is there potentially an issue with having a single, global "g_mojo_handle"
between any functions which want to launch nexes?

If I use both the "monacl shell" and "content handler + mojo shell" (both nonsfi
versions) to run two nexes at the same time, and both of them try to call
"mojo_set_initial_handle", it seems like a race condition could exist.

[Mark Seaborn, 2015/09/01 21:05:46]

Yes.  We don't really want to run multiple nexes in the same process though.  If
one crashes or calls exit(), it will bring any others down with it.

The global handle is OK for now.  We can revisit this when we work out what the
process model should be -- i.e. how to get mojo_shell to create separate
processes.

I think we'd also want to revisit whether GetInitialHandle() should consume the
handle, so that if it's called twice, but the handle is closed between those
calls, the second caller can't get a dangling handle.

[Sean Klein, 2015/09/01 22:55:27]

Acknowledged.

+
+MojoResult _MojoGetInitialHandle(MojoHandle* handle) {
+  // TODO(smklein): Test this handle

[Mark Seaborn, 2015/09/01 21:05:46]

Nit: I would avoid TODOs where the TODO would be addressed in a different
location in the codebase.  It's likely we'd forget to remove it.

[Sean Klein, 2015/09/01 22:55:26]

Done.

+  *handle = g_mojo_handle;
+  return MOJO_RESULT_OK;
+}
+
+} // namespace
+
+void mojo_set_initial_handle(MojoHandle handle) {
+  g_mojo_handle = handle;
+}
+
 const struct nacl_irt_mojo kIrtMojo = {
   MojoCreateSharedBuffer,
   MojoDuplicateBufferHandle,
   MojoMapBuffer,
   MojoUnmapBuffer,
   MojoCreateDataPipe,
   MojoWriteData,
   MojoBeginWriteData,
   MojoEndWriteData,
   MojoReadData,
   MojoBeginReadData,
   MojoEndReadData,
   MojoGetTimeTicksNow,
   MojoClose,
   MojoWait,
   MojoWaitMany,
   MojoCreateMessagePipe,
   MojoWriteMessage,
   MojoReadMessage,
-  nullptr, // TODO(smklein): Add _MojoGetInitialHandle.
+  _MojoGetInitialHandle,
 };
 
 const struct nacl_irt_interface kIrtInterfaces[] = {
   { NACL_IRT_MOJO_v0_1, &kIrtMojo, sizeof(kIrtMojo), nullptr }
 };
 
 size_t mojo_irt_nonsfi_query(const char* interface_ident,
                              void* table, size_t tablesize) {
   size_t result = nacl_irt_query_list(interface_ident,
                                       table,
                                       tablesize,
                                       kIrtInterfaces,
                                       sizeof(kIrtInterfaces));
   if (result != 0)
     return result;
   return nacl_irt_query_core(interface_ident, table, tablesize);
 }
-
-} // namespace
-
-int main(int argc, char** argv, char** environ) {
-  nacl_irt_nonsfi_allow_dev_interfaces();
-  if (argc < 2) {
-    std::cerr << "Usage: " << argv[0] <<  " <executable> <args...>\n";
-    return 1;
-  }
-  const char* nexe_filename = argv[1];
-  int fd = open(nexe_filename, O_RDONLY);
-  if (fd < 0) {
-    std::cerr << "Failed to open " << nexe_filename << ": " <<
-              strerror(errno) << "\n";
-    return 1;
-  }
-  uintptr_t entry = NaClLoadElfFile(fd);
-
-  mojo::embedder::Init(scoped_ptr<mojo::embedder::PlatformSupport>(
-            new mojo::embedder::SimplePlatformSupport()));
-
-  return nacl_irt_nonsfi_entry(argc - 1, argv + 1, environ,
-                               reinterpret_cast<nacl_entry_func_t>(entry),
-                               mojo_irt_nonsfi_query);
-}