[DevTools] Remove dock side knowledge from browser.

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"
@@ skipping 88 matching lines @@
         content::ExecuteScriptAndExtractString(
             window->GetRenderViewHost(),
             base::StringPrintf("uiTests.runTest('%s')", test_name),
             &result));
     EXPECT_EQ("[OK]", result);
   } else {
     FAIL() << "DevTools front-end is broken.";
   }
 }
 
+}  // namespace
+
 class DevToolsSanityTest : public InProcessBrowserTest {
  public:
   DevToolsSanityTest()
       : window_(NULL),
         inspected_rvh_(NULL) {}
 
  protected:
   void RunTest(const std::string& test_name, const std::string& test_page) {
-    OpenDevToolsWindow(test_page);
+    OpenDevToolsWindow(test_page, false);
     RunTestFunction(window_, test_name.c_str());
     CloseDevToolsWindow();
   }
 
   void LoadTestPage(const std::string& test_page) {
     content::WindowedNotificationObserver load_observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     GURL url = test_server()->GetURL(test_page);
     ui_test_utils::NavigateToURL(browser(), url);
     load_observer.Wait();
   }
 
-  void OpenDevToolsWindow(const std::string& test_page) {
+  void OpenDevToolsWindow(const std::string& test_page, bool is_docked) {
     ASSERT_TRUE(test_server()->Start());
     LoadTestPage(test_page);
 
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     inspected_rvh_ = GetInspectedTab()->GetRenderViewHost();
-    window_ = DevToolsWindow::OpenDevToolsWindow(inspected_rvh_);
+    window_ =
+        DevToolsWindow::OpenDevToolsWindowForTest(inspected_rvh_, is_docked);
     observer.Wait();
   }
 
   WebContents* GetInspectedTab() {
     return browser()->tab_strip_model()->GetWebContentsAt(0);
   }
 
   void ToggleDevToolsWindow() {
     content::WindowedNotificationObserver close_observer(
         content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
         content::Source<content::WebContents>(window_->web_contents()));
     DevToolsWindow::ToggleDevToolsWindow(inspected_rvh_, false,
         DevToolsToggleAction::Toggle());
     close_observer.Wait();
   }
 
+  void ToggleDevToolsWindowDontWait() {
+    DevToolsWindow::ToggleDevToolsWindow(inspected_rvh_, false,
+        DevToolsToggleAction::Toggle());
+  }
+
   void CloseDevToolsWindow() {
     DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
     content::WindowedNotificationObserver close_observer(
         content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
         content::Source<content::WebContents>(window_->web_contents()));
     devtools_manager->CloseAllClientHosts();
     close_observer.Wait();
   }
 
   DevToolsWindow* window_;
@@ skipping 41 matching lines @@
     command_line->AppendSwitch(
         switches::kDisableHangMonitor);
   }
 
   void CloseInspectedTab() {
     browser()->tab_strip_model()->CloseWebContentsAt(0,
         TabStripModel::CLOSE_NONE);
   }
 
   void CloseDockedDevTools() {
-    DevToolsWindow::ToggleDevToolsWindow(inspected_rvh_, false,
-        DevToolsToggleAction::Toggle());
+    ToggleDevToolsWindowDontWait();
   }
 
   void CloseUndockedDevTools() {
     chrome::CloseWindow(window_->browser());
   }
 
   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(DevToolsDockSide dock_side,
-                             base::Callback<void(void)> close_method,
-                             bool wait_for_browser_close = true) {
-    OpenDevToolsWindow(kDebuggerTestPage);
-    window_->SetDockSideForTest(dock_side);
+  void RunBeforeUnloadSanityTest(bool is_docked,
+                                 base::Callback<void(void)> close_method,
+                                 bool wait_for_browser_close = true) {
+    OpenDevToolsWindow(kDebuggerTestPage, is_docked);
     content::WindowedNotificationObserver devtools_close_observer(
         content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
         content::Source<content::WebContents>(window_->web_contents()));
     InjectBeforeUnloadListener(window_->web_contents());
     {
       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();
     }
     devtools_close_observer.Wait();
   }
 
   DevToolsWindow* OpenDevToolWindowOnWebContents(
-      content::WebContents* contents) {
+      content::WebContents* contents, bool is_docked) {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
-    DevToolsWindow* window = DevToolsWindow::OpenDevToolsWindow(
-        contents->GetRenderViewHost());
+    DevToolsWindow* window = DevToolsWindow::OpenDevToolsWindowForTest(
+        contents->GetRenderViewHost(), is_docked);
     observer.Wait();
     return window;
   }
 
   void OpenDevToolsPopupWindow(DevToolsWindow* devtools_window) {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     ASSERT_TRUE(content::ExecuteScript(
         devtools_window->web_contents()->GetRenderViewHost(),
@@ skipping 257 matching lines @@
     scoped_refptr<WorkerData> worker_data(new WorkerData());
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&WaitForFirstSharedWorkerOnIOThread, worker_data));
     content::RunMessageLoop();
     return worker_data;
   }
 
   void OpenDevToolsWindowForSharedWorker(WorkerData* worker_data) {
     Profile* profile = browser()->profile();
-    window_ = DevToolsWindow::CreateDevToolsWindowForWorker(profile);
-    window_->Show(DevToolsToggleAction::Show());
     scoped_refptr<DevToolsAgentHost> agent_host(
         DevToolsAgentHost::GetForWorker(
             worker_data->worker_process_id,
             worker_data->worker_route_id));
-    DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(
-        agent_host.get(), window_->GetDevToolsClientHostForTest());
+    window_ = DevToolsWindow::OpenDevToolsWindowForWorker(profile, agent_host);
     RenderViewHost* client_rvh = window_->GetRenderViewHost();
     WebContents* client_contents = WebContents::FromRenderViewHost(client_rvh);
     if (client_contents->IsLoading()) {
       content::WindowedNotificationObserver observer(
           content::NOTIFICATION_LOAD_STOP,
           content::Source<NavigationController>(
               &client_contents->GetController()));
       observer.Wait();
     }
   }
 
   void CloseDevToolsWindow() {
     Browser* browser = window_->browser();
     content::WindowedNotificationObserver close_observer(
         content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
         content::Source<content::WebContents>(window_->web_contents()));
     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(DEVTOOLS_DOCK_SIDE_BOTTOM, base::Bind(
+  RunBeforeUnloadSanityTest(true, base::Bind(
       &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(DEVTOOLS_DOCK_SIDE_BOTTOM, base::Bind(
+  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(DEVTOOLS_DOCK_SIDE_BOTTOM, base::Bind(
+  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(DEVTOOLS_DOCK_SIDE_UNDOCKED, base::Bind(
+  RunBeforeUnloadSanityTest(false, base::Bind(
       &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(DEVTOOLS_DOCK_SIDE_UNDOCKED, base::Bind(
+  RunBeforeUnloadSanityTest(false, base::Bind(
       &DevToolsBeforeUnloadTest::CloseInspectedTab, this));
 }
 
 // Tests that BeforeUnload event gets called on undocked devtools if
 // we try to close the inspected browser.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        TestUndockedDevToolsInspectedBrowserClose) {
-  RunBeforeUnloadSanityTest(DEVTOOLS_DOCK_SIDE_UNDOCKED, base::Bind(
+  RunBeforeUnloadSanityTest(false, base::Bind(
       &DevToolsBeforeUnloadTest::CloseInspectedBrowser, this));
 }
 
 // Tests that BeforeUnload event gets called on undocked devtools if
 // we try to exit application.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        TestUndockedDevToolsApplicationClose) {
-  RunBeforeUnloadSanityTest(DEVTOOLS_DOCK_SIDE_UNDOCKED, base::Bind(
+  RunBeforeUnloadSanityTest(false, base::Bind(
       &chrome::CloseAllBrowsers));
 }
 
 // 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());
-  devtools_window->SetDockSideForTest(DEVTOOLS_DOCK_SIDE_UNDOCKED);
+      GetInspectedTab(), false);
   content::WindowedNotificationObserver devtools_close_observer(
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<content::WebContents>(
           devtools_window->web_contents()));
 
   ASSERT_TRUE(content::ExecuteScript(
       devtools_window->web_contents()->GetRenderViewHost(),
       "window.addEventListener('beforeunload',"
       "function(event) { while (true); });"));
   CloseInspectedTab();
   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());
-  devtools_window->SetDockSideForTest(DEVTOOLS_DOCK_SIDE_UNDOCKED);
+      GetInspectedTab(), false);
   content::WindowedNotificationObserver devtools_close_observer(
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<content::WebContents>(
           devtools_window->web_contents()));
 
   OpenDevToolsPopupWindow(devtools_window);
   CloseDevToolsPopupWindow(devtools_window);
 }
 
 // FLaky on Windows bots: see crbug.com/323847, Linux crbug.com/333554
 #if defined(OS_WIN) || defined(OS_LINUX)
 #define MAYBE_TestDevToolsOnDevTools DISABLED_TestDevToolsOnDevTools
 #else
 #define MAYBE_TestDevToolsOnDevTools TestDevToolsOnDevTools
 #endif
 // Tests that BeforeUnload event gets called on devtools that are opened
 // on another devtools.
 IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest,
                        MAYBE_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);
+      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>(
                     devtools_window->web_contents()));
     close_observers.push_back(close_observer);
     inspected_web_contents = devtools_window->web_contents();
   }
 
@@ skipping 156 matching lines @@
 
 // Tests that console messages are not duplicated on navigation back.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestConsoleOnNavigateBack) {
   RunTest("testConsoleOnNavigateBack", kNavigateBackTestPage);
 }
 
 
 // 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);
+  OpenDevToolsWindow(kDebuggerTestPage, true);
   GURL url = test_server()->GetURL(kNavigateBackTestPage);
   content::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
       content::NotificationService::AllSources());
   ASSERT_TRUE(content::ExecuteScript(
       window_->web_contents(),
       std::string("window.location = \"") + url.spec() + "\""));
   observer.Wait();
 
   ASSERT_TRUE(window_->web_contents()->GetURL().
                   SchemeIs(chrome::kChromeDevToolsScheme));
   ASSERT_EQ(GetInspectedTab()->GetURL(), url);
   CloseDevToolsWindow();
 }
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 // Flakily times out: http://crbug.com/163411
 #define MAYBE_TestReattachAfterCrash DISABLED_TestReattachAfterCrash
 #else
 #define MAYBE_TestReattachAfterCrash TestReattachAfterCrash
 #endif
 // 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, MAYBE_TestReattachAfterCrash) {
-  OpenDevToolsWindow(kDebuggerTestPage);
+  OpenDevToolsWindow(kDebuggerTestPage, false);
 
   content::CrashTab(GetInspectedTab());
   content::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
       content::Source<NavigationController>(
           &browser()->tab_strip_model()->GetActiveWebContents()->
               GetController()));
   chrome::Reload(browser(), CURRENT_TAB);
   observer.Wait();
 
   RunTestFunction(window_, "testReattachAfterCrash");
   CloseDevToolsWindow();
 }
 
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestPageWithNoJavaScript) {
-  OpenDevToolsWindow("about:blank");
+  OpenDevToolsWindow("about:blank", false);
   std::string result;
   ASSERT_TRUE(
       content::ExecuteScriptAndExtractString(
           window_->GetRenderViewHost(),
           "window.domAutomationController.send("
           "    '' + (window.uiTests && (typeof uiTests.runTest)));",
           &result));
   ASSERT_EQ("function", result) << "DevTools front-end is broken.";
   CloseDevToolsWindow();
 }
@@ skipping 73 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_;
 }
-
-}  // namespace