Automatically start the GPU process 5s after browser startup.

content/worker/test/worker_uitest.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 "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/test/automation/automation_proxy.h"
@@ skipping 67 matching lines @@
         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) {
+  bool WaitForProcessCountToBeAtLeast(int tabs, int workers) {
     // The 1 is for the browser process.
     int number_of_processes = 1 + workers + tabs;
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
     // On Unix, we also have a zygote process and a sandbox host process.
     number_of_processes += 2;
 #endif
 
     int cur_process_count;
     for (int i = 0; i < 100; ++i) {
       cur_process_count = 0;
       if (!GetBrowserProcessCount(&cur_process_count))
         return false;
-      if (cur_process_count == number_of_processes)
+      if (cur_process_count >= number_of_processes)
         return true;
 
       // Sometimes the worker processes can take a while to shut down on the
       // bots, so use a longer timeout period to avoid spurious failures.
       base::PlatformThread::Sleep(TestTimeouts::action_max_timeout() / 100);
     }
 
-    EXPECT_EQ(number_of_processes, cur_process_count);
+    EXPECT_GE(cur_process_count, number_of_processes);
     return false;
   }
 
   void RunWorkerFastLayoutTest(const std::string& test_case_file_name) {
     FilePath fast_test_dir;
     fast_test_dir = fast_test_dir.AppendASCII("fast");
 
     FilePath worker_test_dir;
     worker_test_dir = worker_test_dir.AppendASCII("workers");
     InitializeForLayoutTest(fast_test_dir, worker_test_dir, kNoHttpPort);
@@ skipping 67 matching lines @@
 #endif
 TEST_F(WorkerTest, MultipleSharedWorkers) {
   RunTest(FilePath(FILE_PATH_LITERAL("multi_worker.html")), "shared=true");
 }
 
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
 // http://crbug.com/80446
 #define DISABLED_TerminateQueuedWorkers DISABLED_TerminateQueuedWorkers
 #endif
 TEST_F(WorkerTest, DISABLED_TerminateQueuedWorkers) {
-  ASSERT_TRUE(WaitForProcessCountToBe(1, 0));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(1, 0));
   RunTest(FilePath(FILE_PATH_LITERAL("terminate_queued_workers.html")), "");
   // Make sure all workers exit.
-  ASSERT_TRUE(WaitForProcessCountToBe(1, 0));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(1, 0));
 }
 
 #if defined(OS_LINUX)
 // http://crbug.com/30021
 #define IncognitoSharedWorkers DISABLED_IncognitoSharedWorkers
 #endif
 // Incognito windows should not share workers with non-incognito windows
 TEST_F(WorkerTest, IncognitoSharedWorkers) {
   // Load a non-incognito tab and have it create a shared worker
   RunTest(FilePath(FILE_PATH_LITERAL("incognito_worker.html")), "");
@@ skipping 268 matching lines @@
     RunLayoutTest(kLayoutTestFiles[i], kNoHttpPort);
 }
 
 TEST_F(WorkerTest, LimitPerPage) {
   int max_workers_per_tab = WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate;
   GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir),
                                        FilePath(kManySharedWorkersFile));
   url = GURL(url.spec() + StringPrintf("?count=%d", max_workers_per_tab + 1));
 
   NavigateToURL(url);
-  ASSERT_TRUE(WaitForProcessCountToBe(1, max_workers_per_tab));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(1, max_workers_per_tab));
 }
 
 // http://crbug.com/36800
 #if defined(OS_WIN)
 #define MAYBE_LimitTotal DISABLED_LimitTotal
 #else
 #define MAYBE_LimitTotal LimitTotal
 #endif  // defined(OS_WIN)
 TEST_F(WorkerTest, MAYBE_LimitTotal) {
   int max_workers_per_tab = WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate;
@@ skipping 10 matching lines @@
   ASSERT_TRUE(tab->NavigateToURL(
       GURL(url.spec() + StringPrintf("&client_id=%d", 0))));
   scoped_refptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
   for (int i = 1; i < tab_count; ++i) {
     ASSERT_TRUE(window->AppendTab(GURL(
         url.spec() + StringPrintf("&client_id=%d", i))));
   }
 
   // Check that we didn't create more than the max number of workers.
-  ASSERT_TRUE(WaitForProcessCountToBe(tab_count, total_workers));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(tab_count, total_workers));
 
   // Now close a page and check that the queued workers were started.
   const FilePath::CharType* kGoogleDir = FILE_PATH_LITERAL("google");
   const FilePath::CharType* kGoogleFile = FILE_PATH_LITERAL("google.html");
   ASSERT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS,
       tab->NavigateToURL(ui_test_utils::GetTestUrl(FilePath(kGoogleDir),
                                                    FilePath(kGoogleFile))));
 
-  ASSERT_TRUE(WaitForProcessCountToBe(tab_count, total_workers));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(tab_count, total_workers));
 }
 
 // Flaky, http://crbug.com/59786.
 TEST_F(WorkerTest, DISABLED_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, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
-  ASSERT_TRUE(WaitForProcessCountToBe(1, 0));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(1, 0));
 }
 
 // Flaky, http://crbug.com/70861.
 TEST_F(WorkerTest, DISABLED_QueuedSharedWorkerShutdown) {
   // Tests to make sure that queued shared workers are started up when
   // shared workers shut down.
   int max_workers_per_tab = WorkerServiceImpl::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, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
-  ASSERT_TRUE(WaitForProcessCountToBe(1, max_workers_per_tab));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(1, max_workers_per_tab));
 }
 
 // Flaky, http://crbug.com/69881.
 TEST_F(WorkerTest, DISABLED_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 = WorkerServiceImpl::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));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(1, max_workers_per_tab));
 
   // Create same set of workers in new tab (leaves one worker queued from this
   // tab).
   scoped_refptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
   ASSERT_TRUE(window->AppendTab(url));
-  ASSERT_TRUE(WaitForProcessCountToBe(2, max_workers_per_tab));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(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, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
-  ASSERT_TRUE(WaitForProcessCountToBe(3, max_workers_per_tab));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(3, max_workers_per_tab));
 }
 
 // Flaky: http://crbug.com/48148
 TEST_F(WorkerTest, DISABLED_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 = WorkerServiceImpl::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));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(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, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
-  ASSERT_TRUE(WaitForProcessCountToBe(2, max_workers_per_tab+1));
+  ASSERT_TRUE(WaitForProcessCountToBeAtLeast(2, max_workers_per_tab+1));
 }