Use CORS for fetching NaCl resources from extensions.

ppapi/native_client/src/trusted/plugin/plugin.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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "native_client/src/trusted/plugin/plugin.h"
@@ skipping 933 matching lines @@
                      tolower);
     }
 
     const char* manifest_url = LookupArgument(kSrcManifestAttribute);
     if (NexeIsContentHandler()) {
       // For content handlers 'src' will be the URL for the content
       // and 'nacl' will be the URL for the manifest.
       manifest_url = LookupArgument(kNaClManifestAttribute);
       // For content handlers the NEXE runs in the security context of the
       // content it is rendering and the NEXE itself appears to be a
-      // cross-origin resource stored in a Chrome extension.  We request
-      // universal access during the NEXE load so that we can read the NEXE.
+      // cross-origin resource stored in a Chrome extension.
     }
     // Use the document URL as the base for resolving relative URLs to find the
     // manifest.  This takes into account the setting of <base> tags that
     // precede the embed/object.
     CHECK(url_util_ != NULL);
     pp::Var base_var = url_util_->GetDocumentURL(*this);
     if (!base_var.is_string()) {
       PLUGIN_PRINTF(("Plugin::Init (unable to find document url)\n"));
       return false;
     }
@@ skipping 666 matching lines @@
                                             program_url,
                                             translate_callback));
       return;
     } else {
       pp::CompletionCallback open_callback =
           callback_factory_.NewRequiredCallback(&Plugin::NexeFileDidOpen);
       // Will always call the callback on success or failure.
       CHECK(
           nexe_downloader_.Open(program_url,
                                 DOWNLOAD_TO_FILE,
-                                NexeIsContentHandler(),
                                 open_callback,
                                 &UpdateDownloadProgress));
       return;
     }
   }
   // Failed to select the program and/or the translator.
   ReportLoadError(error_info);
 }
 
 void Plugin::RequestNaClManifest(const nacl::string& url) {
@@ skipping 21 matching lines @@
   set_nacl_ready_state(OPENED);
   EnqueueProgressEvent(kProgressEventLoadStart);
   bool is_data_uri = GetUrlScheme(nmf_resolved_url.AsString()) == SCHEME_DATA;
   HistogramEnumerateManifestIsDataURI(static_cast<int>(is_data_uri));
   if (is_data_uri) {
     pp::CompletionCallback open_callback =
         callback_factory_.NewRequiredCallback(&Plugin::NaClManifestBufferReady);
     // Will always call the callback on success or failure.
     CHECK(nexe_downloader_.Open(nmf_resolved_url.AsString(),
                                 DOWNLOAD_TO_BUFFER,
-                                NexeIsContentHandler(),
                                 open_callback,
                                 NULL));
   } else {
     pp::CompletionCallback open_callback =
         callback_factory_.NewRequiredCallback(&Plugin::NaClManifestFileDidOpen);
     // Will always call the callback on success or failure.
     CHECK(nexe_downloader_.Open(nmf_resolved_url.AsString(),
                                 DOWNLOAD_TO_FILE,
-                                NexeIsContentHandler(),
                                 open_callback,
                                 NULL));
   }
 }
 
 
 bool Plugin::SetManifestObject(const nacl::string& manifest_json,
                                ErrorInfo* error_info) {
   PLUGIN_PRINTF(("Plugin::SetManifestObject(): manifest_json='%s'.\n",
        manifest_json.c_str()));
@@ skipping 50 matching lines @@
   PLUGIN_PRINTF(("Plugin::GetFileDesc (url=%s)\n", url.c_str()));
   int32_t file_desc_ok_to_close = NACL_NO_FILE_DESC;
   std::map<nacl::string, int32_t>::iterator it = url_fd_map_.find(url);
   if (it != url_fd_map_.end())
     file_desc_ok_to_close = DUP(it->second);
   return file_desc_ok_to_close;
 }
 
 
 bool Plugin::StreamAsFile(const nacl::string& url,
-                          bool permits_extension_urls,
                           PP_CompletionCallback callback) {
-  PLUGIN_PRINTF(("Plugin::StreamAsFile (url='%s', permits_extension_urls=%d)\n",
-                 url.c_str(), permits_extension_urls));
+  PLUGIN_PRINTF(("Plugin::StreamAsFile (url='%s')\n", url.c_str()));
   FileDownloader* downloader = new FileDownloader();
   downloader->Initialize(this);
   url_downloaders_.insert(downloader);
   pp::CompletionCallback open_callback =
       callback_factory_.NewRequiredCallback(
           &Plugin::UrlDidOpenForStreamAsFile, downloader, callback);
   // Untrusted loads are always relative to the page's origin.
   CHECK(url_util_ != NULL);
   pp::Var resolved_url =
       url_util_->ResolveRelativeToURL(pp::Var(plugin_base_url()), url);
   if (!resolved_url.is_string()) {
     PLUGIN_PRINTF(("Plugin::StreamAsFile: "
                    "could not resolve url \"%s\" relative to plugin \"%s\".",
                    url.c_str(),
                    plugin_base_url().c_str()));
     return false;
   }
   // If true, will always call the callback on success or failure.
   return downloader->Open(url,
                           DOWNLOAD_TO_FILE,
-                          permits_extension_urls || NexeIsContentHandler(),
                           open_callback,
                           &UpdateDownloadProgress);
 }
 
 #ifndef HACK_FOR_MACOS_HANG_REMOVED
 // The following is needed to avoid a plugin startup hang in the
 // MacOS "chrome_browser_tests under gyp" stage.
 // TODO(sehr,mseaborn): remove this hack.
 void (plugin::Plugin::*pmem)(int32_t,
                              plugin::FileDownloader*&,
@@ skipping 254 matching lines @@
   std::string scheme = canonicalized.AsString().substr(comps.scheme.begin,
                                                        comps.scheme.len);
   if (scheme == kChromeExtensionUriScheme)
     return SCHEME_CHROME_EXTENSION;
   if (scheme == kDataUriScheme)
     return SCHEME_DATA;
   return SCHEME_OTHER;
 }
 
 }  // namespace plugin