Move tab functions off Browser into browser_tabstrip and browser_tabrestore.

chrome/browser/ui/pdf/pdf_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/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/snapshot_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 55 matching lines @@
 
     GURL url(ui_test_utils::GetTestUrl(
         GetPDFTestDir(),
         FilePath(FILE_PATH_LITERAL("pdf_browsertest.pdf"))));
     ui_test_utils::NavigateToURL(browser(), url);
   }
 
   void VerifySnapshot(const std::string& expected_filename) {
     snapshot_different_ = true;
     expected_filename_ = expected_filename;
-    TabContents* tab_contents =  browser()->GetActiveTabContents();
+    TabContents* tab_contents =  chrome::GetActiveTabContents(browser());
     tab_contents->snapshot_tab_helper()->CaptureSnapshot();
     ui_test_utils::RegisterAndWait(
         this,
         chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN,
         content::Source<WebContents>(tab_contents->web_contents()));
     ASSERT_FALSE(snapshot_different_) << "Rendering didn't match, see result "
         "at " << snapshot_filename_.value().c_str();
   }
 
   void WaitForResponse() {
     // Even if the plugin has loaded the data or scrolled, because of how
     // pepper painting works, we might not have the data.  One way to force this
     // to be flushed is to do a find operation, since on this two-page test
     // document, it'll wait for us to flush the renderer message loop twice and
     // also the browser's once, at which point we're guaranteed to have updated
     // the backingstore.  Hacky, but it works.
     // Note that we need to change the text each time, because if we don't the
     // renderer code will think the second message is to go to next result, but
     // there are none so the plugin will assert.
 
     string16 query = UTF8ToUTF16(
         std::string("xyzxyz" + base::IntToString(next_dummy_search_value_++)));
     ASSERT_EQ(0, ui_test_utils::FindInPage(
-        browser()->GetActiveTabContents(), query, true, false, NULL));
+        chrome::GetActiveTabContents(browser()), query, true, false, NULL));
   }
 
  private:
   // content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) {
     if (type == chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN) {
       MessageLoopForUI::current()->Quit();
       FilePath reference = ui_test_utils::GetTestFilePath(
@@ skipping 109 matching lines @@
 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, MAYBE_Scroll) {
   ASSERT_NO_FATAL_FAILURE(Load());
 
   // We use wheel mouse event since that's the only one we can easily push to
   // the renderer.  There's no way to push a cross-platform keyboard event at
   // the moment.
   WebKit::WebMouseWheelEvent wheel_event;
   wheel_event.type = WebKit::WebInputEvent::MouseWheel;
   wheel_event.deltaY = -200;
   wheel_event.wheelTicksY = -2;
-  WebContents* web_contents = browser()->GetActiveWebContents();
+  WebContents* web_contents = chrome::GetActiveWebContents(browser());
   web_contents->GetRenderViewHost()->ForwardWheelEvent(wheel_event);
   ASSERT_NO_FATAL_FAILURE(WaitForResponse());
 
   int y_offset = 0;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractInt(
-      browser()->GetActiveWebContents()->GetRenderViewHost(),
+      chrome::GetActiveWebContents(browser())->GetRenderViewHost(),
       std::wstring(),
       L"window.domAutomationController.send(plugin.pageYOffset())",
       &y_offset));
   ASSERT_GT(y_offset, 0);
 }
 
 #if defined(OS_CHROMEOS)
 // TODO(sanjeevr): http://crbug.com/79837
 #define MAYBE_FindAndCopy DISABLED_FindAndCopy
 #else
 #define MAYBE_FindAndCopy FindAndCopy
 #endif
 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, MAYBE_FindAndCopy) {
   ASSERT_NO_FATAL_FAILURE(Load());
   // Verifies that find in page works.
   ASSERT_EQ(3, ui_test_utils::FindInPage(
-      browser()->GetActiveTabContents(), UTF8ToUTF16("adipiscing"),
+      chrome::GetActiveTabContents(browser()), UTF8ToUTF16("adipiscing"),
       true, false, NULL));
 
   // Verify that copying selected text works.
   ui::Clipboard clipboard;
   // Reset the clipboard first.
   ui::Clipboard::ObjectMap objects;
   ui::Clipboard::ObjectMapParams params;
   params.push_back(std::vector<char>());
   objects[ui::Clipboard::CBF_TEXT] = params;
   clipboard.WriteObjects(ui::Clipboard::BUFFER_STANDARD, objects);
 
-  browser()->GetActiveWebContents()->GetRenderViewHost()->Copy();
+  chrome::GetActiveWebContents(browser())->GetRenderViewHost()->Copy();
   ASSERT_NO_FATAL_FAILURE(WaitForResponse());
 
   std::string text;
   clipboard.ReadAsciiText(ui::Clipboard::BUFFER_STANDARD, &text);
   ASSERT_EQ("adipiscing", text);
 }
 
 // Tests that loading async pdfs works correctly (i.e. document fully loads).
 // This also loads all documents that used to crash, to ensure we don't have
 // regressions.
 // If it flakes, reopen http://crbug.com/74548.
 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, SLOW_Loading) {
   ASSERT_TRUE(pdf_test_server()->Start());
 
   NavigationController* controller =
-      &(browser()->GetActiveWebContents()->GetController());
+      &(chrome::GetActiveWebContents(browser())->GetController());
   content::NotificationRegistrar registrar;
   registrar.Add(this,
                 content::NOTIFICATION_LOAD_STOP,
                 content::Source<NavigationController>(controller));
   std::string base_url = std::string("files/");
 
   file_util::FileEnumerator file_enumerator(
       ui_test_utils::GetTestFilePath(GetPDFTestDir(), FilePath()),
       false,
       file_util::FileEnumerator::FILES,
@@ skipping 14 matching lines @@
     GURL url = pdf_test_server()->GetURL(base_url + filename);
     ui_test_utils::NavigateToURL(browser(), url);
 
     while (true) {
       int last_count = load_stop_notification_count();
       // We might get extraneous chrome::LOAD_STOP notifications when
       // doing async loading.  This happens when the first loader is cancelled
       // and before creating a byte-range request loader.
       bool complete = false;
       ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-          browser()->GetActiveWebContents()->GetRenderViewHost(),
+          chrome::GetActiveWebContents(browser())->GetRenderViewHost(),
           std::wstring(),
           L"window.domAutomationController.send(plugin.documentLoadComplete())",
           &complete));
       if (complete)
         break;
 
       // Check if the LOAD_STOP notification could have come while we run a
       // nested message loop for the JS call.
       if (last_count != load_stop_notification_count())
         continue;
-      ui_test_utils::WaitForLoadStop(browser()->GetActiveWebContents());
+      ui_test_utils::WaitForLoadStop(chrome::GetActiveWebContents(browser()));
     }
   }
 }
 
 // Flaky as per http://crbug.com/74549.
 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, DISABLED_OnLoadAndReload) {
   ASSERT_TRUE(pdf_test_server()->Start());
 
   GURL url = pdf_test_server()->GetURL("files/onload_reload.html");
   ui_test_utils::NavigateToURL(browser(), url);
 
   ui_test_utils::WindowedNotificationObserver observer(
       content::NOTIFICATION_LOAD_STOP,
       content::Source<NavigationController>(
-          &browser()->GetActiveWebContents()->GetController()));
+          &chrome::GetActiveWebContents(browser())->GetController()));
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScript(
-      browser()->GetActiveWebContents()->GetRenderViewHost(),
+      chrome::GetActiveWebContents(browser())->GetRenderViewHost(),
       std::wstring(),
       L"reloadPDF();"));
   observer.Wait();
 
-  ASSERT_EQ("success", browser()->GetActiveWebContents()->GetURL().query());
+  ASSERT_EQ("success",
+            chrome::GetActiveWebContents(browser())->GetURL().query());
 }
 
 }  // namespace