Remove browser support for non-PPAPI nexes

ppapi/native_client/src/trusted/plugin/plugin.cc

 // 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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "native_client/src/trusted/plugin/plugin.h"
 
-#include <assert.h>
 #include <fcntl.h>
-#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <algorithm>
 #include <deque>
 #include <string>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
 #include "native_client/src/include/nacl_base.h"
 #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/include/portability.h"
 #include "native_client/src/include/portability_io.h"
 #include "native_client/src/include/portability_string.h"
 #include "native_client/src/shared/platform/nacl_check.h"
-#include "native_client/src/shared/platform/nacl_time.h"
 #include "native_client/src/shared/ppapi_proxy/browser_ppp.h"
-#include "native_client/src/trusted/desc/nacl_desc_base.h"
-#include "native_client/src/trusted/desc/nacl_desc_conn_cap.h"
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "native_client/src/trusted/handle_pass/browser_handle.h"
 #include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
-#include "native_client/src/trusted/plugin/browser_interface.h"
-#include "native_client/src/trusted/plugin/desc_based_handle.h"
 #include "native_client/src/trusted/plugin/json_manifest.h"
 #include "native_client/src/trusted/plugin/nacl_subprocess.h"
 #include "native_client/src/trusted/plugin/nexe_arch.h"
 #include "native_client/src/trusted/plugin/plugin_error.h"
-#include "native_client/src/trusted/plugin/scriptable_handle.h"
+#include "native_client/src/trusted/plugin/scriptable_plugin.h"
 #include "native_client/src/trusted/plugin/service_runtime.h"
 #include "native_client/src/trusted/plugin/string_encoding.h"
 #include "native_client/src/trusted/plugin/utility.h"
-#include "native_client/src/trusted/service_runtime/include/sys/fcntl.h"
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
 
+#include "ppapi/c/dev/ppb_console_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_printing_dev.h"
 #include "ppapi/c/dev/ppp_scrollbar_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_widget_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/c/ppb_var.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_mouse_lock.h"
 #include "ppapi/c/private/ppb_uma_private.h"
 #include "ppapi/cpp/dev/find_dev.h"
 #include "ppapi/cpp/dev/printing_dev.h"
 #include "ppapi/cpp/dev/scrollbar_dev.h"
 #include "ppapi/cpp/dev/selection_dev.h"
 #include "ppapi/cpp/dev/text_input_dev.h"
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/dev/widget_client_dev.h"
 #include "ppapi/cpp/dev/zoom_dev.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/mouse_lock.h"
 #include "ppapi/cpp/rect.h"
 
 using ppapi_proxy::BrowserPpp;
 
 namespace plugin {
 
 namespace {
 
-bool GetReadyStateProperty(void* obj, SrpcParams* params) {
-  Plugin* plugin = static_cast<Plugin*>(obj);
-  params->outs()[0]->u.ival = plugin->nacl_ready_state();
-  return true;
-}
-
 const char* const kTypeAttribute = "type";
 // The "src" attribute of the <embed> tag.  The value is expected to be either
 // a URL or URI pointing to the manifest file (which is expected to contain
 // JSON matching ISAs with .nexe URLs).
 const char* const kSrcManifestAttribute = "src";
 // The "nacl" attribute of the <embed> tag.  We use the value of this attribute
 // to find the manifest file when NaCl is registered as a plug-in for another
 // MIME type because the "src" attribute is used to supply us with the resource
 // of that MIME type that we're supposed to display.
 const char* const kNaClManifestAttribute = "nacl";
 // This is a pretty arbitrary limit on the byte size of the NaCl manfest file.
 // Note that the resulting string object has to have at least one byte extra
 // for the null termination character.
 const size_t kNaClManifestMaxFileBytes = 1024 * 1024;
 
 // Define an argument name to enable 'dev' interfaces. To make sure it doesn't
 // collide with any user-defined HTML attribute, make the first character '@'.
 const char* const kDevAttribute = "@dev";
 
 // URL schemes that we treat in special ways.
 const char* const kChromeExtensionUriScheme = "chrome-extension";
 const char* const kDataUriScheme = "data";
 
 // The key used to find the dictionary nexe URLs in the manifest file.
 const char* const kNexesKey = "nexes";
 
-bool GetLastError(void* obj, SrpcParams* params) {
-  NaClSrpcArg** outs = params->outs();
-  PLUGIN_PRINTF(("GetLastError (obj=%p)\n", obj));
-
-  Plugin* plugin = static_cast<Plugin*>(obj);
-  outs[0]->arrays.str = strdup(plugin->last_error_string().c_str());
-  return true;
-}
-
-bool GetExitStatus(void* obj, SrpcParams* params) {
-  NaClSrpcArg** outs = params->outs();
-  PLUGIN_PRINTF(("GetExitStatus (obj=%p)\n", obj));
-
-  Plugin* plugin = static_cast<Plugin*>(obj);
-  outs[0]->u.ival = plugin->exit_status();
-  return true;
-}
-
 // Up to 20 seconds
 const int64_t kTimeSmallMin = 1;         // in ms
 const int64_t kTimeSmallMax = 20000;     // in ms
 const uint32_t kTimeSmallBuckets = 100;
 
 // Up to 3 minutes, 20 seconds
 const int64_t kTimeMediumMin = 10;         // in ms
 const int64_t kTimeMediumMax = 200000;     // in ms
 const uint32_t kTimeMediumBuckets = 100;
 
@@ skipping 351 matching lines @@
 
  private:
   Plugin* plugin_;
   const PPP_Zoom_Dev* ppp_zoom_;
 
   NACL_DISALLOW_COPY_AND_ASSIGN(ZoomAdapter);
 };
 
 }  // namespace
 
-bool Plugin::ExperimentalJavaScriptApisAreEnabled() {
-  return getenv("NACL_ENABLE_EXPERIMENTAL_JAVASCRIPT_APIS") != NULL;
+static int const kAbiHeaderBuffer = 256;  // must be at least EI_ABIVERSION + 1
+
+void Plugin::AddPropertyGet(const nacl::string& prop_name,
+                            Plugin::PropertyGetter getter) {
+  PLUGIN_PRINTF(("Plugin::AddPropertyGet (prop_name='%s')\n",
+                 prop_name.c_str()));
+  property_getters_[nacl::string(prop_name)] = getter;
 }
 
-static int const kAbiHeaderBuffer = 256;  // must be at least EI_ABIVERSION + 1
-
-void Plugin::LoadMethods() {
-  PLUGIN_PRINTF(("Plugin::LoadMethods ()\n"));
-  // Properties implemented by Plugin.
-  AddPropertyGet(GetReadyStateProperty, "readyState", "i");
+bool Plugin::HasProperty(const nacl::string& prop_name) {
+  PLUGIN_PRINTF(("Plugin::HasProperty (prop_name=%s)\n",
+                 prop_name.c_str()));
+  return property_getters_[prop_name] != NULL;
 }
 
-bool Plugin::HasMethod(uintptr_t method_id, CallType call_type) {
-  PLUGIN_PRINTF(("Plugin::HasMethod (method_id=%x)\n",
-                 static_cast<int>(method_id)));
-  if (GetMethodInfo(method_id, call_type)) {
-    PLUGIN_PRINTF(("true\n"));
-    return true;
-  }
-  if (!ExperimentalJavaScriptApisAreEnabled()) {
-    PLUGIN_PRINTF(("false\n"));
+bool Plugin::GetProperty(const nacl::string& prop_name,
+                         NaClSrpcArg* prop_value) {
+  PLUGIN_PRINTF(("Plugin::GetProperty (prop_name=%s)\n", prop_name.c_str()));
+
+  PropertyGetter getter = property_getters_[prop_name];
+  if (NULL == getter) {
     return false;
   }
-  if (call_type != METHOD_CALL) {
-    // SRPC nexes can only export methods.
-    PLUGIN_PRINTF(("false\n"));
-    return false;
-  }
-  bool has_method = main_subprocess_.HasMethod(method_id);
-  PLUGIN_PRINTF(("%s\n", (has_method ? "true" : "false")));
-  return has_method;
+  (this->*getter)(prop_value);
+  return true;
 }
 
-bool Plugin::InitParams(uintptr_t method_id,
-                        CallType call_type,
-                        SrpcParams* params) {
-  MethodInfo* method_info = GetMethodInfo(method_id, call_type);
-  PLUGIN_PRINTF(("Plugin::InitParams (id=%"NACL_PRIxPTR", method_info=%p)\n",
-                 method_id, method_info));
-  if (NULL != method_info) {
-    return params->Init(method_info->ins(), method_info->outs());
-  }
-  if (!ExperimentalJavaScriptApisAreEnabled()) {
-    return false;
-  }
-  if (call_type != METHOD_CALL) {
-    // SRPC nexes can only export methods.
-    return false;
-  }
-  return main_subprocess_.InitParams(method_id, params);
+void Plugin::GetExitStatus(NaClSrpcArg* prop_value) {
+  PLUGIN_PRINTF(("GetExitStatus (this=%p)\n", reinterpret_cast<void*>(this)));
+  prop_value->tag = NACL_SRPC_ARG_TYPE_INT;
+  prop_value->u.ival = exit_status();
 }
 
-bool Plugin::Invoke(uintptr_t method_id,
-                    CallType call_type,
-                    SrpcParams* params) {
-  MethodInfo* method_info = GetMethodInfo(method_id, call_type);
-
-  if (NULL != method_info && NULL != method_info->function_ptr()) {
-    return method_info->function_ptr()(static_cast<void*>(this), params);
-  }
-  if (!ExperimentalJavaScriptApisAreEnabled()) {
-    return false;
-  }
-  if (call_type != METHOD_CALL) {
-    // SRPC nexes can only export methods.
-    return false;
-  }
-  return main_subprocess_.Invoke(method_id, params);
+void Plugin::GetLastError(NaClSrpcArg* prop_value) {
+  PLUGIN_PRINTF(("GetLastError (this=%p)\n", reinterpret_cast<void*>(this)));
+  prop_value->tag = NACL_SRPC_ARG_TYPE_STRING;
+  prop_value->arrays.str = strdup(last_error_string().c_str());
 }
 
-bool Plugin::Init(BrowserInterface* browser_interface,
-                  int argc,
-                  char* argn[],
-                  char* argv[]) {
+void Plugin::GetReadyStateProperty(NaClSrpcArg* prop_value) {
+  PLUGIN_PRINTF(("GetReadyState (this=%p)\n", reinterpret_cast<void*>(this)));
+  prop_value->tag = NACL_SRPC_ARG_TYPE_INT;
+  prop_value->u.ival = nacl_ready_state();
+}
+
+bool Plugin::Init(int argc, char* argn[], char* argv[]) {
   PLUGIN_PRINTF(("Plugin::Init (instance=%p)\n", static_cast<void*>(this)));
 
 #ifdef NACL_OSX
   // TODO(kochi): For crbug.com/102808, this is a stopgap solution for Lion
   // until we expose IME API to .nexe. This disables any IME interference
   // against key inputs, so you cannot use off-the-spot IME input for NaCl apps.
   // This makes discrepancy among platforms and therefore we should remove
   // this hack when IME API is made available.
   // The default for non-Mac platforms is still off-the-spot IME mode.
   pp::TextInput_Dev(this).SetTextInputType(PP_TEXTINPUT_TYPE_NONE);
 #endif
 
-  browser_interface_ = browser_interface;
   // Remember the embed/object argn/argv pairs.
-  argn_ = new(std::nothrow) char*[argc];
-  argv_ = new(std::nothrow) char*[argc];
+  argn_ = new char*[argc];
+  argv_ = new char*[argc];
   argc_ = 0;
   for (int i = 0; i < argc; ++i) {
     if (NULL != argn_ && NULL != argv_) {
       argn_[argc_] = strdup(argn[i]);
       argv_[argc_] = strdup(argv[i]);
       if (NULL == argn_[argc_] || NULL == argv_[argc_]) {
         // Give up on passing arguments.
         free(argn_[argc_]);
         free(argv_[argc_]);
         continue;
       }
       ++argc_;
     }
   }
   // TODO(sehr): this leaks strings if there is a subsequent failure.
 
   // Set up the factory used to produce DescWrappers.
   wrapper_factory_ = new nacl::DescWrapperFactory();
   if (NULL == wrapper_factory_) {
     return false;
   }
   PLUGIN_PRINTF(("Plugin::Init (wrapper_factory=%p)\n",
                  static_cast<void*>(wrapper_factory_)));
 
-  // Set up the scriptable methods for the plugin.
-  LoadMethods();
+  // Export a property to allow us to get the exit status of a nexe.
+  AddPropertyGet("exitStatus", &Plugin::GetExitStatus);
+  // Export a property to allow us to get the last error description.
+  AddPropertyGet("lastError", &Plugin::GetLastError);
+  // Export a property to allow us to get the ready state of a nexe during load.
+  AddPropertyGet("readyState", &Plugin::GetReadyStateProperty);
 
   PLUGIN_PRINTF(("Plugin::Init (return 1)\n"));
   // Return success.
   return true;
 }
 
 void Plugin::ShutDownSubprocesses() {
   PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (this=%p)\n",
                  static_cast<void*>(this)));
   PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (%s)\n",
@@ skipping 29 matching lines @@
   bool service_runtime_started =
       new_service_runtime->Start(wrapper, error_info);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleCommon (service_runtime_started=%d)\n",
                  service_runtime_started));
   if (!service_runtime_started) {
     return false;
   }
   return true;
 }
 
-bool Plugin::StartSrpcServicesCommon(NaClSubprocess* subprocess,
-                                     ErrorInfo* error_info) {
-  if (!subprocess->StartSrpcServices()) {
-    error_info->SetReport(ERROR_SRPC_CONNECTION_FAIL,
-                          "SRPC connection failure for " +
-                          subprocess->description());
-    return false;
-  }
-  PLUGIN_PRINTF(("Plugin::StartSrpcServicesCommon (established srpc_client "
-                 "%p)\n",
-                 static_cast<void*>(subprocess->srpc_client())));
-  return true;
-}
-
-bool Plugin::StartSrpcServices(NaClSubprocess* subprocess,
-                               ErrorInfo* error_info) {
-  if (!StartSrpcServicesCommon(subprocess, error_info)) {
-    return false;
-  }
-  // TODO(jvoung): This next bit is likely not needed...
-  // If StartSrpcServices is only in the JS API that is just for SRPC nexes
-  // (namely __startSrpcServices), then attempts to start the JS proxy
-  // will fail anyway?
-  // If that is the case, by removing the following line,
-  // the StartSrpcServices == StartSrpcServicesCommon.
-  // We still need this function though, to launch helper SRPC nexes within
-  // the plugin.
-  return StartJSObjectProxy(subprocess, error_info);
-}
-
-bool Plugin::StartJSObjectProxy(NaClSubprocess* subprocess,
-                                ErrorInfo* error_info) {
-  if (!subprocess->StartJSObjectProxy(this, error_info)) {
-    // TODO(sehr,polina): rename the function and env var
-    // to ExperimentalJavaScriptApisAreEnabled.
-    if (error_info->error_code() == ERROR_START_PROXY_CHECK_PPP &&
-        ExperimentalJavaScriptApisAreEnabled()) {
-      // It is not an error for the proxy to fail to find PPP methods if
-      // experimental APIs are enabled. This means we have an SRPC nexe.
-      error_info->Reset();
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
 bool Plugin::LoadNaClModule(nacl::DescWrapper* wrapper,
                             ErrorInfo* error_info,
                             pp::CompletionCallback init_done_cb,
                             pp::CompletionCallback crash_cb) {
   // Before forking a new sel_ldr process, ensure that we do not leak
   // the ServiceRuntime object for an existing subprocess, and that any
   // associated listener threads do not go unjoined because if they
   // outlive the Plugin object, they will not be memory safe.
   ShutDownSubprocesses();
   if (!LoadNaClModuleCommon(wrapper, &main_subprocess_, manifest_.get(),
                             true, error_info, init_done_cb, crash_cb)) {
     return false;
   }
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (%s)\n",
                  main_subprocess_.detailed_description().c_str()));
   return true;
 }
 
 bool Plugin::LoadNaClModuleContinuationIntern(ErrorInfo* error_info) {
-  if (!(StartSrpcServicesCommon(&main_subprocess_, error_info)
-        && StartJSObjectProxy(&main_subprocess_, error_info))) {
+  if (!main_subprocess_.StartSrpcServices()) {
+    error_info->SetReport(ERROR_SRPC_CONNECTION_FAIL,
+                          "SRPC connection failure for " +
+                          main_subprocess_.description());
+    return false;
+  }
+  if (!main_subprocess_.StartJSObjectProxy(this, error_info)) {
     return false;
   }
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (%s)\n",
                  main_subprocess_.detailed_description().c_str()));
   return true;
 }
 
 NaClSubprocess* Plugin::LoadHelperNaClModule(nacl::DescWrapper* wrapper,
                                              const Manifest* manifest,
                                              ErrorInfo* error_info) {
   nacl::scoped_ptr<NaClSubprocess> nacl_subprocess(
-      new NaClSubprocess("helper module", browser_interface_, NULL, NULL));
+      new NaClSubprocess("helper module", NULL, NULL));
   if (NULL == nacl_subprocess.get()) {
     error_info->SetReport(ERROR_SEL_LDR_INIT,
                           "unable to allocate helper subprocess.");
     return NULL;
   }
 
   // Do not report UMA stats for translator-related nexes.
   // TODO(sehr): define new UMA stats for translator related nexe events.
-  if (!(LoadNaClModuleCommon(wrapper, nacl_subprocess.get(), manifest,
-                             false, error_info,
-                             pp::BlockUntilComplete(),
-                             pp::BlockUntilComplete())
-        // We need not wait for the init_done callback.  We can block
-        // here in StartSrpcServicesCommon, since helper NaCl modules
-        // are spawned from a private thread.
-        //
-        // TODO(bsy): if helper module crashes, we should abort.
-        // crash_cb is not used here, so we are relying on crashes
-        // being detected in StartSrpcServicesCommon or later.
-        //
-        // NB: More refactoring might be needed, however, if helper
-        // NaCl modules have their own manifest.  Currently the
-        // manifest is a per-plugin-instance object, not a per
-        // NaClSubprocess object.
-        && StartSrpcServicesCommon(nacl_subprocess.get(), error_info))) {
+  if (!LoadNaClModuleCommon(wrapper, nacl_subprocess.get(), manifest,
+                            false, error_info,
+                            pp::BlockUntilComplete(),
+                            pp::BlockUntilComplete())) {
+    return NULL;
+  }
+  // We need not wait for the init_done callback.  We can block
+  // here in StartSrpcServices, since helper NaCl modules
+  // are spawned from a private thread.
+  //
+  // TODO(bsy): if helper module crashes, we should abort.
+  // crash_cb is not used here, so we are relying on crashes
+  // being detected in StartSrpcServices or later.
+  //
+  // NB: More refactoring might be needed, however, if helper
+  // NaCl modules have their own manifest.  Currently the
+  // manifest is a per-plugin-instance object, not a per
+  // NaClSubprocess object.
+  if (!nacl_subprocess->StartSrpcServices()) {
+    error_info->SetReport(ERROR_SRPC_CONNECTION_FAIL,
+                          "SRPC connection failure for " +
+                          nacl_subprocess->description());
     return NULL;
   }
 
   PLUGIN_PRINTF(("Plugin::LoadHelperNaClModule (%s)\n",
                  nacl_subprocess.get()->detailed_description().c_str()));
 
   return nacl_subprocess.release();
 }
 
 char* Plugin::LookupArgument(const char* key) {
   char** keys = argn();
   for (int ii = 0, len = argc(); ii < len; ++ii) {
     if (!strcmp(keys[ii], key)) {
       return argv()[ii];
     }
   }
   return NULL;
 }
 
-void Plugin::AddPropertyGet(RpcFunction function_ptr,
-                            const char* name,
-                            const char* outs) {
-  uintptr_t method_id = browser_interface()->StringToIdentifier(name);
-  PLUGIN_PRINTF(("Plugin::AddPropertyGet (name='%s', id=%"
-                 NACL_PRIxPTR")\n", name, method_id));
-  MethodInfo* new_method = new MethodInfo(function_ptr, name, "", outs);
-  property_get_methods_.AddMethod(method_id, new_method);
-}
-
-MethodInfo* Plugin::GetMethodInfo(uintptr_t method_id, CallType call_type) {
-  MethodInfo* method_info = NULL;
-  switch (call_type) {
-    case PROPERTY_GET:
-      method_info = property_get_methods_.GetMethod(method_id);
-      break;
-    case PROPERTY_SET:
-    case METHOD_CALL:
-      break;
-  }
-  PLUGIN_PRINTF(("Plugin::GetMethodInfo (id=%"NACL_PRIxPTR", "
-                 "return %p)\n", method_id, static_cast<void*>(method_info)));
-  return method_info;
-}
-
 // Suggested names for progress event types, per
 // http://www.w3.org/TR/progress-events/
 const char* const Plugin::kProgressEventLoadStart = "loadstart";
 const char* const Plugin::kProgressEventProgress =  "progress";
 const char* const Plugin::kProgressEventError =     "error";
 const char* const Plugin::kProgressEventAbort =     "abort";
 const char* const Plugin::kProgressEventLoad =      "load";
 const char* const Plugin::kProgressEventLoadEnd =   "loadend";
 // Define a NaCl specific event type for .nexe crashes.
 const char* const Plugin::kProgressEventCrash =     "crash";
@@ skipping 41 matching lines @@
 }
 
 
 Plugin* Plugin::New(PP_Instance pp_instance) {
   PLUGIN_PRINTF(("Plugin::New (pp_instance=%"NACL_PRId32")\n", pp_instance));
 #if NACL_WINDOWS && !defined(NACL_STANDALONE)
   if (!NaClHandlePassBrowserCtor()) {
     return NULL;
   }
 #endif
-  Plugin* plugin = new(std::nothrow) Plugin(pp_instance);
+  Plugin* plugin = new Plugin(pp_instance);
   PLUGIN_PRINTF(("Plugin::New (plugin=%p)\n", static_cast<void*>(plugin)));
   if (plugin == NULL) {
     return NULL;
   }
   return plugin;
 }
 
 
 // All failures of this function will show up as "Missing Plugin-in", so
 // there is no need to log to JS console that there was an initialization
 // failure. Note that module loading functions will log their own errors.
 bool Plugin::Init(uint32_t argc, const char* argn[], const char* argv[]) {
   PLUGIN_PRINTF(("Plugin::Init (argc=%"NACL_PRIu32")\n", argc));
   HistogramEnumerateOsArch(GetSandboxISA());
   init_time_ = NaClGetTimeOfDayMicroseconds();
 
-  scoped_ptr<BrowserInterface> browser_interface(
-      new(std::nothrow) BrowserInterface);
-  if (browser_interface == NULL) {
-    return false;
-  }
-  ScriptableHandle* handle = ScriptableHandle::NewPlugin(this);
-  if (handle == NULL)
+  ScriptablePlugin* scriptable_plugin = ScriptablePlugin::NewPlugin(this);
+  if (scriptable_plugin == NULL)
     return false;
 
-  set_scriptable_handle(handle);
+  set_scriptable_plugin(scriptable_plugin);
   PLUGIN_PRINTF(("Plugin::Init (scriptable_handle=%p)\n",
-                 static_cast<void*>(scriptable_handle())));
+                 static_cast<void*>(scriptable_plugin_)));
   url_util_ = pp::URLUtil_Dev::Get();
   if (url_util_ == NULL)
     return false;
 
   PLUGIN_PRINTF(("Plugin::Init (url_util_=%p)\n",
                  static_cast<const void*>(url_util_)));
 
   bool status = Plugin::Init(
-      browser_interface.release(),
       static_cast<int>(argc),
       // TODO(polina): Can we change the args on our end to be const to
       // avoid these ugly casts?
       const_cast<char**>(argn),
       const_cast<char**>(argv));
   if (status) {
     // Look for the developer attribute; if it's present, enable 'dev'
     // interfaces.
     const char* dev_settings = LookupArgument(kDevAttribute);
     enable_dev_interfaces_ = (dev_settings != NULL);
@@ skipping 34 matching lines @@
                        " WARNING: 'nacl' property is incorrect. Use 'src'.\n"));
       }
     } else {
       // Issue a GET for the manifest_url.  The manifest file will be parsed to
       // determine the nexe URL.
       // Sets src property to full manifest URL.
       RequestNaClManifest(manifest_url);
     }
   }
 
-  // Export a property to allow us to get the last error description.
-  AddPropertyGet(GetLastError, "lastError", "s");
-  // Export a property to allow us to get the nexe exit status.
-  AddPropertyGet(GetExitStatus, "exitStatus", "i");
-
   PLUGIN_PRINTF(("Plugin::Init (status=%d)\n", status));
   return status;
 }
 
 
 Plugin::Plugin(PP_Instance pp_instance)
     : pp::InstancePrivate(pp_instance),
-      browser_interface_(NULL),
-      scriptable_handle_(NULL),
+      scriptable_plugin_(NULL),
       argc_(-1),
       argn_(NULL),
       argv_(NULL),
-      main_subprocess_("main subprocess", NULL, NULL, NULL),
+      main_subprocess_("main subprocess", NULL, NULL),
       nacl_ready_state_(UNSENT),
       nexe_error_reported_(false),
       wrapper_factory_(NULL),
       last_error_string_(""),
       ppapi_proxy_(NULL),
       enable_dev_interfaces_(false),
       init_time_(0),
       ready_time_(0),
       nexe_size_(0),
       time_of_last_progress_event_(0) {
   PLUGIN_PRINTF(("Plugin::Plugin (this=%p, pp_instance=%"
                  NACL_PRId32")\n", static_cast<void*>(this), pp_instance));
   callback_factory_.Initialize(this);
   nexe_downloader_.Initialize(this);
 }
 
 
 Plugin::~Plugin() {
   int64_t shutdown_start = NaClGetTimeOfDayMicroseconds();
 
-  PLUGIN_PRINTF(("Plugin::~Plugin (this=%p, scriptable_handle=%p)\n",
+  PLUGIN_PRINTF(("Plugin::~Plugin (this=%p, scriptable_plugin=%p)\n",
                  static_cast<void*>(this),
-                 static_cast<void*>(scriptable_handle())));
+                 static_cast<void*>(scriptable_plugin())));
 
   // If the proxy has been shutdown before now, it's likely the plugin suffered
   // an error while loading.
   if (ppapi_proxy_ != NULL) {
     HistogramTimeLarge(
         "NaCl.ModuleUptime.Normal",
         (shutdown_start - ready_time_) / NACL_MICROS_PER_MILLI);
   }
 
 #if NACL_WINDOWS && !defined(NACL_STANDALONE)
   NaClHandlePassBrowserDtor();
 #endif
 
   url_downloaders_.erase(url_downloaders_.begin(), url_downloaders_.end());
 
   ShutdownProxy();
-  ScriptableHandle* scriptable_handle_ = scriptable_handle();
-  ScriptableHandle::Unref(&scriptable_handle_);
+  ScriptablePlugin* scriptable_plugin_ = scriptable_plugin();
+  ScriptablePlugin::Unref(&scriptable_plugin_);
 
   // ShutDownSubprocesses shuts down the main subprocess, which shuts
   // down the main ServiceRuntime object, which kills the subprocess.
   // As a side effect of the subprocess being killed, the reverse
   // services thread(s) will get EOF on the reverse channel(s), and
   // the thread(s) will exit.  In ServiceRuntime::Shutdown, we invoke
   // ReverseService::WaitForServiceThreadsToExit(), so that there will
   // not be an extent thread(s) hanging around.  This means that the
   // ~Plugin will block until this happens.  This is a requirement,
   // since the renderer should be free to unload the plugin code, and
   // we cannot have threads running code that gets unloaded before
   // they exit.
   //
   // By waiting for the threads here, we also ensure that the Plugin
   // object and the subprocess and ServiceRuntime objects is not
   // (fully) destroyed while the threads are running, so resources
   // that are destroyed after ShutDownSubprocesses (below) are
   // guaranteed to be live and valid for access from the service
   // threads.
   //
   // The main_subprocess object, which wraps the main service_runtime
   // object, is dtor'd implicitly after the explicit code below runs,
   // so the main service runtime object will not have been dtor'd,
   // though the Shutdown method may have been called, during the
   // lifetime of the service threads.
   ShutDownSubprocesses();
 
   delete wrapper_factory_;
-  delete browser_interface_;
   delete[] argv_;
   delete[] argn_;
 
   HistogramTimeSmall(
       "NaCl.Perf.ShutdownTime.Total",
       (NaClGetTimeOfDayMicroseconds() - shutdown_start)
           / NACL_MICROS_PER_MILLI);
 
   PLUGIN_PRINTF(("Plugin::~Plugin (this=%p, return)\n",
                  static_cast<void*>(this)));
@@ skipping 65 matching lines @@
     ppapi_proxy_->ppp_messaging_interface()->HandleMessage(
         pp_instance(), message.pp_var());
   }
 }
 
 
 pp::Var Plugin::GetInstanceObject() {
   PLUGIN_PRINTF(("Plugin::GetInstanceObject (this=%p)\n",
                  static_cast<void*>(this)));
   // The browser will unref when it discards the var for this object.
-  ScriptableHandle* handle =
-      static_cast<ScriptableHandle*>(scriptable_handle()->AddRef());
+  ScriptablePlugin* handle =
+      static_cast<ScriptablePlugin*>(scriptable_plugin()->AddRef());
   pp::Var* handle_var = handle->var();
   PLUGIN_PRINTF(("Plugin::GetInstanceObject (handle=%p, handle_var=%p)\n",
                  static_cast<void*>(handle), static_cast<void*>(handle_var)));
   return *handle_var;  // make a copy
 }
 
 void Plugin::HistogramStartupTimeSmall(const std::string& name, float dt) {
   if (nexe_size_ > 0) {
     float size_in_MB = static_cast<float>(nexe_size_) / (1024.f * 1024.f);
     HistogramTimeSmall(name, static_cast<int64_t>(dt));
@@ skipping 189 matching lines @@
   if (NaClSrpcServiceMethodIndex(client_service,
                                  "PPP_InitializeModule:ihs:i") ==
       kNaClSrpcInvalidMethodIndex) {
     error_info->SetReport(
         ERROR_START_PROXY_CHECK_PPP,
         "could not find PPP_InitializeModule() - toolchain version mismatch?");
     PLUGIN_PRINTF(("Plugin::StartProxiedExecution (%s)\n",
                    error_info->message().c_str()));
     return false;
   }
-  nacl::scoped_ptr<BrowserPpp> ppapi_proxy(
-      new(std::nothrow) BrowserPpp(srpc_channel, this));
+  nacl::scoped_ptr<BrowserPpp> ppapi_proxy(new BrowserPpp(srpc_channel, this));
   PLUGIN_PRINTF(("Plugin::StartProxiedExecution (ppapi_proxy=%p)\n",
                  static_cast<void*>(ppapi_proxy.get())));
   if (ppapi_proxy.get() == NULL) {
     error_info->SetReport(ERROR_START_PROXY_ALLOC,
                           "could not allocate proxy memory.");
     return false;
   }
   pp::Module* module = pp::Module::Get();
   PLUGIN_PRINTF(("Plugin::StartProxiedExecution (module=%p)\n",
                  static_cast<void*>(module)));
@@ skipping 22 matching lines @@
                  did_create));
   if (did_create == PP_FALSE) {
     error_info->SetReport(ERROR_START_PROXY_INSTANCE,
                           "could not create instance.");
     return false;
   }
 
   ppapi_proxy_ = ppapi_proxy.release();
 
   // Create PPP* interface adapters to forward calls to .nexe.
-  find_adapter_.reset(new(std::nothrow) FindAdapter(this));
-  mouse_lock_adapter_.reset(new(std::nothrow) MouseLockAdapter(this));
-  printing_adapter_.reset(new(std::nothrow) PrintingAdapter(this));
-  selection_adapter_.reset(new(std::nothrow) SelectionAdapter(this));
-  widget_client_adapter_.reset(new(std::nothrow) WidgetClientAdapter(this));
-  zoom_adapter_.reset(new(std::nothrow) ZoomAdapter(this));
+  find_adapter_.reset(new FindAdapter(this));
+  mouse_lock_adapter_.reset(new MouseLockAdapter(this));
+  printing_adapter_.reset(new PrintingAdapter(this));
+  selection_adapter_.reset(new SelectionAdapter(this));
+  widget_client_adapter_.reset(new WidgetClientAdapter(this));
+  zoom_adapter_.reset(new ZoomAdapter(this));
 
   // Replay missed events.
   if (!view_to_replay_.is_null()) {
     DidChangeView(view_to_replay_);
     view_to_replay_ = pp::View();
   }
   if (!document_load_to_replay_.is_null()) {
     HandleDocumentLoad(document_load_to_replay_);
     document_load_to_replay_ = pp::URLLoader();
   }
@@ skipping 15 matching lines @@
   if (nacl_ready_state() == DONE && !nexe_error_reported()) {  // After loadEnd.
     int64_t crash_time = NaClGetTimeOfDayMicroseconds();
     // Crashes will be more likely near startup, so use a medium histogram
     // instead of a large one.
     HistogramTimeMedium(
         "NaCl.ModuleUptime.Crash",
         (crash_time - ready_time_) / NACL_MICROS_PER_MILLI);
 
     nacl::string message = nacl::string("NaCl module crashed");
     set_last_error_string(message);
-    browser_interface()->AddToConsole(this, message);
+    AddToConsole(message);
 
     EnqueueProgressEvent(kProgressEventCrash);
     set_nexe_error_reported(true);
     CHECK(ppapi_proxy_ == NULL || !ppapi_proxy_->is_valid());
     ShutdownProxy();
   }
   // else ReportLoadError() and ReportAbortError() will be used by loading code
   // to provide error handling and proxy shutdown.
   //
   // NOTE: not all crashes during load will make it here.
@@ skipping 361 matching lines @@
 void Plugin::ReportLoadError(const ErrorInfo& error_info) {
   PLUGIN_PRINTF(("Plugin::ReportLoadError (error='%s')\n",
                  error_info.message().c_str()));
   // Set the readyState attribute to indicate we need to start over.
   set_nacl_ready_state(DONE);
   set_nexe_error_reported(true);
   // Report an error in lastError and on the JavaScript console.
   nacl::string message = nacl::string("NaCl module load failed: ") +
       error_info.message();
   set_last_error_string(message);
-  browser_interface()->AddToConsole(this, message);
+  AddToConsole(message);
   ShutdownProxy();
   // Inform JavaScript that loading encountered an error and is complete.
   EnqueueProgressEvent(kProgressEventError);
   EnqueueProgressEvent(kProgressEventLoadEnd);
 
   // UMA
   HistogramEnumerateLoadStatus(error_info.error_code());
 }
 
 
 void Plugin::ReportLoadAbort() {
   PLUGIN_PRINTF(("Plugin::ReportLoadAbort\n"));
   // Set the readyState attribute to indicate we need to start over.
   set_nacl_ready_state(DONE);
   set_nexe_error_reported(true);
   // Report an error in lastError and on the JavaScript console.
   nacl::string error_string("NaCl module load failed: user aborted");
   set_last_error_string(error_string);
-  browser_interface()->AddToConsole(this, error_string);
+  AddToConsole(error_string);
   ShutdownProxy();
   // Inform JavaScript that loading was aborted and is complete.
   EnqueueProgressEvent(kProgressEventAbort);
   EnqueueProgressEvent(kProgressEventLoadEnd);
 
   // UMA
   HistogramEnumerateLoadStatus(ERROR_LOAD_ABORTED);
 }
 
 void Plugin::UpdateDownloadProgress(
@@ skipping 181 matching lines @@
 
   std::string scheme = canonicalized.AsString().substr(comps.scheme.begin,
                                                        comps.scheme.len);
   if (scheme == kChromeExtensionUriScheme)
     return SCHEME_CHROME_EXTENSION;
   if (scheme == kDataUriScheme)
     return SCHEME_DATA;
   return SCHEME_OTHER;
 }
 
+void Plugin::AddToConsole(const nacl::string& text) {
+  pp::Module* module = pp::Module::Get();
+  const PPB_Var* var_interface =
+      static_cast<const PPB_Var*>(
+          module->GetBrowserInterface(PPB_VAR_INTERFACE));
+  nacl::string prefix_string("NativeClient");
+  PP_Var prefix =
+      var_interface->VarFromUtf8(prefix_string.c_str(),
+                                 static_cast<uint32_t>(prefix_string.size()));
+  PP_Var str = var_interface->VarFromUtf8(text.c_str(),
+                                          static_cast<uint32_t>(text.size()));
+  const PPB_Console_Dev* console_interface =
+      static_cast<const PPB_Console_Dev*>(
+          module->GetBrowserInterface(PPB_CONSOLE_DEV_INTERFACE));
+  console_interface->LogWithSource(pp_instance(), PP_LOGLEVEL_LOG, prefix, str);
+  var_interface->Release(prefix);
+  var_interface->Release(str);
+}
+
 }  // namespace plugin