Create an API around WorkerService that chrome consumes. Rename the existing WorkerService to Wor...

content/worker/test/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/test/automation/automation_proxy.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/base/layout_test_http_server.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "chrome/test/ui/ui_layout_test.h"
-#include "content/browser/worker_host/worker_service.h"
+#include "content/browser/worker_host/worker_service_impl.h"
 #include "content/public/common/url_constants.h"
 #include "net/test/test_server.h"
 
+using content::WorkerServiceImpl;
+
 namespace {
 
 const char kTestCompleteCookie[] = "status";
 const char kTestCompleteSuccess[] = "OK";
 const FilePath::CharType* kTestDir =
     FILE_PATH_LITERAL("workers");
 const FilePath::CharType* kManySharedWorkersFile =
     FILE_PATH_LITERAL("many_shared_workers.html");
 const FilePath::CharType* kManyWorkersFile =
     FILE_PATH_LITERAL("many_workers.html");
@@ skipping 549 matching lines @@
 }
 
 #if defined(OS_MACOSX)
 // See http://crbug.com/48664
 #define MAYBE_LimitPerPage DISABLED_LimitPerPage
 #else
 // See http://crbug.com/36800 for Windows/Linux
 #define MAYBE_LimitPerPage FLAKY_LimitPerPage
 #endif
 TEST_F(WorkerTest, MAYBE_LimitPerPage) {
-  int max_workers_per_tab = WorkerService::kMaxWorkersPerTabWhenSeparate;
+  int max_workers_per_tab = WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate;
   GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir),
                                        FilePath(kManyWorkersFile));
   url = GURL(url.spec() + StringPrintf("?count=%d", max_workers_per_tab + 1));
 
   NavigateToURL(url);
   ASSERT_TRUE(WaitForProcessCountToBe(1, max_workers_per_tab));
 }
 
 // Doesn't crash, but on all platforms, it sometimes fails.
 // Flaky on all platforms: http://crbug.com/28445
 // Hangs on Linux: http://crbug.com/30332
 // Possibly causing ui_tests to hang on Mac: http://crbug.com/88958
 // Times out consistently on all platforms.
 TEST_F(WorkerTest, DISABLED_LimitTotal) {
-  int max_workers_per_tab = WorkerService::kMaxWorkersPerTabWhenSeparate;
-  int total_workers = WorkerService::kMaxWorkersWhenSeparate;
+  int max_workers_per_tab = WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate;
+  int total_workers = WorkerServiceImpl::kMaxWorkersWhenSeparate;
 
   int tab_count = (total_workers / max_workers_per_tab) + 1;
   GURL url = ui_test_utils::GetTestUrl(FilePath(kTestDir),
                                        FilePath(kManyWorkersFile));
   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));
   scoped_refptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
@@ skipping 24 matching lines @@
   std::string value = WaitUntilCookieNonEmpty(tab.get(), url,
       kTestCompleteCookie, TestTimeouts::action_max_timeout_ms());
   ASSERT_STREQ(kTestCompleteSuccess, value.c_str());
   ASSERT_TRUE(WaitForProcessCountToBe(1, 0));
 }
 
 // Flaky, http://crbug.com/70861.
 TEST_F(WorkerTest, FLAKY_QueuedSharedWorkerShutdown) {
   // Tests to make sure that queued shared workers are started up when
   // shared workers shut down.
-  int max_workers_per_tab = WorkerService::kMaxWorkersPerTabWhenSeparate;
+  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));
 }
 
 // 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;
+  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));
 
   // Create same set of workers in new tab (leaves one worker queued from this
@@ skipping 13 matching lines @@
   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));
 }
 
 // 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;
+  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));
   // 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
@@ skipping 170 matching lines @@
 }
 
 #if defined(OS_LINUX)
 // Fails on Linux due to an assert in WebKit's RNG.
 // See http://webkit.org/b/55728.
 #define FileWriterSyncWriteOverlapped DISABLED_FileWriterSyncWriteOverlapped
 #endif
 TEST_F(WorkerFileSystemTest, FileWriterSyncWriteOverlapped) {
   RunWorkerFileSystemLayoutTest("file-writer-sync-write-overlapped.html");
 }