Revert of [DevTools] Move DevToolsWindow testing code to a separate class.

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/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/devtools/browser_list_tabcontents_provider.h"
-#include "chrome/browser/devtools/devtools_window_testing.h"
+#include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_modal_dialogs/javascript_app_modal_dialog.h"
 #include "chrome/browser/ui/app_modal_dialogs/native_app_modal_dialog.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
@@ skipping 49 matching lines @@
 const char kSlowTestPage[] =
     "chunked?waitBeforeHeaders=100&waitBetweenChunks=100&chunksNumber=2";
 const char kSharedWorkerTestPage[] =
     "files/workers/workers_ui_shared_worker.html";
 const char kReloadSharedWorkerTestPage[] =
     "files/workers/debug_shared_worker_initialization.html";
 
 void RunTestFunction(DevToolsWindow* window, const char* test_name) {
   std::string result;
 
-  RenderViewHost* rvh = DevToolsWindowTesting::Get(window)->
-      main_web_contents()->GetRenderViewHost();
   // At first check that JavaScript part of the front-end is loaded by
   // checking that global variable uiTests exists(it's created after all js
   // files have been loaded) and has runTest method.
   ASSERT_TRUE(
       content::ExecuteScriptAndExtractString(
-          rvh,
+          window->web_contents_for_test()->GetRenderViewHost(),
           "window.domAutomationController.send("
           "    '' + (window.uiTests && (typeof uiTests.runTest)));",
           &result));
 
   ASSERT_EQ("function", result) << "DevTools front-end is broken.";
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
-      rvh,
+      window->web_contents_for_test()->GetRenderViewHost(),
       base::StringPrintf("uiTests.runTest('%s')", test_name),
       &result));
   EXPECT_EQ("[OK]", result);
 }
 
 }  // namespace
 
 class DevToolsSanityTest : public InProcessBrowserTest {
  public:
   DevToolsSanityTest()
@@ skipping 10 matching lines @@
   void LoadTestPage(const std::string& test_page) {
     GURL url = 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());
     LoadTestPage(test_page);
 
     inspected_rvh_ = GetInspectedTab()->GetRenderViewHost();
-    window_ = DevToolsWindowTesting::OpenDevToolsWindowSync(
-        inspected_rvh_, is_docked);
+    window_ =
+        DevToolsWindow::OpenDevToolsWindowForTest(inspected_rvh_, is_docked);
+    ui_test_utils::WaitUntilDevToolsWindowLoaded(window_);
   }
 
   WebContents* GetInspectedTab() {
     return browser()->tab_strip_model()->GetWebContentsAt(0);
   }
 
-  void CloseDevToolsWindow() {
-    DevToolsWindowTesting::CloseDevToolsWindowSync(window_);
+  void ToggleDevToolsWindow() {
+    content::WindowedNotificationObserver close_observer(
+        content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+        content::Source<content::WebContents>(
+            window_->web_contents_for_test()));
+    DevToolsWindow::ToggleDevToolsWindow(inspected_rvh_, false,
+        DevToolsToggleAction::Toggle());
+    close_observer.Wait();
   }
 
-  WebContents* main_web_contents() {
-    return DevToolsWindowTesting::Get(window_)->main_web_contents();
+  void ToggleDevToolsWindowDontWait() {
+    DevToolsWindow::ToggleDevToolsWindow(inspected_rvh_, false,
+        DevToolsToggleAction::Toggle());
   }
 
-  WebContents* toolbox_web_contents() {
-    return DevToolsWindowTesting::Get(window_)->toolbox_web_contents();
+  void CloseDevToolsWindow() {
+    DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
+    content::WindowedNotificationObserver close_observer(
+        content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+        content::Source<content::WebContents>(
+            window_->web_contents_for_test()));
+    devtools_manager->CloseAllClientHosts();
+    close_observer.Wait();
   }
 
   DevToolsWindow* window_;
   RenderViewHost* inspected_rvh_;
 };
 
 // Used to block until a dev tools window gets beforeunload event.
 class DevToolsWindowBeforeUnloadObserver
     : public content::WebContentsObserver {
  public:
   explicit DevToolsWindowBeforeUnloadObserver(DevToolsWindow*);
   void Wait();
  private:
   // Invoked when the beforeunload handler fires.
   virtual void BeforeUnloadFired(const base::TimeTicks& proceed_time) OVERRIDE;
 
   bool m_fired;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsWindowBeforeUnloadObserver);
 };
 
 DevToolsWindowBeforeUnloadObserver::DevToolsWindowBeforeUnloadObserver(
     DevToolsWindow* devtools_window)
-    : WebContentsObserver(
-          DevToolsWindowTesting::Get(devtools_window)->main_web_contents()),
+    : WebContentsObserver(devtools_window->web_contents_for_test()),
       m_fired(false) {
 }
 
 void DevToolsWindowBeforeUnloadObserver::Wait() {
   if (m_fired)
     return;
   message_loop_runner_ = new content::MessageLoopRunner;
   message_loop_runner_->Run();
 }
 
 void DevToolsWindowBeforeUnloadObserver::BeforeUnloadFired(
     const base::TimeTicks& proceed_time) {
   m_fired = true;
   if (message_loop_runner_.get())
     message_loop_runner_->Quit();
 }
 
 class DevToolsBeforeUnloadTest: public DevToolsSanityTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitch(
         switches::kDisableHangMonitor);
   }
 
   void CloseInspectedTab() {
     browser()->tab_strip_model()->CloseWebContentsAt(0,
         TabStripModel::CLOSE_NONE);
   }
 
-  void CloseDevToolsWindowAsync() {
-    DevToolsWindowTesting::CloseDevToolsWindow(window_);
+  void CloseDockedDevTools() {
+    ToggleDevToolsWindowDontWait();
+  }
+
+  void CloseUndockedDevTools() {
+    chrome::CloseWindow(window_->browser_for_test());
   }
 
   void CloseInspectedBrowser() {
     chrome::CloseWindow(browser());
   }
-
  protected:
   void InjectBeforeUnloadListener(content::WebContents* web_contents) {
     ASSERT_TRUE(content::ExecuteScript(web_contents->GetRenderViewHost(),
         "window.addEventListener('beforeunload',"
         "function(event) { event.returnValue = 'Foo'; });"));
   }
 
   void RunBeforeUnloadSanityTest(bool is_docked,
                                  base::Callback<void(void)> close_method,
                                  bool wait_for_browser_close = true) {
     OpenDevToolsWindow(kDebuggerTestPage, is_docked);
-    scoped_refptr<content::MessageLoopRunner> runner =
-        new content::MessageLoopRunner;
-    DevToolsWindowTesting::Get(window_)->
-        SetCloseCallback(runner->QuitClosure());
-    InjectBeforeUnloadListener(main_web_contents());
+    content::WindowedNotificationObserver devtools_close_observer(
+        content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+        content::Source<content::WebContents>(
+            window_->web_contents_for_test()));
+    InjectBeforeUnloadListener(window_->web_contents_for_test());
     {
       DevToolsWindowBeforeUnloadObserver before_unload_observer(window_);
       close_method.Run();
       CancelModalDialog();
       before_unload_observer.Wait();
     }
     {
       content::WindowedNotificationObserver close_observer(
           chrome::NOTIFICATION_BROWSER_CLOSED,
           content::Source<Browser>(browser()));
       close_method.Run();
       AcceptModalDialog();
       if (wait_for_browser_close)
         close_observer.Wait();
     }
-    runner->Run();
+    devtools_close_observer.Wait();
   }
 
   DevToolsWindow* OpenDevToolWindowOnWebContents(
       content::WebContents* contents, bool is_docked) {
-    DevToolsWindow* window = DevToolsWindowTesting::OpenDevToolsWindowSync(
+    DevToolsWindow* window = DevToolsWindow::OpenDevToolsWindowForTest(
         contents->GetRenderViewHost(), is_docked);
+    ui_test_utils::WaitUntilDevToolsWindowLoaded(window);
     return window;
   }
 
   void OpenDevToolsPopupWindow(DevToolsWindow* devtools_window) {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     ASSERT_TRUE(content::ExecuteScript(
-        DevToolsWindowTesting::Get(devtools_window)->
-            main_web_contents()->GetRenderViewHost(),
+        devtools_window->web_contents_for_test()->GetRenderViewHost(),
         "window.open(\"\", \"\", \"location=0\");"));
     observer.Wait();
   }
 
   void CloseDevToolsPopupWindow(DevToolsWindow* devtools_window) {
-    DevToolsWindowTesting::CloseDevToolsWindowSync(devtools_window);
+    Browser* popup_browser = NULL;
+    for (chrome::BrowserIterator it; !it.done(); it.Next()) {
+      if (it->is_devtools()) {
+        content::WebContents* contents =
+            it->tab_strip_model()->GetWebContentsAt(0);
+        if (devtools_window->web_contents_for_test() != contents) {
+          popup_browser = *it;
+          break;
+        }
+      }
+    }
+    ASSERT_FALSE(popup_browser == NULL);
+    content::WindowedNotificationObserver close_observer(
+        chrome::NOTIFICATION_BROWSER_CLOSED,
+        content::Source<Browser>(popup_browser));
+    chrome::CloseWindow(popup_browser);
+    close_observer.Wait();
   }
 
   void AcceptModalDialog() {
     NativeAppModalDialog* native_dialog = GetDialog();
     native_dialog->AcceptAppModalDialog();
   }
 
   void CancelModalDialog() {
     NativeAppModalDialog* native_dialog = GetDialog();
     native_dialog->CancelAppModalDialog();
@@ skipping 228 matching lines @@
     content::RunMessageLoop();
     return worker_data;
   }
 
   void OpenDevToolsWindowForSharedWorker(WorkerData* worker_data) {
     Profile* profile = browser()->profile();
     scoped_refptr<DevToolsAgentHost> agent_host(
         DevToolsAgentHost::GetForWorker(
             worker_data->worker_process_id,
             worker_data->worker_route_id));
-    window_ = DevToolsWindowTesting::OpenDevToolsWindowForWorkerSync(
-        profile, agent_host);
+    window_ = DevToolsWindow::OpenDevToolsWindowForWorker(profile, agent_host);
+    content::WaitForLoadStop(window_->web_contents_for_test());
   }
 
   void CloseDevToolsWindow() {
-    DevToolsWindowTesting::CloseDevToolsWindowSync(window_);
+    Browser* browser = window_->browser_for_test();
+    content::WindowedNotificationObserver close_observer(
+        content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+        content::Source<content::WebContents>(
+            window_->web_contents_for_test()));
+    browser->tab_strip_model()->CloseAllTabs();
+    close_observer.Wait();
   }
 
   DevToolsWindow* window_;
 };
 
 // Tests that BeforeUnload event gets called on docked devtools if
 // we try to close them.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest, TestDockedDevToolsClose) {
   RunBeforeUnloadSanityTest(true, base::Bind(
-      &DevToolsBeforeUnloadTest::CloseDevToolsWindowAsync, this), false);
+      &DevToolsBeforeUnloadTest::CloseDockedDevTools, this), false);
 }
 
 // Tests that BeforeUnload event gets called on docked devtools if
 // we try to close the inspected page.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        TestDockedDevToolsInspectedTabClose) {
   RunBeforeUnloadSanityTest(true, base::Bind(
       &DevToolsBeforeUnloadTest::CloseInspectedTab, this));
 }
 
 // Tests that BeforeUnload event gets called on docked devtools if
 // we try to close the inspected browser.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        TestDockedDevToolsInspectedBrowserClose) {
   RunBeforeUnloadSanityTest(true, base::Bind(
       &DevToolsBeforeUnloadTest::CloseInspectedBrowser, this));
 }
 
 // Tests that BeforeUnload event gets called on undocked devtools if
 // we try to close them.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest, TestUndockedDevToolsClose) {
   RunBeforeUnloadSanityTest(false, base::Bind(
-      &DevToolsBeforeUnloadTest::CloseDevToolsWindowAsync, this), false);
+      &DevToolsBeforeUnloadTest::CloseUndockedDevTools, this), false);
 }
 
 // Tests that BeforeUnload event gets called on undocked devtools if
 // we try to close the inspected page.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        TestUndockedDevToolsInspectedTabClose) {
   RunBeforeUnloadSanityTest(false, base::Bind(
       &DevToolsBeforeUnloadTest::CloseInspectedTab, this));
 }
 
@@ skipping 15 matching lines @@
 
 // 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,
                        TestUndockedDevToolsUnresponsive) {
   ASSERT_TRUE(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());
+  content::WindowedNotificationObserver devtools_close_observer(
+      content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+      content::Source<content::WebContents>(
+          devtools_window->web_contents_for_test()));
 
   ASSERT_TRUE(content::ExecuteScript(
-      DevToolsWindowTesting::Get(devtools_window)->main_web_contents()->
-          GetRenderViewHost(),
+      devtools_window->web_contents_for_test()->GetRenderViewHost(),
       "window.addEventListener('beforeunload',"
       "function(event) { while (true); });"));
   CloseInspectedTab();
-  runner->Run();
+  devtools_close_observer.Wait();
 }
 
 // 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());
   LoadTestPage(kDebuggerTestPage);
   DevToolsWindow* devtools_window = OpenDevToolWindowOnWebContents(
       GetInspectedTab(), false);
+  content::WindowedNotificationObserver devtools_close_observer(
+      content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+      content::Source<content::WebContents>(
+          devtools_window->web_contents_for_test()));
 
   OpenDevToolsPopupWindow(devtools_window);
   CloseDevToolsPopupWindow(devtools_window);
 }
 
 // Tests that BeforeUnload event gets called on devtools that are opened
 // on another devtools.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        TestDevToolsOnDevTools) {
   ASSERT_TRUE(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 =
         new content::WindowedNotificationObserver(
                 content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                 content::Source<content::WebContents>(
-                    DevToolsWindowTesting::Get(devtools_window)->
-                        main_web_contents()));
+                    devtools_window->web_contents_for_test()));
     close_observers.push_back(close_observer);
-    inspected_web_contents =
-        DevToolsWindowTesting::Get(devtools_window)->main_web_contents();
+    inspected_web_contents = devtools_window->web_contents_for_test();
   }
 
-  InjectBeforeUnloadListener(
-      DevToolsWindowTesting::Get(windows[0])->main_web_contents());
-  InjectBeforeUnloadListener(
-      DevToolsWindowTesting::Get(windows[2])->main_web_contents());
+  InjectBeforeUnloadListener(windows[0]->web_contents_for_test());
+  InjectBeforeUnloadListener(windows[2]->web_contents_for_test());
   // Try to close second devtools.
   {
     content::WindowedNotificationObserver cancel_browser(
         chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
         content::NotificationService::AllSources());
-    chrome::CloseWindow(DevToolsWindowTesting::Get(windows[1])->browser());
+    chrome::CloseWindow(windows[1]->browser_for_test());
     CancelModalDialog();
     cancel_browser.Wait();
   }
   // Try to close browser window.
   {
     content::WindowedNotificationObserver cancel_browser(
         chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
         content::NotificationService::AllSources());
     chrome::CloseWindow(browser());
     AcceptModalDialog();
@@ skipping 137 matching lines @@
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestDeviceEmulation) {
   RunTest("testDeviceMetricsOverrides", "about:blank");
 }
 
 
 // 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);
-  ui_test_utils::UrlLoadObserver observer(url,
+  // TODO(dgozman): remove this once notifications are gone.
+  // Right now notifications happen after observers, so DevTools window is
+  // already loaded, but we still catch it's notification when looking for
+  // all sources.
+  content::WaitForLoadStop(window_->web_contents_for_test());
+  content::WindowedNotificationObserver observer(
+      content::NOTIFICATION_LOAD_STOP,
       content::NotificationService::AllSources());
   ASSERT_TRUE(content::ExecuteScript(
-      main_web_contents(),
+      window_->web_contents_for_test(),
       std::string("window.location = \"") + url.spec() + "\""));
   observer.Wait();
 
-  ASSERT_TRUE(main_web_contents()->GetURL().
+  ASSERT_TRUE(window_->web_contents_for_test()->GetURL().
                   SchemeIs(content::kChromeDevToolsScheme));
   ASSERT_EQ(url, GetInspectedTab()->GetURL());
   CloseDevToolsWindow();
 }
 
-// Tests that toolbox window is loaded when DevTools window is undocked.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestToolboxLoadedUndocked) {
-  OpenDevToolsWindow(kDebuggerTestPage, false);
-  ASSERT_TRUE(toolbox_web_contents());
-  DevToolsWindow* on_self = DevToolsWindowTesting::OpenDevToolsWindowSync(
-      main_web_contents()->GetRenderViewHost(), false);
-  ASSERT_FALSE(DevToolsWindowTesting::Get(on_self)->toolbox_web_contents());
-  DevToolsWindowTesting::CloseDevToolsWindowSync(on_self);
-  CloseDevToolsWindow();
-}
-
-// Tests that toolbox window is not loaded when DevTools window is docked.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestToolboxNotLoadedDocked) {
-  OpenDevToolsWindow(kDebuggerTestPage, true);
-  ASSERT_FALSE(toolbox_web_contents());
-  DevToolsWindow* on_self = DevToolsWindowTesting::OpenDevToolsWindowSync(
-      main_web_contents()->GetRenderViewHost(), false);
-  ASSERT_FALSE(DevToolsWindowTesting::Get(on_self)->toolbox_web_contents());
-  DevToolsWindowTesting::CloseDevToolsWindowSync(on_self);
-  CloseDevToolsWindow();
-}
-
 // Tests that inspector will reattach to inspected page when it is reloaded
 // after a crash. See http://crbug.com/101952
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestReattachAfterCrash) {
   RunTest("testReattachAfterCrash", std::string());
 }
 
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestPageWithNoJavaScript) {
   OpenDevToolsWindow("about:blank", false);
   std::string result;
   ASSERT_TRUE(
       content::ExecuteScriptAndExtractString(
-          main_web_contents()->GetRenderViewHost(),
+          window_->web_contents_for_test()->GetRenderViewHost(),
           "window.domAutomationController.send("
           "    '' + (window.uiTests && (typeof uiTests.runTest)));",
           &result));
   ASSERT_EQ("function", result) << "DevTools front-end is broken.";
   CloseDevToolsWindow();
 }
 
 #if defined(OS_MACOSX)
 #define MAYBE_InspectSharedWorker DISABLED_InspectSharedWorker
 #else
@@ skipping 69 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(RemoteDebuggingTest, RemoteDebugger) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
     return;
 #endif
 
   ASSERT_TRUE(RunExtensionTest("target_list")) << message_;
 }