Remove old test timeout and process waiting function interfaces.

base/process_util_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_util.h"
 
 #include <fcntl.h>
 #include <io.h>
 #include <windows.h>
 #include <userenv.h>
@@ skipping 528 matching lines @@
 }
 
 bool WaitForExitCode(ProcessHandle handle, int* exit_code) {
   bool success = WaitForExitCodeWithTimeout(
       handle, exit_code, base::TimeDelta::FromMilliseconds(INFINITE));
   CloseProcessHandle(handle);
   return success;
 }
 
 bool WaitForExitCodeWithTimeout(ProcessHandle handle, int* exit_code,
-                                int64 timeout_milliseconds) {
-  if (::WaitForSingleObject(handle, timeout_milliseconds) != WAIT_OBJECT_0)
+                                base::TimeDelta timeout) {
+  if (::WaitForSingleObject(handle, timeout.InMilliseconds()) != WAIT_OBJECT_0)
     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;
 }
 
-bool WaitForExitCodeWithTimeout(ProcessHandle handle, int* exit_code,
-                                base::TimeDelta timeout) {
-  return WaitForExitCodeWithTimeout(
-      handle, exit_code, timeout.InMilliseconds());
-}
-
 ProcessIterator::ProcessIterator(const ProcessFilter* filter)
     : started_iteration_(false),
       filter_(filter) {
   snapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 }
 
 ProcessIterator::~ProcessIterator() {
   CloseHandle(snapshot_);
 }
 
@@ skipping 12 matching lines @@
   memset(entry, 0, sizeof(*entry));
   entry->dwSize = sizeof(*entry);
 }
 
 bool NamedProcessIterator::IncludeEntry() {
   // Case insensitive.
   return _wcsicmp(executable_name_.c_str(), entry().exe_file()) == 0 &&
          ProcessIterator::IncludeEntry();
 }
 
 bool WaitForProcessesToExit(const FilePath::StringType& executable_name,

[jar (doing other things), 2012/07/25 19:03:19]

Who is calling this now?  Should this be deleted?

                             int64 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<int64>(0, wait_milliseconds - (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 WaitForProcessesToExit(const FilePath::StringType& executable_name,
                             base::TimeDelta wait,
                             const ProcessFilter* filter) {
-  return WaitForProcessesToExit(executable_name, wait.InMilliseconds(), filter);
-}
+  const ProcessEntry* entry;
+  bool result = true;
+  DWORD start_time = GetTickCount();
 
-bool WaitForSingleProcess(ProcessHandle handle, int64 wait_milliseconds) {
-  return WaitForSingleProcess(
-      handle, base::TimeDelta::FromMilliseconds(wait_milliseconds));
+  NamedProcessIterator iter(executable_name, filter);
+  while ((entry = iter.NextProcessEntry())) {
+    DWORD remaining_wait =
+        std::max<int64>(0,

[jar (doing other things), 2012/07/25 19:03:19]

nit: Don't bother to wrap line 623 given that you're going to wrap 624 so
quickly.  I'd then probably wrap the above line before the "0,"

+                        wait.InMilliseconds() - (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, base::TimeDelta wait) {
   int exit_code;
   if (!WaitForExitCodeWithTimeout(handle, &exit_code, wait))
     return false;
   return exit_code == 0;
 }
 
 bool CleanupProcesses(const FilePath::StringType& executable_name,
@@ skipping 375 matching lines @@
 
   PERFORMANCE_INFORMATION info;
   if (!InternalGetPerformanceInfo(&info, sizeof(info))) {
     DLOG(ERROR) << "Failed to fetch internal performance info.";
     return 0;
   }
   return (info.CommitTotal * system_info.dwPageSize) / 1024;
 }
 
 }  // namespace base