Change pnacl to read all resources from the extension.

ppapi/native_client/src/trusted/plugin/plugin.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.
 
 #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 848 matching lines @@
   // destroyed.
   const char* event_type_;
   nacl::string url_;
   Plugin::LengthComputable length_computable_;
   uint64_t loaded_bytes_;
   uint64_t total_bytes_;
 };
 
 const char* const Plugin::kNaClMIMEType = "application/x-nacl";
 
-bool Plugin::IsForeignMIMEType() const {
+bool Plugin::NexeIsContentHandler() const {
+  // Tests if the MIME type is not a NaCl MIME type.
+  // If the MIME type is foreign, then this NEXE is being used as a content
+  // type handler rather than directly by an HTML document.
   return
       !mime_type().empty() &&
       mime_type() != kNaClMIMEType;
 }
 
 
 Plugin* Plugin::New(PP_Instance pp_instance) {
   PLUGIN_PRINTF(("Plugin::New (pp_instance=%"NACL_PRId32")\n", pp_instance));
 #if NACL_WINDOWS && !defined(NACL_STANDALONE)
   if (!NaClHandlePassBrowserCtor()) {
@@ skipping 49 matching lines @@
     enable_dev_interfaces_ = (dev_settings != NULL);
 
     const char* type_attr = LookupArgument(kTypeAttribute);
     if (type_attr != NULL) {
       mime_type_ = nacl::string(type_attr);
       std::transform(mime_type_.begin(), mime_type_.end(), mime_type_.begin(),
                      tolower);
     }
 
     const char* manifest_url = LookupArgument(kSrcManifestAttribute);
-    // If the MIME type is foreign, then 'src' will be the URL for the content
-    // and 'nacl' will be the URL for the manifest.
-    if (IsForeignMIMEType()) {
+    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.
     }
     // 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 676 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')\n", url.c_str()));
+  PLUGIN_PRINTF(("Plugin::StreamAsFile (url='%s', permits_extension_urls=%d)\n",
+                 url.c_str(), permits_extension_urls));
   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