Remove the NaCl SRPC proxy from Chrome.

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 56 matching lines @@
   // Factory method for creation.
   static Plugin* New(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 view changes from the browser.
-  virtual void DidChangeView(const pp::View& view);
-
-  // Handles gaining or losing focus.
-  virtual void DidChangeFocus(bool has_focus);
-
-  // Handles input events delivered from the browser to this plugin element.
-  virtual bool HandleInputEvent(const pp::InputEvent& event);
-
-  // Handles gaining or losing focus.
+  // Handles document load, when the plugin is a MIME type handler.
   virtual bool HandleDocumentLoad(const pp::URLLoader& url_loader);
 
   // Returns a scriptable reference to this plugin element.
   // Called by JavaScript document.getElementById(plugin_id).
   virtual pp::Var GetInstanceObject();
 
-  // Handles postMessage from browser
-  virtual void HandleMessage(const pp::Var& message);
-
   // ----- Plugin interface support.
 
   // Load support.
   // NaCl module can be loaded given a DescWrapper.
   //
   // Starts NaCl module but does not wait until low-level
   // initialization (e.g., ld.so dynamic loading of manifest files) is
   // done.  The module will become ready later, asynchronously.  Other
   // event handlers should block until the module is ready before
   // trying to communicate with it, i.e., until nacl_ready_state is
-  // DONE.  Note, however, we already have another mechanism that
-  // prevents event delivery: StartJSObjectProxy plumbs through
-  // NaClSubprocess to SrpcClient which upcalls
-  // Plugin::StartProxiedExecution, which sets ppapi_proxy_.  And NULL
-  // == ppapi_proxy_ prevents events from being delivered, even if
-  // nacl_ready_state is DONE.
+  // DONE.
   //
   // NB: currently we do not time out, so if the untrusted code
   // does not signal that it is ready, then we will deadlock the main
   // thread of the renderer on this subsequent event delivery.  We
   // should include a time-out at which point we declare the
   // nacl_ready_state to be done, and let the normal crash detection
   // mechanism(s) take over.
   //
   // Updates nacl_module_origin() and nacl_module_url().
   bool LoadNaClModule(nacl::DescWrapper* wrapper, ErrorInfo* error_info,
@@ skipping 115 matching lines @@
   bool nexe_error_reported() const { return nexe_error_reported_; }
   void set_nexe_error_reported(bool val) {
     nexe_error_reported_ = val;
   }
 
   nacl::DescWrapperFactory* wrapper_factory() const { return wrapper_factory_; }
 
   // Requests a NaCl manifest download from a |url| relative to the page origin.
   void RequestNaClManifest(const nacl::string& url);
 
-  // Start up proxied execution of the browser API.
-  //
-  // NB: this is currently invoked from the main thread.  If we ever
-  // move it off the main thread (eliminate the possibility of a
-  // malicious nexe that isn't linked against / doesn't use our
-  // ppapi_proxy code that blocks the main thread on the RPCs used
-  // here), then we will need to take care to ensure that the error
-  // and crash reporting state machine (see NexeDidCrash comment)
-  // continues to work.
-  bool StartProxiedExecution(NaClSrpcChannel* srpc_channel,
-                             ErrorInfo* error_info);
-
   // Support for property getting.
   typedef void (Plugin::* PropertyGetter)(NaClSrpcArg* prop_value);
   void AddPropertyGet(const nacl::string& prop_name, PropertyGetter getter);
   bool HasProperty(const nacl::string& prop_name);
   bool GetProperty(const nacl::string& prop_name, NaClSrpcArg* prop_value);
   // The supported property getters.
   void GetExitStatus(NaClSrpcArg* prop_value);
   void GetLastError(NaClSrpcArg* prop_value);
   void GetReadyStateProperty(NaClSrpcArg* prop_value);
 
   // The size returned when a file download operation is unable to determine
   // the size of the file to load.  W3C ProgressEvents specify that unknown
   // sizes return 0.
   static const uint64_t kUnknownBytes = 0;
 
-  // Getter for PPAPI proxy interface.
-  ppapi_proxy::BrowserPpp* ppapi_proxy() const { return ppapi_proxy_; }
-
   // Called back by CallOnMainThread.  Dispatches the first enqueued progress
   // event.
   void DispatchProgressEvent(int32_t result);
 
   // Requests a URL asynchronously resulting in a call to pp_callback with
   // a PP_Error indicating status. On success an open file descriptor
   // corresponding to the url body is recorded for further lookup.
   bool StreamAsFile(const nacl::string& url,
                     PP_CompletionCallback pp_callback);
   // Returns an open POSIX file descriptor retrieved by StreamAsFile()
@@ skipping 126 matching lines @@
 
   // This NEXE is being used as a content type handler rather than directly by
   // an HTML document.
   bool NexeIsContentHandler() const;
 
   // Callback used when loading a URL for SRPC-based StreamAsFile().
   void UrlDidOpenForStreamAsFile(int32_t pp_error,
                                  FileDownloader*& url_downloader,
                                  PP_CompletionCallback pp_callback);
 
-  // Shuts down the proxy for PPAPI nexes.
-  void ShutdownProxy();  // Nexe shutdown + proxy deletion.
-
   // Copy the main service runtime's most recent NaClLog output to the
   // JavaScript console.  Valid to use only after a crash, e.g., via a
   // detail level LOG_FATAL NaClLog entry.  If the crash was not due
   // to a LOG_FATAL this method will do nothing.
   void CopyCrashLogToJsConsole();
 
   ScriptablePlugin* scriptable_plugin_;
 
   int argc_;
   char** argn_;
@@ skipping 25 matching lines @@
 
   // 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_;
 
   // A string containing the text description of the last error
   // produced by this plugin.
   nacl::string last_error_string_;
 
-  // A pointer to the browser end of a proxy pattern connecting the
-  // NaCl plugin to the PPAPI .nexe's PPP interface
-  // (InitializeModule, Shutdown, and GetInterface).
-  // TODO(sehr): this should be a scoped_ptr for shutdown.
-  ppapi_proxy::BrowserPpp* ppapi_proxy_;
-
   // PPAPI Dev interfaces are disabled by default.
   bool enable_dev_interfaces_;
 
   // If we get a DidChangeView event before the nexe is loaded, we store it and
   // replay it to nexe after it's loaded. We need to replay when this View
   // resource is non-is_null().
   pp::View view_to_replay_;
 
   // If we get a HandleDocumentLoad event before the nexe is loaded, we store
   // it and replay it to nexe after it's loaded. We need to replay when this
   // URLLoader resource is non-is_null().
   pp::URLLoader document_load_to_replay_;
 
   nacl::string mime_type_;
 
   // 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, int32_t> url_fd_map_;
 
   // Pending progress events.
   std::queue<ProgressEvent*> progress_events_;
 
-  // Adapter class constructors require a reference to 'this', so we can't
-  // contain them directly.
-  nacl::scoped_ptr<pp::Find_Dev> find_adapter_;
-  nacl::scoped_ptr<pp::MouseLock> mouse_lock_adapter_;
-  nacl::scoped_ptr<pp::Printing_Dev> printing_adapter_;
-  nacl::scoped_ptr<pp::Selection_Dev> selection_adapter_;
-  nacl::scoped_ptr<pp::Zoom_Dev> zoom_adapter_;
-
   // Used for NexeFileDidOpenContinuation
   int64_t load_start_;
 
   int64_t init_time_;
   int64_t ready_time_;
   size_t nexe_size_;
 
   // 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_;
 
   const PPB_NaCl_Private* nacl_interface_;
 };
 
 }  // namespace plugin
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PLUGIN_H_