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

components/nacl/renderer/plugin/pnacl_coordinator.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.
 
 #include "components/nacl/renderer/plugin/pnacl_coordinator.h"
 
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
@@ skipping 83 matching lines @@
     const pp::CompletionCallback& translate_notify_callback) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeToNative (plugin=%p, pexe=%s)\n",
                  static_cast<void*>(plugin), pexe_url.c_str()));
   PnaclCoordinator* coordinator =
       new PnaclCoordinator(plugin, pexe_url,
                            pnacl_options,
                            translate_notify_callback);
 
   GetNaClInterface()->SetPNaClStartTime(plugin->pp_instance());
   int cpus = plugin->nacl_interface()->GetNumberOfProcessors();
-  coordinator->split_module_count_ = std::min(4, std::max(1, cpus));
-
+  coordinator->num_threads_ = std::min(4, std::max(1, cpus));
+  if (pnacl_options.use_subzero) {
+    coordinator->split_module_count_ = 1;
+  } else {
+    coordinator->split_module_count_ = coordinator->num_threads_;
+  }
   // First start a network request for the pexe, to tickle the component
   // updater's On-Demand resource throttler, and to get Last-Modified/ETag
   // cache information. We can cancel the request later if there's
   // a bitcode->nexe cache hit.
   coordinator->OpenBitcodeStream();
   return coordinator;
 }
 
 PnaclCoordinator::PnaclCoordinator(
     Plugin* plugin,
     const std::string& pexe_url,
     const PP_PNaClOptions& pnacl_options,
     const pp::CompletionCallback& translate_notify_callback)
-  : translate_finish_error_(PP_OK),
-    plugin_(plugin),
-    translate_notify_callback_(translate_notify_callback),
-    translation_finished_reported_(false),
-    pexe_url_(pexe_url),
-    pnacl_options_(pnacl_options),
-    architecture_attributes_(GetArchitectureAttributes(plugin)),
-    split_module_count_(1),
-    error_already_reported_(false),
-    pexe_size_(0),
-    pexe_bytes_compiled_(0),
-    expected_pexe_size_(-1) {
+    : translate_finish_error_(PP_OK),
+      plugin_(plugin),
+      translate_notify_callback_(translate_notify_callback),
+      translation_finished_reported_(false),
+      pexe_url_(pexe_url),
+      pnacl_options_(pnacl_options),
+      architecture_attributes_(GetArchitectureAttributes(plugin)),
+      split_module_count_(0),
+      num_threads_(0),
+      error_already_reported_(false),
+      pexe_size_(0),
+      pexe_bytes_compiled_(0),
+      expected_pexe_size_(-1) {
   callback_factory_.Initialize(this);
 }
 
 PnaclCoordinator::~PnaclCoordinator() {
   PLUGIN_PRINTF(("PnaclCoordinator::~PnaclCoordinator (this=%p, "
                  "translate_thread=%p\n",
                  static_cast<void*>(this), translate_thread_.get()));
   // Stopping the translate thread will cause the translate thread to try to
   // run translation_complete_callback_ on the main thread.  This destructor is
   // running from the main thread, and by the time it exits, callback_factory_
@@ skipping 166 matching lines @@
 }
 
 void PnaclCoordinator::BitcodeStreamCacheMiss(int64_t expected_pexe_size,
                                               PP_FileHandle nexe_handle) {
   // IMPORTANT: Make sure that PnaclResources::StartLoad() is only
   // called after you receive a response to a request for a .pexe file.
   //
   // The component updater's resource throttles + OnDemand update/install
   // should block the URL request until the compiler is present. Now we
   // can load the resources (e.g. llc and ld nexes).
-  resources_.reset(new PnaclResources(plugin_));
+  resources_.reset(new PnaclResources(plugin_, pnacl_options_.use_subzero));
   CHECK(resources_ != NULL);
 
   // The first step of loading resources: read the resource info file.
   if (!resources_->ReadResourceInfo()) {
     ExitWithError();
     return;
   }
 
   // Second step of loading resources: call StartLoad to load pnacl-llc
   // and pnacl-ld, based on the filenames found in the resource info file.
   if (!resources_->StartLoad()) {
     ReportNonPpapiError(
         PP_NACL_ERROR_PNACL_RESOURCE_FETCH,
         std::string("The Portable Native Client (pnacl) component is not "
                      "installed. Please consult chrome://components for more "
                       "information."));
     return;
   }
 
   expected_pexe_size_ = expected_pexe_size;
 
-  for (int i = 0; i < split_module_count_; i++) {
+  for (size_t i = 0; i < split_module_count_; i++) {
     PP_FileHandle obj_handle =
         plugin_->nacl_interface()->CreateTemporaryFile(plugin_->pp_instance());
     nacl::scoped_ptr<TempFile> temp_file(new TempFile(plugin_, obj_handle));
     int32_t pp_error = temp_file->Open(true);
     if (pp_error != PP_OK) {
       ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
                        pp_error,
                        "Failed to open scratch object file.");
       return;
     } else {
@@ skipping 84 matching lines @@
 
 void PnaclCoordinator::RunTranslate(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::RunTranslate (pp_error=%"
                  NACL_PRId32 ")\n", pp_error));
   // Invoke llc followed by ld off the main thread.  This allows use of
   // blocking RPCs that would otherwise block the JavaScript main thread.
   pp::CompletionCallback report_translate_finished =
       callback_factory_.NewCallback(&PnaclCoordinator::TranslateFinished);
 
   CHECK(translate_thread_ != NULL);
-  translate_thread_->RunTranslate(report_translate_finished,
-                                  &obj_files_,
-                                  temp_nexe_file_.get(),
-                                  invalid_desc_wrapper_.get(),
-                                  &error_info_,
-                                  resources_.get(),
-                                  &pnacl_options_,
-                                  architecture_attributes_,
-                                  this,
-                                  plugin_);
+  translate_thread_->RunTranslate(report_translate_finished, &obj_files_,
+                                  num_threads_, temp_nexe_file_.get(),
+                                  invalid_desc_wrapper_.get(), &error_info_,
+                                  resources_.get(), &pnacl_options_,
+                                  architecture_attributes_, this, plugin_);
 }
 
 }  // namespace plugin