Remove tabstrip wrappers in browser_tabstrip.

chrome/browser/ui/find_bar/find_bar_host_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/file_util.h"
 #include "base/message_loop.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/common/cancelable_request.h"
@@ skipping 174 matching lines @@
 };
 
 // This test loads a page with frames and starts FindInPage requests.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPageFrames) {
   // First we navigate to our frames page.
   GURL url = GetURL(kFramePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Try incremental search (mimicking user typing in).
   int ordinal = 0;
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(18, FindInPageWchar(web_contents, L"g",
                                 kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
   EXPECT_EQ(11, FindInPageWchar(web_contents, L"go",
                                 kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
   EXPECT_EQ(4, FindInPageWchar(web_contents, L"goo",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
   EXPECT_EQ(3, FindInPageWchar(web_contents, L"goog",
@@ skipping 55 matching lines @@
                                kFwd, kCaseSensitive, &ordinal));
   EXPECT_EQ(0, ordinal);
 }
 
 // Verify search for text within various forms and text areas.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPageFormsTextAreas) {
   std::vector<GURL> urls;
   urls.push_back(GetURL("textintextarea.html"));
   urls.push_back(GetURL("smalltextarea.html"));
   urls.push_back(GetURL("populatedform.html"));
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
 
   for (size_t i = 0; i < urls.size(); ++i) {
     ui_test_utils::NavigateToURL(browser(), urls[i]);
     EXPECT_EQ(1, FindInPageWchar(web_contents, L"cat",
                                  kFwd, kIgnoreCase, NULL));
     EXPECT_EQ(0, FindInPageWchar(web_contents, L"bat",
                                  kFwd, kIgnoreCase, NULL));
   }
 }
 
 // Verify search for text within special URLs such as chrome:history,
 // chrome://downloads, data directory
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, SearchWithinSpecialURL) {
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
 
   FilePath data_dir = ui_test_utils::GetTestFilePath(FilePath(), FilePath());
   ui_test_utils::NavigateToURL(browser(), net::FilePathToFileURL(data_dir));
   EXPECT_EQ(1, FindInPageWchar(web_contents, L"downloads",
                                kFwd, kIgnoreCase, NULL));
 
   ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIHistoryURL));
 
   // The history page does an async request to the history service and then
   // updates the renderer. So we make a query as well, and by the time it comes
@@ skipping 17 matching lines @@
                             ASCIIToWide(download_url.spec()).c_str(), kFwd,
                             kIgnoreCase, NULL));
 }
 
 // Verify search selection coordinates. The data file used is set-up such that
 // the text occurs on the same line, and we verify their positions by verifying
 // their relative positions.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPageSpecialURLs) {
   std::wstring search_string(L"\u5728\u897f\u660c\u536b\u661f\u53d1");
   gfx::Rect first, second, first_reverse;
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(), GetURL("specialchar.html"));
   ui_test_utils::FindInPage(web_contents, WideToUTF16(search_string),
                             kFwd, kIgnoreCase, NULL, &first);
   ui_test_utils::FindInPage(web_contents, WideToUTF16(search_string),
                             kFwd, kIgnoreCase, NULL, &second);
 
   // We have search occurrence in the same row, so top-bottom coordinates should
   // be the same even for second search.
   ASSERT_EQ(first.y(), second.y());
   ASSERT_EQ(first.bottom(), second.bottom());
   ASSERT_LT(first.x(), second.x());
   ASSERT_LT(first.right(), second.right());
 
   ui_test_utils::FindInPage(
       web_contents, WideToUTF16(search_string), kBack, kIgnoreCase, NULL,
       &first_reverse);
   // We find next and we go back so find coordinates should be the same as
   // previous ones.
   ASSERT_EQ(first, first_reverse);
 }
 
 // Verifies that comments and meta data are not searchable.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest,
                        CommentsAndMetaDataNotSearchable) {
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(), GetURL("specialchar.html"));
 
   std::wstring search_string =
       L"\u4e2d\u65b0\u793e\u8bb0\u8005\u5b8b\u5409\u6cb3\u6444\u4e2d\u65b0\u7f51";
   EXPECT_EQ(0, ui_test_utils::FindInPage(
       web_contents, WideToUTF16(search_string), kFwd, kIgnoreCase, NULL, NULL));
 }
 
 // Verifies that span and lists are searchable.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, SpanAndListsSearchable) {
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(), GetURL("FindRandomTests.html"));
 
   std::wstring search_string = L"has light blue eyes and my father has dark";
   EXPECT_EQ(1, ui_test_utils::FindInPage(
       web_contents, WideToUTF16(search_string), kFwd, kIgnoreCase, NULL, NULL));
 
   search_string = L"Google\nApple\nandroid";
   EXPECT_EQ(1, ui_test_utils::FindInPage(
       web_contents, WideToUTF16(search_string), kFwd, kIgnoreCase, NULL, NULL));
 }
 
 // Find in a very large page.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, LargePage) {
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(), GetURL("largepage.html"));
 
   std::wstring search_string = L"daughter of Prince";
   EXPECT_EQ(373,
             FindInPageWchar(web_contents, search_string.c_str(),
                             kFwd, kIgnoreCase, NULL));
 }
 
 // Find a very long string in a large page.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindLongString) {
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(), GetURL("largepage.html"));
 
   FilePath path = ui_test_utils::GetTestFilePath(
       FilePath().AppendASCII("find_in_page"),
       FilePath().AppendASCII("LongFind.txt"));
   std::string query;
   file_util::ReadFileToString(path, &query);
   std::wstring search_string = UTF8ToWide(query);
   EXPECT_EQ(1,
             FindInPageWchar(web_contents, search_string.c_str(),
                             kFwd, kIgnoreCase, NULL));
 }
 
 // Find a big font string in a page.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, BigString) {
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(), GetURL("BigText.html"));
   EXPECT_EQ(1,
             FindInPageWchar(web_contents, L"SomeLargeString",
                             kFwd, kIgnoreCase, NULL));
 }
 
 // Search Back and Forward on a single occurrence.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, SingleOccurrence) {
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(), GetURL("FindRandomTests.html"));
 
   gfx::Rect first_rect;
   EXPECT_EQ(1,
             ui_test_utils::FindInPage(web_contents,
                                       ASCIIToUTF16("2010 Pro Bowl"), kFwd,
                                       kIgnoreCase, NULL, &first_rect));
 
   gfx::Rect second_rect;
   EXPECT_EQ(1,
@@ skipping 13 matching lines @@
                                       kIgnoreCase, NULL, &first_rect));
   EXPECT_EQ(1,
             ui_test_utils::FindInPage(web_contents,
                                       ASCIIToUTF16("2010 Pro Bowl"), kBack,
                                       kIgnoreCase, NULL, &second_rect));
   ASSERT_EQ(first_rect, second_rect);
 }
 
 // Find the whole text file page and find count should be 1.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindWholeFileContent) {
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
 
   FilePath path = ui_test_utils::GetTestFilePath(
       FilePath().AppendASCII("find_in_page"),
       FilePath().AppendASCII("find_test.txt"));
   ui_test_utils::NavigateToURL(browser(), net::FilePathToFileURL(path));
 
   std::string query;
   file_util::ReadFileToString(path, &query);
   std::wstring search_string = UTF8ToWide(query);
   EXPECT_EQ(1,
@@ skipping 14 matching lines @@
 }
 
 // This tests the FindInPage end-state, in other words: what is focused when you
 // close the Find box (ie. if you find within a link the link should be
 // focused).
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPageEndState) {
   // First we navigate to our special focus tracking page.
   GURL url = GetURL(kEndState);
   ui_test_utils::NavigateToURL(browser(), url);
 
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(NULL != web_contents);
   FindTabHelper* find_tab_helper =
       FindTabHelper::FromWebContents(web_contents);
 
   // Verify that nothing has focus.
   std::string result;
   ASSERT_TRUE(FocusedOnPage(web_contents, &result));
   ASSERT_STREQ("{nothing focused}", result.c_str());
 
   // Search for a text that exists within a link on the page.
@@ skipping 31 matching lines @@
 
 // This test loads a single-frame page and makes sure the ordinal returned makes
 // sense as we FindNext over all the items.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPageOrdinal) {
   // First we navigate to our page.
   GURL url = GetURL(kFrameData);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for 'o', which should make the first item active and return
   // '1 in 3' (1st ordinal of a total of 3 matches).
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   int ordinal = 0;
   EXPECT_EQ(3, FindInPageWchar(web_contents, L"o",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
   EXPECT_EQ(3, FindInPageWchar(web_contents, L"o",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(2, ordinal);
   EXPECT_EQ(3, FindInPageWchar(web_contents, L"o",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(3, ordinal);
@@ skipping 15 matching lines @@
 }
 
 // This tests that the ordinal is correctly adjusted after a selection
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest,
                        SelectChangesOrdinal_Issue20883) {
   // First we navigate to our test content.
   GURL url = GetURL(kSelectChangesOrdinal);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for a text that exists within a link on the page.
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(NULL != web_contents);
   FindTabHelper* find_tab_helper =
       FindTabHelper::FromWebContents(web_contents);
 
   int ordinal = 0;
   EXPECT_EQ(4, FindInPageWchar(web_contents,
                                L"google",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 
@@ skipping 15 matching lines @@
   // End the find session.
   find_tab_helper->StopFinding(FindBarController::kKeepSelectionOnPage);
 }
 
 // This tests that we start searching after selected text.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest,
                        StartSearchAfterSelection) {
   // First we navigate to our test content.
   ui_test_utils::NavigateToURL(browser(), GetURL(kStartAfterSelection));
 
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(web_contents != NULL);
   int ordinal = 0;
 
   // Move the selection to the text span.
   std::string result;
   ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
       web_contents->GetRenderViewHost(),
       std::wstring(),
       L"window.domAutomationController.send(selectSpan());",
       &result));
@@ skipping 22 matching lines @@
 
 // This test loads a page with frames and makes sure the ordinal returned makes
 // sense.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPageMultiFramesOrdinal) {
   // First we navigate to our page.
   GURL url = GetURL(kFramePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for 'a', which should make the first item active and return
   // '1 in 7' (1st ordinal of a total of 7 matches).
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   int ordinal = 0;
   EXPECT_EQ(7,
             FindInPageWchar(web_contents, L"a", kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
   EXPECT_EQ(7,
             FindInPageWchar(web_contents, L"a", kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(2, ordinal);
   EXPECT_EQ(7,
             FindInPageWchar(web_contents, L"a", kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(3, ordinal);
@@ skipping 28 matching lines @@
 
 // We could get ordinals out of whack when restarting search in subframes.
 // See http://crbug.com/5132.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindInPage_Issue5132) {
   // First we navigate to our page.
   GURL url = GetURL(kFramePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for 'goa' three times (6 matches on page).
   int ordinal = 0;
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(6, FindInPageWchar(web_contents, L"goa",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
   EXPECT_EQ(6, FindInPageWchar(web_contents, L"goa",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(2, ordinal);
   EXPECT_EQ(6, FindInPageWchar(web_contents, L"goa",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(3, ordinal);
   // Add space to search (should result in no matches).
@@ skipping 21 matching lines @@
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Open the Find box. In most tests we can just search without opening the
   // box first, but in this case we are testing functionality triggered by
   // NOTIFICATION_NAV_ENTRY_COMMITTED in the FindBarController and the observer
   // for that event isn't setup unless the box is open.
   EnsureFindBoxOpen();
 
   // Search for a text that exists within a link on the page.
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(NULL != web_contents);
   int ordinal = 0;
   EXPECT_EQ(8, FindInPageWchar(web_contents,
                                L"e",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 
   // Then navigate away (to any page).
   url = GetURL(kLinkPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Open the Find box again.
   EnsureFindBoxOpen();
 
   EXPECT_EQ(ASCIIToUTF16("e"), GetFindBarText());
   EXPECT_EQ(ASCIIToUTF16(""), GetMatchCountText());
 }
 
 // Load a page with no selectable text and make sure we don't crash.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindUnselectableText) {
   // First we navigate to our page.
   GURL url = GetURL(kUserSelectPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   int ordinal = 0;
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(1, FindInPageWchar(web_contents,
                                L"text",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 }
 
 // Try to reproduce the crash seen in issue 1341577.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindCrash_Issue1341577) {
   // First we navigate to our page.
   GURL url = GetURL(kCrashPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // This would crash the tab. These must be the first two find requests issued
   // against the frame, otherwise an active frame pointer is set and it wont
   // produce the crash.
   // We used to check the return value and |ordinal|. With ICU 4.2, FiP does
   // not find a stand-alone dependent vowel sign of Indic scripts. So, the
   // exptected values are all 0. To make this test pass regardless of
   // ICU version, we just call FiP and see if there's any crash.
   // TODO(jungshik): According to a native Malayalam speaker, it's ok not
   // to find U+0D4C. Still need to investigate further this issue.
   int ordinal = 0;
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   FindInPageWchar(web_contents, L"\u0D4C", kFwd, kIgnoreCase, &ordinal);
   FindInPageWchar(web_contents, L"\u0D4C", kFwd, kIgnoreCase, &ordinal);
 
   // This should work fine.
   EXPECT_EQ(1, FindInPageWchar(web_contents, L"\u0D24\u0D46",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
   EXPECT_EQ(0, FindInPageWchar(web_contents, L"nostring",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(0, ordinal);
 }
 
 // Try to reproduce the crash seen in http://crbug.com/14491, where an assert
 // hits in the BitStack size comparison in WebKit.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindCrash_Issue14491) {
   // First we navigate to our page.
   GURL url = GetURL(kBitstackCrash);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // This used to crash the tab.
   int ordinal = 0;
-  EXPECT_EQ(0, FindInPageWchar(chrome::GetActiveWebContents(browser()),
+  EXPECT_EQ(0, FindInPageWchar(browser()->tab_strip_model()->
+                                   GetActiveWebContents(),
                                L"s", kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(0, ordinal);
 }
 
 // Test to make sure Find does the right thing when restarting from a timeout.
 // We used to have a problem where we'd stop finding matches when all of the
 // following conditions were true:
 // 1) The page has a lot of text to search.
 // 2) The page contains more than one match.
 // 3) It takes longer than the time-slice given to each Find operation (100
 //    ms) to find one or more of those matches (so Find times out and has to try
 //    again from where it left off).
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindRestarts_Issue1155639) {
   // First we navigate to our page.
   GURL url = GetURL(kTooFewMatchesPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // This string appears 5 times at the bottom of a long page. If Find restarts
   // properly after a timeout, it will find 5 matches, not just 1.
   int ordinal = 0;
-  EXPECT_EQ(5, FindInPageWchar(chrome::GetActiveWebContents(browser()),
+  EXPECT_EQ(5, FindInPageWchar(browser()->tab_strip_model()->
+                                   GetActiveWebContents(),
                                L"008.xml",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 }
 
 // Make sure we don't get into an infinite loop when text box contains very
 // large amount of text.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindRestarts_Issue70505) {
   // First we navigate to our page.
   GURL url = GetURL(kLongTextareaPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // If this test hangs on the FindInPage call, then it might be a regression
   // such as the one found in issue http://crbug.com/70505.
   int ordinal = 0;
-  FindInPageWchar(chrome::GetActiveWebContents(browser()),
+  FindInPageWchar(browser()->tab_strip_model()->GetActiveWebContents(),
                   L"a", kFwd, kIgnoreCase, &ordinal);
   EXPECT_EQ(1, ordinal);
   // TODO(finnur): We cannot reliably get the matchcount for this Find call
   // until we fix issue http://crbug.com/71176.
 }
 
 // This tests bug 11761: FindInPage terminates search prematurely.
 // This test is not expected to pass until bug 11761 is fixed.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest,
                        DISABLED_FindInPagePrematureEnd) {
   // First we navigate to our special focus tracking page.
   GURL url = GetURL(kPrematureEnd);
   ui_test_utils::NavigateToURL(browser(), url);
 
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(NULL != web_contents);
 
   // Search for a text that exists within a link on the page.
   int ordinal = 0;
   EXPECT_EQ(2, FindInPageWchar(web_contents, L"html ",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 }
 
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, FindDisappearOnNavigate) {
   // First we navigate to our special focus tracking page.
   GURL url = GetURL(kSimple);
   GURL url2 = GetURL(kFramePage);
   ui_test_utils::NavigateToURL(browser(), url);
 
   chrome::ShowFindBar(browser());
 
   gfx::Point position;
   bool fully_visible = false;
 
   // Make sure it is open.
   EXPECT_TRUE(GetFindBarWindowInfo(&position, &fully_visible));
   EXPECT_TRUE(fully_visible);
 
   // Reload the tab and make sure Find window doesn't go away.
   content::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
       content::Source<NavigationController>(
-          &chrome::GetActiveWebContents(browser())->GetController()));
+          &browser()->tab_strip_model()->GetActiveWebContents()->
+              GetController()));
   chrome::Reload(browser(), CURRENT_TAB);
   observer.Wait();
 
   EXPECT_TRUE(GetFindBarWindowInfo(&position, &fully_visible));
   EXPECT_TRUE(fully_visible);
 
   // Navigate and make sure the Find window goes away.
   ui_test_utils::NavigateToURL(browser(), url2);
 
   EXPECT_TRUE(GetFindBarWindowInfo(&position, &fully_visible));
@@ skipping 81 matching lines @@
 
   gfx::Point start_position;
   gfx::Point position;
   bool fully_visible = false;
   int ordinal = 0;
 
   // Make sure it is open.
   EXPECT_TRUE(GetFindBarWindowInfo(&start_position, &fully_visible));
   EXPECT_TRUE(fully_visible);
 
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
 
   int moved_x_coord = FindInPageTillBoxMoves(web_contents, start_position.x(),
       L"Chromium", kMoveIterations);
   // The find box should have moved.
   EXPECT_TRUE(moved_x_coord != start_position.x());
 
   // Search for something guaranteed not to be obscured by the Find box.
   EXPECT_EQ(1, FindInPageWchar(web_contents, L"Done",
                                kFwd, kIgnoreCase, &ordinal));
   // Check the position.
@@ skipping 36 matching lines @@
 
 // Make sure F3 in a new tab works if Find has previous string to search for.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest,
                        MAYBE_FindNextInNewTabUsesPrepopulate) {
   // First we navigate to any page.
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for 'no_match'. No matches should be found.
   int ordinal = 0;
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(0, FindInPageWchar(web_contents, L"no_match",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(0, ordinal);
 
   // Open another tab (tab B).
   chrome::NewTab(browser());
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Simulate what happens when you press F3 for FindNext. We should get a
   // response here (a hang means search was aborted).
@@ skipping 18 matching lines @@
   // First we navigate to any page.
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   chrome::ShowFindBar(browser());
 
   // Simulate a user clearing the search string. Ideally, we should be
   // simulating keypresses here for searching for something and pressing
   // backspace, but that's been proven flaky in the past, so we go straight to
   // tab_contents.
-  FindTabHelper* find_tab_helper =
-      FindTabHelper::FromWebContents(chrome::GetActiveWebContents(browser()));
+  FindTabHelper* find_tab_helper = FindTabHelper::FromWebContents(
+      browser()->tab_strip_model()->GetActiveWebContents());
   // Stop the (non-existing) find operation, and clear the selection (which
   // signals the UI is still active).
   find_tab_helper->StopFinding(FindBarController::kClearSelectionOnPage);
   // Make sure the Find UI flag hasn't been cleared, it must be so that the UI
   // still responds to browser window resizing.
   ASSERT_TRUE(find_tab_helper->find_ui_active());
 }
 
 // Make sure F3 works after you FindNext a couple of times and end the Find
 // session. See issue http://crbug.com/28306.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, RestartSearchFromF3) {
   // First we navigate to a simple page.
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for 'page'. Should have 1 match.
   int ordinal = 0;
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(1, FindInPageWchar(web_contents, L"page",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(1, ordinal);
 
   // Simulate what happens when you press F3 for FindNext. Still should show
   // one match. This cleared the pre-populate string at one point (see bug).
   EXPECT_EQ(1, ui_test_utils::FindInPage(web_contents, string16(),
                                          kFwd, kIgnoreCase, &ordinal, NULL));
   EXPECT_EQ(1, ordinal);
 
@@ skipping 10 matching lines @@
 // When re-opening the find bar with F3, the find bar should be re-populated
 // with the last search from the same tab rather than the last overall search.
 // http://crbug.com/30006
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, PreferPreviousSearch) {
   // First we navigate to any page.
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Find "Default".
   int ordinal = 0;
-  WebContents* web_contents_1 = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents_1 =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(1, FindInPageWchar(web_contents_1, L"text",
                                kFwd, kIgnoreCase, &ordinal));
 
   // Create a second tab.
   // For some reason we can't use AddSelectedTabWithURL here on ChromeOS. It
   // could be some delicate assumption about the tab starting off unselected or
   // something relating to user gesture.
   chrome::AddBlankTabAt(browser(), -1, true);
   ui_test_utils::NavigateToURL(browser(), url);
-  WebContents* web_contents_2 = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents_2 =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_NE(web_contents_1, web_contents_2);
 
   // Find "given".
   FindInPageWchar(web_contents_2, L"given", kFwd, kIgnoreCase, &ordinal);
 
   // Switch back to first tab.
-  chrome::ActivateTabAt(browser(), 0, false);
+  browser()->tab_strip_model()->ActivateTabAt(0, false);
   browser()->GetFindBarController()->EndFindSession(
       FindBarController::kKeepSelectionOnPage,
       FindBarController::kKeepResultsInFindBox);
   // Simulate F3.
   ui_test_utils::FindInPage(web_contents_1, string16(),
                             kFwd, kIgnoreCase, &ordinal, NULL);
   EXPECT_EQ(FindTabHelper::FromWebContents(web_contents_1)->find_text(),
             WideToUTF16(L"text"));
 }
 
 // This tests that whenever you close and reopen the Find bar, it should show
 // the last search entered in that tab. http://crbug.com/40121.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, PrepopulateSameTab) {
 #if defined(OS_MACOSX)
   // FindInPage on Mac doesn't use prepopulated values. Search there is global.
   return;
 #endif
 
   // First we navigate to any page.
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for the word "page".
   int ordinal = 0;
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(1, FindInPageWchar(web_contents, L"page",
                                kFwd, kIgnoreCase, &ordinal));
 
   // Open the Find box.
   EnsureFindBoxOpen();
 
   EXPECT_EQ(ASCIIToUTF16("page"), GetFindBarText());
   EXPECT_EQ(ASCIIToUTF16("1 of 1"), GetMatchCountText());
 
   // Close the Find box.
@@ skipping 18 matching lines @@
   // FindInPage on Mac doesn't use prepopulated values. Search there is global.
   return;
 #endif
 
   // First we navigate to any page.
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for the word "page".
   int ordinal = 0;
-  WebContents* web_contents_1 = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents_1 =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(1, FindInPageWchar(web_contents_1, L"page",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(ASCIIToUTF16("1 of 1"), GetMatchCountText());
 
   // Now create a second tab and load the same page.
   chrome::AddSelectedTabWithURL(browser(), url, content::PAGE_TRANSITION_TYPED);
-  WebContents* web_contents_2 = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents_2 =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_NE(web_contents_1, web_contents_2);
 
   // Open the Find box.
   EnsureFindBoxOpen();
 
   // The new tab should have "page" prepopulated, since that was the last search
   // in the first tab.
   EXPECT_EQ(ASCIIToUTF16("page"), GetFindBarText());
   // But it should not seem like a search has been issued.
   EXPECT_EQ(string16(), GetMatchCountText());
 }
 
 // This makes sure that we can search for A in tabA, then for B in tabB and
 // when we come back to tabA we should still see A (because that was the last
 // search in that tab).
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, PrepopulatePreserveLast) {
 #if defined(OS_MACOSX)
   // FindInPage on Mac doesn't use prepopulated values. Search there is global.
   return;
 #endif
 
   // First we navigate to any page.
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for the word "page".
   int ordinal = 0;
-  WebContents* web_contents_1 = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents_1 =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(1, FindInPageWchar(web_contents_1, L"page",
                                kFwd, kIgnoreCase, &ordinal));
 
   // Open the Find box.
   EnsureFindBoxOpen();
 
   EXPECT_EQ(ASCIIToUTF16("page"), GetFindBarText());
 
   // Close the Find box.
   browser()->GetFindBarController()->EndFindSession(
       FindBarController::kKeepSelectionOnPage,
       FindBarController::kKeepResultsInFindBox);
 
   // Now create a second tab and load the same page.
   chrome::AddBlankTabAt(browser(), -1, true);
   ui_test_utils::NavigateToURL(browser(), url);
-  WebContents* web_contents_2 = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents_2 =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_NE(web_contents_1, web_contents_2);
 
   // Search for the word "text".
   FindInPageWchar(web_contents_2, L"text", kFwd, kIgnoreCase, &ordinal);
 
   // Go back to the first tab and make sure we have NOT switched the prepopulate
   // text to "text".
-  chrome::ActivateTabAt(browser(), 0, false);
+  browser()->tab_strip_model()->ActivateTabAt(0, false);
 
   // Open the Find box.
   EnsureFindBoxOpen();
 
   // After the Find box has been reopened, it should have been prepopulated with
   // the word "page" again, since that was the last search in that tab.
   EXPECT_EQ(ASCIIToUTF16("page"), GetFindBarText());
 
   // Close the Find box.
   browser()->GetFindBarController()->EndFindSession(
@@ skipping 26 matching lines @@
   // FindInPage on Mac doesn't use prepopulated values. Search there is global.
   return;
 #endif
 
   // First we navigate to the "simple" test page.
   GURL url = GetURL(kSimple);
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Search for the word "page" in the normal browser tab.
   int ordinal = 0;
-  WebContents* web_contents_1 = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents_1 =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(1, FindInPageWchar(web_contents_1, L"page",
                                kFwd, kIgnoreCase, &ordinal));
 
   // Open the Find box.
   EnsureFindBoxOpenForBrowser(browser());
   EXPECT_EQ(ASCIIToUTF16("page"), GetFindBarTextForBrowser(browser()));
 
   // Close the Find box.
   browser()->GetFindBarController()->EndFindSession(
       FindBarController::kKeepSelectionOnPage,
       FindBarController::kKeepResultsInFindBox);
 
   // Open a new incognito window and navigate to the same page.
   Profile* incognito_profile = browser()->profile()->GetOffTheRecordProfile();
   Browser* incognito_browser =
       new Browser(Browser::CreateParams(incognito_profile));
   content::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
       content::NotificationService::AllSources());
   chrome::AddSelectedTabWithURL(incognito_browser, url,
                                 content::PAGE_TRANSITION_AUTO_TOPLEVEL);
   observer.Wait();
   incognito_browser->window()->Show();
 
   // Open the find box and make sure that it is prepopulated with "page".
   EnsureFindBoxOpenForBrowser(incognito_browser);
   EXPECT_EQ(ASCIIToUTF16("page"), GetFindBarTextForBrowser(incognito_browser));
 
   // Search for the word "text" in the incognito tab.
-  WebContents* incognito_tab = chrome::GetActiveWebContents(incognito_browser);
+  WebContents* incognito_tab =
+      incognito_browser->tab_strip_model()->GetActiveWebContents();
   EXPECT_EQ(1, FindInPageWchar(incognito_tab, L"text",
                                kFwd, kIgnoreCase, &ordinal));
   EXPECT_EQ(ASCIIToUTF16("text"), GetFindBarTextForBrowser(incognito_browser));
 
   // Close the Find box.
   incognito_browser->GetFindBarController()->EndFindSession(
       FindBarController::kKeepSelectionOnPage,
       FindBarController::kKeepResultsInFindBox);
 
   // Now open a new tab in the original (non-incognito) browser.
   chrome::AddSelectedTabWithURL(browser(), url, content::PAGE_TRANSITION_TYPED);
-  WebContents* web_contents_2 = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents_2 =
+      browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_NE(web_contents_1, web_contents_2);
 
   // Open the Find box and make sure it is prepopulated with the search term
   // from the original browser, not the search term from the incognito window.
   EnsureFindBoxOpenForBrowser(browser());
   EXPECT_EQ(ASCIIToUTF16("page"), GetFindBarTextForBrowser(browser()));
 }
 
 // This makes sure that dismissing the find bar with kActivateSelection works.
 IN_PROC_BROWSER_TEST_F(FindInPageControllerTest, ActivateLinkNavigatesPage) {
   // First we navigate to our test content.
   GURL url = GetURL(kLinkPage);
   ui_test_utils::NavigateToURL(browser(), url);
 
-  WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
   FindTabHelper* find_tab_helper =
       FindTabHelper::FromWebContents(web_contents);
 
   int ordinal = 0;
   FindInPageWchar(web_contents, L"link", kFwd, kIgnoreCase, &ordinal);
   EXPECT_EQ(ordinal, 1);
 
   // End the find session, click on the link.
   content::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
@@ skipping 70 matching lines @@
   content::RunAllPendingInMessageLoop();  // Needed on Linux.
   EXPECT_TRUE(GetFindBarWindowInfo(&position, NULL));
 
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   chrome::CloseTab(browser());
   EXPECT_TRUE(GetFindBarWindowInfo(&position2, NULL));
   EXPECT_EQ(position, position2);
 }