[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);
     RunTestFunction(window_, test_name.c_str());
@@ skipping 27 matching lines @@
 
   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,
+  void RunBeforeUnloadSanityTest(bool is_docked,
                              base::Callback<void(void)> close_method,
                              bool wait_for_browser_close = true) {
     OpenDevToolsWindow(kDebuggerTestPage);
-    window_->SetDockSideForTest(dock_side);
+    window_->SetIsDockedForTest(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();
     }
@@ skipping 286 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);
+  devtools_window->SetIsDockedForTest(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);
+  devtools_window->SetIsDockedForTest(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);
 }
 
 // Tests that BeforeUnload event gets called on devtools that are opened
@@ skipping 179 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);
+  window_->SetIsDockedForTest(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().
@@ skipping 114 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