Use CORS for fetching NaCl resources from extensions.

ppapi/native_client/src/trusted/plugin/json_manifest.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 <algorithm>
 
 #include "native_client/src/trusted/plugin/json_manifest.h"
 
@@ skipping 178 matching lines @@
   return true;
 }
 
 // this will probably be replaced by jvoung's version that exposes
 // is_portable checks
 bool GetKeyUrl(const Json::Value& dictionary,
                const nacl::string& key,
                const nacl::string& sandbox_isa,
                const Manifest* manifest,
                nacl::string* full_url,
-               bool* permit_extension_url,
                ErrorInfo* error_info,
                bool* is_portable) {
   CHECK(full_url != NULL && error_info != NULL);
   *full_url = "";
   if (!dictionary.isMember(key)) {
     error_info->SetReport(ERROR_MANIFEST_RESOLVE_URL,
                           "file key not found in manifest");
     return false;
   }
   const Json::Value& isa_dict = dictionary[key];
   if (isa_dict.isMember(sandbox_isa)) {
     nacl::string relative_url = isa_dict[sandbox_isa][kUrlKey].asString();
     *is_portable = false;
-    return manifest->ResolveURL(relative_url, full_url, permit_extension_url,
-                                error_info);
+    return manifest->ResolveURL(relative_url, full_url, error_info);
   }
   if (isa_dict.isMember(kPortableKey)) {
     nacl::string relative_url = isa_dict[kPortableKey][kUrlKey].asString();
     *is_portable = true;
-    return manifest->ResolveURL(relative_url, full_url, permit_extension_url,
-                                error_info);
+    return manifest->ResolveURL(relative_url, full_url, error_info);
   }
   error_info->SetReport(ERROR_MANIFEST_RESOLVE_URL,
                         "neither ISA-specific nor portable representations"
                         " exist");
   return false;
 }
 
 }  // namespace
 
 bool JsonManifest::Init(const nacl::string& manifest_json,
@@ skipping 92 matching lines @@
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool JsonManifest::ResolveURL(const nacl::string& relative_url,
                               nacl::string* full_url,
-                              bool* permit_extension_url,
                               ErrorInfo* error_info) const {
-  // JSON manifests cannot confer extension access rights.
-  *permit_extension_url = false;
   // The contents of the manifest are resolved relative to the manifest URL.
   CHECK(url_util_ != NULL);
   pp::Var resolved_url =
       url_util_->ResolveRelativeToURL(pp::Var(manifest_base_url_),
                                       relative_url);
   if (!resolved_url.is_string()) {
     error_info->SetReport(
         ERROR_MANIFEST_RESOLVE_URL,
         "could not resolve url '" + relative_url +
         "' relative to manifest base url '" + manifest_base_url_.c_str() +
@@ skipping 20 matching lines @@
                                &nexe_url,
                                &error_string,
                                prefer_portable_,
                                is_portable)) {
     error_info->SetReport(ERROR_MANIFEST_GET_NEXE_URL,
                           nacl::string("program:") + sandbox_isa_ +
                           error_string);
     return false;
   }
 
-  // The program URL must be in the current origin.
-  bool dummy_permit_extension_url;
-  return ResolveURL(nexe_url, full_url, &dummy_permit_extension_url,
-                    error_info);
+  return ResolveURL(nexe_url, full_url, error_info);
 }
 
 bool JsonManifest::GetFileKeys(std::set<nacl::string>* keys) const {
   if (!dictionary_.isMember(kFilesKey)) {
     // trivial success: no keys when there is no "files" section.
     return true;
   }
   const Json::Value& files = dictionary_[kFilesKey];
   CHECK(files.isObject());
   Json::Value::Members members = files.getMemberNames();
   for (size_t i = 0; i < members.size(); ++i) {
     keys->insert(members[i]);
   }
   return true;
 }
 
 bool JsonManifest::ResolveKey(const nacl::string& key,
                               nacl::string* full_url,
-                              bool* permit_extension_url,
                               ErrorInfo* error_info,
                               bool* is_portable) const {
   NaClLog(3, "JsonManifest::ResolveKey(%s)\n", key.c_str());
   // key must be one of kProgramKey or kFileKey '/' file-section-key
 
   *full_url = "";
   if (key == kProgramKey) {
     return GetKeyUrl(dictionary_, key, sandbox_isa_, this, full_url,
-                     permit_extension_url, error_info, is_portable);
+                     error_info, is_portable);
   }
   nacl::string::const_iterator p = find(key.begin(), key.end(), '/');
   if (p == key.end()) {
     error_info->SetReport(ERROR_MANIFEST_RESOLVE_URL,
                           nacl::string("ResolveKey: invalid key, no slash: ")
                           + key);
     return false;
   }
 
   // generalize to permit other sections?
@@ skipping 16 matching lines @@
     return false;
   }
   if (!files.isMember(rest)) {
     error_info->SetReport(
         ERROR_MANIFEST_RESOLVE_URL,
         nacl::string("ResolveKey: no such \"files\" entry: ") + key);
     *is_portable = false;
     return false;
   }
   return GetKeyUrl(files, rest, sandbox_isa_, this, full_url,
-                   permit_extension_url, error_info, is_portable);
+                   error_info, is_portable);
 }
 
 }  // namespace plugin