Split pnacl and nacl mime types

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 58 matching lines @@
 const char* const kTypeAttribute = "type";
 // The "src" 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 kSrcManifestAttribute = "src";
 // The "nacl" attribute of the <embed> tag.  We use the value of this attribute
 // to find the manifest file when NaCl is registered as a plug-in for another
 // MIME type because the "src" attribute is used to supply us with the resource
 // of that MIME type that we're supposed to display.
 const char* const kNaClManifestAttribute = "nacl";
+// The pseudo-ISA used to indicate portable native client.
+const char* const kPortableISA = "portable";
 // 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 size_t kNaClManifestMaxFileBytes = 1024 * 1024;
 
 // Define an argument name to enable 'dev' interfaces. To make sure it doesn't
 // collide with any user-defined HTML attribute, make the first character '@'.
 const char* const kDevAttribute = "@dev";
 
 // URL schemes that we treat in special ways.
@@ skipping 479 matching lines @@
   // not taken.  Hence it does not need to be deleted when ProgressEvent is
   // 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";
+const char* const Plugin::kPnaclMIMEType = "application/x-pnacl";
 
 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;
+      mime_type() != kNaClMIMEType &&
+      mime_type() != kPnaclMIMEType;
 }
 
 
 Plugin* Plugin::New(PP_Instance pp_instance) {
   PLUGIN_PRINTF(("Plugin::New (pp_instance=%"NACL_PRId32")\n", pp_instance));
   Plugin* plugin = new Plugin(pp_instance);
   PLUGIN_PRINTF(("Plugin::New (plugin=%p)\n", static_cast<void*>(plugin)));
   if (plugin == NULL) {
     return NULL;
   }
@@ skipping 649 matching lines @@
 
 
 bool Plugin::SetManifestObject(const nacl::string& manifest_json,
                                ErrorInfo* error_info) {
   PLUGIN_PRINTF(("Plugin::SetManifestObject(): manifest_json='%s'.\n",
        manifest_json.c_str()));
   if (error_info == NULL)
     return false;
   // Determine whether lookups should use portable (i.e., pnacl versions)
   // rather than platform-specific files.
-  bool should_prefer_portable =
-      (getenv("NACL_PREFER_PORTABLE_IN_MANIFEST") != NULL);
+  bool is_pnacl = (mime_type() == kPnaclMIMEType);
   nacl::scoped_ptr<JsonManifest> json_manifest(
       new JsonManifest(url_util_,
                        manifest_base_url(),
-                       GetSandboxISA(),
-                       should_prefer_portable));
+                       (is_pnacl ? kPortableISA : GetSandboxISA())));
   if (!json_manifest->Init(manifest_json, error_info)) {
     return false;
   }
   manifest_.reset(json_manifest.release());
   return true;
 }
 
 void Plugin::UrlDidOpenForStreamAsFile(int32_t pp_error,
                                        FileDownloader*& url_downloader,
                                        PP_CompletionCallback callback) {
@@ skipping 365 matching lines @@
                                           static_cast<uint32_t>(text.size()));
   const PPB_Console* console_interface =
       static_cast<const PPB_Console*>(
           module->GetBrowserInterface(PPB_CONSOLE_INTERFACE));
   console_interface->LogWithSource(pp_instance(), PP_LOGLEVEL_LOG, prefix, str);
   var_interface->Release(prefix);
   var_interface->Release(str);
 }
 
 }  // namespace plugin