Pepper: Move manifest logic to components/nacl.

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

 // -*- c++ -*-
 // 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.
 
 // The portable representation of an instance and root scriptable object.
 // The PPAPI version of the plugin instantiates a subclass of this class.
 
 #ifndef NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PLUGIN_H_
 #define NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PLUGIN_H_
@@ skipping 93 matching lines @@
   // main-thread-only operations such as file processing.
   bool LoadNaClModuleContinuation(int32_t pp_error);
 
   // Load support.
   // A helper SRPC NaCl module can be loaded given a DescWrapper.
   // Blocks until the helper module signals initialization is done.
   // Does not update nacl_module_origin().
   // Returns NULL or the NaClSubprocess of the new helper NaCl module.
   NaClSubprocess* LoadHelperNaClModule(const nacl::string& helper_url,
                                        nacl::DescWrapper* wrapper,
-                                       const Manifest* manifest,
+                                       int32_t manifest_id,
                                        ErrorInfo* error_info);
 
   enum LengthComputable {
     LENGTH_IS_NOT_COMPUTABLE = 0,
     LENGTH_IS_COMPUTABLE = 1
   };
   // Report successful loading of a module.
   void ReportLoadSuccess(uint64_t loaded_bytes, uint64_t total_bytes);
   // Report an error that was encountered while loading a module.
   void ReportLoadError(const ErrorInfo& error_info);
@@ skipping 32 matching lines @@
   // Returns rich information for a file retrieved by StreamAsFile(). This info
   // contains a file descriptor. The caller must take ownership of this
   // descriptor.
   struct NaClFileInfo GetFileInfo(const nacl::string& url);
 
   // A helper function that indicates if |url| can be requested by the document
   // under the same-origin policy. Strictly speaking, it may be possible for the
   // document to request the URL using CORS even if this function returns false.
   bool DocumentCanRequest(const std::string& url);
 
-  Manifest const* manifest() const { return manifest_.get(); }
-
   // set_exit_status may be called off the main thread.
   void set_exit_status(int exit_status);
 
   const PPB_NaCl_Private* nacl_interface() const { return nacl_interface_; }
   pp::UMAPrivate& uma_interface() { return uma_interface_; }
 
  private:
   NACL_DISALLOW_COPY_AND_ASSIGN(Plugin);
   // The browser will invoke the destructor via the pp::Instance
   // pointer to this object, not from base's Delete().
@@ skipping 20 matching lines @@
                           int out_of_range_replacement);
   void HistogramEnumerateLoadStatus(PP_NaClError error_code);
   void HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code);
   void HistogramHTTPStatusCode(const std::string& name, int status);
 
   // Load a nacl module from the file specified in wrapper.
   // Only to be used from a background (non-main) thread.
   // This will fully initialize the |subprocess| if the load was successful.
   bool LoadNaClModuleFromBackgroundThread(nacl::DescWrapper* wrapper,
                                           NaClSubprocess* subprocess,
-                                          const Manifest* manifest,
+                                          int32_t manifest_id,
                                           const SelLdrStartParams& params);
 
   // Start sel_ldr from the main thread, given the start params.
   // |pp_error| is set by CallOnMainThread (should be PP_OK).
   void StartSelLdrOnMainThread(int32_t pp_error,
                                ServiceRuntime* service_runtime,
                                const SelLdrStartParams& params,
                                pp::CompletionCallback callback);
 
   // Signals that StartSelLdr has finished.
@@ skipping 77 matching lines @@
   // callback to run when the file has been downloaded and is opened for
   // reading.  We use one downloader for all URL downloads to prevent issuing
   // multiple GETs that might arrive out of order.  For example, this will
   // prevent a GET of a NaCl manifest while a .nexe GET is pending.  Note that
   // this will also prevent simultaneous handling of multiple .nexes on a page.
   FileDownloader nexe_downloader_;
   pp::CompletionCallbackFactory<Plugin> callback_factory_;
 
   nacl::scoped_ptr<PnaclCoordinator> pnacl_coordinator_;
 
-  // The manifest dictionary.  Used for looking up resources to be loaded.
-  nacl::scoped_ptr<Manifest> manifest_;
-
   // Keep track of the FileDownloaders created to fetch urls.
   std::set<FileDownloader*> url_downloaders_;
   // Keep track of file descriptors opened by StreamAsFile().
   // These are owned by the browser.
   std::map<nacl::string, NaClFileInfoAutoCloser*> url_file_info_map_;
 
   // Callback to receive .nexe and .dso download progress notifications.
   static void UpdateDownloadProgress(
       PP_Instance pp_instance,
       PP_Resource pp_resource,
       int64_t bytes_sent,
       int64_t total_bytes_to_be_sent,
       int64_t bytes_received,
       int64_t total_bytes_to_be_received);
 
   // Finds the file downloader which owns the given URL loader. This is used
   // in UpdateDownloadProgress to map a url loader back to the URL being
   // downloaded.
   const FileDownloader* FindFileDownloader(PP_Resource url_loader) const;
 
   int64_t time_of_last_progress_event_;
   int exit_status_;
 
   // Open times are in microseconds.
   int64_t nexe_open_time_;
 
   PP_Var manifest_data_var_;
+  int32_t manifest_id_;
 
   const PPB_NaCl_Private* nacl_interface_;
   pp::UMAPrivate uma_interface_;
 };
 
 }  // namespace plugin
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PLUGIN_H_