Switch to TimeDelta interfaces of TestTimeouts in chrome and ui code reviewable by ben.

chrome/browser/process_singleton_browsertest.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.
 
 // This test validates that the ProcessSingleton class properly makes sure
 // that there is only one main browser process.
 //
 // It is currently compiled and run on Windows and Posix(non-Mac) platforms.
 // Mac uses system services and ProcessSingletonMac is a noop.  (Maybe it still
 // makes sense to test that the system services are giving the behavior we
@@ skipping 17 matching lines @@
 #include "chrome/test/base/in_process_browser_test.h"
 
 namespace {
 
 // This is for the code that is to be ran in multiple threads at once,
 // to stress a race condition on first process start.
 // We use the thread safe ref counted base class so that we can use the
 // base::Bind to run the StartChrome methods in many threads.
 class ChromeStarter : public base::RefCountedThreadSafe<ChromeStarter> {
  public:
-  ChromeStarter(int timeout_ms, const FilePath& user_data_dir)
+  ChromeStarter(base::TimeDelta timeout, const FilePath& user_data_dir)
       : ready_event_(false /* manual */, false /* signaled */),
         done_event_(false /* manual */, false /* signaled */),
         process_handle_(base::kNullProcessHandle),
         process_terminated_(false),
-        timeout_ms_(timeout_ms),
+        timeout_(timeout),
         user_data_dir_(user_data_dir) {
   }
 
   // We must reset some data members since we reuse the same ChromeStarter
   // object and start/stop it a few times. We must start fresh! :-)
   void Reset() {
     ready_event_.Reset();
     done_event_.Reset();
     if (process_handle_ != base::kNullProcessHandle)
       base::CloseProcessHandle(process_handle_);
@@ skipping 40 matching lines @@
     // Here we don't wait for the app to be terminated because one of the
     // process will stay alive while the others will be restarted. If we would
     // wait here, we would never get a handle to the main process...
     base::LaunchProcess(command_line, base::LaunchOptions(), &process_handle_);
     ASSERT_NE(base::kNullProcessHandle, process_handle_);
 
     // We can wait on the handle here, we should get stuck on one and only
     // one process. The test below will take care of killing that process
     // to unstuck us once it confirms there is only one.
     process_terminated_ = base::WaitForSingleProcess(process_handle_,
-                                                     timeout_ms_);
+                                                     timeout_);
     // Let the test know we are done.
     done_event_.Signal();
   }
 
   // Public access to simplify the test code using them.
   base::WaitableEvent ready_event_;
   base::WaitableEvent done_event_;
   base::ProcessHandle process_handle_;
   bool process_terminated_;
 
  private:
   friend class base::RefCountedThreadSafe<ChromeStarter>;
 
   ~ChromeStarter() {
     if (process_handle_ != base::kNullProcessHandle)
       base::CloseProcessHandle(process_handle_);
   }
 
-  int timeout_ms_;
+  base::TimeDelta timeout_;
   FilePath user_data_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeStarter);
 };
 
 }  // namespace
 
 // Our test fixture that initializes and holds onto a few global vars.
 class ProcessSingletonTest : public InProcessBrowserTest {
  public:
   ProcessSingletonTest()
       // We use a manual reset so that all threads wake up at once when signaled
       // and thus we must manually reset it for each attempt.
       : threads_waker_(true /* manual */, false /* signaled */) {
     EXPECT_TRUE(temp_profile_dir_.CreateUniqueTempDir());
   }
 
   void SetUp() {
     // Start the threads and create the starters.
     for (size_t i = 0; i < kNbThreads; ++i) {
       chrome_starter_threads_[i].reset(new base::Thread("ChromeStarter"));
       ASSERT_TRUE(chrome_starter_threads_[i]->Start());
       chrome_starters_[i] = new ChromeStarter(
-          TestTimeouts::action_max_timeout_ms(), temp_profile_dir_.path());
+          TestTimeouts::action_max_timeout(), temp_profile_dir_.path());
     }
   }
 
   void TearDown() {
     // Stop the threads.
     for (size_t i = 0; i < kNbThreads; ++i)
       chrome_starter_threads_[i]->Stop();
   }
 
   // This method is used to make sure we kill the main browser process after
@@ skipping 158 matching lines @@
     ASSERT_EQ(static_cast<size_t>(1), pending_starters.size());
     size_t last_index = pending_starters.front();
     pending_starters.clear();
     if (chrome_starters_[last_index]->process_handle_ !=
         base::kNullProcessHandle) {
       KillProcessTree(chrome_starters_[last_index]->process_handle_);
       chrome_starters_[last_index]->done_event_.Wait();
     }
   }
 }