Allow PNaCl NMF to set translator optimization options for experimentation.

ppapi/native_client/src/trusted/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 "native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/checked_cast.h"
@@ skipping 30 matching lines @@
   PnaclManifest(const pp::URLUtil_Dev* url_util, bool use_extension)
       : url_util_(url_util),
         manifest_base_url_(PnaclUrls::GetBaseUrl(use_extension)) {
     // TODO(jvoung): get rid of use_extension when we no longer rely
     // on the chrome webstore extension.  Most of this Manifest stuff
     // can also be simplified then.
   }
   virtual ~PnaclManifest() { }
 
   virtual bool GetProgramURL(nacl::string* full_url,
-                             nacl::string* cache_identity,
-                             ErrorInfo* error_info,
-                             bool* pnacl_translate) const {
+                             PnaclOptions* pnacl_options,
+                             ErrorInfo* error_info) const {
     // Does not contain program urls.
     UNREFERENCED_PARAMETER(full_url);
-    UNREFERENCED_PARAMETER(cache_identity);
+    UNREFERENCED_PARAMETER(pnacl_options);
     UNREFERENCED_PARAMETER(error_info);
-    UNREFERENCED_PARAMETER(pnacl_translate);
     PLUGIN_PRINTF(("PnaclManifest does not contain a program\n"));
     error_info->SetReport(ERROR_MANIFEST_GET_NEXE_URL,
                           "pnacl manifest does not contain a program.");
     return false;
   }
 
   virtual bool ResolveURL(const nacl::string& relative_url,
                           nacl::string* full_url,
                           ErrorInfo* error_info) const {
     // Does not do general URL resolution, simply appends relative_url to
     // the end of manifest_base_url_.
     UNREFERENCED_PARAMETER(error_info);
     *full_url = manifest_base_url_ + relative_url;
     return true;
   }
 
   virtual bool GetFileKeys(std::set<nacl::string>* keys) const {
     // Does not support enumeration.
     PLUGIN_PRINTF(("PnaclManifest does not support key enumeration\n"));
     UNREFERENCED_PARAMETER(keys);
     return false;
   }
 
   virtual bool ResolveKey(const nacl::string& key,
                           nacl::string* full_url,
-                          nacl::string* cache_identity,
-                          ErrorInfo* error_info,
-                          bool* pnacl_translate) const {
+                          PnaclOptions* pnacl_options,
+                          ErrorInfo* error_info) const {
     // All of the extension files are native (do not require pnacl translate).
-    *pnacl_translate = false;
-    // Do not cache these entries.
-    *cache_identity = "";
+    pnacl_options->set_translate(false);
     // We can only resolve keys in the files/ namespace.
     const nacl::string kFilesPrefix = "files/";
     size_t files_prefix_pos = key.find(kFilesPrefix);
     if (files_prefix_pos == nacl::string::npos) {
       error_info->SetReport(ERROR_MANIFEST_RESOLVE_URL,
                             "key did not start with files/");
       return false;
     }
     // Append what follows files to the pnacl URL prefix.
     nacl::string key_basename = key.substr(kFilesPrefix.length());
@@ skipping 17 matching lines @@
   PnaclLDManifest(const Manifest* nexe_manifest,
                   const Manifest* extension_manifest)
       : nexe_manifest_(nexe_manifest),
         extension_manifest_(extension_manifest) {
     CHECK(nexe_manifest != NULL);
     CHECK(extension_manifest != NULL);
   }
   virtual ~PnaclLDManifest() { }
 
   virtual bool GetProgramURL(nacl::string* full_url,
-                             nacl::string* cache_identity,
-                             ErrorInfo* error_info,
-                             bool* pnacl_translate) const {
-    if (nexe_manifest_->GetProgramURL(full_url, cache_identity,
-                                      error_info, pnacl_translate)) {
+                             PnaclOptions* pnacl_options,
+                             ErrorInfo* error_info) const {
+    if (nexe_manifest_->GetProgramURL(full_url, pnacl_options, error_info)) {
       return true;
     }
-    return extension_manifest_->GetProgramURL(full_url, cache_identity,
-                                              error_info, pnacl_translate);
+    return extension_manifest_->GetProgramURL(full_url,
+                                              pnacl_options,
+                                              error_info);
   }
 
   virtual bool ResolveURL(const nacl::string& relative_url,
                           nacl::string* full_url,
                           ErrorInfo* error_info) const {
     if (nexe_manifest_->ResolveURL(relative_url, full_url, error_info)) {
       return true;
     }
     return extension_manifest_->ResolveURL(relative_url, full_url, error_info);
   }
 
   virtual bool GetFileKeys(std::set<nacl::string>* keys) const {
     if (nexe_manifest_->GetFileKeys(keys)) {
       return true;
     }
     return extension_manifest_->GetFileKeys(keys);
   }
 
   virtual bool ResolveKey(const nacl::string& key,
                           nacl::string* full_url,
-                          nacl::string* cache_identity,
-                          ErrorInfo* error_info,
-                          bool* pnacl_translate) const {
-    if (nexe_manifest_->ResolveKey(key, full_url, cache_identity,
-                                   error_info, pnacl_translate)) {
+                          PnaclOptions* pnacl_options,
+                          ErrorInfo* error_info) const {
+    if (nexe_manifest_->ResolveKey(key, full_url, pnacl_options, error_info)) {
       return true;
     }
-    return extension_manifest_->ResolveKey(key, full_url, cache_identity,
-                                           error_info, pnacl_translate);
+    return extension_manifest_->ResolveKey(key, full_url,
+                                           pnacl_options,
+                                           error_info);
   }
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(PnaclLDManifest);
 
   const Manifest* nexe_manifest_;
   const Manifest* extension_manifest_;
 };
 
 //////////////////////////////////////////////////////////////////////
@@ skipping 90 matching lines @@
 //////////////////////////////////////////////////////////////////////
 
 // Out-of-line destructor to keep it from getting put in every .o where
 // callback_source.h is included
 template<>
 CallbackSource<FileStreamData>::~CallbackSource() {}
 
 PnaclCoordinator* PnaclCoordinator::BitcodeToNative(
     Plugin* plugin,
     const nacl::string& pexe_url,
-    const nacl::string& cache_identity,
+    const PnaclOptions& pnacl_options,
     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,
-                           cache_identity, translate_notify_callback);
+                           pnacl_options,
+                           translate_notify_callback);
   coordinator->pnacl_init_time_ = NaClGetTimeOfDayMicroseconds();
   coordinator->off_the_record_ =
       plugin->nacl_interface()->IsOffTheRecord();
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeToNative (manifest=%p, "
                  "off_the_record=%d)\n",
                  reinterpret_cast<const void*>(coordinator->manifest_.get()),
                  coordinator->off_the_record_));
 
   // Load llc and ld.
   std::vector<nacl::string> resource_urls;
@@ skipping 31 matching lines @@
                        component + " load failed.");
     }
     return NACL_NO_FILE_DESC;
   }
   return file_desc_ok_to_close;
 }
 
 PnaclCoordinator::PnaclCoordinator(
     Plugin* plugin,
     const nacl::string& pexe_url,
-    const nacl::string& cache_identity,
+    const PnaclOptions& pnacl_options,
     const pp::CompletionCallback& translate_notify_callback)
   : translate_finish_error_(PP_OK),
     plugin_(plugin),
     translate_notify_callback_(translate_notify_callback),
     file_system_(new pp::FileSystem(plugin, PP_FILESYSTEMTYPE_LOCALTEMPORARY)),
     manifest_(new PnaclManifest(
         plugin->url_util(),
         plugin::PnaclUrls::UsePnaclExtension(plugin))),
     pexe_url_(pexe_url),
-    cache_identity_(cache_identity),
+    pnacl_options_(pnacl_options),
     error_already_reported_(false),
     off_the_record_(false),
     pnacl_init_time_(0),
     pexe_size_(0),
     pexe_bytes_compiled_(0),
     expected_pexe_size_(-1) {
   PLUGIN_PRINTF(("PnaclCoordinator::PnaclCoordinator (this=%p, plugin=%p)\n",
                  static_cast<void*>(this), static_cast<void*>(plugin)));
   callback_factory_.Initialize(this);
   ld_manifest_.reset(new PnaclLDManifest(plugin_->manifest(), manifest_.get()));
@@ skipping 92 matching lines @@
     size_t nexe_size = stbuf.nacl_abi_st_size;
     HistogramSizeKB("NaCl.Perf.Size.PNaClTranslatedNexe",
                     static_cast<int64_t>(nexe_size / 1024));
     HistogramRatio("NaCl.Perf.Size.PexeNexeSizePct", pexe_size_, nexe_size);
   }
 
   // The nexe is written to the temp_nexe_file_.  We must Reset() the file
   // pointer to be able to read it again from the beginning.
   temp_nexe_file_->Reset();
 
-  if (cache_identity_ != "" && cached_nexe_file_ != NULL) {
+  if (pnacl_options_.HasCacheKey() && cached_nexe_file_ != NULL) {
     // We are using a cache, but had a cache miss, which is why we did the
     // translation.  Reset cached_nexe_file_ to have a random name,
-    // for scratch purposes, before renaming to the final cache_identity_.
+    // for scratch purposes, before renaming to the final cache_identity.
     cached_nexe_file_.reset(new LocalTempFile(plugin_, file_system_.get(),
                                               nacl::string(kPnaclTempDir)));
     pp::CompletionCallback cb = callback_factory_.NewCallback(
         &PnaclCoordinator::CachedNexeOpenedForWrite);
     cached_nexe_file_->OpenWrite(cb);
   } else {
     // For now, tolerate bitcode that is missing a cache identity, and
     // tolerate the lack of caching in incognito mode.
     PLUGIN_PRINTF(("PnaclCoordinator -- not caching.\n"));
     NexeReadDidOpen(PP_OK);
@@ skipping 130 matching lines @@
     // returning. We pass the current pp_error along so that it can be reported
     // before returning.
     pp::CompletionCallback cb = callback_factory_.NewCallback(
         &PnaclCoordinator::CorruptCacheFileWasDeleted, pp_error);
     cached_nexe_file_->Delete(cb);
     return;
   }
   // Rename the cached_nexe_file_ file to the cache id, to finalize.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::NexeFileWasRenamed);
-  cached_nexe_file_->Rename(cache_identity_, cb);
+  cached_nexe_file_->Rename(pnacl_options_.GetCacheKey(), cb);
 }
 
 void PnaclCoordinator::CorruptCacheFileWasDeleted(int32_t delete_pp_error,
                                                   int32_t orig_pp_error) {
   if (delete_pp_error != PP_OK) {
     // The cache file was certainly already opened by the time we tried
     // to write to it, so it should certainly be deletable.
     PLUGIN_PRINTF(("PnaclCoordinator::CorruptCacheFileWasDeleted "
                    "delete failed with pp_error=%"NACL_PRId32"\n",
                    delete_pp_error));
@@ skipping 180 matching lines @@
           "PNaCl translation cache directory creation/check failed "
           "(no access).");
       return;
     }
     ReportPpapiError(
         ERROR_PNACL_CACHE_DIRECTORY_CREATE,
         pp_error,
         "PNaCl translation cache directory creation/check failed.");
     return;
   }
-  if (cache_identity_ != "") {
-    cached_nexe_file_.reset(new LocalTempFile(plugin_, file_system_.get(),
-                                              nacl::string(kPnaclTempDir),
-                                              cache_identity_));
+  if (pnacl_options_.HasCacheKey()) {
+    cached_nexe_file_.reset(new LocalTempFile(
+        plugin_, file_system_.get(),
+        nacl::string(kPnaclTempDir),
+        pnacl_options_.GetCacheKey()));
     pp::CompletionCallback cb =
         callback_factory_.NewCallback(&PnaclCoordinator::CachedFileDidOpen);
     cached_nexe_file_->OpenRead(cb);
   } else {
     // For now, tolerate lack of cache identity...
     CachedFileDidOpen(PP_ERROR_FAILED);
   }
 }
 
 void PnaclCoordinator::CachedFileDidOpen(int32_t pp_error) {
@@ skipping 138 matching lines @@
       callback_factory_.NewCallback(&PnaclCoordinator::TranslateFinished);
 
   CHECK(translate_thread_ != NULL);
   translate_thread_->RunTranslate(report_translate_finished,
                                   manifest_.get(),
                                   ld_manifest_.get(),
                                   obj_file_.get(),
                                   temp_nexe_file_.get(),
                                   &error_info_,
                                   resources_.get(),
+                                  &pnacl_options_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin