TabContentsWrapper -> TabContents, part 41.

chrome/browser/ui/gtk/tabs/tab_strip_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/tabs/tab_strip_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
 #include "chrome/browser/ui/gtk/custom_button.h"
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/tabs/dragged_tab_controller_gtk.h"
 #include "chrome/browser/ui/gtk/tabs/tab_strip_menu_controller.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "grit/ui_resources.h"
 #include "ui/base/animation/animation_delegate.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/base/dragdrop/gtk_dnd_util.h"
@@ skipping 805 matching lines @@
   bounds_ = bounds;
 }
 
 void TabStripGtk::UpdateLoadingAnimations() {
   for (int i = 0, index = 0; i < GetTabCount(); ++i, ++index) {
     TabGtk* current_tab = GetTabAt(i);
     if (current_tab->closing()) {
       --index;
     } else {
       TabRendererGtk::AnimationState state;
-      TabContentsWrapper* contents = model_->GetTabContentsAt(index);
+      TabContents* contents = model_->GetTabContentsAt(index);
       if (!contents || !contents->web_contents()->IsLoading()) {
         state = TabGtk::ANIMATION_NONE;
       } else if (contents->web_contents()->IsWaitingForResponse()) {
         state = TabGtk::ANIMATION_WAITING;
       } else {
         state = TabGtk::ANIMATION_LOADING;
       }
       if (current_tab->ValidateLoadingAnimation(state)) {
         // Queue the tab's icon area to be repainted.
         gfx::Rect favicon_bounds = current_tab->favicon_bounds();
@@ skipping 95 matching lines @@
       }
     }
   }
 
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabStripGtk, TabStripModelObserver implementation:
 
-void TabStripGtk::TabInsertedAt(TabContentsWrapper* contents,
+void TabStripGtk::TabInsertedAt(TabContents* contents,
                                 int index,
                                 bool foreground) {
   TRACE_EVENT0("ui::gtk", "TabStripGtk::TabInsertedAt");
 
   DCHECK(contents);
   DCHECK(index == TabStripModel::kNoTab || model_->ContainsIndex(index));
 
   StopAnimation();
 
   bool contains_tab = false;
@@ skipping 44 matching lines @@
     // if GTK paints before the animation event the tab is painted at 0x0
     // which is most likely not where it should be positioned.
     active_animation_->AnimationProgressed(NULL);
   } else {
     Layout();
   }
 
   ReStack();
 }
 
-void TabStripGtk::TabDetachedAt(TabContentsWrapper* contents, int index) {
+void TabStripGtk::TabDetachedAt(TabContents* contents, int index) {
   GenerateIdealBounds();
   StartRemoveTabAnimation(index, contents->web_contents());
   // Have to do this _after_ calling StartRemoveTabAnimation, so that any
   // previous remove is completed fully and index is valid in sync with the
   // model index.
   GetTabAt(index)->set_closing(true);
 }
 
-void TabStripGtk::ActiveTabChanged(TabContentsWrapper* old_contents,
-                                   TabContentsWrapper* new_contents,
+void TabStripGtk::ActiveTabChanged(TabContents* old_contents,
+                                   TabContents* new_contents,
                                    int index,
                                    bool user_gesture) {
   TRACE_EVENT0("ui::gtk", "TabStripGtk::ActiveTabChanged");
   ReStack();
 }
 
 void TabStripGtk::TabSelectionChanged(TabStripModel* tab_strip_model,
                                       const TabStripSelectionModel& old_model) {
   // We have "tiny tabs" if the tabs are so tiny that the unselected ones are
   // a different size to the selected ones.
@@ skipping 33 matching lines @@
                       old_model.selected_indices().end(),
                       model_->selection_model().selected_indices().begin(),
                       model_->selection_model().selected_indices().end(),
                       it2);
   for (std::vector<int>::iterator it = no_longer_selected.begin();
        it != no_longer_selected.end(); ++it) {
     GetTabAtAdjustForAnimation(*it)->StopMiniTabTitleAnimation();
   }
 }
 
-void TabStripGtk::TabMoved(TabContentsWrapper* contents,
+void TabStripGtk::TabMoved(TabContents* contents,
                            int from_index,
                            int to_index) {
   gfx::Rect start_bounds = GetIdealBounds(from_index);
   TabGtk* tab = GetTabAt(from_index);
   tab_data_.erase(tab_data_.begin() + from_index);
   TabData data = {tab, gfx::Rect()};
   tab->set_mini(model_->IsMiniTab(to_index));
   tab->SetBlocked(model_->IsTabBlocked(to_index));
   tab_data_.insert(tab_data_.begin() + to_index, data);
   GenerateIdealBounds();
   StartMoveTabAnimation(from_index, to_index);
   ReStack();
 }
 
-void TabStripGtk::TabChangedAt(TabContentsWrapper* contents, int index,
+void TabStripGtk::TabChangedAt(TabContents* contents, int index,
                                TabChangeType change_type) {
   // Index is in terms of the model. Need to make sure we adjust that index in
   // case we have an animation going.
   TabGtk* tab = GetTabAtAdjustForAnimation(index);
   if (change_type == TITLE_NOT_LOADING) {
     if (tab->mini() && !tab->IsActive())
       tab->StartMiniTabTitleAnimation();
     // We'll receive another notification of the change asynchronously.
     return;
   }
   tab->UpdateData(contents->web_contents(),
                   model_->IsAppTab(index),
                   change_type == LOADING_ONLY);
   tab->UpdateFromModel();
 }
 
 void TabStripGtk::TabReplacedAt(TabStripModel* tab_strip_model,
-                                TabContentsWrapper* old_contents,
-                                TabContentsWrapper* new_contents,
+                                TabContents* old_contents,
+                                TabContents* new_contents,
                                 int index) {
   TabChangedAt(new_contents, index, ALL);
 }
 
-void TabStripGtk::TabMiniStateChanged(TabContentsWrapper* contents, int index) {
+void TabStripGtk::TabMiniStateChanged(TabContents* contents, int index) {
   // Don't do anything if we've already picked up the change from TabMoved.
   if (GetTabAt(index)->mini() == model_->IsMiniTab(index))
     return;
 
   GetTabAt(index)->set_mini(model_->IsMiniTab(index));
   // Don't animate if the window isn't visible yet. The window won't be visible
   // when dragging a mini-tab to a new window.
   if (window_ && window_->window() &&
       gtk_widget_get_visible(GTK_WIDGET(window_->window()))) {
     StartMiniTabAnimation(index);
   } else {
     Layout();
   }
 }
 
-void TabStripGtk::TabBlockedStateChanged(TabContentsWrapper* contents,
+void TabStripGtk::TabBlockedStateChanged(TabContents* contents,
                                          int index) {
   GetTabAt(index)->SetBlocked(model_->IsTabBlocked(index));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabStripGtk, TabGtk::TabDelegate implementation:
 
 bool TabStripGtk::IsTabActive(const TabGtk* tab) const {
   if (tab->closing())
     return false;
@@ skipping 899 matching lines @@
   gtk_container_propagate_expose(GTK_CONTAINER(tabstrip_.get()),
       newtab_button_->widget(), event);
 
   // Paint the tabs in reverse order, so they stack to the left.
   TabGtk* selected_tab = NULL;
   int tab_count = GetTabCount();
   for (int i = tab_count - 1; i >= 0; --i) {
     TabGtk* tab = GetTabAt(i);
     // We must ask the _Tab's_ model, not ourselves, because in some situations
     // the model will be different to this object, e.g. when a Tab is being
-    // removed after its TabContentsWrapper has been destroyed.
+    // removed after its TabContents has been destroyed.
     if (!tab->IsActive()) {
       gtk_container_propagate_expose(GTK_CONTAINER(tabstrip_.get()),
                                      tab->widget(), event);
     } else {
       selected_tab = tab;
     }
   }
 
   // Paint the selected tab last, so it overlaps all the others.
   if (selected_tab) {
@@ skipping 170 matching lines @@
 }
 
 void TabStripGtk::SetNewTabButtonBackground() {
   SkColor color = theme_service_->GetColor(
       ThemeService::COLOR_BUTTON_BACKGROUND);
   SkBitmap* background = theme_service_->GetBitmapNamed(
       IDR_THEME_WINDOW_CONTROL_BACKGROUND);
   SkBitmap* mask = theme_service_->GetBitmapNamed(IDR_NEWTAB_BUTTON_MASK);
   newtab_button_->SetBackground(color, background, mask);
 }