Add an IPC channel between the NaCl loader process and the renderer.

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"
@@ skipping 16 matching lines @@
 #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/ppapi_proxy/browser_ppp.h"
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
 #include "native_client/src/trusted/plugin/json_manifest.h"
+#include "native_client/src/trusted/plugin/nacl_entry_points.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_plugin.h"
 #include "native_client/src/trusted/plugin/service_runtime.h"
 #include "native_client/src/trusted/plugin/utility.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_nacl_private.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"
@@ skipping 46 matching lines @@
 
 // Up to 33 minutes.
 const int64_t kTimeLargeMin = 100;         // in ms
 const int64_t kTimeLargeMax = 2000000;     // in ms
 const uint32_t kTimeLargeBuckets = 100;
 
 const int64_t kSizeKBMin = 1;
 const int64_t kSizeKBMax = 512*1024;     // very large .nexe
 const uint32_t kSizeKBBuckets = 100;
 
+const PPB_NaCl_Private* GetNaclInterface() {
+  pp::Module *module = pp::Module::Get();
+  CHECK(module);
+  return static_cast<const PPB_NaCl_Private*>(
+      module->GetBrowserInterface(PPB_NACL_PRIVATE_INTERFACE));
+}
+
 const PPB_UMA_Private* GetUMAInterface() {
   pp::Module *module = pp::Module::Get();
   CHECK(module);
   return static_cast<const PPB_UMA_Private*>(
       module->GetBrowserInterface(PPB_UMA_PRIVATE_INTERFACE));
 }
 
 void HistogramTimeSmall(const std::string& name, int64_t ms) {
   if (ms < 0) return;
 
@@ skipping 462 matching lines @@
                          crash_cb);
   subprocess->set_service_runtime(new_service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleCommon (service_runtime=%p)\n",
                  static_cast<void*>(new_service_runtime)));
   if (NULL == new_service_runtime) {
     error_info->SetReport(ERROR_SEL_LDR_INIT,
                           "sel_ldr init failure " + subprocess->description());
     return false;
   }
 
+  void* ipc_channel_handle = NULL;
   bool service_runtime_started =
-      new_service_runtime->Start(wrapper, error_info, manifest_base_url());
+      new_service_runtime->Start(wrapper,
+                                 error_info,
+                                 manifest_base_url(),
+                                 &ipc_channel_handle);
+  nacl::scoped_ptr<char> ipc_channel_handle_ptr(
+      reinterpret_cast<char*>(ipc_channel_handle));
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleCommon (service_runtime_started=%d)\n",
                  service_runtime_started));
   if (!service_runtime_started) {
     return false;
   }
+
+  // Try to start the Chrome IPC-based proxy.
+  const PPB_NaCl_Private* ppb_nacl = GetNaclInterface();
+  if (ppb_nacl->StartPpapiProxy(
+          pp_instance(),
+          reinterpret_cast<void*>(ipc_channel_handle_ptr.release()))) {
+    using_ipc_proxy_ = true;
+    // We need to explicitly schedule this here. It is normally called in
+    // response to starting the SRPC proxy.
+    CHECK(init_done_cb.pp_completion_callback().func != NULL);
+    PLUGIN_PRINTF(("Plugin::LoadNaClModuleCommon, started ipc proxy.\n"));
+    pp::Module::Get()->core()->CallOnMainThread(0, init_done_cb, PP_OK);
+  }
   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 we are using the IPC proxy, StartSrpcServices and StartJSObjectProxy
+  // don't makes sense. Return 'true' so that the plugin continues loading.
+  if (using_ipc_proxy_)
+    return true;
+
   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",
@@ skipping 211 matching lines @@
       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) {
+      time_of_last_progress_event_(0),
+      using_ipc_proxy_(false) {
   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();
 
@@ skipping 1011 matching lines @@
                                           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