Add a switch for using PNaCl Subzero and use it for -O0 translation.

components/nacl/renderer/ppb_nacl_private_impl.cc

Index: components/nacl/renderer/ppb_nacl_private_impl.cc
diff --git a/components/nacl/renderer/ppb_nacl_private_impl.cc b/components/nacl/renderer/ppb_nacl_private_impl.cc
index fb5e6dc9e356f52fef1a591e386cada970e43eaf..063da8e384ac88f46bc6e10b5e15af40de99a567 100644
--- a/components/nacl/renderer/ppb_nacl_private_impl.cc
+++ b/components/nacl/renderer/ppb_nacl_private_impl.cc
@@ -267,6 +267,7 @@ class ManifestServiceProxy : public ManifestServiceChannel::Delegate {
     PP_PNaClOptions pnacl_options;
     pnacl_options.translate = PP_FALSE;
     pnacl_options.is_debug = PP_FALSE;
+    pnacl_options.use_subzero = PP_FALSE;
     pnacl_options.opt_level = 2;
     bool is_helper_process = process_type_ == kPNaClTranslatorProcessType;
     if (!ManifestResolveKey(pp_instance_, is_helper_process, key, &url,
@@ -671,6 +672,7 @@ void GetNexeFd(PP_Instance instance,
                const base::Time& last_modified_time,
                const std::string& etag,
                bool has_no_store_header,
+               bool use_subzero,
                base::Callback<void(int32_t, bool, PP_FileHandle)> callback) {
   if (!InitializePnaclResourceHost()) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
@@ -691,6 +693,7 @@ void GetNexeFd(PP_Instance instance,
   cache_info.last_modified = last_modified_time;
   cache_info.etag = etag;
   cache_info.has_no_store_header = has_no_store_header;
+  cache_info.use_subzero = use_subzero;
   cache_info.sandbox_isa = GetSandboxArch();
   cache_info.extra_flags = GetCpuFeatures();
 
@@ -704,8 +707,11 @@ void GetNexeFd(PP_Instance instance,
 void ReportTranslationFinished(PP_Instance instance,
                                PP_Bool success,
                                int32_t opt_level,
+                               PP_Bool use_subzero,
                                int64_t pexe_size,
                                int64_t compile_time_us) {
+  // TODO(jvoung): Log use_subzero stat in UMA.
+  (void)use_subzero;
   if (success == PP_TRUE) {
     static const int32_t kUnknownOptLevel = 4;
     if (opt_level < 0 || opt_level > 3)
@@ -1058,6 +1064,15 @@ PP_Bool ManifestGetProgramURL(PP_Instance instance,
                               &error_info)) {
     *pp_full_url = ppapi::StringVar::StringToPPVar(full_url);
     *pp_uses_nonsfi_mode = PP_FromBool(uses_nonsfi_mode);
+    // Check if we should use Subzero (x86-32 / non-debugging case for now).
+    if (pnacl_options->opt_level == 0 && !pnacl_options->is_debug &&
+        strcmp(GetSandboxArch(), "x86-32") == 0 &&
+        base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnablePNaClSubzero)) {
+      pnacl_options->use_subzero = PP_TRUE;
+      // Subzero -O2 is closer to LLC -O0, so indicate -O2.
+      pnacl_options->opt_level = 2;
+    }
     return PP_TRUE;
   }
 
@@ -1099,7 +1114,8 @@ bool ManifestResolveKey(PP_Instance instance,
 
 PP_Bool GetPNaClResourceInfo(PP_Instance instance,
                              PP_Var* llc_tool_name,
-                             PP_Var* ld_tool_name) {
+                             PP_Var* ld_tool_name,
+                             PP_Var* subzero_tool_name) {
   static const char kFilename[] = "chrome://pnacl-translator/pnacl.json";
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
@@ -1176,18 +1192,30 @@ PP_Bool GetPNaClResourceInfo(PP_Instance instance,
   if (json_data.isMember("pnacl-llc-name")) {
     Json::Value json_name = json_data["pnacl-llc-name"];
     if (json_name.isString()) {
-      std::string llc_tool_name_str = json_name.asString();
-      *llc_tool_name = ppapi::StringVar::StringToPPVar(llc_tool_name_str);
+      *llc_tool_name = ppapi::StringVar::StringToPPVar(json_name.asString());
     }
   }
 
   if (json_data.isMember("pnacl-ld-name")) {
     Json::Value json_name = json_data["pnacl-ld-name"];
     if (json_name.isString()) {
-      std::string ld_tool_name_str = json_name.asString();
-      *ld_tool_name = ppapi::StringVar::StringToPPVar(ld_tool_name_str);
+      *ld_tool_name = ppapi::StringVar::StringToPPVar(json_name.asString());
     }
   }
+
+  if (json_data.isMember("pnacl-sz-name")) {
+    Json::Value json_name = json_data["pnacl-sz-name"];
+    if (json_name.isString()) {
+      *subzero_tool_name =
+          ppapi::StringVar::StringToPPVar(json_name.asString());
+    }
+  } else {
+    // TODO(jvoung): remove fallback after one chrome release
+    // or when we bump the kMinPnaclVersion.
+    // TODO(jvoung): Just use strings instead of PP_Var!
+    *subzero_tool_name = ppapi::StringVar::StringToPPVar("pnacl-sz.nexe");
+  }
+
   return PP_TRUE;
 }
 
@@ -1491,17 +1519,19 @@ class PexeDownloader : public blink::WebURLLoaderClient {
                  scoped_ptr<blink::WebURLLoader> url_loader,
                  const std::string& pexe_url,
                  int32_t pexe_opt_level,
+                 bool use_subzero,
                  const PPP_PexeStreamHandler* stream_handler,
                  void* stream_handler_user_data)
       : instance_(instance),
         url_loader_(url_loader.Pass()),
         pexe_url_(pexe_url),
         pexe_opt_level_(pexe_opt_level),
+        use_subzero_(use_subzero),
         stream_handler_(stream_handler),
         stream_handler_user_data_(stream_handler_user_data),
         success_(false),
         expected_content_length_(-1),
-        weak_factory_(this) { }
+        weak_factory_(this) {}
 
   void Load(const blink::WebURLRequest& request) {
     url_loader_->loadAsynchronously(request, this);
@@ -1539,14 +1569,10 @@ class PexeDownloader : public blink::WebURLLoaderClient {
         has_no_store_header = true;
     }
 
-    GetNexeFd(instance_,
-              pexe_url_,
-              pexe_opt_level_,
-              last_modified_time,
-              etag,
-              has_no_store_header,
-              base::Bind(&PexeDownloader::didGetNexeFd,
-                         weak_factory_.GetWeakPtr()));
+    GetNexeFd(
+        instance_, pexe_url_, pexe_opt_level_, last_modified_time, etag,
+        has_no_store_header, use_subzero_,
+        base::Bind(&PexeDownloader::didGetNexeFd, weak_factory_.GetWeakPtr()));
   }
 
   virtual void didGetNexeFd(int32_t pp_error,
@@ -1606,6 +1632,7 @@ class PexeDownloader : public blink::WebURLLoaderClient {
   scoped_ptr<blink::WebURLLoader> url_loader_;
   std::string pexe_url_;
   int32_t pexe_opt_level_;
+  bool use_subzero_;
   const PPP_PexeStreamHandler* stream_handler_;
   void* stream_handler_user_data_;
   bool success_;
@@ -1616,6 +1643,7 @@ class PexeDownloader : public blink::WebURLLoaderClient {
 void StreamPexe(PP_Instance instance,
                 const char* pexe_url,
                 int32_t opt_level,
+                PP_Bool use_subzero,
                 const PPP_PexeStreamHandler* handler,
                 void* handler_user_data) {
   content::PepperPluginInstance* plugin_instance =
@@ -1634,12 +1662,9 @@ void StreamPexe(PP_Instance instance,
       plugin_instance->GetContainer()->element().document();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
-  PexeDownloader* downloader = new PexeDownloader(instance,
-                                                  url_loader.Pass(),
-                                                  pexe_url,
-                                                  opt_level,
-                                                  handler,
-                                                  handler_user_data);
+  PexeDownloader* downloader =
+      new PexeDownloader(instance, url_loader.Pass(), pexe_url, opt_level,
+                         PP_ToBool(use_subzero), handler, handler_user_data);
 
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
   // Mark the request as requesting a PNaCl bitcode file,