TabContentsWrapper -> TabContents, part 41.

chrome/browser/ui/gtk/browser_window_gtk.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 "chrome/browser/ui/gtk/browser_window_gtk.h"
 
 #include <dlfcn.h>
 #include <gdk/gdkkeysyms.h>
 
 #include <algorithm>
@@ skipping 56 matching lines @@
 #include "chrome/browser/ui/gtk/reload_button_gtk.h"
 #include "chrome/browser/ui/gtk/status_bubble_gtk.h"
 #include "chrome/browser/ui/gtk/tab_contents_container_gtk.h"
 #include "chrome/browser/ui/gtk/tabs/tab_strip_gtk.h"
 #include "chrome/browser/ui/gtk/task_manager_gtk.h"
 #include "chrome/browser/ui/gtk/update_recommended_dialog.h"
 #include "chrome/browser/ui/gtk/website_settings_popup_gtk.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
 #include "chrome/browser/ui/page_info_bubble.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
@@ skipping 738 matching lines @@
     titlebar_->UpdateTitleAndIcon();
 }
 
 void BrowserWindowGtk::BookmarkBarStateChanged(
     BookmarkBar::AnimateChangeType change_type) {
   MaybeShowBookmarkBar(change_type == BookmarkBar::ANIMATE_STATE_CHANGE);
 }
 
 void BrowserWindowGtk::UpdateDevTools() {
   UpdateDevToolsForContents(
-      browser_->GetSelectedWebContents());
+      browser_->GetActiveWebContents());
 }
 
 void BrowserWindowGtk::SetDevToolsDockSide(DevToolsDockSide side) {
   if (devtools_dock_side_ == side)
     return;
 
   if (devtools_container_->tab()) {
     HideDevToolsContainer();
     devtools_dock_side_ = side;
     ShowDevToolsContainer();
@@ skipping 22 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.
-    WebContents* web_contents = browser_->GetSelectedWebContents();
+    WebContents* web_contents = browser_->GetActiveWebContents();
     // 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(web_contents);
   }
 }
 
 void BrowserWindowGtk::SetStarredState(bool is_starred) {
   toolbar_->GetLocationBarView()->SetStarred(is_starred);
 }
@@ skipping 101 matching lines @@
   if (!IsFullscreen())
     GetLocationBar()->FocusLocation(select_all);
 }
 
 void BrowserWindowGtk::UpdateReloadStopState(bool is_loading, bool force) {
   toolbar_->GetReloadButton()->ChangeMode(
       is_loading ? ReloadButtonGtk::MODE_STOP : ReloadButtonGtk::MODE_RELOAD,
       force);
 }
 
-void BrowserWindowGtk::UpdateToolbar(TabContentsWrapper* contents,
+void BrowserWindowGtk::UpdateToolbar(TabContents* contents,
                                      bool should_restore_state) {
   TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::UpdateToolbar");
   toolbar_->UpdateWebContents(contents->web_contents(), should_restore_state);
 }
 
 void BrowserWindowGtk::FocusToolbar() {
   NOTIMPLEMENTED();
 }
 
 void BrowserWindowGtk::FocusAppMenu() {
@@ skipping 111 matching lines @@
 void BrowserWindowGtk::ShowPageInfo(Profile* profile,
                                     const GURL& url,
                                     const SSLStatus& ssl,
                                     bool show_history) {
   browser::ShowPageInfoBubble(window_, profile, url, ssl, show_history,
                               browser_.get());
 }
 
 void BrowserWindowGtk::ShowWebsiteSettings(
     Profile* profile,
-    TabContentsWrapper* tab_contents_wrapper,
+    TabContents* tab_contents,
     const GURL& url,
     const content::SSLStatus& ssl,
     bool show_history) {
     WebsiteSettingsPopupGtk::Show(GetNativeWindow(), profile,
-                                  tab_contents_wrapper, url, ssl);
+                                  tab_contents, url, ssl);
 }
 
 void BrowserWindowGtk::ShowAppMenu() {
   toolbar_->ShowAppMenu();
 }
 
 bool BrowserWindowGtk::PreHandleKeyboardEvent(
     const NativeWebKeyboardEvent& event, bool* is_keyboard_shortcut) {
   GdkEventKey* os_event = &event.os_event->key;
 
@@ skipping 68 matching lines @@
   // It's not necessary to care about the keyboard layout, as
   // gtk_window_activate_key() takes care of it automatically.
   int id = GetCustomCommandId(os_event);
   if (id != -1)
     browser_->ExecuteCommandIfEnabled(id);
   else
     gtk_window_activate_key(window_, os_event);
 }
 
 void BrowserWindowGtk::ShowCreateWebAppShortcutsDialog(
-    TabContentsWrapper* tab_contents) {
+    TabContents* tab_contents) {
   CreateWebApplicationShortcutsDialogGtk::Show(window_, tab_contents);
 }
 
 void BrowserWindowGtk::ShowCreateChromeAppShortcutsDialog(
     Profile* profile, const extensions::Extension* app) {
   CreateChromeApplicationShortcutsDialogGtk::Show(window_, profile, app);
 }
 
 void BrowserWindowGtk::Cut() {
   gtk_util::DoCut(this);
 }
 
 void BrowserWindowGtk::Copy() {
   gtk_util::DoCopy(this);
 }
 
 void BrowserWindowGtk::Paste() {
   gtk_util::DoPaste(this);
 }
 
-void BrowserWindowGtk::ShowInstant(TabContentsWrapper* preview) {
+void BrowserWindowGtk::ShowInstant(TabContents* preview) {
   contents_container_->SetPreview(preview);
   MaybeShowBookmarkBar(false);
 }
 
 void BrowserWindowGtk::HideInstant() {
   contents_container_->PopPreview();
   MaybeShowBookmarkBar(false);
 }
 
 gfx::Rect BrowserWindowGtk::GetInstantBounds() {
@@ skipping 18 matching lines @@
 
 void BrowserWindowGtk::ShowAvatarBubbleFromAvatarButton() {
   if (titlebar_->avatar_button())
     titlebar_->avatar_button()->ShowAvatarBubble();
 }
 
 void BrowserWindowGtk::ShowPasswordGenerationBubble(
     const gfx::Rect& rect,
     autofill::PasswordGenerator* password_generator,
     const webkit::forms::PasswordForm& form) {
-  WebContents* web_contents = browser_->GetSelectedWebContents();
+  WebContents* web_contents = browser_->GetActiveWebContents();
   if (!web_contents || !web_contents->GetContentNativeView()) {
     return;
   }
 
-  TabContentsWrapper* tab_contents =
-      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
   if (!tab_contents)
     return;
 
   new PasswordGenerationBubbleGtk(rect,
                                   form,
                                   web_contents->GetContentNativeView(),
                                   browser()->profile(),
                                   web_contents->GetRenderViewHost(),
                                   password_generator,
                                   tab_contents->password_manager());
@@ skipping 18 matching lines @@
     }
     case chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED:
       // The profile avatar icon may have changed.
       gtk_util::SetWindowIcon(window_, browser_->profile());
       break;
     default:
       break;
   }
 }
 
-void BrowserWindowGtk::TabDetachedAt(TabContentsWrapper* contents, int index) {
+void BrowserWindowGtk::TabDetachedAt(TabContents* 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_->GetSelectedWebContents() will return NULL or something else.
+  // browser_->GetActiveWebContents() will return NULL or something else.
   if (index == browser_->active_index()) {
     infobar_container_->ChangeTabContents(NULL);
     UpdateDevToolsForContents(NULL);
   }
   contents_container_->DetachTab(contents);
 }
 
-void BrowserWindowGtk::ActiveTabChanged(TabContentsWrapper* old_contents,
-                                        TabContentsWrapper* new_contents,
+void BrowserWindowGtk::ActiveTabChanged(TabContents* old_contents,
+                                        TabContents* new_contents,
                                         int index,
                                         bool user_gesture) {
   TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::ActiveTabChanged");
   if (old_contents && !old_contents->in_destructor())
     old_contents->web_contents()->GetView()->StoreFocus();
 
   // Update various elements that are interested in knowing the current
   // WebContents.
   UpdateDevToolsForContents(new_contents->web_contents());
   infobar_container_->ChangeTabContents(new_contents->infobar_tab_helper());
@@ skipping 58 matching lines @@
     NOTREACHED();
   }
   return true;
 }
 
 void BrowserWindowGtk::MaybeShowBookmarkBar(bool animate) {
   TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::MaybeShowBookmarkBar");
   if (!IsBookmarkBarSupported())
     return;
 
-  TabContentsWrapper* tab = GetDisplayedTab();
+  TabContents* tab = GetDisplayedTab();
 
   if (tab)
     bookmark_bar_->SetPageNavigator(browser_.get());
 
   BookmarkBar::State state = browser_->bookmark_bar_state();
   if (contents_container_->HasPreview() && state == BookmarkBar::DETACHED)
     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(WebContents* contents) {
   TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::UpdateDevToolsForContents");
-  TabContentsWrapper* old_devtools = devtools_container_->tab();
-  TabContentsWrapper* devtools_contents = contents ?
+  TabContents* old_devtools = devtools_container_->tab();
+  TabContents* 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) {
     // WebContentsViewGtk::WasShown is not called when tab contents is shown by
@@ skipping 79 matching lines @@
   gfx::Rect bounds(event->x, event->y, event->width, event->height);
 
   // When the window moves, we'll get multiple configure-event signals. We can
   // also get events when the bounds haven't changed, but the window's stacking
   // has, which we aren't interested in. http://crbug.com/70125
   if (bounds == configure_bounds_)
     return FALSE;
 
   GetLocationBar()->GetLocationEntry()->ClosePopup();
 
-  TabContentsWrapper* tab = GetDisplayedTab();
+  TabContents* tab = GetDisplayedTab();
   if (tab) {
     tab->web_contents()->GetRenderViewHost()->NotifyMoveOrResizeStarted();
   }
 
   if (bounds_.size() != bounds.size())
     OnSizeChanged(bounds.width(), bounds.height());
 
   // We update |bounds_| but not |restored_bounds_| here.  The latter needs
   // to be updated conditionally when the window is non-maximized and non-
   // fullscreen, but whether those state updates have been processed yet is
@@ skipping 188 matching lines @@
   // is the case in Valgrind tests).
   if (ui::XDisplayExists() &&
       !prefs->HasPrefPath(prefs::kUseCustomChromeFrame)) {
     custom_frame_default = GetCustomFramePrefDefault();
   }
   prefs->RegisterBooleanPref(prefs::kUseCustomChromeFrame,
                              custom_frame_default,
                              PrefService::SYNCABLE_PREF);
 }
 
-TabContentsWrapper* BrowserWindowGtk::GetDisplayedTab() {
+TabContents* BrowserWindowGtk::GetDisplayedTab() {
   return contents_container_->GetVisibleTab();
 }
 
 void BrowserWindowGtk::QueueToolbarRedraw() {
   gtk_widget_queue_draw(toolbar_->widget());
 }
 
 void BrowserWindowGtk::SetGeometryHints() {
   // If we call gtk_window_maximize followed by gtk_window_present, compiz gets
   // confused and maximizes the window, but doesn't set the
@@ skipping 450 matching lines @@
 // Let the focused widget have first crack at the key event so we don't
 // override their accelerators, except if there is a priority keybinding
 // handler registered (it should take precedence).
 gboolean BrowserWindowGtk::OnKeyPress(GtkWidget* widget, GdkEventKey* event) {
   if (extension_keybinding_registry_->HasPriorityHandler(event))
     return FALSE;
 
   // If a widget besides the native view is focused, we have to try to handle
   // the custom accelerators before letting it handle them.
   WebContents* current_web_contents =
-      browser()->GetSelectedWebContents();
+      browser()->GetActiveWebContents();
   // The current tab might not have a render view if it crashed.
   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;
 
@@ skipping 368 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;
 }