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

chrome/browser/process_singleton_linux_unittest.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 "chrome/browser/process_singleton.h"
 
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>
@@ skipping 86 matching lines @@
             worker_thread_->message_loop_proxy()));
     ASSERT_TRUE(helper->Run());
   }
 
   ProcessSingleton* CreateProcessSingleton() {
     return new ProcessSingleton(temp_dir_.path());
   }
 
   ProcessSingleton::NotifyResult NotifyOtherProcess(
       bool override_kill,
-      int timeout_ms) {
+      base::TimeDelta timeout) {
     scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
     CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram());
     command_line.AppendArg("about:blank");
     if (override_kill) {
       process_singleton->OverrideCurrentPidForTesting(base::GetCurrentProcId() + 1);
       process_singleton->OverrideKillCallbackForTesting(
           base::Bind(&ProcessSingletonLinuxTest::KillCallback,
                      base::Unretained(this)));
     }
 
     return process_singleton->NotifyOtherProcessWithTimeout(
-        command_line, timeout_ms / 1000, true);
+        command_line, timeout.InSeconds(), true);
   }
 
   // A helper method to call ProcessSingleton::NotifyOtherProcessOrCreate().
   ProcessSingleton::NotifyResult NotifyOtherProcessOrCreate(
       const std::string& url,
-      int timeout_ms) {
+      base::TimeDelta timeout) {
     scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
     CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram());
     command_line.AppendArg(url);
     return process_singleton->NotifyOtherProcessWithTimeoutOrCreate(
-        command_line, base::Bind(&NotificationCallback), timeout_ms / 1000);
+        command_line, base::Bind(&NotificationCallback), timeout.InSeconds());
   }
 
   void CheckNotified() {
     ASSERT_EQ(1u, callback_command_lines_.size());
     bool found = false;
     for (size_t i = 0; i < callback_command_lines_[0].size(); ++i) {
       if (callback_command_lines_[0][i] == "about:blank") {
         found = true;
         break;
       }
@@ skipping 93 matching lines @@
   len = readlink(remote_cookie_path.value().c_str(), buf, PATH_MAX);
   ASSERT_GT(len, 0);
   EXPECT_EQ(cookie, std::string(buf, len));
 }
 
 // TODO(james.su@gmail.com): port following tests to Windows.
 // Test success case of NotifyOtherProcess().
 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessSuccess) {
   CreateProcessSingletonOnThread();
   EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED,
-            NotifyOtherProcess(true, TestTimeouts::action_timeout_ms()));
+            NotifyOtherProcess(true, TestTimeouts::action_timeout()));
   CheckNotified();
 }
 
 // Test failure case of NotifyOtherProcess().
 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessFailure) {
   CreateProcessSingletonOnThread();
 
   BlockWorkerThread();
   EXPECT_EQ(ProcessSingleton::PROCESS_NONE,
-            NotifyOtherProcess(true, TestTimeouts::action_timeout_ms()));
+            NotifyOtherProcess(true, TestTimeouts::action_timeout()));
 
   ASSERT_EQ(1, kill_callbacks_);
   UnblockWorkerThread();
 }
 
 // Test that we don't kill ourselves by accident if a lockfile with the same pid
 // happens to exist.
 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessNoSuicide) {
   CreateProcessSingletonOnThread();
   // Replace lockfile with one containing our own pid.
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   std::string symlink_content = base::StringPrintf(
       "%s%c%u",
       net::GetHostName().c_str(),
       '-',
       base::GetCurrentProcId());
   EXPECT_EQ(0, symlink(symlink_content.c_str(), lock_path_.value().c_str()));
 
   // Remove socket so that we will not be able to notify the existing browser.
   EXPECT_EQ(0, unlink(socket_path_.value().c_str()));
 
   EXPECT_EQ(ProcessSingleton::PROCESS_NONE,
-            NotifyOtherProcess(false, TestTimeouts::action_timeout_ms()));
+            NotifyOtherProcess(false, TestTimeouts::action_timeout()));
   // If we've gotten to this point without killing ourself, the test succeeded.
 }
 
 // Test that we can still notify a process on the same host even after the
 // hostname changed.
 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessHostChanged) {
   CreateProcessSingletonOnThread();
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
 
   EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED,
-            NotifyOtherProcess(false, TestTimeouts::action_timeout_ms()));
+            NotifyOtherProcess(false, TestTimeouts::action_timeout()));
   CheckNotified();
 }
 
 // Test that we fail when lock says process is on another host and we can't
 // notify it over the socket.
 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessDifferingHost) {
   CreateProcessSingletonOnThread();
 
   BlockWorkerThread();
 
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
 
   EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE,
-            NotifyOtherProcess(false, TestTimeouts::action_timeout_ms()));
+            NotifyOtherProcess(false, TestTimeouts::action_timeout()));
 
   ASSERT_EQ(0, unlink(lock_path_.value().c_str()));
 
   UnblockWorkerThread();
 }
 
 // Test that we fail when lock says process is on another host and we can't
 // notify it over the socket.
 TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessOrCreate_DifferingHost) {
   CreateProcessSingletonOnThread();
 
   BlockWorkerThread();
 
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
 
   std::string url("about:blank");
   EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE,
-            NotifyOtherProcessOrCreate(url, TestTimeouts::action_timeout_ms()));
+            NotifyOtherProcessOrCreate(url, TestTimeouts::action_timeout()));
 
   ASSERT_EQ(0, unlink(lock_path_.value().c_str()));
 
   UnblockWorkerThread();
 }
 
 // Test that Create fails when another browser is using the profile directory.
 TEST_F(ProcessSingletonLinuxTest, CreateFailsWithExistingBrowser) {
   CreateProcessSingletonOnThread();
 
@@ skipping 30 matching lines @@
   // Change the cookie.
   EXPECT_EQ(0, unlink(cookie_path_.value().c_str()));
   EXPECT_EQ(0, symlink("INCORRECTCOOKIE", cookie_path_.value().c_str()));
 
   // Also change the hostname, so the remote does not retry.
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
 
   std::string url("about:blank");
   EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE,
-            NotifyOtherProcessOrCreate(url, TestTimeouts::action_timeout_ms()));
+            NotifyOtherProcessOrCreate(url, TestTimeouts::action_timeout()));
 }