Use CORS for fetching NaCl resources from extensions.

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 180 matching lines @@
     UNREFERENCED_PARAMETER(error_info);
     UNREFERENCED_PARAMETER(is_portable);
     PLUGIN_PRINTF(("ExtensionManifest 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,
-                          bool* permit_extension_url,
                           ErrorInfo* error_info) const {
     // Does not do general URL resolution, simply appends relative_url to
     // the end of manifest_base_url_.
     UNREFERENCED_PARAMETER(error_info);
     *full_url = manifest_base_url_ + relative_url;
-    // 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.
-    *permit_extension_url = true;
     return true;
   }
 
   virtual bool GetFileKeys(std::set<nacl::string>* keys) const {
     // Does not support enumeration.
     PLUGIN_PRINTF(("ExtensionManifest does not support key enumeration\n"));
     UNREFERENCED_PARAMETER(keys);
     return false;
   }
 
   virtual bool ResolveKey(const nacl::string& key,
                           nacl::string* full_url,
-                          bool* permit_extension_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, permit_extension_url, error_info);
+    return ResolveURL(key_basename, full_url, error_info);
   }
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(ExtensionManifest);
 
   const pp::URLUtil_Dev* url_util_;
   nacl::string manifest_base_url_;
 };
 
 // TEMPORARY: ld needs to look up dynamic libraries in the nexe's manifest
@@ skipping 17 matching lines @@
                              bool* is_portable) const {
     if (nexe_manifest_->GetProgramURL(full_url, error_info, is_portable)) {
       return true;
     }
     return extension_manifest_->GetProgramURL(full_url, error_info,
                                               is_portable);
   }
 
   virtual bool ResolveURL(const nacl::string& relative_url,
                           nacl::string* full_url,
-                          bool* permit_extension_url,
                           ErrorInfo* error_info) const {
-    if (nexe_manifest_->ResolveURL(relative_url, full_url,
-                                   permit_extension_url, error_info)) {
+    if (nexe_manifest_->ResolveURL(relative_url, full_url, error_info)) {
       return true;
     }
-    return extension_manifest_->ResolveURL(relative_url, full_url,
-                                           permit_extension_url, error_info);
+    return extension_manifest_->ResolveURL(relative_url, full_url, error_info);
   }
 
   virtual bool GetFileKeys(std::set<nacl::string>* keys) const {
     if (nexe_manifest_->GetFileKeys(keys)) {
       return true;
     }
     return extension_manifest_->GetFileKeys(keys);
   }
 
   virtual bool ResolveKey(const nacl::string& key,
                           nacl::string* full_url,
-                          bool* permit_extension_url,
                           ErrorInfo* error_info,
                           bool* is_portable) const {
-    if (nexe_manifest_->ResolveKey(key, full_url, permit_extension_url,
-                                   error_info, is_portable)) {
+    if (nexe_manifest_->ResolveKey(key, full_url, error_info, is_portable)) {
       return true;
     }
-    return extension_manifest_->ResolveKey(key, full_url, permit_extension_url,
+    return extension_manifest_->ResolveKey(key, full_url,
                                            error_info, is_portable);
   }
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(PnaclLDManifest);
 
   const Manifest* nexe_manifest_;
   const Manifest* extension_manifest_;
 };
 
@@ skipping 191 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);
 
-  // "false" here indicates the pexe must be in user's manifest file origin.
-  if (!plugin_->StreamAsFile(pexe_url_, false, cb.pp_completion_callback())) {
+  if (!plugin_->StreamAsFile(pexe_url_, cb.pp_completion_callback())) {
     ReportNonPpapiError(nacl::string("failed to download ") + pexe_url_ + ".");
   }
 }
 
 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