Adding SSL ETS Tests

chrome/browser/devtools/devtools_sanity_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/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 37 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/worker_service.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/switches.h"
-#include "net/test/spawned_test_server/spawned_test_server.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/gl/gl_switches.h"
 
 using app_modal::AppModalDialog;
 using app_modal::JavaScriptAppModalDialog;
 using app_modal::NativeAppModalDialog;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::NavigationController;
 using content::RenderViewHost;
@@ skipping 69 matching lines @@
   DevToolsSanityTest() : window_(NULL) {}
 
  protected:
   void RunTest(const std::string& test_name, const std::string& test_page) {
     OpenDevToolsWindow(test_page, false);
     RunTestFunction(window_, test_name.c_str());
     CloseDevToolsWindow();
   }
 
   void LoadTestPage(const std::string& test_page) {
-    GURL url = test_server()->GetURL(test_page);
+    GURL url = spawned_test_server()->GetURL(test_page);
     ui_test_utils::NavigateToURL(browser(), url);
   }
 
   void OpenDevToolsWindow(const std::string& test_page, bool is_docked) {
-    ASSERT_TRUE(test_server()->Start());
+    ASSERT_TRUE(spawned_test_server()->Start());
     LoadTestPage(test_page);
 
     window_ = DevToolsWindowTesting::OpenDevToolsWindowSync(GetInspectedTab(),
                                                             is_docked);
   }
 
   WebContents* GetInspectedTab() {
     return browser()->tab_strip_model()->GetWebContentsAt(0);
   }
 
@@ skipping 313 matching lines @@
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                               base::MessageLoop::QuitWhenIdleClosure());
       delete this;
     }
     scoped_refptr<WorkerData> worker_data_;
   };
 
   void RunTest(const char* test_name,
                const char* test_page,
                const char* worker_path) {
-    ASSERT_TRUE(test_server()->Start());
-    GURL url = test_server()->GetURL(test_page);
+    ASSERT_TRUE(spawned_test_server()->Start());
+    GURL url = spawned_test_server()->GetURL(test_page);
     ui_test_utils::NavigateToURL(browser(), url);
 
     scoped_refptr<WorkerData> worker_data =
         WaitForFirstSharedWorker(worker_path);
     OpenDevToolsWindowForSharedWorker(worker_data.get());
     RunTestFunction(window_, test_name);
     CloseDevToolsWindow();
   }
 
   static void TerminateWorkerOnIOThread(scoped_refptr<WorkerData> worker_data) {
@@ skipping 117 matching lines @@
 #define MAYBE_TestUndockedDevToolsUnresponsive DISABLED_TestUndockedDevToolsUnresponsive
 #else
 #define MAYBE_TestUndockedDevToolsUnresponsive TestUndockedDevToolsUnresponsive
 #endif
 
 // Tests that inspected tab gets closed if devtools renderer
 // becomes unresponsive during beforeunload event interception.
 // @see http://crbug.com/322380
 IN_PROC_BROWSER_TEST_F(DevToolsUnresponsiveBeforeUnloadTest,
                        MAYBE_TestUndockedDevToolsUnresponsive) {
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
   LoadTestPage(kDebuggerTestPage);
   DevToolsWindow* devtools_window = OpenDevToolWindowOnWebContents(
       GetInspectedTab(), false);
 
   scoped_refptr<content::MessageLoopRunner> runner =
       new content::MessageLoopRunner;
   DevToolsWindowTesting::Get(devtools_window)->SetCloseCallback(
       runner->QuitClosure());
 
   ASSERT_TRUE(content::ExecuteScript(
       DevToolsWindowTesting::Get(devtools_window)->main_web_contents()->
           GetRenderViewHost(),
       "window.addEventListener('beforeunload',"
       "function(event) { while (true); });"));
   CloseInspectedTab();
   runner->Run();
 }
 
 // Tests that closing worker inspector window does not cause browser crash
 // @see http://crbug.com/323031
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        TestWorkerWindowClosing) {
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
   LoadTestPage(kDebuggerTestPage);
   DevToolsWindow* devtools_window = OpenDevToolWindowOnWebContents(
       GetInspectedTab(), false);
 
   OpenDevToolsPopupWindow(devtools_window);
   CloseDevToolsPopupWindow(devtools_window);
 }
 
 // Tests that BeforeUnload event gets called on devtools that are opened
 // on another devtools.
 // Disabled because of http://crbug.com/497857
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        DISABLED_TestDevToolsOnDevTools) {
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
   LoadTestPage(kDebuggerTestPage);
 
   std::vector<DevToolsWindow*> windows;
   std::vector<content::WindowedNotificationObserver*> close_observers;
   content::WebContents* inspected_web_contents = GetInspectedTab();
   for (int i = 0; i < 3; ++i) {
     DevToolsWindow* devtools_window = OpenDevToolWindowOnWebContents(
       inspected_web_contents, i == 0);
     windows.push_back(devtools_window);
     content::WindowedNotificationObserver* close_observer =
@@ skipping 164 matching lines @@
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestSettings) {
   OpenDevToolsWindow("about:blank", true);
   RunTestFunction(window_, "testSettings");
   CloseDevToolsWindow();
 }
 
 // Tests that external navigation from inspector page is always handled by
 // DevToolsWindow and results in inspected page navigation.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestDevToolsExternalNavigation) {
   OpenDevToolsWindow(kDebuggerTestPage, true);
-  GURL url = test_server()->GetURL(kNavigateBackTestPage);
+  GURL url = spawned_test_server()->GetURL(kNavigateBackTestPage);
   ui_test_utils::UrlLoadObserver observer(url,
       content::NotificationService::AllSources());
   ASSERT_TRUE(content::ExecuteScript(
       main_web_contents(),
       std::string("window.location = \"") + url.spec() + "\""));
   observer.Wait();
 
   ASSERT_TRUE(main_web_contents()->GetURL().
                   SchemeIs(content::kChromeDevToolsScheme));
   ASSERT_EQ(url, GetInspectedTab()->GetURL());
@@ skipping 77 matching lines @@
           switches::kAshBrowserTests))
     return;
 #endif
 
   RunTest("testSharedWorker", kSharedWorkerTestPage, kSharedWorkerTestWorker);
 }
 
 // Disabled, crashes under Dr.Memory and ASan, http://crbug.com/432444.
 IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest,
                        DISABLED_PauseInSharedWorkerInitialization) {
-  ASSERT_TRUE(test_server()->Start());
-  GURL url = test_server()->GetURL(kReloadSharedWorkerTestPage);
+  ASSERT_TRUE(spawned_test_server()->Start());
+  GURL url = spawned_test_server()->GetURL(kReloadSharedWorkerTestPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   scoped_refptr<WorkerData> worker_data =
       WaitForFirstSharedWorker(kReloadSharedWorkerTestWorker);
   OpenDevToolsWindowForSharedWorker(worker_data.get());
 
   // We should make sure that the worker inspector has loaded before
   // terminating worker.
   RunTestFunction(window_, "testPauseInSharedWorkerInitialization1");
 
@@ skipping 79 matching lines @@
     (defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD))
 #define MAYBE_TestScreenshotRecording DISABLED_TestScreenshotRecording
 #else
 #define MAYBE_TestScreenshotRecording TestScreenshotRecording
 #endif
 // Tests raw headers text.
 IN_PROC_BROWSER_TEST_F(DevToolsPixelOutputTests,
                        MAYBE_TestScreenshotRecording) {
   RunTest("testScreenshotRecording", std::string());
 }