Switch to TimeDelta interfaces in chrome automation test infrastructure.

chrome/test/automation/proxy_launcher.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/test/automation/proxy_launcher.h"
 
 #include <vector>
 
 #include "base/environment.h"
 #include "base/file_util.h"
@@ skipping 112 matching lines @@
 #endif
   }
 
   return true;
 }
 
 bool ProxyLauncher::LaunchBrowserAndServer(const LaunchState& state,
                                            bool wait_for_initial_loads) {
   // Set up IPC testing interface as a server.
   automation_proxy_.reset(CreateAutomationProxy(
-                              TestTimeouts::action_max_timeout_ms()));
+      TestTimeouts::action_max_timeout()));
 
   if (!LaunchBrowser(state))
     return false;
 
   if (!WaitForBrowserLaunch(wait_for_initial_loads))
     return false;
 
   return true;
 }
 
 bool ProxyLauncher::ConnectToRunningBrowser(bool wait_for_initial_loads) {
   // Set up IPC testing interface as a client.
   automation_proxy_.reset(CreateAutomationProxy(
-                              TestTimeouts::action_max_timeout_ms()));
+                              TestTimeouts::action_max_timeout()));
 
   return WaitForBrowserLaunch(wait_for_initial_loads);
 }
 
 void ProxyLauncher::CloseBrowserAndServer() {
   QuitBrowser();
 
   // Suppress spammy failures that seem to be occurring when running
   // the UI tests in single-process mode.
   // TODO(jhughes): figure out why this is necessary at all, and fix it
@@ skipping 106 matching lines @@
 
   // Now, drop the automation IPC channel so that the automation provider in
   // the browser notices and drops its reference to the browser process.
   if (automation_proxy_.get())
     automation_proxy_->Disconnect();
 
   // Wait for the browser process to quit. It should quit once all tabs have
   // been closed.
   int exit_code = -1;
   EXPECT_TRUE(WaitForBrowserProcessToQuit(
-                  TestTimeouts::action_max_timeout_ms(), &exit_code));
+                  TestTimeouts::action_max_timeout(), &exit_code));
   EXPECT_EQ(0, exit_code);  // Expect a clean shutdown.
 
   browser_quit_time_ = base::TimeTicks::Now() - quit_start;
 }
 
 void ProxyLauncher::TerminateBrowser() {
   // If we have already finished waiting for the browser to exit
   // (or it hasn't launched at all), there's nothing to do here.
   if (process_ == base::kNullProcessHandle || !automation_proxy_.get())
     return;
@@ skipping 10 matching lines @@
   // the browser notices and drops its reference to the browser process.
   if (automation_proxy_.get())
     automation_proxy_->Disconnect();
 
 #if defined(OS_POSIX)
   EXPECT_EQ(kill(process_, SIGTERM), 0);
 #endif  // OS_POSIX
 
   int exit_code = -1;
   EXPECT_TRUE(WaitForBrowserProcessToQuit(
-                  TestTimeouts::action_max_timeout_ms(), &exit_code));
+                  TestTimeouts::action_max_timeout(), &exit_code));
   EXPECT_EQ(0, exit_code);  // Expect a clean shutdown.
 
   browser_quit_time_ = base::TimeTicks::Now() - quit_start;
 }
 
 void ProxyLauncher::AssertAppNotRunning(const std::string& error_message) {
   std::string final_error_message(error_message);
 
   ChromeProcessList processes = GetRunningChromeProcesses(process_id_);
   if (!processes.empty()) {
     final_error_message += " Leftover PIDs: [";
     for (ChromeProcessList::const_iterator it = processes.begin();
          it != processes.end(); ++it) {
       final_error_message += StringPrintf(" %d", *it);
     }
     final_error_message += " ]";
   }
   ASSERT_TRUE(processes.empty()) << final_error_message;
 }
 
-bool ProxyLauncher::WaitForBrowserProcessToQuit(int timeout, int* exit_code) {
+bool ProxyLauncher::WaitForBrowserProcessToQuit(
+    base::TimeDelta timeout,
+    int* exit_code) {
 #ifdef WAIT_FOR_DEBUGGER_ON_OPEN
-  timeout = 500000;
+  timeout = base::TimeDelta::FromSeconds(500);
 #endif
   bool success = false;
 
   // Only wait for exit if the "browser, please terminate" message had a
   // chance of making it through.
   if (!automation_proxy_->channel_disconnected_on_failure())
     success = base::WaitForExitCodeWithTimeout(process_, exit_code, timeout);
 
   if (!success)
     TerminateAllChromeProcesses(process_id_);
@@ skipping 165 matching lines @@
 
 NamedProxyLauncher::NamedProxyLauncher(const std::string& channel_id,
                                        bool launch_browser,
                                        bool disconnect_on_failure)
     : channel_id_(channel_id),
       launch_browser_(launch_browser),
       disconnect_on_failure_(disconnect_on_failure) {
 }
 
 AutomationProxy* NamedProxyLauncher::CreateAutomationProxy(
-    int execution_timeout) {
+    base::TimeDelta execution_timeout) {
   AutomationProxy* proxy = new AutomationProxy(execution_timeout,
                                                disconnect_on_failure_);
   proxy->InitializeChannel(channel_id_, true);
   return proxy;
 }
 
 bool NamedProxyLauncher::InitializeConnection(const LaunchState& state,
                                               bool wait_for_initial_loads) {
   if (launch_browser_) {
 #if defined(OS_POSIX)
     // Because we are waiting on the existence of the testing file below,
     // make sure there isn't one already there before browser launch.
     if (!file_util::Delete(FilePath(channel_id_), false)) {
       LOG(ERROR) << "Failed to delete " << channel_id_;
       return false;
     }
 #endif
 
     if (!LaunchBrowser(state)) {
       LOG(ERROR) << "Failed to LaunchBrowser";
       return false;
     }
   }
 
   // Wait for browser to be ready for connections.
   bool channel_initialized = false;
-  for (int wait_time = 0;
-       wait_time < TestTimeouts::action_max_timeout_ms();
-       wait_time += automation::kSleepTime) {
+  base::TimeDelta sleep_time = base::TimeDelta::FromMilliseconds(
+      automation::kSleepTime);
+  for (base::TimeDelta wait_time = base::TimeDelta();
+       wait_time < TestTimeouts::action_max_timeout();
+       wait_time += sleep_time) {
     channel_initialized = IPC::Channel::IsNamedServerInitialized(channel_id_);
     if (channel_initialized)
       break;
-    base::PlatformThread::Sleep(
-        base::TimeDelta::FromMilliseconds(automation::kSleepTime));
+    base::PlatformThread::Sleep(sleep_time);
   }
   if (!channel_initialized) {
     LOG(ERROR) << "Failed to wait for testing channel presence.";
     return false;
   }
 
   if (!ConnectToRunningBrowser(wait_for_initial_loads)) {
     LOG(ERROR) << "Failed to ConnectToRunningBrowser";
     return false;
   }
@@ skipping 14 matching lines @@
 }
 
 // AnonymousProxyLauncher functions
 
 AnonymousProxyLauncher::AnonymousProxyLauncher(bool disconnect_on_failure)
     : disconnect_on_failure_(disconnect_on_failure) {
   channel_id_ = AutomationProxy::GenerateChannelID();
 }
 
 AutomationProxy* AnonymousProxyLauncher::CreateAutomationProxy(
-    int execution_timeout) {
+    base::TimeDelta execution_timeout) {
   AutomationProxy* proxy = new AutomationProxy(execution_timeout,
                                                disconnect_on_failure_);
   proxy->InitializeChannel(channel_id_, false);
   return proxy;
 }
 
 bool AnonymousProxyLauncher::InitializeConnection(const LaunchState& state,
                                                   bool wait_for_initial_loads) {
   return LaunchBrowserAndServer(state, wait_for_initial_loads);
 }
 
 void AnonymousProxyLauncher::TerminateConnection() {
   CloseBrowserAndServer();
 }
 
 std::string AnonymousProxyLauncher::PrefixedChannelID() const {
   return channel_id_;
 }