Trusted plugin: Miscellaneous cleanup.

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 34 matching lines @@
 class URLUtil_Dev;
 }
 
 namespace plugin {
 
 class ErrorInfo;
 class Manifest;
 
 class Plugin : public pp::Instance {
  public:
-  // Factory method for creation.
-  static Plugin* New(PP_Instance instance);
+  explicit Plugin(PP_Instance instance);
 
   // ----- Methods inherited from pp::Instance:
 
   // Initializes this plugin with <embed/object ...> tag attribute count |argc|,
   // names |argn| and values |argn|. Returns false on failure.
   // Gets called by the browser right after New().
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]);
 
   // Handles document load, when the plugin is a MIME type handler.
   virtual bool HandleDocumentLoad(const pp::URLLoader& url_loader);
@@ skipping 92 matching lines @@
   // 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(); }
-  const pp::URLUtil_Dev* url_util() const { return url_util_; }
 
   // 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);
-  // Prevent construction and destruction from outside the class:
-  // must use factory New() method instead.
-  explicit Plugin(PP_Instance instance);
   // The browser will invoke the destructor via the pp::Instance
   // pointer to this object, not from base's Delete().
   ~Plugin();
 
   // Shuts down socket connection, service runtime, and receive thread,
   // in this order, for the main nacl subprocess.
   void ShutDownSubprocesses();
 
   // Access the service runtime for the main NaCl subprocess.
   ServiceRuntime* main_service_runtime() const {
@@ skipping 75 matching lines @@
   void NaClManifestFileDidOpen(int32_t pp_error);
 
   // Processes the JSON manifest string and starts loading the nexe.
   void ProcessNaClManifest(const nacl::string& manifest_json);
 
   // Parses the JSON in |manifest_json| and retains a Manifest in
   // |manifest_| for use by subsequent resource lookups.
   // On success, |true| is returned and |manifest_| is updated to
   // contain a Manifest that is used by SelectNexeURLFromManifest.
   // On failure, |false| is returned, and |manifest_| is unchanged.
-  bool SetManifestObject(const nacl::string& manifest_json,
-                         ErrorInfo* error_info);
+  bool SetManifestObject(const nacl::string& manifest_json);
 
   // Logs timing information to a UMA histogram, and also logs the same timing
   // information divided by the size of the nexe to another histogram.
   void HistogramStartupTimeSmall(const std::string& name, float dt);
   void HistogramStartupTimeMedium(const std::string& name, float dt);
 
   // Callback used when loading a URL for SRPC-based StreamAsFile().
   void UrlDidOpenForStreamAsFile(int32_t pp_error,
                                  FileDownloader* url_downloader,
                                  pp::CompletionCallback pp_callback);
@@ skipping 18 matching lines @@
   // 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_;
-  // URL processing interface for use in looking up resources in manifests.
-  const pp::URLUtil_Dev* url_util_;
 
   // 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,
@@ skipping 15 matching lines @@
   int64_t manifest_open_time_;
   int64_t nexe_open_time_;
 
   const PPB_NaCl_Private* nacl_interface_;
   pp::UMAPrivate uma_interface_;
 };
 
 }  // namespace plugin
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PLUGIN_H_