Replace most of Browser::GetSelectedTabContents calls into Browser::GetSelectedWebContents. I've ...

chrome/browser/extensions/extension_browsertests_misc.cc

 // Copyright (c) 2011 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/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/autoupdate_interceptor.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
@@ skipping 19 matching lines @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "net/base/net_util.h"
 #include "net/test/test_server.h"
 #include "webkit/glue/webpreferences.h"
 
 #if defined(TOOLKIT_VIEWS)
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #endif
 
+using content::WebContents;
+
 const std::string kSubscribePage = "/subscribe.html";
 const std::string kFeedPage = "files/feeds/feed.html";
 const std::string kFeedPageMultiRel = "files/feeds/feed_multi_rel.html";
 const std::string kNoFeedPage = "files/feeds/no_feed.html";
 const std::string kValidFeed0 = "files/feeds/feed_script.xml";
 const std::string kValidFeed1 = "files/feeds/feed1.xml";
 const std::string kValidFeed2 = "files/feeds/feed2.xml";
 const std::string kValidFeed3 = "files/feeds/feed3.xml";
 const std::string kValidFeed4 = "files/feeds/feed4.xml";
 const std::string kValidFeed5 = "files/feeds/feed5.xml";
@@ skipping 39 matching lines @@
       test_data_dir_.AppendASCII("good").AppendASCII("Extensions")
                     .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
                     .AppendASCII("1.0.0.0")));
 
   ui_test_utils::NavigateToURL(
       browser(),
       GURL("chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/page.html"));
 
   bool result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-      browser()->GetSelectedTabContents()->GetRenderViewHost(), L"",
+      browser()->GetSelectedWebContents()->GetRenderViewHost(), L"",
       L"testTabsAPI()", &result));
   EXPECT_TRUE(result);
 
   // There was a bug where we would crash if we navigated to a page in the same
   // extension because no new render view was getting created, so we would not
   // do some setup.
   ui_test_utils::NavigateToURL(
       browser(),
       GURL("chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/page.html"));
   result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-      browser()->GetSelectedTabContents()->GetRenderViewHost(), L"",
+      browser()->GetSelectedWebContents()->GetRenderViewHost(), L"",
       L"testTabsAPI()", &result));
   EXPECT_TRUE(result);
 }
 
 // Tests that GPU-related WebKit preferences are set for extension background
 // pages. See http://crbug.com/64512.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, WebKitPrefsBackgroundPage) {
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("good").AppendASCII("Extensions")
                     .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
@@ skipping 170 matching lines @@
                                         .AppendASCII("title_localized"));
   const Extension* extension = LoadExtension(extension_path);
   ASSERT_TRUE(extension);
 
   ASSERT_EQ(size_before + 1, service->extensions()->size());
 
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur: l10n browser action").c_str(),
                extension->description().c_str());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
                extension->name().c_str());
-  int tab_id = ExtensionTabUtil::GetTabId(browser()->GetSelectedTabContents());
+  int tab_id = ExtensionTabUtil::GetTabId(browser()->GetSelectedWebContents());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
                extension->browser_action()->GetTitle(tab_id).c_str());
 }
 
 // Tests that tooltips of a page action icon can be specified using UTF8.
 // See http://crbug.com/25349.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, TitleLocalizationPageAction) {
   ASSERT_TRUE(test_server()->Start());
 
   ExtensionService* service = browser()->profile()->GetExtensionService();
   const size_t size_before = service->extensions()->size();
 
   FilePath extension_path(test_data_dir_.AppendASCII("browsertest")
                                         .AppendASCII("title_localized_pa"));
   const Extension* extension = LoadExtension(extension_path);
   ASSERT_TRUE(extension);
 
   // Any navigation prompts the location bar to load the page action.
   GURL url = test_server()->GetURL(kLocalization);
   ui_test_utils::NavigateToURL(browser(), url);
   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 
   ASSERT_EQ(size_before + 1, service->extensions()->size());
 
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur: l10n page action").c_str(),
                extension->description().c_str());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
                extension->name().c_str());
-  int tab_id = ExtensionTabUtil::GetTabId(browser()->GetSelectedTabContents());
+  int tab_id = ExtensionTabUtil::GetTabId(browser()->GetSelectedWebContents());
   EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
                extension->page_action()->GetTitle(tab_id).c_str());
 }
 
 GURL GetFeedUrl(net::TestServer* server, const std::string& feed_page,
                 bool direct_url, std::string extension_id) {
   GURL feed_url = server->GetURL(feed_page);
   if (direct_url) {
     // We navigate directly to the subscribe page for feeds where the feed
     // sniffing won't work, in other words, as is the case for malformed feeds.
@@ skipping 26 matching lines @@
     L"    document.getElementById('desc_0').textContent : "
     L"    \"element 'desc_0' not found\""
     L");";
 static const wchar_t* jscript_error =
     L"window.domAutomationController.send("
     L"  document.getElementById('error') ? "
     L"    document.getElementById('error').textContent : "
     L"    \"No error\""
     L");";
 
-bool ValidatePageElement(TabContents* tab,
+bool ValidatePageElement(WebContents* tab,
                          const std::wstring& frame,
                          const std::wstring& javascript,
                          const std::string& expected_value) {
   std::string returned_value;
   std::string error;
 
   if (!ui_test_utils::ExecuteJavaScriptAndExtractString(
           tab->GetRenderViewHost(),
           frame,
           javascript, &returned_value))
@@ skipping 17 matching lines @@
                                const std::string& expected_item_desc,
                                const std::string& expected_error) {
   if (sniff_xml_type) {
     // TODO(finnur): Implement this is a non-flaky way.
   }
 
   // Navigate to the subscribe page directly.
   ui_test_utils::NavigateToURL(browser,
                                GetFeedUrl(server, url, true, extension_id));
 
-  TabContents* tab = browser->GetSelectedTabContents();
+  WebContents* tab = browser->GetSelectedWebContents();
   ASSERT_TRUE(ValidatePageElement(tab,
                                   L"",
                                   jscript_feed_title,
                                   expected_feed_title));
   ASSERT_TRUE(ValidatePageElement(tab,
                                   L"//html/body/div/iframe[1]",
                                   jscript_anchor,
                                   expected_item_title));
   ASSERT_TRUE(ValidatePageElement(tab,
                                   L"//html/body/div/iframe[1]",
@@ skipping 251 matching lines @@
 
   bool result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       host->render_view_host(), L"", L"testLastError()", &result));
   EXPECT_TRUE(result);
 }
 
 // Helper function for common code shared by the 3 WindowOpen tests below.
 static void WindowOpenHelper(Browser* browser, const GURL& start_url,
                              const std::string& newtab_url,
-                             TabContents** newtab_result) {
+                             WebContents** newtab_result) {
   ui_test_utils::NavigateToURL(browser, start_url);
 
   ui_test_utils::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
       content::NotificationService::AllSources());
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScript(
-      browser->GetSelectedTabContents()->GetRenderViewHost(), L"",
+      browser->GetSelectedWebContents()->GetRenderViewHost(), L"",
       L"window.open('" + UTF8ToWide(newtab_url) + L"');"));
 
   // Now the active tab in last active window should be the new tab.
   Browser* last_active_browser = BrowserList::GetLastActive();
   EXPECT_TRUE(last_active_browser);
-  TabContents* newtab = last_active_browser->GetSelectedTabContents();
+  WebContents* newtab = last_active_browser->GetSelectedWebContents();
   EXPECT_TRUE(newtab);
   GURL expected_url = start_url.Resolve(newtab_url);
   observer.Wait();
   EXPECT_EQ(expected_url,
             newtab->GetController().GetLastCommittedEntry()->GetURL());
   if (newtab_result)
     *newtab_result = newtab;
 }
 
 // Tests that an extension page can call window.open to an extension URL and
 // the new window has extension privileges.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, WindowOpenExtension) {
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("uitest").AppendASCII("window_open")));
 
-  TabContents* newtab;
+  WebContents* newtab;
   ASSERT_NO_FATAL_FAILURE(WindowOpenHelper(
       browser(),
       GURL(std::string("chrome-extension://") + last_loaded_extension_id_ +
            "/test.html"),
       "newtab.html", &newtab));
 
   bool result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       newtab->GetRenderViewHost(), L"", L"testExtensionApi()", &result));
   EXPECT_TRUE(result);
@@ skipping 15 matching lines @@
 }
 
 // Tests that calling window.open from the newtab page to an extension URL
 // gives the new window extension privileges - even though the opening page
 // does not have extension privileges, we break the script connection, so
 // there is no privilege leak.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, WindowOpenNoPrivileges) {
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("uitest").AppendASCII("window_open")));
 
-  TabContents* newtab;
+  WebContents* newtab;
   ASSERT_NO_FATAL_FAILURE(WindowOpenHelper(
       browser(),
       GURL("about:blank"),
       std::string("chrome-extension://") + last_loaded_extension_id_ +
           "/newtab.html",
       &newtab));
 
   // Extension API should succeed.
   bool result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
@@ skipping 17 matching lines @@
 #endif
 
 // Tests that a renderer's plugin list is properly updated when we load and
 // unload an extension that contains a plugin.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, MAYBE_PluginLoadUnload) {
   FilePath extension_dir =
       test_data_dir_.AppendASCII("uitest").AppendASCII("plugins");
 
   ui_test_utils::NavigateToURL(browser(),
       net::FilePathToFileURL(extension_dir.AppendASCII("test.html")));
-  TabContents* tab = browser()->GetSelectedTabContents();
+  WebContents* tab = browser()->GetSelectedWebContents();
 
   // With no extensions, the plugin should not be loaded.
   bool result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->GetRenderViewHost(), L"", L"testPluginWorks()", &result));
   EXPECT_FALSE(result);
 
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->set_show_extensions_prompts(false);
   const size_t size_before = service->extensions()->size();
@@ skipping 62 matching lines @@
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->set_show_extensions_prompts(false);
   const size_t size_before = service->extensions()->size();
   const Extension* extension = LoadExtension(extension_dir);
   ASSERT_TRUE(extension);
   EXPECT_EQ(size_before + 1, service->extensions()->size());
 
   // Load the test page through the extension URL, and the plugin should work.
   ui_test_utils::NavigateToURL(browser(),
       extension->GetResourceURL("test.html"));
-  TabContents* tab = browser()->GetSelectedTabContents();
+  WebContents* tab = browser()->GetSelectedWebContents();
   bool result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->GetRenderViewHost(), L"", L"testPluginWorks()", &result));
   // We don't allow extension plugins to run on ChromeOS.
 #if defined(OS_CHROMEOS)
   EXPECT_FALSE(result);
 #else
   EXPECT_TRUE(result);
 #endif
 
@@ skipping 25 matching lines @@
   ASSERT_TRUE(extension);
   ExtensionService* service = browser()->profile()->GetExtensionService();
   ASSERT_EQ(1u, service->extensions()->size());
 
   // Go to the Extension Settings page and click the Options button.
   ui_test_utils::NavigateToURL(
       browser(), GURL(std::string(chrome::kChromeUISettingsURL) +
                       chrome::kExtensionsSubPage));
   TabStripModel* tab_strip = browser()->tabstrip_model();
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScript(
-      browser()->GetSelectedTabContents()->GetRenderViewHost(), L"",
+      browser()->GetSelectedWebContents()->GetRenderViewHost(), L"",
       jscript_click_option_button));
 
   // If the options page hasn't already come up, wait for it.
   if (tab_strip->count() == 1) {
     ui_test_utils::WaitForNewTab(browser());
   }
   ASSERT_EQ(2, tab_strip->count());
 
   EXPECT_EQ(extension->GetResourceURL("options.html"),
             tab_strip->GetTabContentsAt(1)->tab_contents()->GetURL());
 }
 
 //==============================================================================
 // STOP! Please do not add any more random-ass tests here. Create new files for
 // your tests grouped by functionality. Also, you should strongly consider using
 // ExtensionAPITest if possible.
 //==============================================================================