Move all the layout tests that ran under browser_tests to run under content_browsertests.

content/browser/worker_host/test/worker_browsertest.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/bind.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/browser_tabstrip.h"
-#include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/worker_host/worker_process_host.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/test/browser_test_utils.h"
+#include "content/public/test/test_utils.h"
+#include "content/shell/shell.h"
+#include "content/shell/shell_content_browser_client.h"
+#include "content/shell/shell_resource_dispatcher_host_delegate.h"
+#include "content/test/content_browser_test_utils.h"
 #include "content/test/layout_browsertest.h"
 #include "googleurl/src/gurl.h"
 
 using content::BrowserThread;
 using content::WorkerServiceImpl;
 
 class WorkerLayoutTest : public InProcessBrowserLayoutTest {
  public:
   WorkerLayoutTest() : InProcessBrowserLayoutTest(
       FilePath(), FilePath().AppendASCII("fast").AppendASCII("workers")) {
@@ skipping 233 matching lines @@
   FilePath websocket_test_dir;
   ASSERT_TRUE(PathService::Get(content::DIR_LAYOUT_TESTS, &websocket_test_dir));
 
   content::TestWebSocketServer websocket_server;
   ASSERT_TRUE(websocket_server.Start(websocket_test_dir));
 
   for (size_t i = 0; i < arraysize(kLayoutTestFiles); ++i)
     RunHttpLayoutTest(kLayoutTestFiles[i]);
 }
 
-class WorkerTest : public InProcessBrowserTest {
+class WorkerTest : public content::ContentBrowserTest {
  public:
   WorkerTest() {}
 
   GURL GetTestURL(const std::string& test_case, const std::string& query) {
-    FilePath test_file_path = ui_test_utils::GetTestFilePath(
-        FilePath(FILE_PATH_LITERAL("workers")),
-        FilePath().AppendASCII(test_case));
-    return ui_test_utils::GetFileUrlWithQuery(test_file_path, query);
+    FilePath test_file_path = content::GetTestFilePath(
+        "workers", test_case.c_str());
+    return content::GetFileUrlWithQuery(test_file_path, query);
   }
 
-  void RunTest(Browser* browser,
+  void RunTest(content::Shell* window,
                const std::string& test_case,
                const std::string& query) {
     GURL url = GetTestURL(test_case, query);
     const string16 expected_title = ASCIIToUTF16("OK");
-    content::TitleWatcher title_watcher(
-        chrome::GetActiveWebContents(browser), expected_title);
-    ui_test_utils::NavigateToURL(browser, url);
+    content::TitleWatcher title_watcher(window->web_contents(), expected_title);
+    content::NavigateToURL(window, url);
     string16 final_title = title_watcher.WaitAndGetTitle();
     EXPECT_EQ(expected_title, final_title);
   }
 
   void RunTest(const std::string& test_case, const std::string& query) {
-    RunTest(browser(), test_case, query);
+    RunTest(shell(), test_case, query);
   }
 
   static void CountWorkerProcesses(int *cur_process_count) {
     *cur_process_count = 0;
     for (WorkerProcessHostIterator iter; !iter.Done(); ++iter)
       (*cur_process_count)++;
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, MessageLoop::QuitClosure());
   }
 
   bool WaitForWorkerProcessCount(int count) {
     int cur_process_count;
     for (int i = 0; i < 100; ++i) {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&CountWorkerProcesses, &cur_process_count));
-      ui_test_utils::RunMessageLoop();
+
+      base::RunLoop run_loop;
+      content::RunThisRunLoop(&run_loop);
       if (cur_process_count == count)
         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(cur_process_count, count);
     return false;
   }
+
+  static void QuitUIMessageLoop(base::Callback<void()> callback) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
+  }
+
+  void NavigateAndWaitForAuth(const GURL& url) {
+    content::ShellContentBrowserClient* browser_client =
+        static_cast<content::ShellContentBrowserClient*>(
+            content::GetContentClient()->browser());
+    scoped_refptr<content::MessageLoopRunner> runner =
+        new content::MessageLoopRunner();
+    browser_client->resource_dispatcher_host_delegate()->
+        set_login_request_callback(
+            base::Bind(&QuitUIMessageLoop, runner->QuitClosure()));
+    shell()->LoadURL(url);
+    runner->Run();
+  }
 };
 
 IN_PROC_BROWSER_TEST_F(WorkerTest, SingleWorker) {
   RunTest("single_worker.html", "");
 }
 
 IN_PROC_BROWSER_TEST_F(WorkerTest, MultipleWorkers) {
   RunTest("multi_worker.html", "");
 }
 
 IN_PROC_BROWSER_TEST_F(WorkerTest, SingleSharedWorker) {
   RunTest("single_worker.html", "shared=true");
 }
 
 // http://crbug.com/96435
 IN_PROC_BROWSER_TEST_F(WorkerTest, MultipleSharedWorkers) {
   RunTest("multi_worker.html", "shared=true");
 }
 
 // Incognito windows should not share workers with non-incognito windows
 // http://crbug.com/30021
 IN_PROC_BROWSER_TEST_F(WorkerTest, IncognitoSharedWorkers) {
   // Load a non-incognito tab and have it create a shared worker
   RunTest("incognito_worker.html", "");
 
   // Incognito worker should not share with non-incognito
-  RunTest(CreateIncognitoBrowser(), "incognito_worker.html", "");
+  RunTest(CreateOffTheRecordBrowser(), "incognito_worker.html", "");
 }
 
 // Make sure that auth dialog is displayed from worker context.
 // http://crbug.com/33344
 IN_PROC_BROWSER_TEST_F(WorkerTest, WorkerHttpAuth) {
   ASSERT_TRUE(test_server()->Start());
   GURL url = test_server()->GetURL("files/workers/worker_auth.html");
 
-  ui_test_utils::NavigateToURLWithDisposition(
-      browser(), url, CURRENT_TAB, ui_test_utils::BROWSER_TEST_WAIT_FOR_AUTH);
+  NavigateAndWaitForAuth(url);
 }
 
 // Make sure that auth dialog is displayed from shared worker context.
 // http://crbug.com/33344
 IN_PROC_BROWSER_TEST_F(WorkerTest, SharedWorkerHttpAuth) {
   ASSERT_TRUE(test_server()->Start());
   GURL url = test_server()->GetURL("files/workers/shared_worker_auth.html");
-  ui_test_utils::NavigateToURLWithDisposition(
-      browser(), url, CURRENT_TAB, ui_test_utils::BROWSER_TEST_WAIT_FOR_AUTH);
+  NavigateAndWaitForAuth(url);
 }
 
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
 // This test is flaky inside the Linux SUID sandbox.
 // http://crbug.com/130116
 IN_PROC_BROWSER_TEST_F(WorkerTest, DISABLED_LimitPerPage) {
 #else
 IN_PROC_BROWSER_TEST_F(WorkerTest, LimitPerPage) {
 #endif
   int max_workers_per_tab = WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate;
   std::string query = StringPrintf("?count=%d", max_workers_per_tab + 1);
 
   GURL url = GetTestURL("many_shared_workers.html", query);
-  ui_test_utils::NavigateToURL(browser(), url);
+  content::NavigateToURL(shell(), url);
   ASSERT_TRUE(WaitForWorkerProcessCount(max_workers_per_tab));
 }
 
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
 // This test is flaky inside the Linux SUID sandbox.
 // http://crbug.com/130116
 IN_PROC_BROWSER_TEST_F(WorkerTest, DISABLED_LimitTotal) {
 #else
 // http://crbug.com/36800
 IN_PROC_BROWSER_TEST_F(WorkerTest, LimitTotal) {
 #endif
   if (base::SysInfo::AmountOfPhysicalMemoryMB() < 8192) {
     LOG(INFO) << "WorkerTest.LimitTotal not running because it needs 8 GB RAM.";
     return;
   }
 
   int max_workers_per_tab = WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate;
   int total_workers = WorkerServiceImpl::kMaxWorkersWhenSeparate;
 
   std::string query = StringPrintf("?count=%d", max_workers_per_tab);
   GURL url = GetTestURL("many_shared_workers.html", query);
-  ui_test_utils::NavigateToURL(
-      browser(), GURL(url.spec() + StringPrintf("&client_id=0")));
+  content::NavigateToURL(
+      shell(), GURL(url.spec() + StringPrintf("&client_id=0")));
 
   // Adding 1 so that we cause some workers to be queued.
   int tab_count = (total_workers / max_workers_per_tab) + 1;
   for (int i = 1; i < tab_count; ++i) {
-    ui_test_utils::NavigateToURLWithDisposition(
-        browser(), GURL(url.spec() + StringPrintf("&client_id=%d", i)),
-        NEW_FOREGROUND_TAB,
-        ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+    content::NavigateToURL(
+        CreateBrowser(), GURL(url.spec() + StringPrintf("&client_id=%d", i)));
   }
 
   // Check that we didn't create more than the max number of workers.
   ASSERT_TRUE(WaitForWorkerProcessCount(total_workers));
 
   // Now close a page and check that the queued workers were started.
-  const FilePath kGoogleDir(FILE_PATH_LITERAL("google"));
-  const FilePath kGoogleFile(FILE_PATH_LITERAL("google.html"));
-  url = GURL(ui_test_utils::GetTestUrl(kGoogleDir, kGoogleFile));
-  ui_test_utils::NavigateToURL(browser(), url);
+  url = GURL(content::GetTestUrl("google", "google.html"));
+  content::NavigateToURL(shell(), url);
 
   ASSERT_TRUE(WaitForWorkerProcessCount(total_workers));
 }
 
 // Flaky, http://crbug.com/59786.
 IN_PROC_BROWSER_TEST_F(WorkerTest, WorkerClose) {
   RunTest("worker_close.html", "");
   ASSERT_TRUE(WaitForWorkerProcessCount(0));
 }
 
 // Flaky, http://crbug.com/70861.
 IN_PROC_BROWSER_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 = WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate;
   std::string query = StringPrintf("?count=%d", max_workers_per_tab);
   RunTest("queued_shared_worker_shutdown.html", query);
   ASSERT_TRUE(WaitForWorkerProcessCount(max_workers_per_tab));
 }
 
 // Flaky, http://crbug.com/69881.
 // Sometimes triggers
 //     Check failed: message_ports_[message_port_id].queued_messages.empty().
 IN_PROC_BROWSER_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;
   std::string query = StringPrintf("?count=%d", max_workers_per_tab + 1);
   GURL url = GetTestURL("many_shared_workers.html", query);
-  ui_test_utils::NavigateToURL(browser(), url);
+  content::NavigateToURL(shell(), url);
   ASSERT_TRUE(WaitForWorkerProcessCount(max_workers_per_tab));
 
   // Create same set of workers in new tab (leaves one worker queued from this
   // tab).
   url = GetTestURL("many_shared_workers.html", query);
-  ui_test_utils::NavigateToURLWithDisposition(
-        browser(), url, NEW_FOREGROUND_TAB,
-        ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+  content::NavigateToURL(CreateBrowser(), url);
   ASSERT_TRUE(WaitForWorkerProcessCount(max_workers_per_tab));
 
   // Now shutdown one of the shared workers - this will fire both queued
   // workers, but only one instance should be started.
   url = GetTestURL("shutdown_shared_worker.html", "?id=0");
-  ui_test_utils::NavigateToURLWithDisposition(
-      browser(), url, NEW_FOREGROUND_TAB,
-        ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
+  content::NavigateToURL(CreateBrowser(), url);
   ASSERT_TRUE(WaitForWorkerProcessCount(max_workers_per_tab));
 }
 
 // Flaky: http://crbug.com/48148
 IN_PROC_BROWSER_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;
   std::string query = StringPrintf("?count=%d", max_workers_per_tab + 1);
   GURL url = GetTestURL("many_shared_workers.html", query);
-  ui_test_utils::NavigateToURL(browser(), url);
+  content::NavigateToURL(shell(), url);
   ASSERT_TRUE(WaitForWorkerProcessCount(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.
   query = StringPrintf("?id=%d", max_workers_per_tab);
   url = GetTestURL("single_shared_worker.html", query);
-  ui_test_utils::NavigateToURLWithDisposition(
-      browser(), url, NEW_FOREGROUND_TAB,
-        ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
+  content::NavigateToURL(CreateBrowser(), url);
 
   ASSERT_TRUE(WaitForWorkerProcessCount(max_workers_per_tab + 1));
 }