Replace Browser::GetTabContentsAt with GetWebContentsAt and update all callers.

chrome/browser/browser_keyevents_browsertest.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 "build/build_config.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/ui/browser.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/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
-#include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/web_contents.h"
 #include "net/test/test_server.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 
 namespace {
 
 const char kTestingPage[] = "files/keyevents_test.html";
 const wchar_t kSuppressEventJS[] =
     L"window.domAutomationController.send(setDefaultAction('%ls', %ls));";
 const wchar_t kGetResultJS[] =
     L"window.domAutomationController.send(keyEventResult[%d]);";
@@ skipping 101 matching lines @@
     ui_test_utils::ClickOnView(browser(), vid);
   }
 
   // Set the suppress flag of an event specified by |type|. If |suppress| is
   // true then the web page will suppress all events with |type|. Following
   // event types are supported: keydown, keypress, keyup and textInput.
   void SuppressEventByType(int tab_index, const wchar_t* type, bool suppress) {
     ASSERT_LT(tab_index, browser()->tab_count());
     bool actual;
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-        browser()->GetTabContentsAt(tab_index)->GetRenderViewHost(),
+        browser()->GetWebContentsAt(tab_index)->GetRenderViewHost(),
         L"",
         base::StringPrintf(kSuppressEventJS, type, GetBoolString(!suppress)),
         &actual));
     ASSERT_EQ(!suppress, actual);
   }
 
   void SuppressEvents(int tab_index, bool keydown, bool keypress,
                       bool keyup, bool textinput) {
     ASSERT_NO_FATAL_FAILURE(
         SuppressEventByType(tab_index, L"keydown", keydown));
     ASSERT_NO_FATAL_FAILURE(
         SuppressEventByType(tab_index, L"keypress", keypress));
     ASSERT_NO_FATAL_FAILURE(
         SuppressEventByType(tab_index, L"keyup", keyup));
     ASSERT_NO_FATAL_FAILURE(
         SuppressEventByType(tab_index, L"textInput", textinput));
   }
 
   void SuppressAllEvents(int tab_index, bool suppress) {
     SuppressEvents(tab_index, suppress, suppress, suppress, suppress);
   }
 
   void GetResultLength(int tab_index, int* length) {
     ASSERT_LT(tab_index, browser()->tab_count());
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractInt(
-        browser()->GetTabContentsAt(tab_index)->GetRenderViewHost(),
+        browser()->GetWebContentsAt(tab_index)->GetRenderViewHost(),
         L"", kGetResultLengthJS, length));
   }
 
   void CheckResult(int tab_index, int length, const char* const result[]) {
     ASSERT_LT(tab_index, browser()->tab_count());
     int actual_length;
     ASSERT_NO_FATAL_FAILURE(GetResultLength(tab_index, &actual_length));
     ASSERT_GE(actual_length, length);
     for (int i = 0; i < actual_length; ++i) {
       std::string actual;
       ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractString(
-          browser()->GetTabContentsAt(tab_index)->GetRenderViewHost(),
+          browser()->GetWebContentsAt(tab_index)->GetRenderViewHost(),
           L"", base::StringPrintf(kGetResultJS, i), &actual));
 
       // If more events were received than expected, then the additional events
       // must be keyup events.
       if (i < length)
         ASSERT_STREQ(result[i], actual.c_str());
       else
         ASSERT_EQ('U', actual[0]);
     }
   }
 
   void CheckFocusedElement(int tab_index, const wchar_t* focused) {
     ASSERT_LT(tab_index, browser()->tab_count());
     std::string actual;
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractString(
-        browser()->GetTabContentsAt(tab_index)->GetRenderViewHost(),
+        browser()->GetWebContentsAt(tab_index)->GetRenderViewHost(),
         L"", kGetFocusedElementJS, &actual));
     ASSERT_EQ(WideToUTF8(focused), actual);
   }
 
   void SetFocusedElement(int tab_index, const wchar_t* focused) {
     ASSERT_LT(tab_index, browser()->tab_count());
     bool actual;
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-        browser()->GetTabContentsAt(tab_index)->GetRenderViewHost(),
+        browser()->GetWebContentsAt(tab_index)->GetRenderViewHost(),
         L"",
         base::StringPrintf(kSetFocusedElementJS, focused),
         &actual));
     ASSERT_TRUE(actual);
   }
 
   void CheckTextBoxValue(int tab_index, const wchar_t* id,
                          const wchar_t* value) {
     ASSERT_LT(tab_index, browser()->tab_count());
     std::string actual;
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractString(
-        browser()->GetTabContentsAt(tab_index)->GetRenderViewHost(),
+        browser()->GetWebContentsAt(tab_index)->GetRenderViewHost(),
         L"",
         base::StringPrintf(kGetTextBoxValueJS, id),
         &actual));
     ASSERT_EQ(WideToUTF8(value), actual);
   }
 
   void SetTextBoxValue(int tab_index, const wchar_t* id,
                        const wchar_t* value) {
     ASSERT_LT(tab_index, browser()->tab_count());
     std::string actual;
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractString(
-        browser()->GetTabContentsAt(tab_index)->GetRenderViewHost(),
+        browser()->GetWebContentsAt(tab_index)->GetRenderViewHost(),
         L"",
         base::StringPrintf(kSetTextBoxValueJS, id, value),
         &actual));
     ASSERT_EQ(WideToUTF8(value), actual);
   }
 
   void StartTest(int tab_index, int result_length) {
     ASSERT_LT(tab_index, browser()->tab_count());
     bool actual;
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-        browser()->GetTabContentsAt(tab_index)->GetRenderViewHost(),
+        browser()->GetWebContentsAt(tab_index)->GetRenderViewHost(),
         L"", base::StringPrintf(kStartTestJS, result_length), &actual));
     ASSERT_TRUE(actual);
   }
 
   void TestKeyEvent(int tab_index, const KeyEventTestData& test) {
     ASSERT_LT(tab_index, browser()->tab_count());
     ASSERT_EQ(tab_index, browser()->active_index());
 
     // Inform our testing web page that we are about to start testing a key
     // event.
     ASSERT_NO_FATAL_FAILURE(StartTest(tab_index, test.result_length));
     ASSERT_NO_FATAL_FAILURE(SuppressEvents(
         tab_index, test.suppress_keydown, test.suppress_keypress,
         test.suppress_keyup, test.suppress_textinput));
 
     // We need to create a finish observer before sending the key event,
     // because the test finished message might be arrived before returning
     // from the SendKeyPressSync() method.
     TestFinishObserver finish_observer(
-        browser()->GetTabContentsAt(tab_index)->GetRenderViewHost());
+        browser()->GetWebContentsAt(tab_index)->GetRenderViewHost());
 
     ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
         browser(), test.key, test.ctrl, test.shift, test.alt, test.command));
     ASSERT_TRUE(finish_observer.WaitForFinish());
     ASSERT_NO_FATAL_FAILURE(CheckResult(
         tab_index, test.result_length, test.result));
   }
 
   std::string GetTestDataDescription(const KeyEventTestData& data) {
     std::string desc = base::StringPrintf(
@@ skipping 431 matching lines @@
   // Make sure the focus is in the testing page.
   ASSERT_NO_FATAL_FAILURE(ClickOnView(VIEW_ID_TAB_CONTAINER));
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Reserved accelerators can't be suppressed.
   ASSERT_NO_FATAL_FAILURE(SuppressAllEvents(1, true));
 
   ui_test_utils::WindowedNotificationObserver wait_for_tab_closed(
       content::NOTIFICATION_TAB_CLOSED,
       content::Source<content::NavigationController>(
-          &browser()->GetTabContentsAt(1)->GetController()));
+          &browser()->GetWebContentsAt(1)->GetController()));
 
   // Press Ctrl/Cmd+W, which will close the tab.
 #if defined(OS_MACOSX)
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
       browser(), ui::VKEY_W, false, false, false, true));
 #else
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
       browser(), ui::VKEY_W, true, false, false, false));
 #endif
 
@@ skipping 130 matching lines @@
   EXPECT_NO_FATAL_FAILURE(TestKeyEvent(tab_index, kTestAltKeySuppress));
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Ctrl+Alt should have no effect.
   EXPECT_NO_FATAL_FAILURE(TestKeyEvent(tab_index, kTestCtrlAltKey));
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 }
 #endif
 
 }  // namespace