Pepper: Move PnaclOptions outside trusted plugin.

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 "ppapi/native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/checked_cast.h"
@@ skipping 24 matching lines @@
 // Here, we provide a manifest that redirects to PNaCl component files
 // that are part of Chrome.
 class PnaclManifest : public Manifest {
  public:
   PnaclManifest(const nacl::string& sandbox_arch)
       : sandbox_arch_(sandbox_arch) { }
 
   virtual ~PnaclManifest() { }
 
   virtual bool GetProgramURL(nacl::string* full_url,
-                             PnaclOptions* pnacl_options,
+                             PP_PNaClOptions* pnacl_options,
                              bool* uses_nonsfi_mode,
                              ErrorInfo* error_info) const {
     // Does not contain program urls.
     UNREFERENCED_PARAMETER(full_url);
     UNREFERENCED_PARAMETER(pnacl_options);
     UNREFERENCED_PARAMETER(uses_nonsfi_mode);
     UNREFERENCED_PARAMETER(error_info);
     PLUGIN_PRINTF(("PnaclManifest does not contain a program\n"));
     error_info->SetReport(PP_NACL_ERROR_MANIFEST_GET_NEXE_URL,
                           "pnacl manifest does not contain a program.");
     return false;
   }
 
   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,
-                          PnaclOptions* pnacl_options,
+                          PP_PNaClOptions* pnacl_options,
                           ErrorInfo* error_info) const {
     // All of the component files are native (do not require pnacl translate).
-    pnacl_options->set_translate(false);
+    pnacl_options->translate = PP_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(PP_NACL_ERROR_MANIFEST_RESOLVE_URL,
                             "key did not start with files/");
       return false;
     }
     // Resolve the full URL to the file. Provide it with a platform-specific
     // prefix.
@@ skipping 92 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 PnaclOptions& pnacl_options,
+    const PP_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,
                            pnacl_options,
                            translate_notify_callback);
   coordinator->pnacl_init_time_ = NaClGetTimeOfDayMicroseconds();
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeToNative (manifest=%p, ",
                  reinterpret_cast<const void*>(coordinator->manifest_.get())));
 
   int cpus = plugin->nacl_interface()->GetNumberOfProcessors();
   coordinator->split_module_count_ = std::min(4, std::max(1, cpus));
 
   // 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 nacl::string& pexe_url,
-    const PnaclOptions& pnacl_options,
+    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),
     manifest_(new PnaclManifest(plugin->nacl_interface()->GetSandboxArch())),
     pexe_url_(pexe_url),
     pnacl_options_(pnacl_options),
     split_module_count_(1),
     num_object_files_opened_(0),
@@ skipping 97 matching lines @@
   if (ExpectedProgressKnown()) {
     pexe_bytes_compiled_ = expected_pexe_size_;
     plugin_->EnqueueProgressEvent(PP_NACL_EVENT_PROGRESS,
                                   pexe_url_,
                                   plugin::Plugin::LENGTH_IS_COMPUTABLE,
                                   pexe_bytes_compiled_,
                                   expected_pexe_size_);
   }
 
   // If there are no errors, report stats from this thread (the main thread).
-  HistogramOptLevel(plugin_->uma_interface(), pnacl_options_.opt_level());
+  HistogramOptLevel(plugin_->uma_interface(), pnacl_options_.opt_level);
   HistogramKBPerSec(plugin_->uma_interface(),
                     "NaCl.Perf.PNaClLoadTime.CompileKBPerSec",
                     pexe_size_ / 1024.0,
                     translate_thread_->GetCompileTime() / 1000000.0);
   HistogramSizeKB(plugin_->uma_interface(), "NaCl.Perf.Size.Pexe",
                   static_cast<int64_t>(pexe_size_ / 1024));
 
   struct nacl_abi_stat stbuf;
   struct NaClDesc* desc = temp_nexe_file_->read_wrapper()->desc();
   int stat_ret;
@@ skipping 137 matching lines @@
   temp_nexe_file_.reset(new TempFile(plugin_));
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::NexeFdDidOpen);
   int32_t nexe_fd_err =
       plugin_->nacl_interface()->GetNexeFd(
           plugin_->pp_instance(),
           streaming_downloader_->full_url().c_str(),
           // TODO(dschuff): Get this value from the pnacl json file after it
           // rolls in from NaCl.
           1,
-          pnacl_options_.opt_level(),
+          pnacl_options_.opt_level,
           headers.c_str(),
           "", // No extra compile flags yet.
           &is_cache_hit_,
           temp_nexe_file_->existing_handle(),
           cb.pp_completion_callback());
   if (nexe_fd_err < PP_OK_COMPLETIONPENDING) {
     ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP, nexe_fd_err,
                      nacl::string("Call to GetNexeFd failed"));
   }
 }
@@ skipping 185 matching lines @@
                                   temp_nexe_file_.get(),
                                   invalid_desc_wrapper_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   &pnacl_options_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin