views: Use Tab pointer directly when calling TabStrip::tab_at.

chrome/browser/ui/views/tabs/tab_strip.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/views/tabs/tab_strip.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 637 matching lines @@
   else
     DoLayout();
 
   SwapLayoutIfNecessary();
 }
 
 void TabStrip::MoveTab(int from_model_index,
                        int to_model_index,
                        const TabRendererData& data) {
   DCHECK_GT(tabs_.view_size(), 0);
-  BaseTab* last_tab = tab_at(tab_count() - 1);
+  Tab* last_tab = tab_at(tab_count() - 1);
   tab_at(from_model_index)->SetData(data);
   if (touch_layout_.get()) {
     tabs_.MoveViewOnly(from_model_index, to_model_index);
     int mini_count = 0;
     GenerateIdealBoundsForMiniTabs(&mini_count);
     touch_layout_->MoveTab(
         from_model_index, to_model_index, controller_->GetActiveIndex(),
         GetStartXForNormalTabs(), mini_count);
   } else {
     tabs_.Move(from_model_index, to_model_index);
   }
   StartMoveTabAnimation();
   if (TabDragController::IsAttachedTo(this) &&
       (last_tab != tab_at(tab_count() - 1) || last_tab->dragging())) {
     newtab_button_->SetVisible(false);
   }
   SwapLayoutIfNecessary();
 }
 
 void TabStrip::RemoveTabAt(int model_index) {
   if (touch_layout_.get()) {
-    BaseTab* tab = tab_at(model_index);
+    Tab* tab = tab_at(model_index);
     tab->set_closing(true);
     int old_x = tabs_.ideal_bounds(model_index).x();
     // We still need to paint the tab until we actually remove it. Put it in
     // tabs_closing_map_ so we can find it.
     RemoveTabFromViewModel(model_index);
     touch_layout_->RemoveTab(model_index, GenerateIdealBoundsForMiniTabs(NULL),
                              old_x);
     ScheduleRemoveTabAnimation(tab);
   } else if (in_tab_close_ && model_index != GetModelCount()) {
     StartMouseInitiatedRemoveTabAnimation(model_index);
   } else {
     StartRemoveTabAnimation(model_index);
   }
   SwapLayoutIfNecessary();
 }
 
 void TabStrip::SetTabData(int model_index, const TabRendererData& data) {
-  BaseTab* tab = tab_at(model_index);
+  Tab* tab = tab_at(model_index);
   bool mini_state_changed = tab->data().mini != data.mini;
   tab->SetData(data);
 
   if (mini_state_changed) {
     if (touch_layout_.get()) {
       int mini_tab_count = 0;
       int start_x = GenerateIdealBoundsForMiniTabs(&mini_tab_count);
       touch_layout_->SetXAndMiniCount(start_x, mini_tab_count);
     }
     if (GetWidget() && GetWidget()->IsVisible())
@@ skipping 104 matching lines @@
   tab->set_theme_provider(GetThemeProvider());
   return tab;
 }
 
 bool TabStrip::IsDragSessionActive() const {
   return drag_controller_.get() != NULL;
 }
 
 bool TabStrip::IsActiveDropTarget() const {
   for (int i = 0; i < tab_count(); ++i) {
-    BaseTab* tab = tab_at(i);
+    Tab* tab = tab_at(i);
     if (tab->dragging())
       return true;
   }
   return false;
 }
 
 bool TabStrip::IsTabStripEditable() const {
   return !IsDragSessionActive() && !IsActiveDropTarget();
 }
 
@@ skipping 139 matching lines @@
     CHECK(false);
     return;
   }
   std::vector<BaseTab*> tabs;
   int size_to_selected = 0;
   int x = tab->GetMirroredXInView(event.x());
   int y = event.y();
   // Build the set of selected tabs to drag and calculate the offset from the
   // first selected tab.
   for (int i = 0; i < tab_count(); ++i) {
-    BaseTab* other_tab = tab_at(i);
+    Tab* other_tab = tab_at(i);
     if (IsTabSelected(other_tab)) {
       tabs.push_back(other_tab);
       if (other_tab == tab) {
         size_to_selected = GetSizeNeededForTabs(tabs);
         x = size_to_selected - tab->width() + x;
       }
     }
   }
   DCHECK(!tabs.empty());
   DCHECK(std::find(tabs.begin(), tabs.end(), tab) != tabs.end());
@@ skipping 469 matching lines @@
 
 void TabStrip::StartInsertTabAnimation(int model_index) {
   PrepareForAnimation();
 
   // The TabStrip can now use its entire width to lay out Tabs.
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
 
   GenerateIdealBounds();
 
-  BaseTab* tab = tab_at(model_index);
+  Tab* tab = tab_at(model_index);
   if (model_index == 0) {
     tab->SetBounds(0, ideal_bounds(model_index).y(), 0,
                    ideal_bounds(model_index).height());
   } else {
-    BaseTab* last_tab = tab_at(model_index - 1);
+    Tab* last_tab = tab_at(model_index - 1);
     tab->SetBounds(last_tab->bounds().right() + tab_h_offset(),
                    ideal_bounds(model_index).y(), 0,
                    ideal_bounds(model_index).height());
   }
 
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMoveTabAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartRemoveTabAnimation(int model_index) {
   PrepareForAnimation();
 
   // Mark the tab as closing.
-  BaseTab* tab = tab_at(model_index);
+  Tab* tab = tab_at(model_index);
   tab->set_closing(true);
 
   RemoveTabFromViewModel(model_index);
 
   ScheduleRemoveTabAnimation(tab);
 }
 
 void TabStrip::ScheduleRemoveTabAnimation(BaseTab* tab) {
   // Start an animation for the tabs.
   GenerateIdealBounds();
@@ skipping 727 matching lines @@
 
   PrepareForAnimation();
 
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMouseInitiatedRemoveTabAnimation(int model_index) {
   // The user initiated the close. We want to persist the bounds of all the
   // existing tabs, so we manually shift ideal_bounds then animate.
-  BaseTab* tab_closing = tab_at(model_index);
+  Tab* tab_closing = tab_at(model_index);
   int delta = tab_closing->width() + tab_h_offset();
   // If the tab being closed is a mini-tab next to a non-mini-tab, be sure to
   // add the extra padding.
   DCHECK_NE(model_index + 1, tab_count());
   if (tab_closing->data().mini && model_index + 1 < tab_count() &&
       !tab_at(model_index + 1)->data().mini) {
     delta += kMiniToNonMiniGap;
   }
 
   for (int i = model_index + 1; i < tab_count(); ++i) {
@@ skipping 92 matching lines @@
 
   int mini_tab_count = GetMiniTabCount();
   int normal_count = tab_count() - mini_tab_count;
   if (normal_count <= 1 || normal_count == mini_tab_count)
     return false;
   int x = GetStartXForNormalTabs();
   int available_width = width() - x - new_tab_button_width();
   return (Tab::GetTouchWidth() * normal_count +
           tab_h_offset() * (normal_count - 1)) > available_width;
 }