Multi-Process Tracking Support

base/process/process_win.cc

 // Copyright (c) 2011 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 "base/process/process.h"
 
 #include "base/debug/activity_tracker.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/kill.h"
@@ skipping 121 matching lines @@
 bool Process::Terminate(int exit_code, bool wait) const {
   DCHECK(IsValid());
   bool result = (::TerminateProcess(Handle(), exit_code) != FALSE);
   if (result && wait) {
     // The process may not end immediately due to pending I/O
     if (::WaitForSingleObject(Handle(), 60 * 1000) != WAIT_OBJECT_0)
       DPLOG(ERROR) << "Error waiting for process exit";
   } else if (!result) {
     DPLOG(ERROR) << "Unable to terminate process";
   }
+  if (result) {
+    base::debug::GlobalActivityTracker::RecordProcessExitIfEnabled(Pid(),
+                                                                   exit_code);
+  }
   return result;
 }
 
 bool Process::WaitForExit(int* exit_code) const {
   return WaitForExitWithTimeout(TimeDelta::FromMilliseconds(INFINITE),
                                 exit_code);
 }
 
 bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) const {
   // Record the event that this thread is blocking upon (for hang diagnosis).
   base::debug::ScopedProcessWaitActivity process_activity(this);
 
   // Limit timeout to INFINITE.
   DWORD timeout_ms = saturated_cast<DWORD>(timeout.InMilliseconds());
   if (::WaitForSingleObject(Handle(), timeout_ms) != WAIT_OBJECT_0)
     return false;
 
   DWORD temp_code;  // Don't clobber out-parameters in case of failure.
   if (!::GetExitCodeProcess(Handle(), &temp_code))
     return false;
 
   if (exit_code)
     *exit_code = temp_code;
+
+  base::debug::GlobalActivityTracker::RecordProcessExitIfEnabled(
+      Pid(), static_cast<int>(temp_code));
   return true;
 }
 
 bool Process::IsProcessBackgrounded() const {
   DCHECK(IsValid());
   DWORD priority = GetPriority();
   if (priority == 0)
     return false;  // Failure case.
   return ((priority == BELOW_NORMAL_PRIORITY_CLASS) ||
           (priority == IDLE_PRIORITY_CLASS));
@@ skipping 14 matching lines @@
 
   return (::SetPriorityClass(Handle(), priority) != 0);
 }
 
 int Process::GetPriority() const {
   DCHECK(IsValid());
   return ::GetPriorityClass(Handle());
 }
 
 }  // namespace base