Add cross-origin loading of NEXEs for MIME type handlers

src/trusted/plugin/ppapi/plugin_ppapi.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/plugin_ppapi.h"
 
 #include <stdio.h>
 
@@ skipping 20 matching lines @@
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
 
 namespace plugin {
 
 namespace {
 
 // The "src" attribute of the <embed> tag. The value is expected to be a URL
 // pointing to the nexe (aka nacl module) file.
 const char* const kSrcAttribute = "src";
+const char* const kTypeAttribute = "type";
 // The "nacl" attribute of the <embed> tag.  The value is expected to be either
 // a URL or URI pointing to the manifest file (which is expected to contain
 // JSON matching ISAs with .nexe URLs).
 const char* const kNaclManifestAttribute = "nacl";
 // This is a pretty arbitrary limit on the byte size of the NaCl manfest file.
 // Note that the resulting string object has to have at least one byte extra
 // for the null termination character.
 const ssize_t kNaclManifestMaxFileBytesPlusNull = 1024;
 const ssize_t kNaclManifestMaxFileBytesNoNull =
     kNaclManifestMaxFileBytesPlusNull - 1;
@@ skipping 10 matching lines @@
   PluginPpapi* plugin =
       static_cast<PluginPpapi*>(reinterpret_cast<Plugin*>(obj));
   const char* url = ins[0]->arrays.str;
   // TODO(sehr,polina): Ensure that origin checks are performed here.
   return plugin->UrlAsNaClDesc(
       url, *reinterpret_cast<pp::Var*>(ins[1]->arrays.oval));
 }
 
 }  // namespace
 
+const char* const PluginPpapi::kNaClMIMEType = "application/x-nacl";
+
 bool PluginPpapi::SetAsyncCallback(void* obj, SrpcParams* params) {
   PluginPpapi* plugin =
       static_cast<PluginPpapi*>(reinterpret_cast<Plugin*>(obj));
   if (plugin->service_runtime_ == NULL) {
     params->set_exception_string("No subprocess running");
     return false;
   }
   if (plugin->receive_thread_running_) {
     params->set_exception_string("A callback has already been registered");
     return false;
@@ skipping 56 matching lines @@
                  static_cast<void*>(scriptable_handle())));
   bool status = Plugin::Init(
       browser_interface,
       PPInstanceToInstanceIdentifier(static_cast<pp::Instance*>(this)),
       static_cast<int>(argc),
       // TODO(polina): Can we change the args on our end to be const to
       // avoid these ugly casts? This will also require changes to npapi code.
       const_cast<char**>(argn),
       const_cast<char**>(argv));
   if (status) {
+    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);
+    }
     // Note: The order of attribute lookup is important.  This pattern looks
     // for a "nacl" attribute first, then a "src" attribute.
     const char* nacl_attr = LookupArgument(kNaclManifestAttribute);
     PLUGIN_PRINTF(("PluginPpapi::Init (nacl_attr=%s)\n", nacl_attr));
     if (nacl_attr != NULL) {
       // Issue a GET for the "nacl" attribute.  The value of the attribute
       // can be a URI or a URL pointing to the manifest file. The manifest
       // file will be parsed to determine the nexe URL. Then, just like for
       // the "src" attribute below, SetSrcPropertyImpl() will be called.
       //
@@ skipping 422 matching lines @@
 
 
 bool PluginPpapi::Failure(const nacl::string& error) {
   PLUGIN_PRINTF(("PluginPpapi::Failure (error='%s')\n", error.c_str()));
   browser_interface()->AddToConsole(instance_id(), error);
   ShutdownProxy();
   return false;
 }
 
 }  // namespace plugin