Consistently use int64 for integers holding number of milliseconds.

base/process_util_posix.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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 266 matching lines @@
     return true;
   }
 
   // If it didn't exit cleanly, it must have been signaled.
   DCHECK(WIFSIGNALED(status));
   return false;
 }
 
 namespace {
 
-int WaitpidWithTimeout(ProcessHandle handle, int wait_milliseconds,
+int WaitpidWithTimeout(ProcessHandle handle, int64 wait_milliseconds,
                        bool* success) {
   // This POSIX version of this function only guarantees that we wait no less
   // than |wait_milliseconds| for the proces to exit.  The child process may
   // exit sometime before the timeout has ended but we may still block for
   // up to 0.25 seconds after the fact.
   //
   // waitpid() has no direct support on POSIX for specifying a timeout, you can
   // either ask it to block indefinitely or return immediately (WNOHANG).
   // When a child process terminates a SIGCHLD signal is sent to the parent.
   // Catching this signal would involve installing a signal handler which may
@@ skipping 34 matching lines @@
   }
 
   if (success)
     *success = (ret_pid != -1);
 
   return status;
 }
 
 }  // namespace
 
-bool WaitForSingleProcess(ProcessHandle handle, int wait_milliseconds) {
+bool WaitForSingleProcess(ProcessHandle handle, int64 wait_milliseconds) {
   bool waitpid_success;
   int status;
   if (wait_milliseconds == base::kNoTimeout)
     waitpid_success = (HANDLE_EINTR(waitpid(handle, &status, 0)) != -1);
   else
     status = WaitpidWithTimeout(handle, wait_milliseconds, &waitpid_success);
   if (status != -1) {
     DCHECK(waitpid_success);
     return WIFEXITED(status);
   } else {
     return false;
   }
 }
 
-bool CrashAwareSleep(ProcessHandle handle, int wait_milliseconds) {
+bool CrashAwareSleep(ProcessHandle handle, int64 wait_milliseconds) {
   bool waitpid_success;
   int status = WaitpidWithTimeout(handle, wait_milliseconds, &waitpid_success);
   if (status != -1) {
     DCHECK(waitpid_success);
     return !(WIFEXITED(status) || WIFSIGNALED(status));
   } else {
     // If waitpid returned with an error, then the process doesn't exist
     // (which most probably means it didn't exist before our call).
     return waitpid_success;
   }
@@ skipping 128 matching lines @@
   const ProcessEntry* entry;
 
   NamedProcessIterator iter(executable_name, filter);
   while ((entry = iter.NextProcessEntry()) != NULL)
     result = KillProcess((*entry).pid, exit_code, true) && result;
 
   return result;
 }
 
 bool WaitForProcessesToExit(const std::wstring& executable_name,
-                            int wait_milliseconds,
+                            int64 wait_milliseconds,
                             const ProcessFilter* filter) {
   bool result = false;
 
   // TODO(port): This is inefficient, but works if there are multiple procs.
   // TODO(port): use waitpid to avoid leaving zombies around
 
   base::Time end_time = base::Time::Now() +
       base::TimeDelta::FromMilliseconds(wait_milliseconds);
   do {
     NamedProcessIterator iter(executable_name, filter);
     if (!iter.NextProcessEntry()) {
       result = true;
       break;
     }
     PlatformThread::Sleep(100);
   } while ((base::Time::Now() - end_time) > base::TimeDelta());
 
   return result;
 }
 
 bool CleanupProcesses(const std::wstring& executable_name,
-                      int wait_milliseconds,
+                      int64 wait_milliseconds,
                       int exit_code,
                       const ProcessFilter* filter) {
   bool exited_cleanly =
       WaitForProcessesToExit(executable_name, wait_milliseconds,
-                           filter);
+                             filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
 }
 
 }  // namespace base