Change pnacl to read all resources from the extension.

ppapi/native_client/src/trusted/plugin/pnacl_coordinator.cc

 // Copyright (c) 2011 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 15 matching lines @@
 
 namespace plugin {
 
 class Plugin;
 
 namespace {
 
 const char kLlcUrl[] = "llc";
 const char kLdUrl[] = "ld";
 
-nacl::string ResourceBaseUrl() {
-  return nacl::string("pnacl_support/") + GetSandboxISA() + "/";
+nacl::string ExtensionUrl() {
+  // TODO(sehr,jvoung): Find a better way to express the URL for the pnacl
+  // extension than a constant string here.
+  const nacl::string kPnaclExtensionOrigin =
+      "chrome-extension://gcodniebolpnpaiggndmcmmfpldlknih/";
+  return kPnaclExtensionOrigin + GetSandboxISA() + "/";
 }
 
 nacl::string Random32CharHexString(struct NaClDescRng* rng) {
   struct NaClDesc* desc = reinterpret_cast<struct NaClDesc*>(rng);
   const struct NaClDescVtbl* vtbl =
       reinterpret_cast<const struct NaClDescVtbl*>(desc->base.vtbl);
 
   nacl::string hex_string;
   const int32_t kTempFileNameWords = 4;
   for (int32_t i = 0; i < kTempFileNameWords; ++i) {
@@ skipping 117 matching lines @@
   // Run the client's completion callback.
   pp::Core* core = pp::Module::Get()->core();
   core->CallOnMainThread(0, done_callback_, PP_OK);
 }
 
 //////////////////////////////////////////////////////////////////////
 //  Pnacl-specific manifest support.
 //////////////////////////////////////////////////////////////////////
 class PnaclManifest : public Manifest {
  public:
-  PnaclManifest(const pp::URLUtil_Dev* url_util,
-                const nacl::string& manifest_base_url)
-      : Manifest(url_util, manifest_base_url, GetSandboxISA(), false) {
-    size_t last_slash_pos = manifest_base_url_.rfind("/");
-    CHECK(last_slash_pos != nacl::string::npos);
-    // url_prefix contains everything in manifest_base_url up to and including
-    // the last slash.
-    url_prefix_ =
-        manifest_base_url_.substr(0, last_slash_pos + 1) + ResourceBaseUrl();
+  PnaclManifest(const pp::URLUtil_Dev* url_util)
+      : Manifest(url_util, ExtensionUrl(), GetSandboxISA(), false) {
   }
   virtual ~PnaclManifest() { }
 
   virtual bool GetProgramURL(nacl::string* full_url,
                              ErrorInfo* error_info,
                              bool* is_portable) {
     // Does not contain program urls.
     UNREFERENCED_PARAMETER(full_url);
     UNREFERENCED_PARAMETER(error_info);
     UNREFERENCED_PARAMETER(is_portable);
     PLUGIN_PRINTF(("PnaclManifest does not contain a program\n"));
     error_info->SetReport(ERROR_MANIFEST_GET_NEXE_URL,
                           "pnacl manifest does not contain a program");
     return false;
   }
 
   virtual bool ResolveURL(const nacl::string& relative_url,
                           nacl::string* full_url,
                           ErrorInfo* error_info) const {
     // Does not do general URL resolution, simply appends relative_url to
-    // the end of url_prefix_.
+    // the end of manifest_base_url_.
     UNREFERENCED_PARAMETER(error_info);
-    *full_url = url_prefix_ + relative_url;
+    *full_url = manifest_base_url_ + relative_url;
     return true;
   }
 
   virtual bool GetFileKeys(std::set<nacl::string>* keys) const {
     // Does not support enumeration.
     PLUGIN_PRINTF(("PnaclManifest does not support key enumeration\n"));
     UNREFERENCED_PARAMETER(keys);
     return false;
   }
 
   virtual bool ResolveKey(const nacl::string& key,
                           nacl::string* full_url,
                           ErrorInfo* error_info,
                           bool* is_portable) const {
     *is_portable = false;
     // We can only resolve keys in the files/ namespace.
     const nacl::string kFilesPrefix = "files/";
     size_t files_prefix_pos = key.find(kFilesPrefix);
     if (files_prefix_pos == nacl::string::npos) {
       error_info->SetReport(ERROR_MANIFEST_RESOLVE_URL,
                             "key did not start with files/");
       return false;
     }
     // Append what follows files to the pnacl URL prefix.
     nacl::string key_basename = key.substr(kFilesPrefix.length());
     return ResolveURL(key_basename, full_url, error_info);
   }
 
- private:
-  nacl::string url_prefix_;
+  // Since the pnacl coordinator manifest provides access to resources
+  // in the chrome extension, lookups will need to access resources in their
+  // extension origin rather than the plugin's origin.
+  virtual bool PermitsExtensionUrls() const {
+    return true;
+  }
 };
 
 //////////////////////////////////////////////////////////////////////
 //  The coordinator class.
 //////////////////////////////////////////////////////////////////////
 PnaclCoordinator* PnaclCoordinator::BitcodeToNative(
     Plugin* plugin,
     const nacl::string& pexe_url,
     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,
-                           translate_notify_callback,
-                           ResourceBaseUrl());
+      new PnaclCoordinator(plugin, pexe_url, translate_notify_callback);
+  PLUGIN_PRINTF(("PnaclCoordinator::BitcodeToNative (manifest=%p)\n",
+                 reinterpret_cast<const void*>(coordinator->manifest_)));
   // 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->resource_base_url_,
+                         coordinator->manifest_,
                          resource_urls,
                          resources_cb));
   CHECK(coordinator->resources_ != NULL);
   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,
@@ skipping 16 matching lines @@
   if (file_desc_ok_to_close == NACL_NO_FILE_DESC) {
     ReportPpapiError(PP_ERROR_FAILED, component + " could not dup fd.\n");
     return -1;
   }
   return file_desc_ok_to_close;
 }
 
 PnaclCoordinator::PnaclCoordinator(
     Plugin* plugin,
     const nacl::string& pexe_url,
-    const pp::CompletionCallback& translate_notify_callback,
-    const nacl::string& resource_base_url)
+    const pp::CompletionCallback& translate_notify_callback)
   : plugin_(plugin),
     translate_notify_callback_(translate_notify_callback),
-    resource_base_url_(resource_base_url),
     llc_subprocess_(NULL),
     ld_subprocess_(NULL),
     subprocesses_should_die_(false),
     file_system_(new pp::FileSystem(plugin, PP_FILESYSTEMTYPE_LOCALTEMPORARY)),
-    // TODO(sehr,jvoung): change base url to pnacl extension/testing url.
-    manifest_(new PnaclManifest(plugin->url_util(),
-                                plugin->manifest_base_url())),
+    manifest_(new PnaclManifest(plugin->url_util())),
     pexe_url_(pexe_url) {
   PLUGIN_PRINTF(("PnaclCoordinator::PnaclCoordinator (this=%p, plugin=%p)\n",
                  static_cast<void*>(this), static_cast<void*>(plugin)));
   callback_factory_.Initialize(this);
   NaClXMutexCtor(&subprocess_mu_);
-  // Check the temporary file system.
-  CHECK(file_system_ != NULL);
 }
 
 PnaclCoordinator::~PnaclCoordinator() {
   PLUGIN_PRINTF(("PnaclCoordinator::~PnaclCoordinator (this=%p)\n",
                  static_cast<void*>(this)));
   // Join helper thread which will block the page from refreshing while a
   // translation is happening.
   if (translate_thread_.get() != NULL) {
     SetSubprocessesShouldDie(true);
     NaClThreadJoin(translate_thread_.get());
@@ skipping 97 matching lines @@
   PLUGIN_PRINTF(("PnaclCoordinator::NexePairDidOpen (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     ReportPpapiError(pp_error);
     return;
   }
   // Load the pexe file and get the translation started.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::RunTranslate);
 
-  if (!plugin_->StreamAsFile(pexe_url_, cb.pp_completion_callback())) {
+  if (!plugin_->StreamAsFile(pexe_url_,
+                             manifest_->PermitsExtensionUrls(),
+                             cb.pp_completion_callback())) {
     ReportNonPpapiError(nacl::string("failed to download ") + pexe_url_ + "\n");
   }
 }
 
 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;
@@ skipping 108 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