Remove browser support for non-PPAPI nexes

ppapi/native_client/src/trusted/plugin/service_runtime.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.
  */
 
 #define NACL_LOG_MODULE_NAME "Plugin::ServiceRuntime"
 
 #include "native_client/src/trusted/plugin/service_runtime.h"
 
 #include <string.h>
-#include <map>
 #include <set>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "base/compiler_specific.h"
 
 #include "native_client/src/include/portability_io.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/shared/imc/nacl_imc.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/shared/platform/nacl_sync.h"
 #include "native_client/src/shared/platform/nacl_sync_checked.h"
 #include "native_client/src/shared/platform/nacl_sync_raii.h"
 #include "native_client/src/shared/platform/scoped_ptr_refcount.h"
 #include "native_client/src/trusted/desc/nacl_desc_imc.h"
 #include "native_client/src/trusted/desc/nrd_xfer.h"
 #include "native_client/src/trusted/desc/nrd_xfer_effector.h"
 #include "native_client/src/trusted/handle_pass/browser_handle.h"
 #include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
-
-// browser_interface includes portability.h for uintptr_t etc, but it
-// also transitively includes windows.h, where PostMessage gets
-// defined as a preprocessor symbol
-#include "native_client/src/trusted/plugin/browser_interface.h"
-
 #include "native_client/src/trusted/plugin/manifest.h"
 
 // This is here due to a Windows API collision; plugin.h through
 // file_downloader.h transitively includes Instance.h which defines a
 // PostMessage method, so this undef must appear before any of those.
 #ifdef PostMessage
 #undef PostMessage
 #endif
 #include "native_client/src/trusted/plugin/plugin.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/srpc_client.h"
 #include "native_client/src/trusted/plugin/utility.h"
 
 #include "native_client/src/trusted/weak_ref/call_on_main_thread.h"
 
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
 #include "native_client/src/trusted/service_runtime/include/sys/nacl_imc_api.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/core.h"
 #include "ppapi/cpp/completion_callback.h"
 
-using std::vector;
-
 namespace plugin {
 
 PluginReverseInterface::PluginReverseInterface(
     nacl::WeakRefAnchor* anchor,
     Plugin* plugin,
     const Manifest* manifest,
     ServiceRuntime* service_runtime,
     pp::CompletionCallback init_done_cb,
     pp::CompletionCallback crash_cb)
       : anchor_(anchor),
@@ skipping 59 matching lines @@
   }
 }
 
 void PluginReverseInterface::Log_MainThreadContinuation(
     LogToJavaScriptConsoleResource* p,
     int32_t err) {
   UNREFERENCED_PARAMETER(err);
   NaClLog(4,
           "PluginReverseInterface::Log_MainThreadContinuation(%s)\n",
           p->message.c_str());
-  plugin_->browser_interface()->AddToConsole(static_cast<Plugin*>(plugin_),
-                                             p->message);
+  plugin_->AddToConsole(p->message);
 }
 void PluginReverseInterface::PostMessage_MainThreadContinuation(
     PostMessageResource* p,
     int32_t err) {
   UNREFERENCED_PARAMETER(err);
   NaClLog(4,
           "PluginReverseInterface::PostMessage_MainThreadContinuation(%s)\n",
           p->message.c_str());
   plugin_->PostMessage(std::string("DEBUG_POSTMESSAGE:") + p->message);
 }
@@ skipping 222 matching lines @@
   service_runtime_->set_exit_status(exit_status);
 }
 
 ServiceRuntime::ServiceRuntime(Plugin* plugin,
                                const Manifest* manifest,
                                bool should_report_uma,
                                pp::CompletionCallback init_done_cb,
                                pp::CompletionCallback crash_cb)
     : plugin_(plugin),
       should_report_uma_(should_report_uma),
-      browser_interface_(plugin->browser_interface()),
       reverse_service_(NULL),
       subprocess_(NULL),
-      async_receive_desc_(NULL),
-      async_send_desc_(NULL),
       anchor_(new nacl::WeakRefAnchor()),
       rev_interface_(new PluginReverseInterface(anchor_, plugin,
                                                 manifest,
                                                 this,
                                                 init_done_cb, crash_cb)),
       exit_status_(-1) {
   NaClSrpcChannelInitialize(&command_channel_);
   NaClXMutexCtor(&mu_);
 }
 
@@ skipping 101 matching lines @@
   }
   return true;
 }
 
 bool ServiceRuntime::Start(nacl::DescWrapper* nacl_desc,
                            ErrorInfo* error_info) {
   PLUGIN_PRINTF(("ServiceRuntime::Start (nacl_desc=%p)\n",
                  reinterpret_cast<void*>(nacl_desc)));
 
   nacl::scoped_ptr<nacl::SelLdrLauncher>
-      tmp_subprocess(new(std::nothrow) nacl::SelLdrLauncher());
+      tmp_subprocess(new nacl::SelLdrLauncher());
   if (NULL == tmp_subprocess.get()) {
     PLUGIN_PRINTF(("ServiceRuntime::Start (subprocess create failed)\n"));
     error_info->SetReport(ERROR_SEL_LDR_CREATE_LAUNCHER,
                           "ServiceRuntime: failed to create sel_ldr launcher");
     return false;
   }
   nacl::Handle sockets[3];
   if (!tmp_subprocess->Start(NACL_ARRAY_SIZE(sockets), sockets)) {
     PLUGIN_PRINTF(("ServiceRuntime::Start (start failed)\n"));
     error_info->SetReport(ERROR_SEL_LDR_LAUNCH,
                           "ServiceRuntime: failed to start");
     return false;
   }
 
-  async_receive_desc_.reset(
-      plugin()->wrapper_factory()->MakeImcSock(sockets[1]));
-  async_send_desc_.reset(plugin()->wrapper_factory()->MakeImcSock(sockets[2]));
-
   subprocess_.reset(tmp_subprocess.release());
   if (!InitCommunication(nacl_desc, error_info)) {
     subprocess_.reset(NULL);
     return false;
   }
 
   PLUGIN_PRINTF(("ServiceRuntime::Start (return 1)\n"));
   return true;
 }
 
 SrpcClient* ServiceRuntime::SetupAppChannel() {
   PLUGIN_PRINTF(("ServiceRuntime::SetupAppChannel (subprocess_=%p)\n",
                  reinterpret_cast<void*>(subprocess_.get())));
   nacl::DescWrapper* connect_desc = subprocess_->socket_addr()->Connect();
   if (NULL == connect_desc) {
     PLUGIN_PRINTF(("ServiceRuntime::SetupAppChannel (connect failed)\n"));
     return NULL;
   } else {
     PLUGIN_PRINTF(("ServiceRuntime::SetupAppChannel (conect_desc=%p)\n",
                    static_cast<void*>(connect_desc)));
-    SrpcClient* srpc_client = SrpcClient::New(plugin(), connect_desc);
+    SrpcClient* srpc_client = SrpcClient::New(connect_desc);
     PLUGIN_PRINTF(("ServiceRuntime::SetupAppChannel (srpc_client=%p)\n",
                    static_cast<void*>(srpc_client)));
     delete connect_desc;
     return srpc_client;
   }
 }
 
 bool ServiceRuntime::Kill() {
   return subprocess_->KillChildProcess();
 }
@@ skipping 56 matching lines @@
   nacl::MutexLocker take(&mu_);
   return exit_status_;
 }
 
 void ServiceRuntime::set_exit_status(int exit_status) {
   nacl::MutexLocker take(&mu_);
   exit_status_ = exit_status & 0xff;
 }
 
 }  // namespace plugin