Switch to TimeDelta interfaces in chrome automation test infrastructure.

chrome/test/ui/ui_test.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/ui/ui_test.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #include <sys/types.h>
 #endif
@@ skipping 101 matching lines @@
 void UITestBase::SetUp() {
   // Tests that do a session restore (e.g. SessionRestoreUITest, StartupTest)
   // call SetUp() multiple times because they restart the browser mid-test.
   // We don't want to reset the ProxyLauncher's state in those cases.
   if (!launcher_.get())
     launcher_.reset(CreateProxyLauncher());
   launcher_->AssertAppNotRunning("Please close any other instances "
                                  "of the app before testing.");
 
   JavaScriptExecutionController::set_timeout(
-      TestTimeouts::action_max_timeout_ms());
+      TestTimeouts::action_max_timeout());
   test_start_time_ = Time::NowFromSystemTime();
 
   SetLaunchSwitches();
   ASSERT_TRUE(launcher_->InitializeConnection(DefaultLaunchState(),
                                               wait_for_initial_loads_));
 }
 
 void UITestBase::TearDown() {
   if (launcher_.get())
     launcher_->TerminateConnection();
 
   CheckErrorsAndCrashes();
 }
 
 AutomationProxy* UITestBase::automation() const {
   return launcher_->automation();
 }
 
+base::TimeDelta UITestBase::action_timeout() {
+  return automation()->action_timeout();
+}
+
 int UITestBase::action_timeout_ms() {
-  return automation()->action_timeout_ms();
+  return action_timeout().InMilliseconds();
+}
+
+void UITestBase::set_action_timeout(base::TimeDelta timeout) {
+  automation()->set_action_timeout(timeout);
+  VLOG(1) << "Automation action timeout set to "
+          << timeout.InMilliseconds() << " ms";
 }
 
 void UITestBase::set_action_timeout_ms(int timeout) {
-  automation()->set_action_timeout_ms(timeout);
-  VLOG(1) << "Automation action timeout set to " << timeout << " ms";
+  set_action_timeout(base::TimeDelta::FromMilliseconds(timeout));
 }
 
 ProxyLauncher* UITestBase::CreateProxyLauncher() {
   return new AnonymousProxyLauncher(false);
 }
 
 ProxyLauncher::LaunchState UITestBase::DefaultLaunchState() {
   FilePath browser_executable = browser_directory_.Append(GetExecutablePath());
   CommandLine command(browser_executable);
   command.AppendArguments(launch_arguments_, false);
@@ skipping 249 matching lines @@
 
   bool succeeded = automation()->Send(new AutomationMsg_CloseBrowser(
       browser->handle(), &result, application_closed));
 
   if (!succeeded)
     return false;
 
   if (*application_closed) {
     int exit_code = -1;
     EXPECT_TRUE(launcher_->WaitForBrowserProcessToQuit(
-        TestTimeouts::action_max_timeout_ms(), &exit_code));
+        TestTimeouts::action_max_timeout(), &exit_code));
     EXPECT_EQ(0, exit_code);  // Expect a clean shutown.
   }
 
   return result;
 }
 
 // static
 FilePath UITestBase::ComputeTypicalUserDataSource(
     UITestBase::ProfileType profile_type) {
   FilePath source_history_file;
@@ skipping 158 matching lines @@
   PathService::Get(chrome::DIR_USER_DATA, &path);
   path = path.AppendASCII(chrome::kInitialProfile);
   return LoadDictionaryValueFromPath(path.Append(chrome::kPreferencesFilename));
 }
 
 void UITest::WaitForFinish(const std::string &name,
                            const std::string &id,
                            const GURL &url,
                            const std::string& test_complete_cookie,
                            const std::string& expected_cookie_value,
-                           const int wait_time) {
+                           const base::TimeDelta wait_time) {
   // The webpage being tested has javascript which sets a cookie
   // which signals completion of the test.  The cookie name is
   // a concatenation of the test name and the test id.  This allows
   // us to run multiple tests within a single webpage and test
   // that they all c
   std::string cookie_name = name;
   cookie_name.append(".");
   cookie_name.append(id);
   cookie_name.append(".");
   cookie_name.append(test_complete_cookie);
@@ skipping 13 matching lines @@
     if (file_util::EvictFileFromSystemCache(path))
       return true;
     base::PlatformThread::Sleep(kDelay);
   }
   return false;
 }
 
 bool UITest::WaitUntilJavaScriptCondition(TabProxy* tab,
                                           const std::wstring& frame_xpath,
                                           const std::wstring& jscript,
-                                          int timeout_ms) {
+                                          base::TimeDelta timeout) {
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(250);
-  const int kMaxDelays = timeout_ms / kDelay.InMilliseconds();
+  const int kMaxDelays = timeout / kDelay;
 
   // Wait until the test signals it has completed.
   for (int i = 0; i < kMaxDelays; ++i) {
     bool done_value = false;
     bool success = tab->ExecuteAndExtractBool(frame_xpath, jscript,
                                               &done_value);
     EXPECT_TRUE(success);
     if (!success)
       return false;
     if (done_value)
       return true;
 
     base::PlatformThread::Sleep(kDelay);
   }
 
   ADD_FAILURE() << "Timeout reached in WaitUntilJavaScriptCondition";
   return false;
 }
 
 bool UITest::WaitUntilCookieValue(TabProxy* tab,
                                   const GURL& url,
                                   const char* cookie_name,
-                                  int timeout_ms,
+                                  base::TimeDelta timeout,
                                   const char* expected_value) {
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(250);
-  const int kMaxDelays = timeout_ms / kDelay.InMilliseconds();
+  const int kMaxDelays = timeout / kDelay;
 
   std::string cookie_value;
   for (int i = 0; i < kMaxDelays; ++i) {
     EXPECT_TRUE(tab->GetCookieByName(url, cookie_name, &cookie_value));
     if (cookie_value == expected_value)
       return true;
 
     base::PlatformThread::Sleep(kDelay);
   }
 
   ADD_FAILURE() << "Timeout reached in WaitUntilCookieValue";
   return false;
 }
 
 std::string UITest::WaitUntilCookieNonEmpty(TabProxy* tab,
                                             const GURL& url,
                                             const char* cookie_name,
-                                            int timeout_ms) {
+                                            base::TimeDelta timeout) {
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(250);
-  const int kMaxDelays = timeout_ms / kDelay.InMilliseconds();
+  const int kMaxDelays = timeout / kDelay;
 
   for (int i = 0; i < kMaxDelays; ++i) {
     std::string cookie_value;
     EXPECT_TRUE(tab->GetCookieByName(url, cookie_name, &cookie_value));
     if (!cookie_value.empty())
       return cookie_value;
 
     base::PlatformThread::Sleep(kDelay);
   }
 
@@ skipping 37 matching lines @@
                                       &session_end_completed));
   ASSERT_TRUE(session_end_completed);
 
   // Make sure session restore says we didn't crash.
   scoped_ptr<DictionaryValue> profile_prefs(GetDefaultProfilePreferences());
   ASSERT_TRUE(profile_prefs.get());
   ASSERT_TRUE(profile_prefs->GetBoolean(prefs::kSessionExitedCleanly,
                                         &exited_cleanly));
   ASSERT_TRUE(exited_cleanly);
 }