Avoid blocking the PNaCl translator processes when chrome NaCl GDB flag is on.

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 "ppapi/native_client/src/trusted/plugin/plugin.h"
@@ skipping 417 matching lines @@
   } else if (ipc_result == PP_EXTERNAL_PLUGIN_ERROR_INSTANCE) {
     error_info->SetReport(PP_NACL_ERROR_START_PROXY_INSTANCE,
                           "could not create instance.");
     return false;
   }
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (%s)\n",
                  main_subprocess_.detailed_description().c_str()));
   return true;
 }
 
-NaClSubprocess* Plugin::LoadHelperNaClModule(nacl::DescWrapper* wrapper,
+NaClSubprocess* Plugin::LoadHelperNaClModule(const nacl::string& helper_url,
+                                             nacl::DescWrapper* wrapper,
                                              const Manifest* manifest,
                                              ErrorInfo* error_info) {
   nacl::scoped_ptr<NaClSubprocess> nacl_subprocess(
       new NaClSubprocess("helper module", NULL, NULL));
   if (NULL == nacl_subprocess.get()) {
     error_info->SetReport(PP_NACL_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.
   // NOTE: The PNaCl translator nexes are not built to use the IRT.  This is
   // done to save on address space and swap space.
   // TODO(jvoung): See if we still need the uses_ppapi variable, now that
   // LaunchSelLdr always happens on the main thread.
-  SelLdrStartParams params(manifest_base_url(),
+  SelLdrStartParams params(helper_url,
                            false /* uses_irt */,
                            false /* uses_ppapi */,
                            enable_dev_interfaces_,
                            false /* enable_dyncode_syscalls */,
                            false /* enable_exception_handling */,
                            true /* enable_crash_throttling */);
   if (!LoadNaClModuleFromBackgroundThread(wrapper, nacl_subprocess.get(),
                                           manifest, params)) {
     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(PP_NACL_ERROR_SRPC_CONNECTION_FAIL,
                           "SRPC connection failure for " +
                           nacl_subprocess->description());
     return NULL;
   }
 
-  PLUGIN_PRINTF(("Plugin::LoadHelperNaClModule (%s)\n",
+  PLUGIN_PRINTF(("Plugin::LoadHelperNaClModule (%s, %s)\n",
+                 helper_url.c_str(),
                  nacl_subprocess.get()->detailed_description().c_str()));
 
   return nacl_subprocess.release();
 }
 
 std::string Plugin::LookupArgument(const std::string& key) const {
   std::map<std::string, std::string>::const_iterator it = args_.find(key);
   if (it != args_.end())
     return it->second;
   return std::string();
@@ skipping 981 matching lines @@
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   exit_status_ = exit_status;
   nacl_interface_->SetReadOnlyProperty(pp_instance(),
                                        pp::Var("exitStatus").pp_var(),
                                        pp::Var(exit_status_).pp_var());
 }
 
 
 }  // namespace plugin