POSIX: add command line option to launch renderers in a wrapper

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2006-2008 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 
 #include "build/build_config.h"
@@ skipping 266 matching lines @@
   if (browser_command_line.HasSwitch(switches::kInProcessPlugins)) {
     // In process plugins won't work if the sandbox is enabled.
     in_sandbox = false;
   }
 
 #if defined(OS_WIN)
   bool child_needs_help =
       DebugFlags::ProcessDebugFlags(&cmd_line,
                                     DebugFlags::RENDERER,
                                     in_sandbox);
+#elif defined(OS_POSIX)
+  if (browser_command_line.HasSwitch(switches::kRendererCmdPrefix)) {
+    // launch the renderer child with some prefix (usually "gdb --args")
+    const std::wstring prefix =
+        browser_command_line.GetSwitchValue(switches::kRendererCmdPrefix);
+    cmd_line.PrependWrapper(prefix);
+  }
 #endif
 
   cmd_line.AppendSwitchWithValue(switches::kProcessType,
                                  switches::kRendererProcess);
 
   cmd_line.AppendSwitchWithValue(switches::kProcessChannelID,
                                  channel_id);
 
   const std::wstring& profile_path =
       browser_command_line.GetSwitchValue(switches::kUserDataDir);
@@ skipping 340 matching lines @@
       process_.set_handle(OpenProcess(MAXIMUM_ALLOWED, FALSE, peer_pid));
 #elif defined(OS_POSIX)
       // ProcessHandle is just a pid.
       process_.set_handle(peer_pid);
 #endif
       DCHECK(process_.handle());
     }
   } else {
     // Need to verify that the peer_pid is actually the process we know, if
     // it is not, we need to panic now. See bug 1002150.
-    CHECK(peer_pid == process_.pid());
+    if (peer_pid != process_.pid()) {
+      // In the case that we are running the renderer in a wrapper, this check
+      // is invalid as it's the wrapper PID that we'll have, not the actual
+      // renderer
+      const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
+      if (cmd_line.HasSwitch(switches::kRendererCmdPrefix))
+        return;
+      CHECK(peer_pid == process_.pid());
+    }
   }
 }
 
 // Static. This function can be called from the IO Thread or from the UI thread.
 void BrowserRenderProcessHost::BadMessageTerminateProcess(uint16 msg_type,
                                                           base::ProcessHandle process) {
   LOG(ERROR) << "bad message " << msg_type << " terminating renderer.";
   if (BrowserRenderProcessHost::run_renderer_in_process()) {
     // In single process mode it is better if we don't suicide but just crash.
     CHECK(false);
@@ skipping 131 matching lines @@
   // child processes determine the pid of the parent.
   // Build the channel ID.  This is composed of a unique identifier for the
   // parent browser process, an identifier for the renderer/plugin instance,
   // and a random component. We use a random component so that a hacked child
   // process can't cause denial of service by causing future named pipe creation
   // to fail.
   return StringPrintf(L"%d.%x.%d",
                       base::GetCurrentProcId(), instance,
                       base::RandInt(0, std::numeric_limits<int>::max()));
 }