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

chrome/browser/ui/views/frame/browser_view.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 "chrome/browser/ui/views/frame/browser_view.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 201 matching lines @@
 void BookmarkExtensionBackground::Paint(gfx::Canvas* canvas,
                                         views::View* view) const {
   ui::ThemeProvider* tp = host_view_->GetThemeProvider();
   int toolbar_overlap = host_view_->GetToolbarOverlap();
   // The client edge is drawn below the toolbar bounds.
   if (toolbar_overlap)
     toolbar_overlap += views::NonClientFrameView::kClientEdgeThickness;
   if (host_view_->IsDetached()) {
     // Draw the background to match the new tab page.
     int height = 0;
-    TabContents* contents = browser_->GetSelectedTabContents();
+    WebContents* contents = browser_->GetSelectedWebContents();
     if (contents && contents->GetView())
       height = contents->GetView()->GetContainerSize().height();
     NtpBackgroundUtil::PaintBackgroundDetachedMode(
         host_view_->GetThemeProvider(), canvas,
         gfx::Rect(0, toolbar_overlap, host_view_->width(),
                   host_view_->height() - toolbar_overlap), height);
 
     // As 'hidden' according to the animation is the full in-tab state,
     // we invert the value - when current_state is at '0', we expect the
     // bar to be docked.
@@ skipping 299 matching lines @@
     if (active_browser && (browser_ != active_browser)) {
       active_browser->window()->FlashFrame();
       active_browser->window()->Activate();
     }
     AppModalDialogQueue::GetInstance()->ActivateModalDialog();
     return true;
   }
   return false;
 }
 
-TabContents* BrowserView::GetSelectedTabContents() const {
-  return browser_->GetSelectedTabContents();
+WebContents* BrowserView::GetSelectedWebContents() const {
+  return browser_->GetSelectedWebContents();
 }
 
 TabContentsWrapper* BrowserView::GetSelectedTabContentsWrapper() const {
   return browser_->GetSelectedTabContentsWrapper();
 }
 
 SkBitmap BrowserView::GetOTRAvatarIcon() const {
   static SkBitmap* otr_avatar_ = new SkBitmap();
 
   if (otr_avatar_->isNull()) {
@@ skipping 326 matching lines @@
     } else {
       ProcessFullscreen(true, GURL(),
                         FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION);
     }
   } else {
     ProcessFullscreen(false, GURL(), FEB_TYPE_NONE);
   }
 }
 
 void BrowserView::RestoreFocus() {
-  TabContents* selected_tab_contents = GetSelectedTabContents();
-  if (selected_tab_contents)
-    selected_tab_contents->GetView()->RestoreFocus();
+  WebContents* selected_web_contents = GetSelectedWebContents();
+  if (selected_web_contents)
+    selected_web_contents->GetView()->RestoreFocus();
 }
 
 LocationBar* BrowserView::GetLocationBar() const {
   return GetLocationBarView();
 }
 
 void BrowserView::SetFocusToLocationBar(bool select_all) {
 #if defined(OS_WIN)
   // On Windows changing focus to the location bar causes the browser window
   // to become active. This can steal focus if the user has another window
@@ skipping 410 matching lines @@
 
 void BrowserView::Paste() {
   ui_controls::SendKeyPress(GetNativeHandle(), ui::VKEY_V,
                             true, false, false, false);
 }
 
 void BrowserView::ShowInstant(TabContentsWrapper* preview) {
   if (!preview_container_)
     preview_container_ = new TabContentsContainer();
   contents_->SetPreview(preview_container_, preview->tab_contents());
-  preview_container_->ChangeTabContents(preview->tab_contents());
+  preview_container_->ChangeWebContents(preview->web_contents());
 }
 
 void BrowserView::HideInstant() {
   if (!preview_container_)
     return;
 
   // The contents must be changed before SetPreview is invoked.
-  preview_container_->ChangeTabContents(NULL);
+  preview_container_->ChangeWebContents(NULL);
   contents_->SetPreview(NULL, NULL);
   delete preview_container_;
   preview_container_ = NULL;
 }
 
 gfx::Rect BrowserView::GetInstantBounds() {
   return contents_->GetPreviewBounds();
 }
 
 WindowOpenDisposition BrowserView::GetDispositionForPopupBounds(
@@ skipping 54 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, content::NotificationObserver implementation:
 
 void BrowserView::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_SIDEBAR_CHANGED:
       if (content::Details<SidebarContainer>(details)->tab_contents() ==
-          browser_->GetSelectedTabContents()) {
+          browser_->GetSelectedWebContents()) {
         UpdateSidebar();
       }
       break;
 
     default:
       NOTREACHED() << "Got a notification we didn't register for!";
       break;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, TabStripModelObserver implementation:
 
 void BrowserView::TabDetachedAt(TabContentsWrapper* contents, int index) {
   // We use index here rather than comparing |contents| because by this time
   // the model has already removed |contents| from its list, so
-  // browser_->GetSelectedTabContents() will return NULL or something else.
+  // browser_->GetSelectedWebContents() will return NULL or something else.
   if (index == browser_->tabstrip_model()->active_index()) {
     // We need to reset the current tab contents to NULL before it gets
     // freed. This is because the focus manager performs some operations
     // on the selected TabContents when it is removed.
-    contents_container_->ChangeTabContents(NULL);
+    contents_container_->ChangeWebContents(NULL);
     infobar_container_->ChangeTabContents(NULL);
     UpdateSidebarForContents(NULL);
     UpdateDevToolsForContents(NULL);
   }
 }
 
 void BrowserView::TabDeactivated(TabContentsWrapper* contents) {
   // We do not store the focus when closing the tab to work-around bug 4633.
   // Some reports seem to show that the focus manager and/or focused view can
   // be garbage at that point, it is not clear why.
@@ skipping 14 matching lines @@
                                 int index) {
   if (index != browser_->tabstrip_model()->active_index())
     return;
 
   if (contents_->preview_tab_contents() == new_contents->tab_contents()) {
     // If 'preview' is becoming active, swap the 'active' and 'preview' and
     // delete what was the active.
     contents_->MakePreviewContentsActiveContents();
     TabContentsContainer* old_container = contents_container_;
     contents_container_ = preview_container_;
-    old_container->ChangeTabContents(NULL);
+    old_container->ChangeWebContents(NULL);
     delete old_container;
     preview_container_ = NULL;
   }
   // Update the UI for the new contents.
   ProcessTabSelected(new_contents);
 }
 
 void BrowserView::TabStripEmpty() {
   // Make sure all optional UI is removed before we are destroyed, otherwise
   // there will be consequences (since our view hierarchy will still have
@@ skipping 188 matching lines @@
 
 void BrowserView::OnWidgetActivationChanged(views::Widget* widget,
                                             bool active) {
   if (active) {
     BrowserList::SetLastActive(browser_.get());
     browser_->OnWindowActivated();
   }
 }
 
 void BrowserView::OnWindowBeginUserBoundsChange() {
-  TabContents* tab_contents = GetSelectedTabContents();
-  if (!tab_contents)
+  WebContents* web_contents = GetSelectedWebContents();
+  if (!web_contents)
     return;
-  tab_contents->GetRenderViewHost()->NotifyMoveOrResizeStarted();
+  web_contents->GetRenderViewHost()->NotifyMoveOrResizeStarted();
 }
 
 void BrowserView::OnWidgetMove() {
   if (!initialized_) {
     // Creating the widget can trigger a move. Ignore it until we've initialized
     // things.
     return;
   }
 
   // Cancel any tabstrip animations, some of them may be invalidated by the
@@ skipping 332 matching lines @@
   last_animation_time_ = now;
   if (browser_->is_type_tabbed()) {
     // Loading animations are shown in the tab for tabbed windows.  We check the
     // browser type instead of calling IsTabStripVisible() because the latter
     // will return false for fullscreen windows, but we still need to update
     // their animations (so that when they come out of fullscreen mode they'll
     // be correct).
     tabstrip_->UpdateLoadingAnimations();
   } else if (ShouldShowWindowIcon()) {
     // ... or in the window icon area for popups and app windows.
-    TabContents* tab_contents = browser_->GetSelectedTabContents();
-    // GetSelectedTabContents can return NULL for example under Purify when
+    WebContents* web_contents = browser_->GetSelectedWebContents();
+    // GetSelectedWebContents can return NULL for example under Purify when
     // the animations are running slowly and this function is called on a timer
     // through LoadingAnimationCallback.
-    frame_->UpdateThrobber(tab_contents && tab_contents->IsLoading());
+    frame_->UpdateThrobber(web_contents && web_contents->IsLoading());
   }
 }
 
 // BrowserView, private --------------------------------------------------------
 
 #if defined(OS_WIN) && !defined(USE_AURA)
 void BrowserView::InitSystemMenu() {
   system_menu_contents_.reset(new views::SystemMenuModel(this));
   // We add the menu items in reverse order so that insertion_index never needs
   // to change.
@@ skipping 71 matching lines @@
 
   bool visible = NULL != sidebar_contents &&
                  browser_->SupportsWindowFeature(Browser::FEATURE_SIDEBAR);
 
   bool should_show = visible && !sidebar_container_->visible();
   bool should_hide = !visible && sidebar_container_->visible();
 
   // Update sidebar content.
   TabContents* old_contents =
       static_cast<TabContents*>(sidebar_container_->web_contents());
-  sidebar_container_->ChangeTabContents(sidebar_contents);
+  sidebar_container_->ChangeWebContents(sidebar_contents);
   SidebarManager::GetInstance()->
       NotifyStateChanges(old_contents, sidebar_contents);
 
   // Update sidebar UI width.
   if (should_show) {
     // Restore split offset.
     int sidebar_width = g_browser_process->local_state()->GetInteger(
         prefs::kExtensionSidebarWidth);
     if (sidebar_width < 0) {
       // Initial load, set to default value.
@@ skipping 16 matching lines @@
         prefs::kExtensionSidebarWidth,
         sidebar_split_->width() - sidebar_split_->divider_offset());
 
     sidebar_container_->SetVisible(false);
     sidebar_split_->InvalidateLayout();
     Layout();
   }
 }
 
 void BrowserView::UpdateDevToolsForContents(TabContentsWrapper* wrapper) {
-  TabContents* devtools_contents = NULL;
+  WebContents* devtools_contents = NULL;
   if (wrapper) {
     TabContentsWrapper* devtools_contents_wrapper =
-        DevToolsWindow::GetDevToolsContents(wrapper->tab_contents());
+        DevToolsWindow::GetDevToolsContents(wrapper->web_contents());
     if (devtools_contents_wrapper)
-      devtools_contents = devtools_contents_wrapper->tab_contents();
+      devtools_contents = devtools_contents_wrapper->web_contents();
   }
 
   bool should_show = devtools_contents && !devtools_container_->visible();
   bool should_hide = !devtools_contents && devtools_container_->visible();
 
-  devtools_container_->ChangeTabContents(devtools_contents);
+  devtools_container_->ChangeWebContents(devtools_contents);
 
   if (should_show)
     ShowDevToolsContainer();
   else if (should_hide)
     HideDevToolsContainer();
 }
 
 void BrowserView::ShowDevToolsContainer() {
   if (!devtools_focus_tracker_.get()) {
     // Install devtools focus tracker when dev tools window is shown for the
@@ skipping 404 matching lines @@
     default:
       // Do nothing.
       break;
   }
 #endif
 }
 
 void BrowserView::ProcessTabSelected(TabContentsWrapper* new_contents) {
   // If |contents_container_| already has the correct TabContents, we can save
   // some work.  This also prevents extra events from being reported by the
-  // Visibility API under Windows, as ChangeTabContents will briefly hide
+  // Visibility API under Windows, as ChangeWebContents will briefly hide
   // the TabContents window.
   DCHECK(new_contents);
   bool change_tab_contents =
       contents_container_->web_contents() != new_contents->tab_contents();
 
   // Update various elements that are interested in knowing the current
   // TabContents.
 
   // When we toggle the NTP floating bookmarks bar and/or the info bar,
   // we don't want any TabContents to be attached, so that we
   // avoid an unnecessary resize and re-layout of a TabContents.
   if (change_tab_contents)
-    contents_container_->ChangeTabContents(NULL);
+    contents_container_->ChangeWebContents(NULL);
   infobar_container_->ChangeTabContents(new_contents->infobar_tab_helper());
   if (bookmark_bar_view_.get()) {
     bookmark_bar_view_->SetBookmarkBarState(
         browser_->bookmark_bar_state(),
         BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
   }
   UpdateUIForContents(new_contents);
   if (change_tab_contents)
-    contents_container_->ChangeTabContents(new_contents->tab_contents());
+    contents_container_->ChangeWebContents(new_contents->web_contents());
   UpdateSidebarForContents(new_contents);
 
   UpdateDevToolsForContents(new_contents);
-  // TODO(beng): This should be called automatically by ChangeTabContents, but I
+  // TODO(beng): This should be called automatically by ChangeWebContents, but I
   //             am striving for parity now rather than cleanliness. This is
   //             required to make features like Duplicate Tab, Undo Close Tab,
   //             etc not result in sad tab.
   new_contents->tab_contents()->DidBecomeSelected();
   if (BrowserList::GetLastActive() == browser_ &&
       !browser_->tabstrip_model()->closing_all() && GetWidget()->IsVisible()) {
     // We only restore focus if our window is visible, to avoid invoking blur
     // handlers when we are eventually shown.
     new_contents->tab_contents()->GetView()->RestoreFocus();
   }
@@ skipping 44 matching lines @@
   browser::CreateViewsBubble(bubble);
   bubble->SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble->Show();
 }
 
 void BrowserView::ShowAvatarBubbleFromAvatarButton() {
   AvatarMenuButton* button = frame_->GetAvatarMenuButton();
   if (button)
     button->ShowAvatarBubble();
 }