[DevTools] Add toolbox web contents to show in undocked mode.

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 71 matching lines @@
     "files/workers/debug_shared_worker_initialization.html";
 
 void RunTestFunction(DevToolsWindow* window, const char* test_name) {
   std::string result;
 
   // 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(
-          window->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.";
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
-      window->web_contents()->GetRenderViewHost(),
+      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 22 matching lines @@
     ui_test_utils::WaitUntilDevToolsWindowLoaded(window_);
   }
 
   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()));
+        content::Source<content::WebContents>(
+            window_->web_contents_for_test()));
     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()));
+        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(devtools_window->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();
 }
 
@@ skipping 14 matching lines @@
   void CloseInspectedTab() {
     browser()->tab_strip_model()->CloseWebContentsAt(0,
         TabStripModel::CLOSE_NONE);
   }
 
   void CloseDockedDevTools() {
     ToggleDevToolsWindowDontWait();
   }
 
   void CloseUndockedDevTools() {
-    chrome::CloseWindow(window_->browser());
+    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);
     content::WindowedNotificationObserver devtools_close_observer(
         content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-        content::Source<content::WebContents>(window_->web_contents()));
-    InjectBeforeUnloadListener(window_->web_contents());
+        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()));
@@ skipping 11 matching lines @@
         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(
-        devtools_window->web_contents()->GetRenderViewHost(),
+        devtools_window->web_contents_for_test()->GetRenderViewHost(),
         "window.open(\"\", \"\", \"location=0\");"));
     observer.Wait();
   }
 
   void CloseDevToolsPopupWindow(DevToolsWindow* 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() != contents) {
+        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);
@@ skipping 240 matching lines @@
     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_ = DevToolsWindow::OpenDevToolsWindowForWorker(profile, agent_host);
-    RenderViewHost* client_rvh = window_->web_contents()->GetRenderViewHost();
-    WebContents* client_contents = WebContents::FromRenderViewHost(client_rvh);
-    content::WaitForLoadStop(client_contents);
+    content::WaitForLoadStop(window_->web_contents_for_test());
   }
 
   void CloseDevToolsWindow() {
-    Browser* browser = window_->browser();
+    Browser* browser = window_->browser_for_test();
     content::WindowedNotificationObserver close_observer(
         content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-        content::Source<content::WebContents>(window_->web_contents()));
+        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) {
@@ skipping 53 matching lines @@
 // @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);
   content::WindowedNotificationObserver devtools_close_observer(
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<content::WebContents>(
-          devtools_window->web_contents()));
+          devtools_window->web_contents_for_test()));
 
   ASSERT_TRUE(content::ExecuteScript(
-      devtools_window->web_contents()->GetRenderViewHost(),
+      devtools_window->web_contents_for_test()->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(), false);
   content::WindowedNotificationObserver devtools_close_observer(
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<content::WebContents>(
-          devtools_window->web_contents()));
+          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>(
-                    devtools_window->web_contents()));
+                    devtools_window->web_contents_for_test()));
     close_observers.push_back(close_observer);
-    inspected_web_contents = devtools_window->web_contents();
+    inspected_web_contents = devtools_window->web_contents_for_test();
   }
 
-  InjectBeforeUnloadListener(windows[0]->web_contents());
-  InjectBeforeUnloadListener(windows[2]->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(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 156 matching lines @@
 
 // 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);
   // 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());
+  content::WaitForLoadStop(window_->web_contents_for_test());
   content::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
       content::NotificationService::AllSources());
   ASSERT_TRUE(content::ExecuteScript(
-      window_->web_contents(),
+      window_->web_contents_for_test(),
       std::string("window.location = \"") + url.spec() + "\""));
   observer.Wait();
 
-  ASSERT_TRUE(window_->web_contents()->GetURL().
+  ASSERT_TRUE(window_->web_contents_for_test()->GetURL().
                   SchemeIs(content::kChromeDevToolsScheme));
   ASSERT_EQ(url, GetInspectedTab()->GetURL());
   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(
-          window_->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_;
 }