Allow PNaCl NMF to set translator optimization options for experimentation.

ppapi/native_client/src/trusted/plugin/pnacl_coordinator.h

 // 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.
 
 #ifndef NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_COORDINATOR_H_
 #define NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_COORDINATOR_H_
 
 #include <set>
 #include <map>
 #include <vector>
 
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/include/nacl_string.h"
 #include "native_client/src/shared/platform/nacl_sync_raii.h"
 
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "native_client/src/trusted/plugin/callback_source.h"
 #include "native_client/src/trusted/plugin/delayed_callback.h"
 #include "native_client/src/trusted/plugin/file_downloader.h"
 #include "native_client/src/trusted/plugin/local_temp_file.h"
 #include "native_client/src/trusted/plugin/nacl_subprocess.h"
 #include "native_client/src/trusted/plugin/plugin_error.h"
+#include "native_client/src/trusted/plugin/pnacl_options.h"
 #include "native_client/src/trusted/plugin/pnacl_resources.h"
 
 #include "ppapi/c/pp_file_info.h"
 #include "ppapi/c/trusted/ppb_file_io_trusted.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/file_io.h"
 #include "ppapi/cpp/file_ref.h"
 #include "ppapi/cpp/file_system.h"
 
 
 namespace plugin {
 
 class Manifest;
 class Plugin;
 class PnaclCoordinator;
 class PnaclTranslateThread;
 class TempFile;
 
 // A class invoked by Plugin to handle PNaCl client-side translation.
 // Usage:
 // (1) Invoke the factory method, e.g.,
 //     PnaclCoordinator* coord = BitcodeToNative(plugin,
 //                                               "http://foo.com/my.pexe",
+//                                               pnacl_options,
 //                                               TranslateNotifyCallback);
 // (2) TranslateNotifyCallback gets invoked when translation is complete.
 //     If the translation was successful, the pp_error argument is PP_OK.
 //     Other values indicate errors.
 // (3) After finish_callback runs, get the file descriptor of the translated
 //     nexe, e.g.,
 //     fd = coord->ReleaseTranslatedFD();
 // (4) Load the nexe from "fd".
 // (5) delete coord.
 //
@@ skipping 36 matching lines @@
 // OPEN_NEXE_FOR_SEL_LDR
 //   Complete when NexeReadDidOpen is invoked.
 class PnaclCoordinator: public CallbackSource<FileStreamData> {
  public:
   virtual ~PnaclCoordinator();
 
   // The factory method for translations.
   static PnaclCoordinator* BitcodeToNative(
       Plugin* plugin,
       const nacl::string& pexe_url,
-      const nacl::string& cache_identity,
+      const PnaclOptions& pnacl_options,
       const pp::CompletionCallback& translate_notify_callback);
 
   // Call this to take ownership of the FD of the translated nexe after
   // BitcodeToNative has completed (and the finish_callback called).
   nacl::DescWrapper* ReleaseTranslatedFD() { return translated_fd_.release(); }
 
   // Looks up a file descriptor for an url that was already downloaded.
   // This is used for getting the descriptor for llc and ld nexes as well
   // as the libraries and object files used by the linker.
   int32_t GetLoadedFileDesc(int32_t pp_error,
@@ skipping 26 matching lines @@
   // Get the last known load progress.
   void GetCurrentProgress(int64_t* bytes_loaded, int64_t* bytes_total);
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(PnaclCoordinator);
 
   // BitcodeToNative is the factory method for PnaclCoordinators.
   // Therefore the constructor is private.
   PnaclCoordinator(Plugin* plugin,
                    const nacl::string& pexe_url,
-                   const nacl::string& cache_identity,
+                   const PnaclOptions& pnacl_options,
                    const pp::CompletionCallback& translate_notify_callback);
 
   // Callback for when llc and ld have been downloaded.
   // This is the first callback invoked in response to BitcodeToNative.
   void ResourcesDidLoad(int32_t pp_error);
 
   // Callbacks for temporary file related stages.
   // They are invoked from ResourcesDidLoad and proceed in declaration order.
   // Invoked when the temporary file system is successfully opened in PPAPI.
   void FileSystemDidOpen(int32_t pp_error);
@@ skipping 63 matching lines @@
   // The manifest used by ld's reverse service to look up objects and libraries.
   nacl::scoped_ptr<const Manifest> ld_manifest_;
   // An auxiliary class that manages downloaded resources (llc and ld nexes).
   nacl::scoped_ptr<PnaclResources> resources_;
 
   // State used for querying the temporary directory.
   nacl::scoped_ptr<pp::FileRef> dir_ref_;
 
   // The URL for the pexe file.
   nacl::string pexe_url_;
-  // Optional cache identity for translation caching.
-  nacl::string cache_identity_;
+  // Options for translation.
+  PnaclOptions pnacl_options_;
+
   // Object file, produced by the translator and consumed by the linker.
   nacl::scoped_ptr<TempFile> obj_file_;
   // Translated nexe file, produced by the linker.
   nacl::scoped_ptr<TempFile> temp_nexe_file_;
   // Cached nexe file, consumed by sel_ldr.  This will be NULL if we do
   // not have a writeable cache file.  That is currently the case when
   // off_the_record_ is true.
   nacl::scoped_ptr<LocalTempFile> cached_nexe_file_;
 
   // Downloader for streaming translation
   nacl::scoped_ptr<FileDownloader> streaming_downloader_;
 
   // Used to report information when errors (PPAPI or otherwise) are reported.
   ErrorInfo error_info_;
+
   // True if an error was already reported, and translate_notify_callback_
   // was already run/consumed.
   bool error_already_reported_;
 
   // True if compilation is off_the_record.
   bool off_the_record_;
 
   // State for timing and size information for UMA stats.
   int64_t pnacl_init_time_;
   int64_t pexe_size_;  // Count as we stream -- will converge to pexe size.
   int64_t pexe_bytes_compiled_;  // Count as we compile.
   int64_t expected_pexe_size_;   // Expected download total (-1 if unknown).
 
   // The helper thread used to do translations via SRPC.
   // Keep this last in declaration order to ensure the other variables
   // haven't been destroyed yet when its destructor runs.
   nacl::scoped_ptr<PnaclTranslateThread> translate_thread_;
 };
 
 //----------------------------------------------------------------------
 
 }  // namespace plugin;
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PNACL_COORDINATOR_H_