Fix the windows implementation of KillProcess and WaitForSingleProcess to not...

base/process_util_win.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.
 
 #include "base/process_util.h"
 
 #include <windows.h>
 #include <winternl.h>
 #include <psapi.h>
 
@@ skipping 142 matching lines @@
 
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden, ProcessHandle* process_handle) {
   return LaunchApp(cl.command_line_string(), wait,
                    start_hidden, process_handle);
 }
 
 // Attempts to kill the process identified by the given process
 // entry structure, giving it the specified exit code.
 // Returns true if this is successful, false otherwise.
-bool KillProcess(int process_id, int exit_code, bool wait) {
+bool KillProcessById(DWORD process_id, int exit_code, bool wait) {
   HANDLE process = OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE,
                                FALSE,  // Don't inherit handle
                                process_id);
-  if (process)
-    return KillProcess(process, exit_code, wait);
-  return false;
+  if (!process)
+    return false;
+
+  bool ret = KillProcess(process, exit_code, wait);
+  CloseHandle(process);
+  return ret;
 }
 
-bool KillProcess(HANDLE process, int exit_code, bool wait) {
-  bool result = !!TerminateProcess(process, exit_code);
+bool KillProcess(ProcessHandle process, int exit_code, bool wait) {
+  bool result = (TerminateProcess(process, exit_code) != FALSE);
   if (result && wait) {
     // The process may not end immediately due to pending I/O
     if (WAIT_OBJECT_0 != WaitForSingleObject(process, 60 * 1000))
       DLOG(ERROR) << "Error waiting for process exit: " << GetLastError();
   } else {
     DLOG(ERROR) << "Unable to terminate process: " << GetLastError();
   }
-  CloseHandle(process);
   return result;
 }
 
 bool DidProcessCrash(ProcessHandle handle) {
   DWORD exitcode = 0;
   if (!::GetExitCodeProcess(handle, &exitcode)) {
     NOTREACHED();
     return false;
   }
   if (exitcode == STILL_ACTIVE) {
@@ skipping 53 matching lines @@
     return false;
   }
   DWORD temp_code;  // Don't clobber out-parameters in case of failure.
   if (!::GetExitCodeProcess(handle, &temp_code))
     return false;
   *exit_code = temp_code;
   return true;
 }
 
 NamedProcessIterator::NamedProcessIterator(const std::wstring& executable_name,
-                                           const ProcessFilter* filter) :
-  started_iteration_(false),
-  executable_name_(executable_name),
-  filter_(filter) {
-    snapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-  }
+                                           const ProcessFilter* filter)
+    : started_iteration_(false),
+      executable_name_(executable_name),
+      filter_(filter) {
+  snapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+}
 
 NamedProcessIterator::~NamedProcessIterator() {
   CloseHandle(snapshot_);
 }
 
 
 const ProcessEntry* NamedProcessIterator::NextProcessEntry() {
   bool result = false;
   do {
     result = CheckForNextProcess();
@@ skipping 37 matching lines @@
     ++count;
   return count;
 }
 
 bool KillProcesses(const std::wstring& executable_name, int exit_code,
                    const ProcessFilter* filter) {
   bool result = true;
   const ProcessEntry* entry;
 
   NamedProcessIterator iter(executable_name, filter);
-  while (entry = iter.NextProcessEntry())
-    result = KillProcess((*entry).th32ProcessID, exit_code, true) && result;
+  while (entry = iter.NextProcessEntry()) {
+    if (!KillProcessById((*entry).th32ProcessID, exit_code, true))
+      result = false;
+  }
 
   return result;
 }
 
 bool WaitForProcessesToExit(const std::wstring& executable_name,
                             int wait_milliseconds,
                             const ProcessFilter* filter) {
   const ProcessEntry* entry;
   bool result = true;
   DWORD start_time = GetTickCount();
 
   NamedProcessIterator iter(executable_name, filter);
   while (entry = iter.NextProcessEntry()) {
     DWORD remaining_wait =
       std::max(0, wait_milliseconds -
           static_cast<int>(GetTickCount() - start_time));
     HANDLE process = OpenProcess(SYNCHRONIZE,
                                  FALSE,
                                  entry->th32ProcessID);
     DWORD wait_result = WaitForSingleObject(process, remaining_wait);
     CloseHandle(process);
     result = result && (wait_result == WAIT_OBJECT_0);
   }
 
   return result;
 }
 
 bool WaitForSingleProcess(ProcessHandle handle, int wait_milliseconds) {
   bool retval = WaitForSingleObject(handle, wait_milliseconds) == WAIT_OBJECT_0;
-  CloseHandle(handle);
   return retval;
 }
 
 bool CleanupProcesses(const std::wstring& executable_name,
                       int wait_milliseconds,
                       int exit_code,
                       const ProcessFilter* filter) {
   bool exited_cleanly = WaitForProcessesToExit(executable_name,
                                                wait_milliseconds,
                                                filter);
@@ skipping 274 matching lines @@
 void EnableTerminationOnHeapCorruption() {
   // Ignore the result code. Supported on XP SP3 and Vista.
   HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
 }
 
 void RaiseProcessToHighPriority() {
   SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 }
 
 }  // namespace base