Remove browser support for non-PPAPI nexes

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_
 
 #include <stdio.h>
 
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
-#include <vector>
 
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/include/nacl_scoped_ptr.h"
 #include "native_client/src/include/nacl_string.h"
 #include "native_client/src/trusted/plugin/file_downloader.h"
-#include "native_client/src/trusted/plugin/method_map.h"
 #include "native_client/src/trusted/plugin/nacl_subprocess.h"
 #include "native_client/src/trusted/plugin/pnacl_coordinator.h"
 #include "native_client/src/trusted/plugin/service_runtime.h"
 #include "native_client/src/trusted/plugin/utility.h"
 
 #include "ppapi/cpp/private/var_private.h"
 // for pp::VarPrivate
 #include "ppapi/cpp/private/instance_private.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/url_loader.h"
@@ skipping 19 matching lines @@
 }
 
 namespace ppapi_proxy {
 class BrowserPpp;
 }
 
 namespace plugin {
 
 class ErrorInfo;
 class Manifest;
-class PnaclCoordinator;
 class ProgressEvent;
-class ScriptableHandle;
-
-typedef enum {
-  METHOD_CALL = 0,
-  PROPERTY_GET,
-  PROPERTY_SET
-} CallType;
-
+class ScriptablePlugin;
 
 class Plugin : public pp::InstancePrivate {
  public:
   // 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.
@@ skipping 79 matching lines @@
   };
   // Report successful loading of a module.
   void ReportLoadSuccess(LengthComputable length_computable,
                          uint64_t loaded_bytes,
                          uint64_t total_bytes);
   // Report an error that was encountered while loading a module.
   void ReportLoadError(const ErrorInfo& error_info);
   // Report loading a module was aborted, typically due to user action.
   void ReportLoadAbort();
 
+  // Write a text string on the JavaScript console.
+  void AddToConsole(const nacl::string& text);
+
   // Dispatch a JavaScript event to indicate a key step in loading.
   // |event_type| is a character string indicating which type of progress
   // event (loadstart, progress, error, abort, load, loadend).  Events are
   // enqueued on the JavaScript event loop, which then calls back through
   // DispatchProgressEvent.
   void EnqueueProgressEvent(const char* event_type);
   void EnqueueProgressEvent(const char* event_type,
                             const nacl::string& url,
                             LengthComputable length_computable,
                             uint64_t loaded_bytes,
@@ skipping 12 matching lines @@
   void ReportSelLdrLoadStatus(int status);
 
   // Report nexe death after load to JS and shut down the proxy.
   void ReportDeadNexe();
 
   // The embed/object tag argument list.
   int argc() const { return argc_; }
   char** argn() const { return argn_; }
   char** argv() const { return argv_; }
 
-  BrowserInterface* browser_interface() const { return browser_interface_; }
   Plugin* plugin() const { return const_cast<Plugin*>(this); }
 
   // URL resolution support.
   // plugin_base_url is the URL used for resolving relative URLs used in
   // src="...".
   nacl::string plugin_base_url() const { return plugin_base_url_; }
   void set_plugin_base_url(nacl::string url) { plugin_base_url_ = url; }
   // manifest_base_url is the URL used for resolving relative URLs mentioned
   // in manifest files.  If the manifest is a data URI, this is an empty string.
   nacl::string manifest_base_url() const { return manifest_base_url_; }
@@ skipping 39 matching lines @@
   // 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);
 
-  // Determines whether experimental APIs are usable.
-  static bool ExperimentalJavaScriptApisAreEnabled();
-
-  // Methods for method and property dispatch.
-  bool InitParams(uintptr_t method_id, CallType call_type, SrpcParams* params);
-  bool HasMethod(uintptr_t method_id, CallType call_type);
-  bool Invoke(uintptr_t method_id, CallType call_type, SrpcParams* params);
-  std::vector<uintptr_t>* GetPropertyIdentifiers() {
-    return property_get_methods_.Keys();
-  }
+  // 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
@@ skipping 45 matching lines @@
 #ifndef HACK_FOR_MACOS_HANG_REMOVED
   void XYZZY(const nacl::string& url, pp::VarPrivate js_callback);
 #endif  // HACK_FOR_MACOS_HANG_REMOVED
   // 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();
 
-  bool Init(BrowserInterface* browser_interface,
-            int argc,
-            char* argn[],
-            char* argv[]);
-  void LoadMethods();
+  bool Init(int argc, char* argn[], char* argv[]);
   // Shuts down socket connection, service runtime, and receive thread,
   // in this order, for the main nacl subprocess.
   void ShutDownSubprocesses();
 
-  ScriptableHandle* scriptable_handle() const { return scriptable_handle_; }
-  void set_scriptable_handle(ScriptableHandle* scriptable_handle) {
-    scriptable_handle_ = scriptable_handle;
+  ScriptablePlugin* scriptable_plugin() const { return scriptable_plugin_; }
+  void set_scriptable_plugin(ScriptablePlugin* scriptable_plugin) {
+    scriptable_plugin_ = scriptable_plugin;
   }
 
   // Access the service runtime for the main NaCl subprocess.
   ServiceRuntime* main_service_runtime() const {
     return main_subprocess_.service_runtime();
   }
 
-  // Setting the properties and methods exported.
-  void AddPropertyGet(RpcFunction function_ptr,
-                      const char* name,
-                      const char* outs);
-
   // Help load a nacl module, from the file specified in wrapper.
   // This will fully initialize the |subprocess| if the load was successful.
   bool LoadNaClModuleCommon(nacl::DescWrapper* wrapper,
                             NaClSubprocess* subprocess,
                             const Manifest* manifest,
                             bool should_report_uma,
                             ErrorInfo* error_info,
                             pp::CompletionCallback init_done_cb,
                             pp::CompletionCallback crash_cb);
-  bool StartSrpcServices(NaClSubprocess* subprocess, ErrorInfo* error_info);
-  bool StartSrpcServicesCommon(NaClSubprocess* subprocess,
-                               ErrorInfo* error_info);
-  bool StartJSObjectProxy(NaClSubprocess* subprocess, ErrorInfo* error_info);
-
-  MethodInfo* GetMethodInfo(uintptr_t method_id, CallType call_type);
 
   // Callback used when getting the URL for the .nexe file.  If the URL loading
   // is successful, the file descriptor is opened and can be passed to sel_ldr
   // with the sandbox on.
   void NexeFileDidOpen(int32_t pp_error);
   void NexeFileDidOpenContinuation(int32_t pp_error);
 
   // Callback used when the reverse channel closes.  This is an
   // asynchronous event that might turn into a JavaScript error or
   // crash event -- this is controlled by the two state variables
@@ skipping 58 matching lines @@
   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.
 
-  BrowserInterface* browser_interface_;
-  ScriptableHandle* scriptable_handle_;
+  ScriptablePlugin* scriptable_plugin_;
 
   int argc_;
   char** argn_;
   char** argv_;
 
   // Keep track of the NaCl module subprocess that was spun up in the plugin.
   NaClSubprocess main_subprocess_;
 
   nacl::string plugin_base_url_;
   nacl::string manifest_base_url_;
   nacl::string manifest_url_;
   ReadyState nacl_ready_state_;
   bool nexe_error_reported_;  // error or crash reported
 
   nacl::DescWrapperFactory* wrapper_factory_;
 
-  MethodMap property_get_methods_;
+  std::map<nacl::string, PropertyGetter> property_getters_;
 
   // File download support.  |nexe_downloader_| can be opened with a specific
   // 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_;
 
@@ skipping 67 matching lines @@
   // 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_;
 };
 
 }  // namespace plugin
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_PLUGIN_PLUGIN_H_