Multi-Process Tracking Support

base/process/launch_win.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.
 
 #include "base/process/launch.h"
 
 #include <fcntl.h>
 #include <io.h>
 #include <shellapi.h>
 #include <windows.h>
 #include <userenv.h>
 #include <psapi.h>
 
 #include <ios>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
+#include "base/debug/activity_tracker.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/process/kill.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
 #include "base/win/startup_information.h"
@@ skipping 58 matching lines @@
   // Create the child process.
   PROCESS_INFORMATION temp_process_info = {};
   if (!CreateProcess(nullptr, &writable_command_line_string[0], nullptr,
                      nullptr,
                      TRUE,  // Handles are inherited.
                      0, nullptr, nullptr, &start_info, &temp_process_info)) {
     NOTREACHED() << "Failed to start process";
     return false;
   }
   base::win::ScopedProcessInformation proc_info(temp_process_info);
+  base::debug::GlobalActivityTracker::RecordProcessLaunchIfEnabled(
+      proc_info.process_id());
 
   // Close our writing end of pipe now. Otherwise later read would not be able
   // to detect end of child's output.
   scoped_out_write.Close();
 
   // Read output from the child process's pipe for STDOUT
   const int kBufferSize = 1024;
   char buffer[kBufferSize];
 
   for (;;) {
     DWORD bytes_read = 0;
     BOOL success =
         ReadFile(out_read, buffer, kBufferSize, &bytes_read, nullptr);
     if (!success || bytes_read == 0)
       break;
     output->append(buffer, bytes_read);
   }
 
   // Let's wait for the process to finish.
   WaitForSingleObject(proc_info.process_handle(), INFINITE);
 
   int exit_code;
   base::TerminationStatus status = GetTerminationStatus(
       proc_info.process_handle(), &exit_code);
+  base::debug::GlobalActivityTracker::RecordProcessExitIfEnabled(
+      proc_info.process_id(), exit_code);
   return status != base::TERMINATION_STATUS_PROCESS_CRASHED &&
          status != base::TERMINATION_STATUS_ABNORMAL_TERMINATION;
 }
 
 }  // namespace
 
 void RouteStdioToConsole(bool create_console_if_not_found) {
   // Don't change anything if stdout or stderr already point to a
   // valid stream.
   //
@@ skipping 178 matching lines @@
       scoped_process.Terminate(kProcessKilledExitCode, true);
       return Process();
     }
 
     ResumeThread(process_info.thread_handle());
   }
 
   if (options.wait)
     WaitForSingleObject(process_info.process_handle(), INFINITE);
 
+  base::debug::GlobalActivityTracker::RecordProcessLaunchIfEnabled(
+      process_info.process_id());
   return Process(process_info.TakeProcessHandle());
 }
 
 Process LaunchElevatedProcess(const CommandLine& cmdline,
                               const LaunchOptions& options) {
   const string16 file = cmdline.GetProgram().value();
   const string16 arguments = cmdline.GetArgumentsString();
 
   SHELLEXECUTEINFO shex_info = {};
   shex_info.cbSize = sizeof(shex_info);
   shex_info.fMask = SEE_MASK_NOCLOSEPROCESS;
   shex_info.hwnd = GetActiveWindow();
   shex_info.lpVerb = L"runas";
   shex_info.lpFile = file.c_str();
   shex_info.lpParameters = arguments.c_str();
   shex_info.lpDirectory = nullptr;
   shex_info.nShow = options.start_hidden ? SW_HIDE : SW_SHOW;
   shex_info.hInstApp = nullptr;
 
   if (!ShellExecuteEx(&shex_info)) {
     DPLOG(ERROR);
     return Process();
   }
 
   if (options.wait)
     WaitForSingleObject(shex_info.hProcess, INFINITE);
 
+  base::debug::GlobalActivityTracker::RecordProcessLaunchIfEnabled(
+      GetProcessId(shex_info.hProcess));
   return Process(shex_info.hProcess);
 }
 
 bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags) {
   JOBOBJECT_EXTENDED_LIMIT_INFORMATION limit_info = {};
   limit_info.BasicLimitInformation.LimitFlags = limit_flags;
   return 0 != SetInformationJobObject(
       job_object,
       JobObjectExtendedLimitInformation,
       &limit_info,
@@ skipping 10 matching lines @@
 
 bool GetAppOutput(const StringPiece16& cl, std::string* output) {
   return GetAppOutputInternal(cl, false, output);
 }
 
 void RaiseProcessToHighPriority() {
   SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 }
 
 }  // namespace base