Persist the Instant API to committed search result pages.

chrome/browser/instant/instant_browsertest.cc

 // Copyright 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 "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/instant/instant_loader.h"
 #include "chrome/browser/instant/instant_model_observer.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_instant_controller.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
-#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 106 matching lines @@
                                                    WrapScript(script), result);
   }
 
   bool GetStringFromJS(content::RenderViewHost* rvh,
                        const std::string& script,
                        std::string* result) WARN_UNUSED_RESULT {
     return content::ExecuteJavaScriptAndExtractString(
         rvh, std::wstring(), WrapScript(script), result);
   }
 
-  bool UpdateSearchState(TabContents* tab) WARN_UNUSED_RESULT {
-    content::RenderViewHost* rvh = tab->web_contents()->GetRenderViewHost();
+  bool UpdateSearchState(content::WebContents* contents) WARN_UNUSED_RESULT {
+    content::RenderViewHost* rvh = contents->GetRenderViewHost();
     return GetIntFromJS(rvh, "onvisibilitycalls", &onvisibilitycalls_) &&
            GetIntFromJS(rvh, "onchangecalls", &onchangecalls_) &&
            GetIntFromJS(rvh, "onsubmitcalls", &onsubmitcalls_) &&
            GetIntFromJS(rvh, "oncancelcalls", &oncancelcalls_) &&
            GetIntFromJS(rvh, "onresizecalls", &onresizecalls_) &&
            GetStringFromJS(rvh, "value", &value_) &&
            GetBoolFromJS(rvh, "verbatim", &verbatim_) &&
            GetIntFromJS(rvh, "height", &height_);
   }
 
   bool ExecuteScript(const std::string& script) WARN_UNUSED_RESULT {
     return content::ExecuteJavaScript(
-        instant()->GetPreviewContents()->web_contents()->GetRenderViewHost(),
-        std::wstring(), UTF8ToWide(script));
+        instant()->GetPreviewContents()->GetRenderViewHost(), std::wstring(),
+        UTF8ToWide(script));
   }
 
-  bool CheckVisibilityIs(TabContents* tab, bool expected) WARN_UNUSED_RESULT {
+  bool CheckVisibilityIs(content::WebContents* contents,
+                         bool expected) WARN_UNUSED_RESULT {
     bool actual = !expected;  // Purposely start with a mis-match.
     // We can only use ASSERT_*() in a method that returns void, hence this
     // convoluted check.
-    return GetBoolFromJS(tab->web_contents()->GetRenderViewHost(),
+    return GetBoolFromJS(contents->GetRenderViewHost(),
                          "!document.webkitHidden", &actual) &&
            actual == expected;
   }
 
   GURL instant_url_;
 
   int onvisibilitycalls_;
   int onchangecalls_;
   int onsubmitcalls_;
   int oncancelcalls_;
   int onresizecalls_;
 
   std::string value_;
   bool verbatim_;
   int height_;
 };
 
 // Test that Instant is preloaded when the omnibox is focused.
 IN_PROC_BROWSER_TEST_F(InstantTest, OmniboxFocusLoadsInstant) {
-  // The omnibox gets focus before the test begins. At this time, there's no
-  // InstantController (which is only created in SetupInstant() below), so no
-  // preloading has happened yet.
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
-  EXPECT_FALSE(instant()->GetPreviewContents());
 
   // Explicitly unfocus the omnibox.
   EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
   ui_test_utils::ClickOnView(browser(), VIEW_ID_TAB_CONTAINER);
 
   EXPECT_TRUE(ui_test_utils::IsViewFocused(browser(), VIEW_ID_TAB_CONTAINER));
   EXPECT_FALSE(omnibox()->model()->has_focus());
 
+  // Delete any existing preview.
+  instant()->loader_.reset();
+  EXPECT_FALSE(instant()->GetPreviewContents());
+
   // Refocus the omnibox. The InstantController should've preloaded Instant.
   FocusOmniboxAndWaitForInstantSupport();
 
   EXPECT_FALSE(ui_test_utils::IsViewFocused(browser(), VIEW_ID_TAB_CONTAINER));
   EXPECT_TRUE(omnibox()->model()->has_focus());
 
-  TabContents* preview_tab = instant()->GetPreviewContents();
+  content::WebContents* preview_tab = instant()->GetPreviewContents();
   EXPECT_TRUE(preview_tab);
 
   // Check that the page supports Instant, but it isn't showing.
-  EXPECT_TRUE(instant()->loader()->supports_instant());
+  EXPECT_TRUE(instant()->loader_->supports_instant());
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 
-  // Adding a new tab shouldn't delete or recreate the TabContents; otherwise,
+  // Adding a new tab shouldn't delete or recreate the preview; otherwise,
   // what's the point of preloading?
   AddBlankTabAndShow(browser());
   EXPECT_EQ(preview_tab, instant()->GetPreviewContents());
 
   // Unfocusing and refocusing the omnibox should also preserve the preview.
   ui_test_utils::ClickOnView(browser(), VIEW_ID_TAB_CONTAINER);
   EXPECT_TRUE(ui_test_utils::IsViewFocused(browser(), VIEW_ID_TAB_CONTAINER));
 
   FocusOmnibox();
   EXPECT_FALSE(ui_test_utils::IsViewFocused(browser(), VIEW_ID_TAB_CONTAINER));
@@ skipping 48 matching lines @@
   EXPECT_EQ(0, active_tab_onvisibilitycalls);
 }
 
 // Test that the onsubmit event is dispatched upon pressing Enter.
 IN_PROC_BROWSER_TEST_F(InstantTest, OnSubmitEvent) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   FocusOmniboxAndWaitForInstantSupport();
   SetOmniboxTextAndWaitForInstantToShow("search");
 
   // Stash a reference to the preview, so we can refer to it after commit.
-  TabContents* preview_tab = instant()->GetPreviewContents();
+  content::WebContents* preview_tab = instant()->GetPreviewContents();
   EXPECT_TRUE(preview_tab);
 
   // The state of the searchbox before the commit.
   EXPECT_TRUE(UpdateSearchState(preview_tab));
   EXPECT_EQ("search", value_);
   EXPECT_FALSE(verbatim_);
   EXPECT_EQ(0, onsubmitcalls_);
   EXPECT_EQ(1, onvisibilitycalls_);
 
   // Before the commit, the active tab is the NTP (i.e., not Instant).
-  TabContents* active_tab =
-      browser()->tab_strip_model()->GetActiveTabContents();
+  content::WebContents* active_tab =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_NE(preview_tab, active_tab);
-  EXPECT_EQ(1, active_tab->web_contents()->GetController().GetEntryCount());
+  EXPECT_EQ(1, active_tab->GetController().GetEntryCount());
   EXPECT_EQ(std::string(chrome::kAboutBlankURL),
             omnibox()->model()->PermanentURL().spec());
 
   // Commit the search by pressing Enter.
   browser()->window()->GetLocationBar()->AcceptInput();
 
   // After the commit, Instant should not be showing.
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 
   // The old loader is deleted and a new one is created.
   EXPECT_TRUE(instant()->GetPreviewContents());
   EXPECT_NE(instant()->GetPreviewContents(), preview_tab);
 
   // Check that the current active tab is indeed what was once the preview.
-  EXPECT_EQ(preview_tab, browser()->tab_strip_model()->GetActiveTabContents());
+  EXPECT_EQ(preview_tab, browser()->tab_strip_model()->GetActiveWebContents());
 
   // We should have two navigation entries, one for the NTP, and one for the
   // Instant search that was committed.
-  EXPECT_EQ(2, preview_tab->web_contents()->GetController().GetEntryCount());
+  EXPECT_EQ(2, preview_tab->GetController().GetEntryCount());
 
   // Check that the omnibox contains the Instant URL we loaded.
   EXPECT_EQ(instant_url_, omnibox()->model()->PermanentURL());
 
   // Check that the searchbox API values have been reset.
   std::string value;
-  EXPECT_TRUE(GetStringFromJS(preview_tab->web_contents()->GetRenderViewHost(),
+  EXPECT_TRUE(GetStringFromJS(preview_tab->GetRenderViewHost(),
                               "chrome.searchBox.value", &value));
   EXPECT_EQ("", value);
 
   // However, the page should've correctly received the committed query.
   EXPECT_TRUE(UpdateSearchState(preview_tab));
   EXPECT_EQ("search", value_);
   EXPECT_TRUE(verbatim_);
   EXPECT_EQ(1, onsubmitcalls_);
   EXPECT_EQ(1, onvisibilitycalls_);
 }
 
 // Test that the oncancel event is dispatched upon clicking on the preview.
 IN_PROC_BROWSER_TEST_F(InstantTest, OnCancelEvent) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
   FocusOmniboxAndWaitForInstantSupport();
   SetOmniboxTextAndWaitForInstantToShow("search");
 
   // Stash a reference to the preview, so we can refer to it after commit.
-  TabContents* preview_tab = instant()->GetPreviewContents();
+  content::WebContents* preview_tab = instant()->GetPreviewContents();
   EXPECT_TRUE(preview_tab);
 
   // The state of the searchbox before the commit.
   EXPECT_TRUE(UpdateSearchState(preview_tab));
   EXPECT_EQ("search", value_);
   EXPECT_FALSE(verbatim_);
   EXPECT_EQ(0, oncancelcalls_);
   EXPECT_EQ(1, onvisibilitycalls_);
 
   // Before the commit, the active tab is the NTP (i.e., not Instant).
-  TabContents* active_tab =
-      browser()->tab_strip_model()->GetActiveTabContents();
+  content::WebContents* active_tab =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_NE(preview_tab, active_tab);
-  EXPECT_EQ(1, active_tab->web_contents()->GetController().GetEntryCount());
+  EXPECT_EQ(1, active_tab->GetController().GetEntryCount());
   EXPECT_EQ(std::string(chrome::kAboutBlankURL),
             omnibox()->model()->PermanentURL().spec());
 
   // Commit the search by clicking on the preview.
   ui_test_utils::ClickOnView(browser(), VIEW_ID_TAB_CONTAINER);
 
   // After the commit, Instant should not be showing.
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 
   // The old loader is deleted and a new one is created.
   EXPECT_TRUE(instant()->GetPreviewContents());
   EXPECT_NE(instant()->GetPreviewContents(), preview_tab);
 
   // Check that the current active tab is indeed what was once the preview.
-  EXPECT_EQ(preview_tab, browser()->tab_strip_model()->GetActiveTabContents());
+  EXPECT_EQ(preview_tab, browser()->tab_strip_model()->GetActiveWebContents());
 
   // We should have two navigation entries, one for the NTP, and one for the
   // Instant search that was committed.
-  EXPECT_EQ(2, preview_tab->web_contents()->GetController().GetEntryCount());
+  EXPECT_EQ(2, preview_tab->GetController().GetEntryCount());
 
   // Check that the omnibox contains the Instant URL we loaded.
   EXPECT_EQ(instant_url_, omnibox()->model()->PermanentURL());
 
   // Check that the searchbox API values have been reset.
   std::string value;
-  EXPECT_TRUE(GetStringFromJS(preview_tab->web_contents()->GetRenderViewHost(),
+  EXPECT_TRUE(GetStringFromJS(preview_tab->GetRenderViewHost(),
                               "chrome.searchBox.value", &value));
   EXPECT_EQ("", value);
 
   // However, the page should've correctly received the committed query.
   EXPECT_TRUE(UpdateSearchState(preview_tab));
   EXPECT_EQ("search", value_);
   EXPECT_TRUE(verbatim_);
   EXPECT_EQ(1, oncancelcalls_);
   EXPECT_EQ(1, onvisibilitycalls_);
 }
 
 // Test that the onreisze event is dispatched upon typing in the omnibox.
 IN_PROC_BROWSER_TEST_F(InstantTest, OnResizeEvent) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
 
-  // This makes Instant load the preview, along with an initial onresize() (see
-  // SearchBoxExtension::PageSupportsInstant() for why).
   FocusOmniboxAndWaitForInstantSupport();
 
   EXPECT_TRUE(UpdateSearchState(instant()->GetPreviewContents()));
-  EXPECT_EQ(1, onresizecalls_);
+  EXPECT_EQ(0, onresizecalls_);
   EXPECT_EQ(0, height_);
 
   // Type a query into the omnibox. This should cause an onresize() event, with
   // a valid (non-zero) height.
   SetOmniboxTextAndWaitForInstantToShow("search");
 
   EXPECT_TRUE(UpdateSearchState(instant()->GetPreviewContents()));
-  EXPECT_EQ(2, onresizecalls_);
+  EXPECT_EQ(1, onresizecalls_);
   EXPECT_LT(0, height_);
 }
 
 // Test that the INSTANT_COMPLETE_NOW behavior works as expected.
 IN_PROC_BROWSER_TEST_F(InstantTest, SuggestionIsCompletedNow) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   FocusOmniboxAndWaitForInstantSupport();
 
   // Tell the JS to request the given behavior.
   EXPECT_TRUE(ExecuteScript("behavior = 'now'"));
@@ skipping 198 matching lines @@
   // Type a URL. The Instant preview shouldn't be showing.
   SetOmniboxText("http://deadly/nadder");
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 
   // Unfocus and refocus the omnibox.
   ui_test_utils::ClickOnView(browser(), VIEW_ID_TAB_CONTAINER);
   EXPECT_TRUE(ui_test_utils::IsViewFocused(browser(), VIEW_ID_TAB_CONTAINER));
   FocusOmnibox();
 
-  TabContents* preview_tab = instant()->GetPreviewContents();
+  content::WebContents* preview_tab = instant()->GetPreviewContents();
   EXPECT_TRUE(preview_tab);
 
   // The omnibox text hasn't changed, so Instant still shouldn't be showing.
   EXPECT_EQ(ASCIIToUTF16("http://deadly/nadder"), omnibox()->GetText());
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 
   // Commit the URL. The omnibox should reflect the URL minus the scheme.
   browser()->window()->GetLocationBar()->AcceptInput();
-  TabContents* active_tab =
-      browser()->tab_strip_model()->GetActiveTabContents();
+  content::WebContents* active_tab =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_NE(preview_tab, active_tab);
   EXPECT_EQ(ASCIIToUTF16("deadly/nadder"), omnibox()->GetText());
 
   // Instant shouldn't have done anything.
   EXPECT_EQ(preview_tab, instant()->GetPreviewContents());
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 }
 
 // Test that Instant can't be fooled into committing a URL.
 IN_PROC_BROWSER_TEST_F(InstantTest, DoesNotCommitURLsTwo) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   FocusOmniboxAndWaitForInstantSupport();
 
   // Type a query. This causes the preview to be shown.
   SetOmniboxTextAndWaitForInstantToShow("query");
 
-  TabContents* preview_tab = instant()->GetPreviewContents();
+  content::WebContents* preview_tab = instant()->GetPreviewContents();
   EXPECT_TRUE(preview_tab);
 
   // Type a URL. This causes the preview to be hidden.
   SetOmniboxText("http://hideous/zippleback");
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 
   // Pretend the omnibox got focus. It already had focus, so we are just trying
   // to tickle a different code path.
   instant()->OmniboxGotFocus();
 
   // Commit the URL. As before, check that Instant wasn't committed.
   browser()->window()->GetLocationBar()->AcceptInput();
-  TabContents* active_tab =
-      browser()->tab_strip_model()->GetActiveTabContents();
+  content::WebContents* active_tab =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_NE(preview_tab, active_tab);
   EXPECT_EQ(ASCIIToUTF16("hideous/zippleback"), omnibox()->GetText());
 
   // As before, Instant shouldn't have done anything.
   EXPECT_EQ(preview_tab, instant()->GetPreviewContents());
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 }
 
 // Test that a non-Instant search provider shows no previews.
 IN_PROC_BROWSER_TEST_F(InstantTest, NonInstantSearchProvider) {
   instant_url_ = test_server()->GetURL("files/empty.html");
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
 
   // Focus the omnibox. When the support determination response comes back,
-  // Instant will destroy the non-Instant page.
+  // Instant will destroy the non-Instant page, and attempt to recreate it.
+  // We can know this happened by looking at the blacklist.
+  EXPECT_EQ(0, instant()->blacklisted_urls_[instant_url_.spec()]);
   FocusOmniboxAndWaitForInstantSupport();
-  EXPECT_FALSE(instant()->GetPreviewContents());
+  EXPECT_EQ(1, instant()->blacklisted_urls_[instant_url_.spec()]);
 }
 
 // Test that the renderer doesn't crash if JavaScript is blocked.
 IN_PROC_BROWSER_TEST_F(InstantTest, NoCrashOnBlockedJS) {
   browser()->profile()->GetHostContentSettingsMap()->SetDefaultContentSetting(
       CONTENT_SETTINGS_TYPE_JAVASCRIPT, CONTENT_SETTING_BLOCK);
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
 
   // Wait for notification that the Instant API has been determined. As long as
   // we get the notification we're good (the renderer didn't crash).
   FocusOmniboxAndWaitForInstantSupport();
 }
 
 // Test that the preview and active tab's visibility states are set correctly.
 IN_PROC_BROWSER_TEST_F(InstantTest, PageVisibility) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   FocusOmniboxAndWaitForInstantSupport();
 
-  TabContents* active_tab =
-      browser()->tab_strip_model()->GetActiveTabContents();
-  TabContents* preview_tab = instant()->GetPreviewContents();
+  content::WebContents* active_tab =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  content::WebContents* preview_tab = instant()->GetPreviewContents();
 
   // Inititally, the active tab is showing; the preview is not.
   EXPECT_TRUE(CheckVisibilityIs(active_tab, true));
   EXPECT_TRUE(CheckVisibilityIs(preview_tab, false));
 
   // Type a query and wait for Instant to show.
   SetOmniboxTextAndWaitForInstantToShow("query");
   EXPECT_TRUE(CheckVisibilityIs(active_tab, true));
   EXPECT_TRUE(CheckVisibilityIs(preview_tab, true));
 
   // Deleting the omnibox text should hide the preview.
   SetOmniboxText("");
   EXPECT_TRUE(CheckVisibilityIs(active_tab, true));
   EXPECT_TRUE(CheckVisibilityIs(preview_tab, false));
 
   // Typing a query should show the preview again.
   SetOmniboxTextAndWaitForInstantToShow("query");
   EXPECT_TRUE(CheckVisibilityIs(active_tab, true));
   EXPECT_TRUE(CheckVisibilityIs(preview_tab, true));
 
   // Commit the preview.
   browser()->window()->GetLocationBar()->AcceptInput();
-  EXPECT_EQ(preview_tab, browser()->tab_strip_model()->GetActiveTabContents());
+  EXPECT_EQ(preview_tab, browser()->tab_strip_model()->GetActiveWebContents());
   EXPECT_TRUE(CheckVisibilityIs(preview_tab, true));
 }
 
 // Test that the task manager identifies Instant's preview tab correctly.
 IN_PROC_BROWSER_TEST_F(InstantTest, TaskManagerPrefix) {
   // The browser starts with a new tab, so there's just one renderer initially.
   TaskManagerModel* task_manager = TaskManager::GetInstance()->model();
   task_manager->StartUpdating();
   TaskManagerBrowserTestUtil::WaitForWebResourceChange(1);
 
@@ skipping 16 matching lines @@
   for (int i = 0; i < task_manager->ResourceCount(); ++i) {
     string16 title = task_manager->GetResourceTitle(i);
     if (StartsWith(title, prefix, true))
       ++instant_previews;
   }
   EXPECT_EQ(1, instant_previews);
 }
 
 void HistoryQueryDone(base::RunLoop* run_loop,
                       bool* result,
-                      HistoryService::Handle  /* handle */,
+                      HistoryService::Handle /* handle */,
                       bool success,
-                      const history::URLRow*  /* urlrow */,
-                      history::VisitVector*  /* visitvector */) {
+                      const history::URLRow* /* urlrow */,
+                      history::VisitVector* /* visitvector */) {
   *result = success;
   run_loop->Quit();
 }
 
 void KeywordQueryDone(base::RunLoop* run_loop,
                       std::vector<string16>* result,
                       HistoryService::Handle  /* handle */,
                       std::vector<history::KeywordSearchTermVisit>* terms) {
   for (size_t i = 0; i < terms->size(); ++i)
     result->push_back((*terms)[i].term);
@@ skipping 12 matching lines @@
   // enter into history for search terms extraction to work correctly.
   std::string search_url = template_url->url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("search")));
 
   HistoryService* history = HistoryServiceFactory::GetForProfile(
       browser()->profile(), Profile::EXPLICIT_ACCESS);
   ui_test_utils::WaitForHistoryToLoad(history);
 
   // Perform a search.
   SetOmniboxTextAndWaitForInstantToShow("search");
-  EXPECT_EQ(instant_url_.spec(), instant()->loader()->instant_url());
 
   // Commit the search.
   browser()->window()->GetLocationBar()->AcceptInput();
 
   bool found = false;
   CancelableRequestConsumer consumer;
 
   // The fake search URL should be in history.
   base::RunLoop run_loop1;
   history->QueryURL(GURL(search_url), false, &consumer,
@@ skipping 54 matching lines @@
 // - The preview is not showing.
 // - The omnibox doesn't have focus.
 IN_PROC_BROWSER_TEST_F(InstantTest, InstantLoaderRefresh) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   FocusOmniboxAndWaitForInstantSupport();
 
   // The preview is refreshed only after all three conditions above are met.
   SetOmniboxTextAndWaitForInstantToShow("query");
   instant()->stale_loader_timer_.Stop();
   instant()->OnStaleLoader();
-  EXPECT_TRUE(instant()->loader()->supports_instant());
-  instant()->Hide(true);
-  EXPECT_TRUE(instant()->loader()->supports_instant());
+  EXPECT_TRUE(instant()->loader_->supports_instant());
+  instant()->Hide();
+  EXPECT_TRUE(instant()->loader_->supports_instant());
   instant()->OmniboxLostFocus(NULL);
-  EXPECT_FALSE(instant()->loader()->supports_instant());
+  EXPECT_FALSE(instant()->loader_->supports_instant());
 
   // Try with a different ordering.
   SetOmniboxTextAndWaitForInstantToShow("query");
   instant()->stale_loader_timer_.Stop();
   instant()->OnStaleLoader();
-  EXPECT_TRUE(instant()->loader()->supports_instant());
+  EXPECT_TRUE(instant()->loader_->supports_instant());
   instant()->OmniboxLostFocus(NULL);
   // TODO(sreeram): Currently, OmniboxLostFocus() calls Hide(). Eventually,
   // when it stops hiding the preview, uncomment these two lines below:
-  //     EXPECT_TRUE(instant()->loader()->supports_instant());
-  //     instant()->Hide(true);
-  EXPECT_FALSE(instant()->loader()->supports_instant());
+  //     EXPECT_TRUE(instant()->loader_->supports_instant());
+  //     instant()->Hide();
+  EXPECT_FALSE(instant()->loader_->supports_instant());
 }
 
 // Test that suggestions are case insensitive. http://crbug.com/150728
 IN_PROC_BROWSER_TEST_F(InstantTest, SuggestionsAreCaseInsensitive) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   FocusOmniboxAndWaitForInstantSupport();
 
   EXPECT_TRUE(ExecuteScript("suggestion = [ { value: 'INSTANT' } ]"));
 
   SetOmniboxTextAndWaitForInstantToShow("in");
@@ skipping 46 matching lines @@
 }
 
 // Test that the preview can be committed onto a new tab.
 IN_PROC_BROWSER_TEST_F(InstantTest, CommitInNewTab) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   FocusOmniboxAndWaitForInstantSupport();
 
   // Use the Instant page as the active tab, so we can exploit its visibility
   // handler to check visibility transitions.
   ui_test_utils::NavigateToURL(browser(), instant_url_);
-  TabContents* active_tab =
-      browser()->tab_strip_model()->GetActiveTabContents();
+  content::WebContents* active_tab =
+      browser()->tab_strip_model()->GetActiveWebContents();
 
   int active_tab_onvisibilitycalls = -1;
-  EXPECT_TRUE(GetIntFromJS(active_tab->web_contents()->GetRenderViewHost(),
-                           "onvisibilitycalls", &active_tab_onvisibilitycalls));
+  EXPECT_TRUE(GetIntFromJS(active_tab->GetRenderViewHost(), "onvisibilitycalls",
+                           &active_tab_onvisibilitycalls));
   EXPECT_EQ(0, active_tab_onvisibilitycalls);
 
   SetOmniboxTextAndWaitForInstantToShow("search");
 
   // Stash a reference to the preview, so we can refer to it after commit.
-  TabContents* preview_tab = instant()->GetPreviewContents();
+  content::WebContents* preview_tab = instant()->GetPreviewContents();
   EXPECT_TRUE(preview_tab);
 
   // The state of the searchbox before the commit.
   EXPECT_TRUE(UpdateSearchState(preview_tab));
   EXPECT_EQ("search", value_);
   EXPECT_FALSE(verbatim_);
   EXPECT_EQ(0, onsubmitcalls_);
   EXPECT_EQ(1, onvisibilitycalls_);
 
   // The state of the active tab before the commit.
   EXPECT_NE(preview_tab, active_tab);
-  EXPECT_EQ(2, active_tab->web_contents()->GetController().GetEntryCount());
+  EXPECT_EQ(2, active_tab->GetController().GetEntryCount());
   EXPECT_EQ(instant_url_, omnibox()->model()->PermanentURL());
   active_tab_onvisibilitycalls = -1;
-  EXPECT_TRUE(GetIntFromJS(active_tab->web_contents()->GetRenderViewHost(),
-                           "onvisibilitycalls", &active_tab_onvisibilitycalls));
+  EXPECT_TRUE(GetIntFromJS(active_tab->GetRenderViewHost(), "onvisibilitycalls",
+                           &active_tab_onvisibilitycalls));
   EXPECT_EQ(0, active_tab_onvisibilitycalls);
 
   // Commit the search by pressing Alt-Enter.
   omnibox()->model()->AcceptInput(NEW_FOREGROUND_TAB, false);
 
   // After the commit, Instant should not be showing.
   EXPECT_FALSE(instant()->IsCurrent());
   EXPECT_TRUE(instant()->model()->mode().is_default());
 
   // The old loader is deleted and a new one is created.
   EXPECT_TRUE(instant()->GetPreviewContents());
   EXPECT_NE(instant()->GetPreviewContents(), preview_tab);
 
   // Check that we have two tabs and that the new active tab is indeed what was
   // once the preview. The preview tab should have just one navigation entry,
   // for the Instant search that was committed.
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
-  EXPECT_EQ(preview_tab, browser()->tab_strip_model()->GetActiveTabContents());
-  EXPECT_EQ(1, preview_tab->web_contents()->GetController().GetEntryCount());
+  EXPECT_EQ(preview_tab, browser()->tab_strip_model()->GetActiveWebContents());
+  EXPECT_EQ(1, preview_tab->GetController().GetEntryCount());
 
   // Check that the omnibox contains the Instant URL we loaded.
   EXPECT_EQ(instant_url_, omnibox()->model()->PermanentURL());
 
   // Check that the searchbox API values have been reset.
   std::string value;
-  EXPECT_TRUE(GetStringFromJS(preview_tab->web_contents()->GetRenderViewHost(),
+  EXPECT_TRUE(GetStringFromJS(preview_tab->GetRenderViewHost(),
                               "chrome.searchBox.value", &value));
   EXPECT_EQ("", value);
 
   // However, the page should've correctly received the committed query.
   EXPECT_TRUE(UpdateSearchState(preview_tab));
   EXPECT_EQ("search", value_);
   EXPECT_TRUE(verbatim_);
   EXPECT_EQ(1, onsubmitcalls_);
   EXPECT_EQ(1, onvisibilitycalls_);
 
   // The ex-active tab should've gotten a visibility change marking it hidden.
   EXPECT_NE(active_tab, preview_tab);
-  EXPECT_TRUE(GetIntFromJS(active_tab->web_contents()->GetRenderViewHost(),
-                           "onvisibilitycalls", &active_tab_onvisibilitycalls));
+  EXPECT_TRUE(GetIntFromJS(active_tab->GetRenderViewHost(), "onvisibilitycalls",
+                           &active_tab_onvisibilitycalls));
   EXPECT_EQ(1, active_tab_onvisibilitycalls);
 }
 
 // Test that suggestions are reusable.
 IN_PROC_BROWSER_TEST_F(InstantTest, SuggestionsAreReusable) {
   ASSERT_NO_FATAL_FAILURE(SetupInstant());
   FocusOmniboxAndWaitForInstantSupport();
 
   EXPECT_TRUE(ExecuteScript("suggestion = [ { value: 'instant' } ];"
                             "behavior = 'never';"));
 
   SetOmniboxTextAndWaitForInstantToShow("in");
   EXPECT_EQ(ASCIIToUTF16("stant"), omnibox()->GetInstantSuggestion());
 
   SetOmniboxText("ins");
   EXPECT_EQ(ASCIIToUTF16("tant"), omnibox()->GetInstantSuggestion());
 
   SetOmniboxText("in");
   EXPECT_EQ(ASCIIToUTF16("stant"), omnibox()->GetInstantSuggestion());
 
   SetOmniboxText("insane");
   EXPECT_EQ(ASCIIToUTF16(""), omnibox()->GetInstantSuggestion());
 }