DevTools: migrate DevTools APIs to use WebContents instead of RenderViewHost.

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 91 matching lines @@
       rvh,
       base::StringPrintf("uiTests.runTest('%s')", test_name),
       &result));
   EXPECT_EQ("[OK]", result);
 }
 
 }  // namespace
 
 class DevToolsSanityTest : public InProcessBrowserTest {
  public:
-  DevToolsSanityTest()
-      : window_(NULL),
-        inspected_rvh_(NULL) {}
+  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);
     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_ = DevToolsWindowTesting::OpenDevToolsWindowSync(GetInspectedTab(),
+                                                            is_docked);
   }
 
   WebContents* GetInspectedTab() {
     return browser()->tab_strip_model()->GetWebContentsAt(0);
   }
 
   void CloseDevToolsWindow() {
     DevToolsWindowTesting::CloseDevToolsWindowSync(window_);
   }
 
   WebContents* main_web_contents() {
     return DevToolsWindowTesting::Get(window_)->main_web_contents();
   }
 
   WebContents* toolbox_web_contents() {
     return DevToolsWindowTesting::Get(window_)->toolbox_web_contents();
   }
 
   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.
@@ skipping 74 matching lines @@
       close_method.Run();
       AcceptModalDialog();
       if (wait_for_browser_close)
         close_observer.Wait();
     }
     runner->Run();
   }
 
   DevToolsWindow* OpenDevToolWindowOnWebContents(
       content::WebContents* contents, bool is_docked) {
-    DevToolsWindow* window = DevToolsWindowTesting::OpenDevToolsWindowSync(
-        contents->GetRenderViewHost(), is_docked);
+    DevToolsWindow* window =
+        DevToolsWindowTesting::OpenDevToolsWindowSync(contents, is_docked);
     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(),
@@ skipping 550 matching lines @@
   ASSERT_TRUE(main_web_contents()->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);
+  DevToolsWindow* on_self =
+      DevToolsWindowTesting::OpenDevToolsWindowSync(main_web_contents(), 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);
+  DevToolsWindow* on_self =
+      DevToolsWindowTesting::OpenDevToolsWindowSync(main_web_contents(), 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());
 }
@@ skipping 45 matching lines @@
   // Wait until worker script is paused on the debugger statement.
   RunTestFunction(window_, "testPauseInSharedWorkerInitialization");
   CloseDevToolsWindow();
 }
 
 class DevToolsAgentHostTest : public InProcessBrowserTest {};
 
 // Tests DevToolsAgentHost retention by its target.
 IN_PROC_BROWSER_TEST_F(DevToolsAgentHostTest, TestAgentHostReleased) {
   ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
-  RenderViewHost* rvh = browser()->tab_strip_model()->GetWebContentsAt(0)->
-      GetRenderViewHost();
-  DevToolsAgentHost* agent_raw = DevToolsAgentHost::GetOrCreateFor(rvh).get();
+  WebContents* web_contents = browser()->tab_strip_model()->GetWebContentsAt(0);
+  DevToolsAgentHost* agent_raw =
+      DevToolsAgentHost::GetOrCreateFor(web_contents).get();
   const std::string agent_id = agent_raw->GetId();
   ASSERT_EQ(agent_raw, DevToolsAgentHost::GetForId(agent_id)) <<
       "DevToolsAgentHost cannot be found by id";
   browser()->tab_strip_model()->
       CloseWebContentsAt(0, TabStripModel::CLOSE_NONE);
   ASSERT_FALSE(DevToolsAgentHost::GetForId(agent_id).get())
       << "DevToolsAgentHost is not released when the tab is closed";
 }
 
 class RemoteDebuggingTest: public ExtensionApiTest {
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     ExtensionApiTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(switches::kRemoteDebuggingPort, "9222");
 
     // Override the extension root path.
     PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_);
     test_data_dir_ = test_data_dir_.AppendASCII("devtools");
   }
 };
 
 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_;
 }