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

chrome/browser/ui/gtk/browser_window_gtk.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/gtk/browser_window_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include <dlfcn.h>
 #include <string>
@@ skipping 789 matching lines @@
     titlebar_->UpdateTitleAndIcon();
 }
 
 void BrowserWindowGtk::BookmarkBarStateChanged(
     BookmarkBar::AnimateChangeType change_type) {
   MaybeShowBookmarkBar(change_type == BookmarkBar::ANIMATE_STATE_CHANGE);
 }
 
 void BrowserWindowGtk::UpdateDevTools() {
   UpdateDevToolsForContents(
-      browser_->GetSelectedTabContents());
+      browser_->GetSelectedWebContents());
 }
 
 void BrowserWindowGtk::SetDevToolsDockSide(DevToolsDockSide side)
 {
   if (devtools_dock_side_ == side)
     return;
 
   if (contents_split_) {
     HideDevToolsContainer();
     devtools_dock_side_ = side;
@@ skipping 23 matching lines @@
 void BrowserWindowGtk::LoadingAnimationCallback() {
   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();
+    WebContents* web_contents = browser_->GetSelectedTabContents();
     // GetSelectedTabContents can return NULL for example under Purify when
     // the animations are running slowly and this function is called on
     // a timer through LoadingAnimationCallback.
-    titlebar_->UpdateThrobber(tab_contents);
+    titlebar_->UpdateThrobber(web_contents);
   }
 }
 
 void BrowserWindowGtk::SetStarredState(bool is_starred) {
   toolbar_->GetLocationBarView()->SetStarred(is_starred);
 }
 
 gfx::Rect BrowserWindowGtk::GetRestoredBounds() const {
   return restored_bounds_;
 }
@@ skipping 389 matching lines @@
     }
 
     default:
       NOTREACHED() << "Got a notification we didn't register for!";
   }
 }
 
 void BrowserWindowGtk::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()) {
     infobar_container_->ChangeTabContents(NULL);
     UpdateDevToolsForContents(NULL);
   }
   contents_container_->DetachTab(contents);
 }
 
 void BrowserWindowGtk::ActiveTabChanged(TabContentsWrapper* old_contents,
                                         TabContentsWrapper* new_contents,
                                         int index,
                                         bool user_gesture) {
   TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::ActiveTabChanged");
   if (old_contents && !old_contents->tab_contents()->IsBeingDestroyed())
     old_contents->tab_contents()->GetView()->StoreFocus();
 
   // Update various elements that are interested in knowing the current
   // TabContents.
-  UpdateDevToolsForContents(new_contents->tab_contents());
+  UpdateDevToolsForContents(new_contents->web_contents());
   infobar_container_->ChangeTabContents(new_contents->infobar_tab_helper());
   contents_container_->SetTab(new_contents);
 
   new_contents->tab_contents()->DidBecomeSelected();
   // TODO(estade): after we manage browser activation, add a check to make sure
   // we are the active browser before calling RestoreFocus().
   if (!browser_->tabstrip_model()->closing_all()) {
     new_contents->tab_contents()->GetView()->RestoreFocus();
     if (new_contents->find_tab_helper()->find_ui_active())
       browser_->GetFindBarController()->find_bar()->SetFocusAndSelection();
@@ skipping 66 matching lines @@
     state = BookmarkBar::HIDDEN;
 
   toolbar_->UpdateForBookmarkBarVisibility(state == BookmarkBar::DETACHED);
   PlaceBookmarkBar(state == BookmarkBar::DETACHED);
   bookmark_bar_->SetBookmarkBarState(
       state,
       animate ? BookmarkBar::ANIMATE_STATE_CHANGE :
                 BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
 }
 
-void BrowserWindowGtk::UpdateDevToolsForContents(TabContents* contents) {
+void BrowserWindowGtk::UpdateDevToolsForContents(WebContents* contents) {
   TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::UpdateDevToolsForContents");
   TabContentsWrapper* old_devtools = devtools_container_->tab();
   TabContentsWrapper* devtools_contents = contents ?
       DevToolsWindow::GetDevToolsContents(contents) : NULL;
   if (old_devtools == devtools_contents)
     return;
 
   if (old_devtools)
     devtools_container_->DetachTab(old_devtools);
 
   devtools_container_->SetTab(devtools_contents);
   if (devtools_contents) {
     // TabContentsViewGtk::WasShown is not called when tab contents is shown by
     // anything other than user selecting a Tab.
     // See TabContentsViewViews::OnWindowPosChanged for reference on how it
     // should be implemented.
-    devtools_contents->tab_contents()->ShowContents();
+    devtools_contents->web_contents()->ShowContents();
   }
 
   bool should_show = old_devtools == NULL && devtools_contents != NULL;
   bool should_hide = old_devtools != NULL && devtools_contents == NULL;
 
   if (should_show)
     ShowDevToolsContainer();
   else if (should_hide)
     HideDevToolsContainer();
 }
@@ skipping 722 matching lines @@
       GetBrowserWindowForNativeWindow(GTK_WINDOW(acceleratable));
   DCHECK(browser_window != NULL);
   return browser_window->browser()->ExecuteCommandIfEnabled(command_id);
 }
 
 // Let the focused widget have first crack at the key event so we don't
 // override their accelerators.
 gboolean BrowserWindowGtk::OnKeyPress(GtkWidget* widget, GdkEventKey* event) {
   // If a widget besides the native view is focused, we have to try to handle
   // the custom accelerators before letting it handle them.
-  TabContents* current_tab_contents =
-      browser()->GetSelectedTabContents();
+  WebContents* current_web_contents =
+      browser()->GetSelectedWebContents();
   // The current tab might not have a render view if it crashed.
-  if (!current_tab_contents || !current_tab_contents->GetContentNativeView() ||
-      !gtk_widget_is_focus(current_tab_contents->GetContentNativeView())) {
+  if (!current_web_contents || !current_web_contents->GetContentNativeView() ||
+      !gtk_widget_is_focus(current_web_contents->GetContentNativeView())) {
     int command_id = GetCustomCommandId(event);
     if (command_id == -1)
       command_id = GetPreHandleCommandId(event);
 
     if (command_id != -1 && browser_->ExecuteCommandIfEnabled(command_id))
       return TRUE;
 
     // Propagate the key event to child widget first, so we don't override their
     // accelerators.
     if (!gtk_window_propagate_key_event(GTK_WINDOW(widget), event)) {
@@ skipping 367 matching lines @@
           wm_type == ui::WM_OPENBOX ||
           wm_type == ui::WM_XFWM4);
 }
 
 // static
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   BrowserWindowGtk* browser_window_gtk = new BrowserWindowGtk(browser);
   browser_window_gtk->Init();
   return browser_window_gtk;
 }