Add cross-origin loading of NEXEs for MIME type handlers

src/trusted/plugin/ppapi/file_downloader.cc

 // Copyright (c) 2011 The Native Client 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/ppapi/file_downloader.h"
 
 #include <stdio.h>
 #include <string>
 
 #include "native_client/src/include/portability_io.h"
 #include "native_client/src/shared/platform/nacl_check.h"
+#include "native_client/src/trusted/plugin/ppapi/plugin_ppapi.h"
 #include "native_client/src/trusted/plugin/utility.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/dev/ppb_file_io_dev.h"
+#include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/cpp/dev/file_ref_dev.h"
 #include "ppapi/cpp/url_request_info.h"
 #include "ppapi/cpp/url_response_info.h"
 
 namespace {
 
-const char* const kChromeExtensionScheme = "chrome-extension";
+const char* const kChromeExtensionScheme = "chrome-extension:";
 const int32_t kExtensionRequestStatusOk = 0;
 
 // A helper function that tests to see if |url| is in the chrome-extension
 // scheme.  Note that this routine assumes that the scheme part of |url| is
 // all lower-case UTF8.
 bool IsChromeExtensionUrl(const std::string& url) {
   // The scheme has to exist and be at the start of |url|.
   return url.find(kChromeExtensionScheme) == 0;
 }
 }
 
 namespace plugin {
 
-void FileDownloader::Initialize(pp::Instance* instance) {
+void FileDownloader::Initialize(PluginPpapi* instance) {
   PLUGIN_PRINTF(("FileDownloader::FileDownloader (this=%p)\n",
                  static_cast<void*>(this)));
   CHECK(instance != NULL);
   CHECK(instance_ == NULL);
   if (instance == NULL)
     return;
   if (instance_ != NULL)
     return;  // Can only initialize once.
   instance_ = instance;
   callback_factory_.Initialize(this);
 }
 
 
 bool FileDownloader::Open(const nacl::string& url,
                           const pp::CompletionCallback& callback) {
   CHECK(instance_ != NULL);
   url_to_open_ = url;
   url_ = url;
   file_open_notify_callback_ = callback;
   // Reset the url loader and file reader.
   // Note that we have the only refernce to the underlying objects, so
   // this will implicitly close any pending IO and destroy them.
   url_loader_ = pp::URLLoader(instance_);
+
+  if (!instance_->mime_type().empty() &&
+      instance_->mime_type() != kNaClMIMEType &&
+      IsChromeExtensionUrl(url)) {
+    // This NEXE is being used as a content type handler rather than directly
+    // by an HTML document. In that case, 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 this load so that we can read the NEXE.
+    const PPB_URLLoaderTrusted* url_loaded_trusted =
+        static_cast<const PPB_URLLoaderTrusted*>(
+        pp::Module::Get()->GetBrowserInterface(PPB_URLLOADERTRUSTED_INTERFACE));
+    if (url_loaded_trusted)
+      url_loaded_trusted->GrantUniversalAccess(url_loader_.pp_resource());
+  }
+
   file_reader_ = pp::FileIO_Dev(instance_);
   file_io_trusted_interface_ = static_cast<const PPB_FileIOTrusted_Dev*>(
       pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_DEV_INTERFACE));
   if (file_io_trusted_interface_ == NULL)
     return false;  // Interface not supported by our browser
 
   // Prepare the url request.
   pp::URLRequestInfo url_request(instance_);
   url_request.SetURL(url_);
   url_request.SetStreamToFile(true);
@@ skipping 141 matching lines @@
 }
 
 
 void FileDownloader::FileOpenNotify(int32_t pp_error) {
   PLUGIN_PRINTF(("FileDownloader::FileOpenNotify (pp_error=%"NACL_PRId32")\n",
                  pp_error));
   file_open_notify_callback_.Run(pp_error);
 }
 
 }  // namespace plugin