Split SelLdrLauncher into SelLdrLauncher{Standalone,Chrome} classes

src/trusted/nonnacl_util/sel_ldr_launcher.cc

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <assert.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 11 matching lines @@
 #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/service_runtime/env_cleanser.h"
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
 
 using std::vector;
 
 
 namespace nacl {
 
-SelLdrLauncher::SelLdrLauncher()
-  :
-#if defined(NACL_STANDALONE)
-    child_process_(kInvalidHandle),
-#endif
-    channel_(kInvalidHandle),
+SelLdrLauncherBase::SelLdrLauncherBase()
+  : channel_(kInvalidHandle),
     bootstrap_socket_(NULL),
-    socket_addr_(NULL),
+    socket_addr_(NULL) {
+}
+
+SelLdrLauncherBase::~SelLdrLauncherBase() {
+  if (kInvalidHandle != channel_) {
+    Close(channel_);
+  }
+}
+
+SelLdrLauncherStandalone::SelLdrLauncherStandalone()
+  : child_process_(kInvalidHandle),
     sel_ldr_locator_(new PluginSelLdrLocator()) {
 }
 
-SelLdrLauncher::SelLdrLauncher(SelLdrLocator* sel_ldr_locator)
-  :
-#if defined(NACL_STANDALONE)
-    child_process_(kInvalidHandle),
-#endif
-    channel_(kInvalidHandle),
-    bootstrap_socket_(NULL),
-    socket_addr_(NULL),
-    sel_ldr_locator_(sel_ldr_locator) {
-  CHECK(sel_ldr_locator != NULL);
-}
-
-void SelLdrLauncher::GetPluginDirectory(char* buffer, size_t len) {
+void SelLdrLauncherStandalone::GetPluginDirectory(char* buffer, size_t len) {
   sel_ldr_locator_->GetDirectory(buffer, len);
 }
 
 static DescWrapper* GetSockAddr(DescWrapper* desc) {
   DescWrapper::MsgHeader   header;
   DescWrapper::MsgIoVec    iovec[1];
   DescWrapper*             descs[NACL_ABI_IMC_USER_DESC_MAX];
   scoped_array<unsigned char> bytes(
       new unsigned char[NACL_ABI_IMC_USER_BYTES_MAX]);
   if (bytes.get() == NULL) {
@@ skipping 13 matching lines @@
     return NULL;
   }
   // Check that there was exactly one descriptor passed.
   if (1 != header.ndescv_length) {
     return NULL;
   }
 
   return descs[0];
 }
 
-bool SelLdrLauncher::SetupCommandAndLoad(NaClSrpcChannel* command,
-                                         DescWrapper* nexe) {
+bool SelLdrLauncherBase::SetupCommandAndLoad(NaClSrpcChannel* command,
+                                             DescWrapper* nexe) {
   // Get the bootstrap socket.
   CHECK(factory_ == NULL);
   factory_.reset(new DescWrapperFactory);
   CHECK(channel_ != kInvalidHandle);
   bootstrap_socket_.reset(factory_->MakeImcSock(channel_));
   if (bootstrap_socket_ == NULL) {
     NaClLog(4, ("SelLdrLauncher::SetupCommandAndLoad: "
                 "getting bootstrap socket failed\n"));
     return false;
   }
@@ skipping 33 matching lines @@
               "rpc_result= %d is not successful\n",
               static_cast<int>(rpc_result));
       NaClSrpcDtor(command);
       return false;
     }
   }
   return true;
 }
 
 bool
-SelLdrLauncher::StartModuleAndSetupAppChannel(NaClSrpcChannel* command,
-                                              NaClSrpcChannel* out_app_chan) {
+SelLdrLauncherBase::StartModuleAndSetupAppChannel(
+    NaClSrpcChannel* command,
+    NaClSrpcChannel* out_app_chan) {
   // Start untrusted code module.
   int start_result;
   NaClSrpcResultCodes rpc_result = NaClSrpcInvokeBySignature(command,
                                                              "start_module::i",
                                                              &start_result);
   NaClLog(4, "SelLdrLauncher::StartModule rpc result %d\n",
           static_cast<int>(rpc_result));
   if (NACL_SRPC_RESULT_OK != rpc_result && LOAD_OK != start_result) {
     NaClSrpcDtor(command);
     NaClLog(4, "SelLdrLauncher::StartModuleAndSetupAppChannel: "
@@ skipping 26 matching lines @@
 static char **GetEnviron() {
 #if NACL_OSX
   /* Mac dynamic libraries cannot access the environ variable directly. */
   return *_NSGetEnviron();
 #else
   return environ;
 #endif
 }
 #endif
 
-void SelLdrLauncher::BuildCommandLine(vector<nacl::string>* command) {
+void SelLdrLauncherStandalone::BuildCommandLine(vector<nacl::string>* command) {
   assert(sel_ldr_ != NACL_NO_FILE_PATH);  // Set by InitCommandLine().
   if (!command_prefix_.empty())
     command->insert(command->end(),
                     command_prefix_.begin(), command_prefix_.end());
   if (!sel_ldr_bootstrap_.empty())
     command->push_back(sel_ldr_bootstrap_);
   command->push_back(sel_ldr_);
   if (!sel_ldr_bootstrap_.empty())
     command->push_back("--r_debug=0xXXXXXXXXXXXXXXXX");
   command->push_back("-R");  // RPC will be used to point to the nexe.
@@ skipping 22 matching lines @@
 #endif
 
   if (application_argv_.size() > 0) {
     // Separator between sel_universal and app args.
     command->push_back("--");
     command->insert(command->end(),
                     application_argv_.begin(), application_argv_.end());
   }
 }
 
-void SelLdrLauncher::InitCommandLine(const vector<nacl::string>& prefix,
-                                     const vector<nacl::string>& sel_ldr_argv,
-                                     const vector<nacl::string>& app_argv) {
+void SelLdrLauncherStandalone::InitCommandLine(
+    const vector<nacl::string>& prefix,
+    const vector<nacl::string>& sel_ldr_argv,
+    const vector<nacl::string>& app_argv) {
   assert(sel_ldr_ == NACL_NO_FILE_PATH);  // Make sure we don't call this twice.
 
   char* var = getenv("NACL_SEL_LDR");
   if (var != NULL) {
     sel_ldr_ = var;
   } else {
     sel_ldr_ = GetSelLdrPathName();
   }
   char *bootstrap_var = getenv("NACL_SEL_LDR_BOOTSTRAP");
   if (bootstrap_var != NULL) {
@@ skipping 19 matching lines @@
   //      NaCl module.
   // "-i" maps the host OS file descriptor dest_fd into the nexe namespace as
   //      file descriptor 5.
   // TODO(sehr): remove the -i option and use the dest_fd directly with -X.
   sel_ldr_argv_.push_back("-X");
   sel_ldr_argv_.push_back("5");
   sel_ldr_argv_.push_back("-i");
   sel_ldr_argv_.push_back(nacl::string("5:") + dest_fd);
 }
 
-void SelLdrLauncher::CloseHandlesAfterLaunch() {
+void SelLdrLauncherStandalone::CloseHandlesAfterLaunch() {
   for (size_t i = 0; i < close_after_launch_.size(); i++) {
     Close(close_after_launch_[i]);
   }
   close_after_launch_.clear();
 }
 
-DescWrapper* SelLdrLauncher::Wrap(NaClDesc* raw_desc) {
+DescWrapper* SelLdrLauncherBase::Wrap(NaClDesc* raw_desc) {
   CHECK(factory_ != NULL);
   return factory_->MakeGeneric(raw_desc);
 }
 
-DescWrapper* SelLdrLauncher::WrapCleanup(NaClDesc* raw_desc) {
+DescWrapper* SelLdrLauncherBase::WrapCleanup(NaClDesc* raw_desc) {
   CHECK(factory_ != NULL);
   return factory_->MakeGenericCleanup(raw_desc);
 }
 
-#if defined(NACL_STANDALONE)
-bool SelLdrLauncher::Start(const char* url) {
+bool SelLdrLauncherStandalone::Start(const char* url) {
   UNREFERENCED_PARAMETER(url);
   vector<nacl::string> prefix;
   vector<nacl::string> args_for_sel_ldr;
   vector<nacl::string> args_for_nexe;
   const char* irt_library_path = getenv("NACL_IRT_LIBRARY");
   if (NULL != irt_library_path) {
     args_for_sel_ldr.push_back("-B");
     args_for_sel_ldr.push_back(irt_library_path);
   }
   if (!StartViaCommandLine(prefix, args_for_sel_ldr, args_for_nexe)) {
     return false;
   }
   return true;
 }
 
-bool SelLdrLauncher::Start(int socket_count,
-                           Handle* result_sockets,
-                           const char* url) {
-  UNREFERENCED_PARAMETER(socket_count);
-  UNREFERENCED_PARAMETER(result_sockets);
-  return Start(url);
-}
-#endif  // defined(NACL_STANDALONE)
-
 }  // namespace nacl