Remove sleep_timeout_ms and fix all the callers.

chrome/test/ui/ui_test.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 294 matching lines @@
   const int kCycles = 10;
   for (int i = 0; i < kCycles; i++) {
     bool visible = false;
     bool animating = true;
     if (!browser->GetBookmarkBarVisibility(&visible, &animating))
       return false;  // Some error.
     if (visible == wait_for_open && !animating)
       return true;  // Bookmark bar visibility change complete.
 
     // Give it a chance to catch up.
-    bool browser_survived = CrashAwareSleep(sleep_timeout_ms() / kCycles);
+    bool browser_survived = CrashAwareSleep(
+        TestTimeouts::action_timeout_ms() / kCycles);
     EXPECT_TRUE(browser_survived);
     if (!browser_survived)
       return false;
   }
 
   ADD_FAILURE() << "Timeout reached in WaitForBookmarkBarVisibilityChange";
   return false;
 }
 
 GURL UITestBase::GetActiveTabURL(int window_index) {
@@ skipping 53 matching lines @@
     return 0;
 
   int result = 0;
   EXPECT_TRUE(window->GetTabCount(&result));
 
   return result;
 }
 
 void UITestBase::WaitUntilTabCount(int tab_count) {
   const int kMaxIntervals = 10;
-  const int kIntervalMs = sleep_timeout_ms() / kMaxIntervals;
+  const int kIntervalMs = TestTimeouts::action_timeout_ms() / kMaxIntervals;
 
   for (int i = 0; i < kMaxIntervals; ++i) {
     bool browser_survived = CrashAwareSleep(kIntervalMs);
     EXPECT_TRUE(browser_survived);
     if (!browser_survived)
       return;
     if (GetTabCount() == tab_count)
       return;
   }
 
@@ skipping 247 matching lines @@
   std::string cookie_value = WaitUntilCookieNonEmpty(tab.get(), url,
                                                      cookie_name.c_str(),
                                                      wait_time);
   EXPECT_EQ(expected_cookie_value, cookie_value);
 }
 
 bool UITest::EvictFileFromSystemCacheWrapper(const FilePath& path) {
   for (int i = 0; i < 10; i++) {
     if (file_util::EvictFileFromSystemCache(path))
       return true;
-    base::PlatformThread::Sleep(sleep_timeout_ms() / 10);
+    base::PlatformThread::Sleep(TestTimeouts::action_timeout_ms() / 10);
   }
   return false;
 }
 
 void UITest::WaitForGeneratedFileAndCheck(
     const FilePath& generated_file,
     const FilePath& original_file,
     bool compare_files,
     bool need_equal,
     bool delete_generated_file) {
   // Check whether the target file has been generated.
   base::PlatformFileInfo previous, current;
   bool exist = false;
   const int kCycles = 20;
   for (int i = 0; i < kCycles; ++i) {
     if (exist) {
       file_util::GetFileInfo(generated_file, &current);
       if (current.size == previous.size)
         break;
       previous = current;
     } else if (file_util::PathExists(generated_file)) {
       file_util::GetFileInfo(generated_file, &previous);
       exist = true;
     }
-    base::PlatformThread::Sleep(sleep_timeout_ms() / kCycles);
+    base::PlatformThread::Sleep(TestTimeouts::action_timeout_ms() / kCycles);
   }
   EXPECT_TRUE(exist);
 
   if (compare_files) {
     // Check whether the generated file is equal with original file according to
     // parameter: need_equal.
     int64 generated_file_size = 0;
     int64 original_file_size = 0;
 
     EXPECT_TRUE(file_util::GetFileSize(generated_file, &generated_file_size));
@@ skipping 97 matching lines @@
                                                bool wait_for_open) {
   const int kCycles = 10;
   for (int i = 0; i < kCycles; i++) {
     bool visible = false;
     if (!browser->IsFindWindowFullyVisible(&visible))
       return false;  // Some error.
     if (visible == wait_for_open)
       return true;  // Find window visibility change complete.
 
     // Give it a chance to catch up.
-    bool browser_survived = CrashAwareSleep(sleep_timeout_ms() / kCycles);
+    bool browser_survived = CrashAwareSleep(
+        TestTimeouts::action_timeout_ms() / kCycles);
     EXPECT_TRUE(browser_survived);
     if (!browser_survived)
       return false;
   }
 
   ADD_FAILURE() << "Timeout reached in WaitForFindWindowVisibilityChange";
   return false;
 }
 
 bool UITest::WaitForDownloadShelfVisibilityChange(BrowserProxy* browser,
                                                   bool wait_for_open) {
   const int kCycles = 10;
   int fail_count = 0;
   int incorrect_state_count = 0;
   base::Time start = base::Time::Now();
   for (int i = 0; i < kCycles; i++) {
     // Give it a chance to catch up.
-    bool browser_survived = CrashAwareSleep(sleep_timeout_ms() / kCycles);
+    bool browser_survived = CrashAwareSleep(
+        TestTimeouts::action_timeout_ms() / kCycles);
     EXPECT_TRUE(browser_survived);
     if (!browser_survived) {
       LOG(INFO) << "Elapsed time: " << (base::Time::Now() - start).InSecondsF()
                 << " seconds"
                 << " call failed " << fail_count << " times"
                 << " state was incorrect " << incorrect_state_count << " times";
       ADD_FAILURE() << "Browser failed in " << __FUNCTION__;
       return false;
     }
 
@@ skipping 12 matching lines @@
     incorrect_state_count++;
   }
 
   LOG(INFO) << "Elapsed time: " << (base::Time::Now() - start).InSecondsF()
             << " seconds"
             << " call failed " << fail_count << " times"
             << " state was incorrect " << incorrect_state_count << " times";
   ADD_FAILURE() << "Timeout reached in " << __FUNCTION__;
   return false;
 }