Remove action_max_timeout_ms and fix all the callers.

chrome/worker/worker_uitest.cc

 // 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 "base/file_path.h"
 #include "base/string_util.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/worker_host/worker_service.h"
@@ skipping 30 matching lines @@
   virtual ~WorkerTest() { }
 
   void RunTest(const FilePath& test_case) {
     scoped_refptr<TabProxy> tab(GetActiveTab());
     ASSERT_TRUE(tab.get());
 
     GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir), test_case);
     ASSERT_TRUE(tab->NavigateToURL(url));
 
     std::string value = WaitUntilCookieNonEmpty(tab.get(), url,
-        kTestCompleteCookie, action_max_timeout_ms());
+        kTestCompleteCookie, TestTimeouts::action_max_timeout_ms());
     ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
   }
 
   void RunIncognitoTest(const FilePath& test_case) {
     scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
     ASSERT_TRUE(browser.get());
 
     // Open an Incognito window.
     ASSERT_TRUE(browser->RunCommand(IDC_NEW_INCOGNITO_WINDOW));
     scoped_refptr<BrowserProxy> incognito(automation()->GetBrowserWindow(1));
     ASSERT_TRUE(incognito.get());
     int window_count;
     ASSERT_TRUE(automation()->GetBrowserWindowCount(&window_count));
     ASSERT_EQ(2, window_count);
 
     scoped_refptr<TabProxy> tab(incognito->GetTab(0));
     ASSERT_TRUE(tab.get());
 
     GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir), test_case);
     ASSERT_TRUE(tab->NavigateToURL(url));
 
     std::string value = WaitUntilCookieNonEmpty(tab.get(), url,
-        kTestCompleteCookie, action_max_timeout_ms());
+        kTestCompleteCookie, TestTimeouts::action_max_timeout_ms());
 
     // Close the incognito window
     ASSERT_TRUE(incognito->RunCommand(IDC_CLOSE_WINDOW));
     ASSERT_TRUE(automation()->GetBrowserWindowCount(&window_count));
     ASSERT_EQ(1, window_count);
 
     ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
   }
 
   bool WaitForProcessCountToBe(int tabs, int workers) {
@@ skipping 515 matching lines @@
 }
 
 // Flaky, http://crbug.com/59786.
 TEST_F(WorkerTest, FLAKY_WorkerClose) {
   scoped_refptr<TabProxy> tab(GetActiveTab());
   ASSERT_TRUE(tab.get());
   GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir),
                                        FilePath(kWorkerClose));
   ASSERT_TRUE(tab->NavigateToURL(url));
   std::string value = WaitUntilCookieNonEmpty(tab.get(), url,
-      kTestCompleteCookie, action_max_timeout_ms());
+      kTestCompleteCookie, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
   ASSERT_TRUE(WaitForProcessCountToBe(1, 0));
 }
 
 TEST_F(WorkerTest, QueuedSharedWorkerShutdown) {
   // Tests to make sure that queued shared workers are started up when
   // shared workers shut down.
   int max_workers_per_tab = WorkerService::kMaxWorkersPerTabWhenSeparate;
   GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir),
       FilePath(kQuerySharedWorkerShutdownFile));
   url = GURL(url.spec() + StringPrintf("?count=%d", max_workers_per_tab));
 
   scoped_refptr<TabProxy> tab(GetActiveTab());
   ASSERT_TRUE(tab.get());
   ASSERT_TRUE(tab->NavigateToURL(url));
   std::string value = WaitUntilCookieNonEmpty(tab.get(), url,
-      kTestCompleteCookie, action_max_timeout_ms());
+      kTestCompleteCookie, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
   ASSERT_TRUE(WaitForProcessCountToBe(1, max_workers_per_tab));
 }
 
 // Flaky, http://crbug.com/69881.
 TEST_F(WorkerTest, FLAKY_MultipleTabsQueuedSharedWorker) {
   // Tests to make sure that only one instance of queued shared workers are
   // started up even when those instances are on multiple tabs.
   int max_workers_per_tab = WorkerService::kMaxWorkersPerTabWhenSeparate;
   GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir),
@@ skipping 13 matching lines @@
   ASSERT_TRUE(WaitForProcessCountToBe(2, max_workers_per_tab));
 
   // Now shutdown one of the shared workers - this will fire both queued
   // workers, but only one instance should be started
   GURL url2 = ui_test_utils::GetTestUrl(FilePath(kTestDir),
                                         FilePath(kShutdownSharedWorkerFile));
   url2 = GURL(url2.spec() + "?id=0");
   ASSERT_TRUE(window->AppendTab(url2));
 
   std::string value = WaitUntilCookieNonEmpty(tab.get(), url,
-      kTestCompleteCookie, action_max_timeout_ms());
+      kTestCompleteCookie, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
   ASSERT_TRUE(WaitForProcessCountToBe(3, max_workers_per_tab));
 }
 
 // Flaky: http://crbug.com/48148
 TEST_F(WorkerTest, FLAKY_QueuedSharedWorkerStartedFromOtherTab) {
   // Tests to make sure that queued shared workers are started up when
   // an instance is launched from another tab.
   int max_workers_per_tab = WorkerService::kMaxWorkersPerTabWhenSeparate;
   GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir),
                                        FilePath(kManySharedWorkersFile));
   url = GURL(url.spec() + StringPrintf("?count=%d", max_workers_per_tab+1));
 
   scoped_refptr<TabProxy> tab(GetActiveTab());
   ASSERT_TRUE(tab.get());
   ASSERT_TRUE(tab->NavigateToURL(url));
   ASSERT_TRUE(WaitForProcessCountToBe(1, max_workers_per_tab));
   // First window has hit its limit. Now launch second window which creates
   // the same worker that was queued in the first window, to ensure it gets
   // connected to the first window too.
   scoped_refptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
   GURL url2 = ui_test_utils::GetTestUrl(FilePath(kTestDir),
                                         FilePath(kSingleSharedWorkersFile));
   url2 = GURL(url2.spec() + StringPrintf("?id=%d", max_workers_per_tab));
   ASSERT_TRUE(window->AppendTab(url2));
 
   std::string value = WaitUntilCookieNonEmpty(tab.get(), url,
-      kTestCompleteCookie, action_max_timeout_ms());
+      kTestCompleteCookie, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
   ASSERT_TRUE(WaitForProcessCountToBe(2, max_workers_per_tab+1));
 }
 
 // FileSystem worker tests.
 // They are disabled for now as the feature is not enabled by default.
 // http://crbug.com/32277
 TEST_F(WorkerTest, DISABLED_WorkerFileSystemTemporaryTest) {
   RunWorkerFileSystemLayoutTest("simple-temporary.html");
 }
@@ skipping 10 matching lines @@
   RunWorkerFileSystemLayoutTest("simple-persistent-sync.html");
 }
 
 TEST_F(WorkerTest, DISABLED_WorkerFileSystemAsyncOperationsTest) {
   RunWorkerFileSystemLayoutTest("async-operations.html");
 }
 
 TEST_F(WorkerTest, DISABLED_WorkerFileSystemSyncOperationsTest) {
   RunWorkerFileSystemLayoutTest("sync-operations.html");
 }