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

components/nacl/renderer/plugin/pnacl_resources.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_resources.h"
 
+#include <vector>
+
+#include "base/macros.h"
 #include "components/nacl/renderer/plugin/plugin.h"
 #include "components/nacl/renderer/plugin/utility.h"
 #include "native_client/src/include/portability_io.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "ppapi/c/pp_errors.h"
 
 namespace plugin {
 
 namespace {
 
 static const char kPnaclBaseUrl[] = "chrome://pnacl-translator/";
 
 std::string GetFullUrl(const std::string& partial_url) {
   return std::string(kPnaclBaseUrl) + GetNaClInterface()->GetSandboxArch() +
          "/" + partial_url;
 }
 
 }  // namespace
 
-PnaclResources::PnaclResources(Plugin* plugin)
-    : plugin_(plugin) {
-  llc_file_info_ = kInvalidNaClFileInfo;
-  ld_file_info_ = kInvalidNaClFileInfo;
+PnaclResources::PnaclResources(Plugin* plugin, bool use_subzero)
+    : plugin_(plugin), use_subzero_(use_subzero) {
+  for (size_t i = 0; i < arraysize(resources_); ++i) {
+    resources_[i].file_info = kInvalidNaClFileInfo;
+  }
 }
 
 PnaclResources::~PnaclResources() {
-  if (llc_file_info_.handle != PP_kInvalidFileHandle)
-    CloseFileHandle(llc_file_info_.handle);
-  if (ld_file_info_.handle != PP_kInvalidFileHandle)
-    CloseFileHandle(ld_file_info_.handle);
+  for (size_t i = 0; i < arraysize(resources_); ++i) {
+    if (resources_[i].file_info.handle != PP_kInvalidFileHandle)
+      CloseFileHandle(resources_[i].file_info.handle);
+  }
+}
+
+const std::string& PnaclResources::GetUrl(ResourceType type) const {
+  size_t index = static_cast<size_t>(type);

[Derek Schuff, 2015/03/30 16:39:47]

would making ResourceType an enum class avoid the casting?

[jvoung (off chromium), 2015/03/30 20:26:40]

Doesn't seem to help:

http://stackoverflow.com/questions/12927951/array-indexing-converting-to-inte...

"no known conversion from 'plugin::PnaclResources::ResourceType' to 'size_type'"

and I'm not sure if "std::underlying_type" for converting is considered a
"library feature"... c++11 library features aren't allowed yet.

[Derek Schuff, 2015/03/30 21:03:12]

yeah it's declared in <type_traits>. oh well.

+  if (index < kNumTypes) {
+    return resources_[index].tool_name;
+  }
+  DCHECK(false && "Index out of bounds");

[Derek Schuff, 2015/03/30 16:39:47]

it looks like chrome style is
DCHECK(condition) << "message"

[jvoung (off chromium), 2015/03/30 20:26:40]

=(

Unfortunately this is the NaCl DCHECK macro. I tried using base/logging.h but
stuff like "LOG_FATAL" is a macro for NaCl (defined as -4) and conflicts with
LOG_FATAL (not a macro, defined as 3) in base/logging.h.

Added a TODO to use cleaner checks.

[Derek Schuff, 2015/03/30 21:03:12]

fun :/

+  // Return a dummy URL.
+  return resources_[kNumTypes].tool_name;
+}
+
+PP_NaClFileInfo PnaclResources::TakeFileInfo(ResourceType type) {
+  size_t index = static_cast<size_t>(type);
+  if (index >= kNumTypes) {
+    DCHECK(false && "Index out of bounds");
+    return kInvalidNaClFileInfo;
+  }
+  return resources_[index].file_info;
 }
 
 bool PnaclResources::ReadResourceInfo() {
   PP_Var pp_llc_tool_name_var;
   PP_Var pp_ld_tool_name_var;
+  PP_Var pp_subzero_tool_name_var;
   if (!plugin_->nacl_interface()->GetPnaclResourceInfo(
-          plugin_->pp_instance(),
-          &pp_llc_tool_name_var,
-          &pp_ld_tool_name_var)) {
+          plugin_->pp_instance(), &pp_llc_tool_name_var, &pp_ld_tool_name_var,
+          &pp_subzero_tool_name_var)) {
     return false;
   }
   pp::Var llc_tool_name(pp::PASS_REF, pp_llc_tool_name_var);
   pp::Var ld_tool_name(pp::PASS_REF, pp_ld_tool_name_var);
-  llc_tool_name_ = GetFullUrl(llc_tool_name.AsString());
-  ld_tool_name_ = GetFullUrl(ld_tool_name.AsString());
+  pp::Var subzero_tool_name(pp::PASS_REF, pp_subzero_tool_name_var);
+  resources_[kLLC].tool_name = GetFullUrl(llc_tool_name.AsString());
+  resources_[kLD].tool_name = GetFullUrl(ld_tool_name.AsString());
+  resources_[kSubzero].tool_name = GetFullUrl(subzero_tool_name.AsString());
   return true;
 }
 
-PP_NaClFileInfo PnaclResources::TakeLlcFileInfo() {
-  PP_NaClFileInfo to_return = llc_file_info_;
-  llc_file_info_ = kInvalidNaClFileInfo;
-  return to_return;
-}
-
-PP_NaClFileInfo PnaclResources::TakeLdFileInfo() {
-  PP_NaClFileInfo to_return = ld_file_info_;
-  ld_file_info_ = kInvalidNaClFileInfo;
-  return to_return;
-}
 
 bool PnaclResources::StartLoad() {
   PLUGIN_PRINTF(("PnaclResources::StartLoad\n"));
 
   // Do a blocking load of each of the resources.
-  plugin_->nacl_interface()->GetReadExecPnaclFd(llc_tool_name_.c_str(),
-                                                &llc_file_info_);
-  plugin_->nacl_interface()->GetReadExecPnaclFd(ld_tool_name_.c_str(),
-                                                &ld_file_info_);
-  return (llc_file_info_.handle != PP_kInvalidFileHandle &&
-          ld_file_info_.handle != PP_kInvalidFileHandle);
+  std::vector<ResourceType> to_load;
+  if (use_subzero_) {
+    to_load.push_back(kSubzero);
+  } else {
+    to_load.push_back(kLLC);
+  }
+  to_load.push_back(kLD);
+  bool all_valid = true;
+  for (ResourceType t : to_load) {
+    plugin_->nacl_interface()->GetReadExecPnaclFd(
+        resources_[t].tool_name.c_str(), &resources_[t].file_info);
+    all_valid =
+        all_valid && resources_[t].file_info.handle != PP_kInvalidFileHandle;
+  }
+  return all_valid;
 }
 
 }  // namespace plugin