RFC: Add an interface for having the browser open a pnacl support file

ppapi/native_client/src/trusted/plugin/pnacl_coordinator.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 "native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/portability_io.h"
@@ skipping 379 matching lines @@
                                            error_info, pnacl_translate);
   }
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(PnaclLDManifest);
 
   const Manifest* nexe_manifest_;
   const Manifest* extension_manifest_;
 };
 
+static int64_t start_download_time = 0;
+
 //////////////////////////////////////////////////////////////////////
 //  The coordinator class.
 //////////////////////////////////////////////////////////////////////
 PnaclCoordinator* PnaclCoordinator::BitcodeToNative(
     Plugin* plugin,
     const nacl::string& pexe_url,
     const nacl::string& cache_identity,
     const pp::CompletionCallback& translate_notify_callback) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeToNative (plugin=%p, pexe=%s)\n",
                  static_cast<void*>(plugin), pexe_url.c_str()));
   PnaclCoordinator* coordinator =
       new PnaclCoordinator(plugin, pexe_url,
                            cache_identity, translate_notify_callback);
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeToNative (manifest=%p)\n",
                  reinterpret_cast<const void*>(coordinator->manifest_.get())));
   // Load llc and ld.
   std::vector<nacl::string> resource_urls;
   resource_urls.push_back(kLlcUrl);
   resource_urls.push_back(kLdUrl);
   pp::CompletionCallback resources_cb =
       coordinator->callback_factory_.NewCallback(
           &PnaclCoordinator::ResourcesDidLoad);
   coordinator->resources_.reset(
       new PnaclResources(plugin,
                          coordinator,
                          coordinator->manifest_.get(),
                          resource_urls,
                          resources_cb));
   CHECK(coordinator->resources_ != NULL);
+
+  start_download_time = NaClGetTimeOfDayMicroseconds();
   coordinator->resources_->StartDownloads();
   // ResourcesDidLoad will be invoked when all resources have been received.
   return coordinator;
 }
 
 int32_t PnaclCoordinator::GetLoadedFileDesc(int32_t pp_error,
                                             const nacl::string& url,
                                             const nacl::string& component) {
   PLUGIN_PRINTF(("PnaclCoordinator::GetLoadedFileDesc (pp_error=%"
                  NACL_PRId32", url=%s, component=%s)\n", pp_error,
@@ skipping 177 matching lines @@
 
 void PnaclCoordinator::TranslateFailed(const nacl::string& error_string) {
   PLUGIN_PRINTF(("PnaclCoordinator::TranslateFailed (error_string=%"
                  NACL_PRId32")\n", error_string.c_str()));
   pp::Core* core = pp::Module::Get()->core();
   error_info_.SetReport(ERROR_UNKNOWN,
                         nacl::string("PnaclCoordinator: ") + error_string);
   core->CallOnMainThread(0, report_translate_finished_, PP_ERROR_FAILED);
 }
 
+
+// DEBUGGING test junk -- to be removed before checkin and replaced
+// with something like a test...
+static void TestPnaclOpenFile(const nacl::string& filename, bool expect_works) {
+  PLUGIN_PRINTF(("JAN calling get_readonly_pnacl_fd: %s\n", filename.c_str()));
+  int fd = get_readonly_pnacl_fd(filename.c_str());

[Mark Seaborn, 2012/06/20 20:12:55]

I don't think get_readonly_pnacl_fd needs to be a global variable.  You can just
call GetBrowserInterface(PPB_NACL_PRIVATE_INTERFACE) here.

+  const char *expect_success_msg = expect_works ? "YAY!" : "NOO!";
+  const char *expect_fail_msg = expect_works ? "NOO!" : "YAY!";
+
+  if (fd < 0) {
+    PLUGIN_PRINTF(("JAN get %s failed (fd='%d') %s\n",
+                   filename.c_str(), fd, expect_fail_msg));
+  } else {
+    PLUGIN_PRINTF(("JAN get %s succeeded (fd='%d') %s\n",
+                   filename.c_str(), fd, expect_success_msg));
+    // Try to stat the mofo.
+    struct stat stat_buf;
+    if (0 != fstat(fd, &stat_buf)) {
+      PLUGIN_PRINTF(("JAN stat %s fd failed: %s\n",
+                     filename.c_str(), expect_fail_msg));
+    } else {
+      PLUGIN_PRINTF(("JAN stat %s fd (size='%d') succeed: %s\n",
+                     filename.c_str(), stat_buf.st_size, expect_success_msg));
+    }
+    close(fd);
+    PLUGIN_PRINTF(("JAN got fd for %s and now closing: %d\n",
+                   filename.c_str(), fd));
+  }
+}
+
+static void WINAPI DoTestFileOpens(void* arg) {
+  nacl::string sandbox_isa = GetSandboxISA();
+  // We should probably use FilePath.Append() to join these.
+  TestPnaclOpenFile(sandbox_isa + nacl::string("/llc"), true);
+  TestPnaclOpenFile(sandbox_isa + nacl::string("/ld"), true);
+  TestPnaclOpenFile(sandbox_isa + nacl::string("/crtbegin.o"), true);
+
+  // Stuff that shouldn't work.
+  TestPnaclOpenFile("non-existent-file", false);
+  TestPnaclOpenFile("../../chrome_shutdown_ms.txt", false);
+  TestPnaclOpenFile("/bin/ls", false);
+  TestPnaclOpenFile("$HOME/.bashrc", false);
+}
+// END DEBUGGING test junk.
+
+
 void PnaclCoordinator::ResourcesDidLoad(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::ResourcesDidLoad (pp_error=%"
                  NACL_PRId32")\n", pp_error));
+
+  int64_t end_download_time = NaClGetTimeOfDayMicroseconds();
+  PLUGIN_PRINTF(("PnaclCoordinator:: url load time total=%"NACL_PRId64")\n",
+                 end_download_time - start_download_time));
+
+  // BEGIN debugging hack.
+  // On thread accesses work...
+  PLUGIN_PRINTF(("JAN Testing from main thread.\n"));
+  int64_t start_download_time2 = NaClGetTimeOfDayMicroseconds();
+  DoTestFileOpens(NULL);
+  int64_t end_download_time2 = NaClGetTimeOfDayMicroseconds();
+  PLUGIN_PRINTF(("PnaclCoordinator::fd load time total=%"NACL_PRId64")\n",
+                 end_download_time2 - start_download_time2));
+
+  // Off thread use doesn't seem to work...
+  // PLUGIN_PRINTF(("JAN Testing from secondary thread.\n"));
+  // static NaClThread *debugging_file_thread = new NaClThread();
+  // if (!NaClThreadCreateJoinable(debugging_file_thread,
+  //                               DoTestFileOpens,
+  //                               NULL,
+  //                               128 * 1024)) {
+  //   PLUGIN_PRINTF(("JAN Failed to creaate test thread\n"));
+  // }
+  PLUGIN_PRINTF(("JAN Testing all done!\n"));
+  // END debugging.
+
   if (pp_error != PP_OK) {
     ReportPpapiError(pp_error, "resources failed to load.");
     return;
   }
   // Open the local temporary file system to create the temporary files
   // for the object and nexe.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::FileSystemDidOpen);
   if (!file_system_->Open(0, cb)) {
     ReportNonPpapiError("failed to open file system.");
@@ skipping 90 matching lines @@
   }
 }
 
 void PnaclCoordinator::RunTranslate(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::RunTranslate (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   int32_t fd = GetLoadedFileDesc(pp_error, pexe_url_, "pexe");
   if (fd < 0) {
     return;
   }
+
   pexe_wrapper_.reset(plugin_->wrapper_factory()->MakeFileDesc(fd, O_RDONLY));
   // Invoke llc followed by ld off the main thread.  This allows use of
   // blocking RPCs that would otherwise block the JavaScript main thread.
   report_translate_finished_ =
       callback_factory_.NewCallback(&PnaclCoordinator::TranslateFinished);
   translate_thread_.reset(new NaClThread);
   if (translate_thread_ == NULL) {
     ReportNonPpapiError("could not allocate thread struct.");
     return;
   }
@@ skipping 101 matching lines @@
   nacl::MutexLocker ml(&subprocess_mu_);
   return subprocesses_should_die_;
 }
 
 void PnaclCoordinator::SetSubprocessesShouldDie(bool subprocesses_should_die) {
   nacl::MutexLocker ml(&subprocess_mu_);
   subprocesses_should_die_ = subprocesses_should_die;
 }
 
 }  // namespace plugin