Debug exit code

content/browser/child_process_launcher.cc

 // Copyright 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.
 
 #include "content/browser/child_process_launcher.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 414 matching lines @@
     BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
                             base::Bind(&TerminateOnLauncherThread, zygote_,
                                        base::Passed(&process_)));
   }
 }
 
 void ChildProcessLauncher::Launch(
     SandboxedProcessLauncherDelegate* delegate,
     base::CommandLine* cmd_line,
     int child_process_id) {
+  fprintf(stderr, "Launch: %s\n", cmd_line->GetCommandLineString().c_str()); fflush(stderr);
   DCHECK(CalledOnValidThread());
 
 #if defined(OS_ANDROID)
   // Android only supports renderer, sandboxed utility and gpu.
   std::string process_type =
       cmd_line->GetSwitchValueASCII(switches::kProcessType);
   CHECK(process_type == switches::kGpuProcess ||
         process_type == switches::kRendererProcess ||
 #if defined(ENABLE_PLUGINS)
         process_type == switches::kPpapiPluginProcess ||
@@ skipping 77 matching lines @@
     base::WeakPtr<ChildProcessLauncher> instance,
     bool terminate_on_shutdown,
     mojo::edk::ScopedPlatformHandle server_handle,
     ZygoteHandle zygote,
 #if defined(OS_ANDROID)
     base::ScopedFD ipcfd,
     base::ScopedFD mojo_fd,
 #endif
     base::Process process,
     int error_code) {
+  fprintf(stderr, "DidLaunch\n"); fflush(stderr);
   if (!process.IsValid())
     LOG(ERROR) << "Failed to launch child process";
 
   if (instance.get()) {
     instance->Notify(zygote, std::move(server_handle),
 #if defined(OS_ANDROID)
                      std::move(ipcfd),
 #endif
                      std::move(process), error_code);
   } else {
@@ skipping 44 matching lines @@
 
 const base::Process& ChildProcessLauncher::GetProcess() const {
   // TODO(crbug.com/469248): This fails in some tests.
   // DCHECK(CalledOnValidThread());
   return process_;
 }
 
 base::TerminationStatus ChildProcessLauncher::GetChildTerminationStatus(
     bool known_dead,
     int* exit_code) {
+  fprintf(stderr, "GetChildTerminationStatus\n"); fflush(stderr);
   DCHECK(CalledOnValidThread());
   if (!process_.IsValid()) {
+    fprintf(stderr, "cached status: %d\n", termination_status_); fflush(stderr);
     // Process is already gone, so return the cached termination status.
     if (exit_code)
       *exit_code = exit_code_;
     return termination_status_;
   }
 
+  fprintf(stderr, "UpdateTerminationStatus\n"); fflush(stderr);
   UpdateTerminationStatus(known_dead);
   if (exit_code)
     *exit_code = exit_code_;
 
   // POSIX: If the process crashed, then the kernel closed the socket
   // for it and so the child has already died by the time we get
   // here. Since GetTerminationStatus called waitpid with WNOHANG,
   // it'll reap the process.  However, if GetTerminationStatus didn't
   // reap the child (because it was still running), we'll need to
   // Terminate via ProcessWatcher. So we can't close the handle here.
   if (termination_status_ != base::TERMINATION_STATUS_STILL_RUNNING)
     process_.Close();
 
   return termination_status_;
 }
 
 ChildProcessLauncher::Client* ChildProcessLauncher::ReplaceClientForTest(
     Client* client) {
   Client* ret = client_;
   client_ = client;
   return ret;
 }
 
 }  // namespace content