More TabStrip refactoring.

chrome/browser/views/tabs/tab_strip.cc

 // Copyright (c) 2010 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/views/tabs/tab_strip.h"
 
 #include "app/animation_container.h"
 #include "app/drag_drop_types.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
 #include "base/compiler_specific.h"
 #include "base/stl_util-inl.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/view_ids.h"
-#include "chrome/browser/views/tabs/dragged_tab_controller.h"
 #include "chrome/browser/views/tabs/tab.h"
 #include "chrome/browser/views/tabs/tab_strip_controller.h"
 #include "chrome/common/pref_names.h"
 #include "gfx/canvas.h"
 #include "gfx/path.h"
 #include "gfx/size.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/controls/image_view.h"
 #include "views/widget/default_theme_provider.h"
-#include "views/widget/root_view.h"
 #include "views/window/non_client_view.h"
 #include "views/window/window.h"
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #include "views/widget/widget_win.h"
 #elif defined(OS_LINUX)
 #include "views/widget/widget_gtk.h"
 #endif
 
@@ skipping 65 matching lines @@
   Tab* tab_;
 
   DISALLOW_COPY_AND_ASSIGN(NewTabAlphaDelegate);
 };
 
 // Animation delegate used when a dragged tab is released. When done sets the
 // dragging state to false.
 class ResetDraggingStateDelegate
     : public views::BoundsAnimator::OwnedAnimationDelegate {
  public:
-  explicit ResetDraggingStateDelegate(Tab* tab) : tab_(tab) {
+  explicit ResetDraggingStateDelegate(BaseTabRenderer* tab) : tab_(tab) {
   }
 
   virtual void AnimationEnded(const Animation* animation) {
     tab_->set_dragging(false);
   }
 
   virtual void AnimationCanceled(const Animation* animation) {
     tab_->set_dragging(false);
   }
 
  private:
-  Tab* tab_;
+  BaseTabRenderer* tab_;
 
   DISALLOW_COPY_AND_ASSIGN(ResetDraggingStateDelegate);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // NewTabButton
 //
 //  A subclass of button that hit-tests to the shape of the new tab button.
 
 class NewTabButton : public views::ImageButton {
@@ skipping 61 matching lines @@
       CompleteRemove();
   }
 
  private:
   void CompleteRemove() {
     if (!tab_->closing()) {
       // The tab was added back yet we weren't canceled. This shouldn't happen.
       NOTREACHED();
       return;
     }
-    tabstrip_->RemoveTab(tab_);
+    tabstrip_->RemoveAndDeleteTab(tab_);
     HighlightCloseButton();
   }
 
   // When the animation completes, we send the Container a message to simulate
   // a mouse moved event at the current mouse position. This tickles the Tab
   // the mouse is currently over to show the "hot" state of the close button.
   void HighlightCloseButton() {
     if (tabstrip_->available_width_for_tabs_ == -1 ||
         tabstrip_->IsDragSessionActive()) {
       // This function is not required (and indeed may crash!) for removes
@@ skipping 31 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 // static
 const int TabStrip::mini_to_non_mini_gap_ = 3;
 
 // static
 const int TabStrip::extra_gap_for_nano_ = 10;
 
 TabStrip::TabStrip(TabStripController* controller)
-    : BaseTabStrip(controller),
+    : BaseTabStrip(controller, BaseTabStrip::HORIZONTAL_TAB_STRIP),
       resize_layout_factory_(this),
       added_as_message_loop_observer_(false),
       needs_resize_layout_(false),
       current_unselected_width_(Tab::GetStandardSize().width()),
       current_selected_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       animation_container_(new AnimationContainer()),
       ALLOW_THIS_IN_INITIALIZER_LIST(bounds_animator_(this)),
       animation_type_(ANIMATION_DEFAULT),
       new_tab_button_enabled_(true),
-      cancelling_animation_(false),
-      attaching_dragged_tab_(false) {
+      cancelling_animation_(false) {
   Init();
 }
 
 TabStrip::~TabStrip() {
   // The animations may reference the tabs. Shut down the animation before we
   // delete the tabs.
   StopAnimating(false);
 
-  // TODO(beng): remove this if it doesn't work to fix the TabSelectedAt bug.
-  drag_controller_.reset(NULL);
+  DestroyDragController();
 
   // Make sure we unhook ourselves as a message loop observer so that we don't
   // crash in the case where the user closes the window after closing a tab
   // but before moving the mouse.
   RemoveMessageLoopObserver();
 
   // The children (tabs) may callback to us from their destructor. Delete them
   // so that if they call back we aren't in a weird state.
   RemoveAllChildViews(true);
 }
 
-void TabStrip::DestroyDragController() {
-  if (IsDragSessionActive())
-    drag_controller_.reset(NULL);
-}
-
-gfx::Rect TabStrip::GetIdealBounds(int tab_data_index) {
-  DCHECK_GE(tab_data_index, 0);
-  DCHECK_LT(tab_data_index, GetTabCount());
-  return tab_data_[tab_data_index].ideal_bounds;
-}
-
 void TabStrip::InitTabStripButtons() {
   newtab_button_ = new NewTabButton(this);
   if (browser_defaults::kSizeTabButtonToTopOfTabStrip) {
     newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                       views::ImageButton::ALIGN_BOTTOM);
   }
   LoadNewTabButtonImage();
   newtab_button_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_NEWTAB));
   AddChildView(newtab_button_);
 }
 
 gfx::Rect TabStrip::GetNewTabButtonBounds() {
   return newtab_button_->bounds();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabStrip, BaseTabStrip implementation:
 
 int TabStrip::GetPreferredHeight() {
   return GetPreferredSize().height();
 }
 
 void TabStrip::SetBackgroundOffset(const gfx::Point& offset) {
-  int tab_count = GetTabCount();
-  for (int i = 0; i < tab_count; ++i)
+  for (int i = 0; i < tab_count(); ++i)
     GetTabAtTabDataIndex(i)->SetBackgroundOffset(offset);
 }
 
 bool TabStrip::IsPositionInWindowCaption(const gfx::Point& point) {
   views::View* v = GetViewForPoint(point);
 
   // If there is no control at this location, claim the hit was in the title
   // bar to get a move action.
   if (v == this)
     return true;
@@ skipping 10 matching lines @@
 
   // All other regions, including the new Tab button, should be considered part
   // of the containing Window's client area so that regular events can be
   // processed for them.
   return false;
 }
 
 void TabStrip::SetDraggedTabBounds(int tab_index, const gfx::Rect& tab_bounds) {
 }
 
-bool TabStrip::IsDragSessionActive() const {
-  return drag_controller_.get() != NULL;
-}
-
 bool TabStrip::IsAnimating() const {
   return bounds_animator_.IsAnimating() || new_tab_timer_.IsRunning();
 }
 
 TabStrip* TabStrip::AsTabStrip() {
   return this;
 }
 
-void TabStrip::AddTabAt(int model_index,
-                        bool foreground,
-                        const TabRendererData& data) {
-  Tab* tab = CreateTab();
-  tab->SetAnimationContainer(animation_container_.get());
-  tab->SetData(data);
-
-  TabData d = { tab, gfx::Rect() };
-  tab_data_.insert(tab_data_.begin() +
-                   ModelIndexToTabDataIndex(model_index), d);
-
-  AddChildView(tab);
-
-  // Don't animate the first tab, it looks weird, and don't animate anything
-  // if the containing window isn't visible yet.
-  if (GetTabCount() > 1 && GetWindow() && GetWindow()->IsVisible()) {
-    if (!IsDragSessionActive() && !attaching_dragged_tab_ &&
-        ShouldStartIntertTabAnimationAtEnd(model_index, foreground)) {
-      StartInsertTabAnimationAtEnd();
-    } else {
-      StartInsertTabAnimation(model_index);
-    }
-  } else {
-    Layout();
-  }
-}
-
 void TabStrip::RemoveTabAt(int model_index, bool initiated_close) {
   if (initiated_close) {
     int model_count = GetModelCount();
     if (model_index != model_count && model_count > 0) {
       Tab* last_tab = GetTabAtModelIndex(model_count - 1);
       // Limit the width available to the TabStrip for laying out Tabs, so that
       // Tabs are not resized until a later time (when the mouse pointer leaves
       // the TabStrip).
       available_width_for_tabs_ = GetAvailableWidthForTabs(last_tab);
       needs_resize_layout_ = true;
       AddMessageLoopObserver();
     } else if (model_count) {
       Tab* last_tab = GetTabAtModelIndex(model_count);
       // Limit the width available to the TabStrip for laying out Tabs, so that
       // Tabs are not resized until a later time (when the mouse pointer leaves
       // the TabStrip).
       available_width_for_tabs_ = GetAvailableWidthForTabs(last_tab);
       needs_resize_layout_ = true;
       AddMessageLoopObserver();
     }
   }
-
   StartRemoveTabAnimation(model_index);
 }
 
 void TabStrip::SelectTabAt(int old_model_index, int new_model_index) {
   // We have "tiny tabs" if the tabs are so tiny that the unselected ones are
   // a different size to the selected ones.
   bool tiny_tabs = current_unselected_width_ != current_selected_width_;
   if (!IsAnimating() && (!needs_resize_layout_ || tiny_tabs)) {
     Layout();
   } else {
     SchedulePaint();
   }
 
   if (old_model_index >= 0) {
-    GetTabAtTabDataIndex(ModelIndexToTabDataIndex(old_model_index))->
+    GetTabAtTabDataIndex(ModelIndexToTabIndex(old_model_index))->
         StopMiniTabTitleAnimation();
   }
 }
 
-void TabStrip::MoveTab(int from_model_index, int to_model_index) {
-  StartMoveTabAnimation(from_model_index, to_model_index);
-}
-
 void TabStrip::TabTitleChangedNotLoading(int model_index) {
   Tab* tab = GetTabAtModelIndex(model_index);
   if (tab->data().mini && !tab->IsSelected())
     tab->StartMiniTabTitleAnimation();
 }
 
 void TabStrip::SetTabData(int model_index, const TabRendererData& data) {
   Tab* tab = GetTabAtModelIndex(model_index);
   bool mini_state_changed = tab->data().mini != data.mini;
   tab->SetData(data);
   tab->SchedulePaint();
 
   if (mini_state_changed) {
     if (GetWindow() && GetWindow()->IsVisible())
       StartMiniTabAnimation();
     else
       Layout();
   }
 }
 
 void TabStrip::StartHighlight(int model_index) {
   GetTabAtModelIndex(model_index)->StartPulse();
 }
 
 void TabStrip::StopAllHighlighting() {
-  for (int i = 0; i < GetTabCount(); ++i)
+  for (int i = 0; i < tab_count(); ++i)
     GetTabAtTabDataIndex(i)->StopPulse();
 }
 
-BaseTabRenderer* TabStrip::GetBaseTabAtModelIndex(int model_index) const {
-  return GetTabAtModelIndex(model_index);
-}
-
-BaseTabRenderer* TabStrip::GetBaseTabAtTabIndex(int tab_index) const {
-  return GetTabAtTabDataIndex(tab_index);
-}
-
-int TabStrip::GetModelIndexOfBaseTab(const BaseTabRenderer* tab) const {
-  return GetModelIndexOfTab(static_cast<const Tab*>(tab));
-}
-
 BaseTabRenderer* TabStrip::CreateTabForDragging() {
   Tab* tab = new Tab(NULL);
   // Make sure the dragged tab shares our theme provider. We need to explicitly
   // do this as during dragging there isn't a theme provider.
   tab->SetThemeProvider(GetThemeProvider());
   return tab;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, views::View overrides:
 
 void TabStrip::PaintChildren(gfx::Canvas* canvas) {
   // Tabs are painted in reverse order, so they stack to the left.
-  int tab_count = GetTabCount();
-
   // Phantom tabs appear behind all other tabs and are rendered first. To make
   // them slightly transparent we render them to a different layer.
   if (HasPhantomTabs()) {
     SkRect bounds;
     bounds.set(0, 0, SkIntToScalar(width()), SkIntToScalar(height()));
     canvas->saveLayerAlpha(&bounds, kPhantomTabAlpha,
                            SkCanvas::kARGB_ClipLayer_SaveFlag);
     canvas->drawARGB(0, 255, 255, 255, SkXfermode::kClear_Mode);
-    for (int i = tab_count - 1; i >= 0; --i) {
+    for (int i = tab_count() - 1; i >= 0; --i) {
       Tab* tab = GetTabAtTabDataIndex(i);
       if (tab->data().phantom)
         tab->ProcessPaint(canvas);
     }
     canvas->restore();
 
     canvas->saveLayerAlpha(&bounds, kPhantomTabIconAlpha,
                            SkCanvas::kARGB_ClipLayer_SaveFlag);
     canvas->drawARGB(0, 255, 255, 255, SkXfermode::kClear_Mode);
-    for (int i = tab_count - 1; i >= 0; --i) {
+    for (int i = tab_count() - 1; i >= 0; --i) {
       Tab* tab = GetTabAtTabDataIndex(i);
       if (tab->data().phantom) {
         canvas->save();
         canvas->ClipRectInt(tab->MirroredX(), tab->y(), tab->width(),
                             tab->height());
         canvas->TranslateInt(tab->MirroredX(), tab->y());
         tab->PaintIcon(canvas);
         canvas->restore();
       }
     }
     canvas->restore();
   }
 
   Tab* selected_tab = NULL;
 
   Tab* dragging_tab = NULL;
 
   int model_count = GetModelCount();
 
-  for (int i = tab_count - 1; i >= 0; --i) {
+  for (int i = tab_count() - 1; i >= 0; --i) {
     Tab* tab = GetTabAtTabDataIndex(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 TabContents has been destroyed.
     if (!tab->data().phantom) {
       if (tab->dragging()) {
         dragging_tab = tab;
       } else if (!tab->IsSelected()) {
         if (tab->render_unselected() && model_count > 1) {
           // See comment above kNetTabAnimationSelectedOffset as to why we do
@@ skipping 41 matching lines @@
     newtab_button_->ProcessPaint(canvas);
   }
 
   // And the dragged tab.
   if (dragging_tab)
     dragging_tab->ProcessPaint(canvas);
 }
 
 // Overridden to support automation. See automation_proxy_uitest.cc.
 views::View* TabStrip::GetViewByID(int view_id) const {
-  if (GetTabCount() > 0) {
+  if (tab_count() > 0) {
     if (view_id == VIEW_ID_TAB_LAST) {
-      return GetTabAtTabDataIndex(GetTabCount() - 1);
+      return GetTabAtTabDataIndex(tab_count() - 1);
     } else if ((view_id >= VIEW_ID_TAB_0) && (view_id < VIEW_ID_TAB_LAST)) {
       int index = view_id - VIEW_ID_TAB_0;
-      if (index >= 0 && index < GetTabCount()) {
+      if (index >= 0 && index < tab_count()) {
         return GetTabAtTabDataIndex(index);
       } else {
         return NULL;
       }
     }
   }
 
   return View::GetViewByID(view_id);
 }
 
 void TabStrip::Layout() {
-  // Called from:
-  // - window resize
-  StopAnimating(false);
-
-  GenerateIdealBounds();
-
-  for (int i = 0, tab_count = GetTabCount(); i < tab_count; ++i)
-    tab_data_[i].tab->SetBounds(tab_data_[i].ideal_bounds);
+  BaseTabStrip::Layout();
 
   if (new_tab_button_enabled_) {
     newtab_button_->SetBounds(newtab_button_bounds_);
     newtab_button_->SetVisible(true);
   } else {
     newtab_button_->SetVisible(false);
   }
-
-  SchedulePaint();
 }
 
 gfx::Size TabStrip::GetPreferredSize() {
   return gfx::Size(0, Tab::GetMinimumUnselectedSize().height());
 }
 
 void TabStrip::OnDragEntered(const DropTargetEvent& event) {
   // Force animations to stop, otherwise it makes the index calculation tricky.
   StopAnimating(true);
 
@@ skipping 40 matching lines @@
   // Return any view that isn't a Tab or this TabStrip immediately. We don't
   // want to interfere.
   views::View* v = View::GetViewForPoint(point);
   if (v && v != this && v->GetClassName() != Tab::kTabClassName)
     return v;
 
   // The display order doesn't necessarily match the child list order, so we
   // walk the display list hit-testing Tabs. Since the selected tab always
   // renders on top of adjacent tabs, it needs to be hit-tested before any
   // left-adjacent Tab, so we look ahead for it as we walk.
-  int tab_count = GetTabCount();
-  for (int i = 0; i < tab_count; ++i) {
-    Tab* next_tab = i < (tab_count - 1) ? GetTabAtTabDataIndex(i + 1) : NULL;
+  for (int i = 0; i < tab_count(); ++i) {
+    Tab* next_tab = i < (tab_count() - 1) ? GetTabAtTabDataIndex(i + 1) : NULL;
     if (next_tab && next_tab->IsSelected() && IsPointInTab(next_tab, point))
       return next_tab;
     Tab* tab = GetTabAtTabDataIndex(i);
     if (IsPointInTab(tab, point))
       return tab;
   }
 
   // No need to do any floating view stuff, we don't use them in the TabStrip.
   return this;
 }
 
 void TabStrip::ThemeChanged() {
   LoadNewTabButtonImage();
 }
 
 void TabStrip::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
   AnimationType last_type = animation_type_;
 
   ResetAnimationState(false);
 
   if (!cancelling_animation_ && last_type == ANIMATION_NEW_TAB_2)
     NewTabAnimation2Done();
 }
 
 Tab* TabStrip::CreateTab() {
-  return new Tab(this);
+  Tab* tab = new Tab(this);
+  tab->SetAnimationContainer(animation_container_.get());
+  return tab;
+}
+
+void TabStrip::StartInsertTabAnimation(int model_index, bool foreground) {
+  if (!IsDragSessionActive() && !attaching_dragged_tab() &&
+      ShouldStartIntertTabAnimationAtEnd(model_index, foreground)) {
+    StartInsertTabAnimationAtEnd();
+  } else {
+    StartInsertTabAnimationImpl(model_index);
+  }
+}
+
+void TabStrip::StartMoveTabAnimation() {
+  ResetAnimationState(true);
+
+  GenerateIdealBounds();
+  AnimateToIdealBounds();
+}
+
+void TabStrip::StartedDraggingTab(BaseTabRenderer* tab) {
+  tab->set_dragging(true);
+
+  // Stop any animations on the tab.
+  bounds_animator_.StopAnimatingView(tab);
+
+  // Move the tab to its ideal bounds.
+  GenerateIdealBounds();
+  int tab_data_index = TabIndexOfTab(tab);
+  DCHECK(tab_data_index != -1);
+  tab->SetBounds(ideal_bounds(tab_data_index));
+  SchedulePaint();
+}
+
+void TabStrip::StoppedDraggingTab(BaseTabRenderer* tab) {
+  int tab_data_index = TabIndexOfTab(tab);
+  if (tab_data_index == -1) {
+    // The tab was removed before the drag completed. Don't do anything.
+    return;
+  }
+
+  // Animate the view back to its correct position.
+  ResetAnimationState(true);
+  GenerateIdealBounds();
+  AnimateToIdealBounds();
+  bounds_animator_.AnimateViewTo(tab, ideal_bounds(TabIndexOfTab(tab)));
+
+  // Install a delegate to reset the dragging state when done. We have to leave
+  // dragging true for the tab otherwise it'll draw beneath the new tab button.
+  bounds_animator_.SetAnimationDelegate(tab,
+                                        new ResetDraggingStateDelegate(tab),
+                                        true);
 }
 
 void TabStrip::ViewHierarchyChanged(bool is_add,
                                     views::View* parent,
                                     views::View* child) {
   if (is_add && child == this)
     InitTabStripButtons();
 }
 
-bool TabStrip::OnMouseDragged(const views::MouseEvent&  event) {
-  if (drag_controller_.get())
-    drag_controller_->Drag();
-  return true;
-}
-
-void TabStrip::OnMouseReleased(const views::MouseEvent& event,
-                               bool canceled) {
-  EndDrag(canceled);
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, Tab::Delegate implementation:
 
 bool TabStrip::IsTabSelected(const BaseTabRenderer* btr) const {
   const Tab* tab = static_cast<const Tab*>(btr);
   if (tab->closing() || tab->render_unselected())
     return false;
 
   return BaseTabStrip::IsTabSelected(btr);
 }
 
-bool TabStrip::IsTabPinned(const BaseTabRenderer* btr) const {
-  const Tab* tab = static_cast<const Tab*>(btr);
-  if (tab->closing())
-    return false;
-
-  return BaseTabStrip::IsTabPinned(tab);
-}
-
-void TabStrip::MaybeStartDrag(BaseTabRenderer* btr,
-                              const views::MouseEvent& event) {
-  Tab* tab = static_cast<Tab*>(btr);
-  // Don't accidentally start any drag operations during animations if the
-  // mouse is down... during an animation tabs are being resized automatically,
-  // so the View system can misinterpret this easily if the mouse is down that
-  // the user is dragging.
-  if (IsAnimating() || tab->closing() || !HasAvailableDragActions())
-    return;
-  int model_index = GetModelIndexOfTab(tab);
-  if (!IsValidModelIndex(model_index)) {
-    CHECK(false);
-    return;
-  }
-  drag_controller_.reset(new DraggedTabController(tab, this));
-  drag_controller_->CaptureDragInfo(tab, event.location());
-}
-
-void TabStrip::ContinueDrag(const views::MouseEvent& event) {
-  // We can get called even if |MaybeStartDrag| wasn't called in the event of
-  // a TabStrip animation when the mouse button is down. In this case we should
-  // _not_ continue the drag because it can lead to weird bugs.
-  if (drag_controller_.get()) {
-    bool started_drag = drag_controller_->started_drag();
-    drag_controller_->Drag();
-    if (drag_controller_->started_drag() && !started_drag) {
-      // The drag just started. Redirect mouse events to us to that the tab that
-      // originated the drag can be safely deleted.
-      GetRootView()->SetMouseHandler(this);
-    }
-  }
-}
-
-bool TabStrip::EndDrag(bool canceled) {
-  if (!drag_controller_.get())
-    return false;
-  bool started_drag = drag_controller_->started_drag();
-  drag_controller_->EndDrag(canceled);
-  return started_drag;
-}
-
-bool TabStrip::HasAvailableDragActions() const {
-  return controller()->HasAvailableDragActions() != 0;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, views::BaseButton::ButtonListener implementation:
 
 void TabStrip::ButtonPressed(views::Button* sender, const views::Event& event) {
   if (sender == newtab_button_)
     controller()->CreateNewTab();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, MessageLoop::Observer implementation:
@@ skipping 91 matching lines @@
                            tp->GetBitmapNamed(IDR_NEWTAB_BUTTON_P));
   newtab_button_->SetImage(views::CustomButton::BS_HOT,
                            tp->GetBitmapNamed(IDR_NEWTAB_BUTTON_H));
   newtab_button_->SetBackground(color, background,
                                 tp->GetBitmapNamed(IDR_NEWTAB_BUTTON_MASK));
   if (in_test)
     delete tp;
 }
 
 Tab* TabStrip::GetTabAtTabDataIndex(int tab_data_index) const {
-  DCHECK_GE(tab_data_index, 0);
-  DCHECK_LT(tab_data_index, GetTabCount());
-  return tab_data_[tab_data_index].tab;
+  return static_cast<Tab*>(base_tab_at_tab_index(tab_data_index));
 }
 
 Tab* TabStrip::GetTabAtModelIndex(int model_index) const {
-  return GetTabAtTabDataIndex(ModelIndexToTabDataIndex(model_index));
-}
-
-int TabStrip::GetTabCount() const {
-  return static_cast<int>(tab_data_.size());
+  return GetTabAtTabDataIndex(ModelIndexToTabIndex(model_index));
 }
 
 void TabStrip::GetCurrentTabWidths(double* unselected_width,
                                    double* selected_width) const {
   *unselected_width = current_unselected_width_;
   *selected_width = current_selected_width_;
 }
 
 void TabStrip::GetDesiredTabWidths(int tab_count,
                                    int mini_tab_count,
@@ skipping 77 matching lines @@
       *selected_width = std::max(available_width - total_offset -
           (min_unselected_width * (tab_count - 1)), min_selected_width);
     }
   }
 }
 
 void TabStrip::ResizeLayoutTabs() {
   // We've been called back after the TabStrip has been emptied out (probably
   // just prior to the window being destroyed). We need to do nothing here or
   // else GetTabAt below will crash.
-  if (GetTabCount() == 0)
+  if (tab_count() == 0)
     return;
 
   resize_layout_factory_.RevokeAll();
 
   // It is critically important that this is unhooked here, otherwise we will
   // keep spying on messages forever.
   RemoveMessageLoopObserver();
 
   available_width_for_tabs_ = -1;
   int mini_tab_count = GetMiniTabCount();
-  if (mini_tab_count == GetTabCount()) {
+  if (mini_tab_count == tab_count()) {
     // Only mini-tabs, we know the tab widths won't have changed (all
     // mini-tabs have the same width), so there is nothing to do.
     return;
   }
   Tab* first_tab  = GetTabAtTabDataIndex(mini_tab_count);
   double unselected, selected;
-  GetDesiredTabWidths(GetTabCount(), mini_tab_count, GetNanoTabCount(),
+  GetDesiredTabWidths(tab_count(), mini_tab_count, GetNanoTabCount(),
                       &unselected, &selected);
   int w = Round(first_tab->IsSelected() ? selected : selected);
 
   // We only want to run the animation if we're not already at the desired
   // size.
   if (abs(first_tab->width() - w) > 1)
     StartResizeLayoutAnimation();
 }
 
 bool TabStrip::IsCursorInTabStripZone() const {
@@ skipping 30 matching lines @@
     MessageLoopForUI::current()->RemoveObserver(this);
     added_as_message_loop_observer_ = false;
   }
 }
 
 gfx::Rect TabStrip::GetDropBounds(int drop_index,
                                   bool drop_before,
                                   bool* is_beneath) {
   DCHECK(drop_index != -1);
   int center_x;
-  if (drop_index < GetTabCount()) {
+  if (drop_index < tab_count()) {
     Tab* tab = GetTabAtTabDataIndex(drop_index);
     if (drop_before)
       center_x = tab->x() - (kTabHOffset / 2);
     else
       center_x = tab->x() + (tab->width() / 2);
   } else {
     Tab* last_tab = GetTabAtTabDataIndex(drop_index - 1);
     center_x = last_tab->x() + last_tab->width() + (kTabHOffset / 2);
   }
 
@@ skipping 21 matching lines @@
 
   return drop_bounds;
 }
 
 void TabStrip::UpdateDropIndex(const DropTargetEvent& event) {
   // If the UI layout is right-to-left, we need to mirror the mouse
   // coordinates since we calculate the drop index based on the
   // original (and therefore non-mirrored) positions of the tabs.
   const int x = MirroredXCoordinateInsideView(event.x());
   // We don't allow replacing the urls of mini-tabs.
-  for (int i = GetMiniTabCount(); i < GetTabCount(); ++i) {
+  for (int i = GetMiniTabCount(); i < tab_count(); ++i) {
     Tab* tab = GetTabAtTabDataIndex(i);
     const int tab_max_x = tab->x() + tab->width();
     const int hot_width = tab->width() / 3;
     if (x < tab_max_x) {
       if (x < tab->x() + hot_width)
         SetDropIndex(i, true);
       else if (x >= tab_max_x - hot_width)
         SetDropIndex(i + 1, true);
       else
         SetDropIndex(i, false);
       return;
     }
   }
 
   // The drop isn't over a tab, add it to the end.
-  SetDropIndex(GetTabCount(), true);
+  SetDropIndex(tab_count(), true);
 }
 
 void TabStrip::SetDropIndex(int tab_data_index, bool drop_before) {
   if (tab_data_index == -1) {
     if (drop_info_.get())
       drop_info_.reset(NULL);
     return;
   }
 
   if (drop_info_.get() && drop_info_->drop_index == tab_data_index &&
@@ skipping 77 matching lines @@
   arrow_window->Close();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Called from:
 // - BasicLayout
 // - Tab insertion/removal
 // - Tab reorder
 void TabStrip::GenerateIdealBounds() {
-  int tab_count = GetTabCount();
   int non_closing_tab_count = 0;
   int mini_tab_count = 0;
   int nano_tab_count = 0;
-  for (int i = 0; i < tab_count; ++i) {
-    if (!tab_data_[i].tab->closing()) {
+  for (int i = 0; i < tab_count(); ++i) {
+    BaseTabRenderer* tab = base_tab_at_tab_index(i);
+    if (!tab->closing()) {
       ++non_closing_tab_count;
-      if (tab_data_[i].tab->data().mini)
+      if (tab->data().mini)
         mini_tab_count++;
-      if (tab_data_[i].tab->data().app)
+      if (tab->data().app)
         nano_tab_count++;
     }
   }
 
   double unselected, selected;
   GetDesiredTabWidths(non_closing_tab_count, mini_tab_count, nano_tab_count,
                       &unselected, &selected);
 
   current_unselected_width_ = unselected;
   current_selected_width_ = selected;
 
   // NOTE: This currently assumes a tab's height doesn't differ based on
   // selected state or the number of tabs in the strip!
   int tab_height = Tab::GetStandardSize().height();
   double tab_x = 0;
   bool last_was_mini = false;
-  for (int i = 0; i < tab_count; ++i) {
-    if (!tab_data_[i].tab->closing()) {
+  for (int i = 0; i < tab_count(); ++i) {
       Tab* tab = GetTabAtTabDataIndex(i);
+    if (!tab->closing()) {
       double tab_width = unselected;
       if (tab->data().mini) {
         tab_width = Tab::GetMiniWidth();
       } else {
         if (last_was_mini) {
           // Give a bigger gap between mini and non-mini tabs.
           tab_x += mini_to_non_mini_gap_;
           if (nano_tab_count > 0)
             tab_x += extra_gap_for_nano_;
         }
         if (tab->IsSelected())
           tab_width = selected;
       }
       double end_of_tab = tab_x + tab_width;
       int rounded_tab_x = Round(tab_x);
-      tab_data_[i].ideal_bounds =
+      set_ideal_bounds(i,
           gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
-                    tab_height);
+                    tab_height));
       tab_x = end_of_tab + kTabHOffset;
       last_was_mini = tab->data().mini;
     }
   }
 
   // Update bounds of new tab button.
   int new_tab_x;
   int new_tab_y = browser_defaults::kSizeTabButtonToTopOfTabStrip ?
       0 : kNewTabButtonVOffset;
   if (abs(Round(unselected) - Tab::GetStandardSize().width()) > 1 &&
       available_width_for_tabs_ == -1) {
     // We're shrinking tabs, so we need to anchor the New Tab button to the
     // right edge of the TabStrip's bounds, rather than the right edge of the
     // right-most Tab, otherwise it'll bounce when animating.
     new_tab_x = width() - newtab_button_bounds_.width();
   } else {
     new_tab_x = Round(tab_x - kTabHOffset) + kNewTabButtonHOffset;
   }
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
 }
 
 void TabStrip::NewTabAnimation1Done() {
-  int tab_data_index = static_cast<int>(tab_data_.size() - 1);
+  int tab_data_index = tab_count() - 1;
   Tab* tab = GetTabAtTabDataIndex(tab_data_index);
 
   gfx::Rect old_tab_bounds = tab->bounds();
 
   GenerateIdealBounds();
 
-  gfx::Rect& end_bounds = tab_data_[tab_data_index].ideal_bounds;
+  gfx::Rect end_bounds = ideal_bounds(tab_data_index);
   end_bounds.Offset(kNewTabOvershoot, 0);
+  set_ideal_bounds(tab_data_index, end_bounds);
 
   int x = old_tab_bounds.right() - end_bounds.width();
   int w = end_bounds.width();
   if (x < 0) {
     w += x;
     x = 0;
   }
   tab->SetBounds(x, old_tab_bounds.y(), w, end_bounds.height());
 
   AnimateToIdealBounds();
@@ skipping 13 matching lines @@
 
   GenerateIdealBounds();
 
   AnimateToIdealBounds();
 
   SlideAnimation* animation = new SlideAnimation(NULL);
   animation->SetSlideDuration(kNewTab3DurationMs);
   animation->SetTweenType(Tween::EASE_IN_OUT);
 
   // BoundsAnimator takes ownership of animation.
-  bounds_animator_.SetAnimationForView(tab_data_.back().tab, animation);
+  bounds_animator_.SetAnimationForView(
+      GetTabAtTabDataIndex(tab_count() - 1), animation);
 }
 
 void TabStrip::AnimateToIdealBounds() {
-  for (size_t i = 0; i < tab_data_.size(); ++i) {
-    if (!tab_data_[i].tab->closing() && !tab_data_[i].tab->dragging()) {
-      bounds_animator_.AnimateViewTo(tab_data_[i].tab,
-                                     tab_data_[i].ideal_bounds);
-    }
+  for (int i = 0; i < tab_count(); ++i) {
+    Tab* tab = GetTabAtTabDataIndex(i);
+    if (!tab->closing() && !tab->dragging())
+      bounds_animator_.AnimateViewTo(tab, ideal_bounds(i));
   }
 
   if (animation_type_ != ANIMATION_NEW_TAB_3) {
     bounds_animator_.AnimateViewTo(newtab_button_, newtab_button_bounds_);
   }
 }
 
 bool TabStrip::ShouldStartIntertTabAnimationAtEnd(int model_index,
                                                   bool foreground) {
   return foreground && (model_index + 1 == GetModelCount()) &&
       controller()->IsNewTabPage(model_index);
 }
 
 void TabStrip::StartResizeLayoutAnimation() {
   ResetAnimationState(true);
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartInsertTabAnimationAtEnd() {
   ResetAnimationState(true);
 
   // The TabStrip can now use its entire width to lay out Tabs.
   available_width_for_tabs_ = -1;
 
   animation_type_ = ANIMATION_NEW_TAB_1;
 
   GenerateIdealBounds();
 
-  int tab_data_index = ModelIndexToTabDataIndex(GetModelCount() - 1);
-  Tab* tab = tab_data_[tab_data_index].tab;
+  int tab_data_index = ModelIndexToTabIndex(GetModelCount() - 1);
+  Tab* tab = GetTabAtTabDataIndex(tab_data_index);
   tab->SizeToNewTabButtonImages();
   tab->SetBounds(newtab_button_->x() +
                      (newtab_button_->width() - tab->width()) / 2,
-                 tab_data_[tab_data_index].ideal_bounds.y(),
+                 ideal_bounds(tab_data_index).y(),
                  tab->width(), tab->height());
   tab->set_render_as_new_tab(true);
 
   new_tab_timer_.Start(base::TimeDelta::FromMilliseconds(kNewTabDurationMs),
                        this, &TabStrip::NewTabAnimation1Done);
 }
 
-void TabStrip::StartInsertTabAnimation(int model_index) {
+void TabStrip::StartInsertTabAnimationImpl(int model_index) {
   ResetAnimationState(true);
 
   // The TabStrip can now use its entire width to lay out Tabs.
   available_width_for_tabs_ = -1;
 
   GenerateIdealBounds();
 
-  int tab_data_index = ModelIndexToTabDataIndex(model_index);
-  Tab* tab = tab_data_[tab_data_index].tab;
+  int tab_data_index = ModelIndexToTabIndex(model_index);
+  BaseTabRenderer* tab = base_tab_at_tab_index(tab_data_index);
   if (model_index == 0) {
-    tab->SetBounds(0, tab_data_[tab_data_index].ideal_bounds.y(), 0,
-                   tab_data_[tab_data_index].ideal_bounds.height());
+    tab->SetBounds(0, ideal_bounds(tab_data_index).y(), 0,
+                   ideal_bounds(tab_data_index).height());
   } else {
-    Tab* last_tab = tab_data_[tab_data_index - 1].tab;
+    BaseTabRenderer* last_tab = base_tab_at_tab_index(tab_data_index - 1);
     tab->SetBounds(last_tab->bounds().right() + kTabHOffset,
-                   tab_data_[tab_data_index].ideal_bounds.y(), 0,
-                   tab_data_[tab_data_index].ideal_bounds.height());
+                   ideal_bounds(tab_data_index).y(), 0,
+                   ideal_bounds(tab_data_index).height());
   }
 
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartRemoveTabAnimation(int model_index) {
   ResetAnimationState(true);
 
   // Mark the tab as closing.
-  int tab_data_index = ModelIndexToTabDataIndex(model_index);
-  Tab* tab = tab_data_[tab_data_index].tab;
+  Tab* tab = GetTabAtModelIndex(model_index);
   tab->set_closing(true);
 
   // Start an animation for the tabs.
   GenerateIdealBounds();
   AnimateToIdealBounds();
 
   // Animate the tab being closed to 0x0.
   gfx::Rect tab_bounds = tab->bounds();
   tab_bounds.set_width(0);
   bounds_animator_.AnimateViewTo(tab, tab_bounds);
 
   // Register delegate to do cleanup when done, BoundsAnimator takes
   // ownership of RemoveTabDelegate.
   bounds_animator_.SetAnimationDelegate(tab, new RemoveTabDelegate(this, tab),
                                         true);
 }
 
-void TabStrip::StartMoveTabAnimation(int from_model_index,
-                                     int to_model_index) {
-  ResetAnimationState(true);
-
-  int from_tab_data_index = ModelIndexToTabDataIndex(from_model_index);
-
-  Tab* tab = tab_data_[from_tab_data_index].tab;
-  tab_data_.erase(tab_data_.begin() + from_tab_data_index);
-
-  TabData data = {tab, gfx::Rect()};
-
-  int to_tab_data_index = ModelIndexToTabDataIndex(to_model_index);
-
-  tab_data_.insert(tab_data_.begin() + to_tab_data_index, data);
-
-  GenerateIdealBounds();
-  AnimateToIdealBounds();
-}
-
 void TabStrip::StartMiniTabAnimation() {
   ResetAnimationState(true);
 
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StopAnimating(bool layout) {
   if (!IsAnimating())
     return;
@@ skipping 19 matching lines @@
 void TabStrip::ResetAnimationState(bool stop_new_tab_timer) {
   if (animation_type_ == ANIMATION_NEW_TAB_2)
     newtab_button_->SchedulePaint();
 
   if (stop_new_tab_timer)
     new_tab_timer_.Stop();
 
   animation_type_ = ANIMATION_DEFAULT;
 
   // Reset the animation state of each tab.
-  for (int i = 0, count = GetTabCount(); i < count; ++i) {
+  for (int i = 0; i < tab_count(); ++i) {
     Tab* tab = GetTabAtTabDataIndex(i);
     tab->set_render_as_new_tab(false);
     tab->set_render_unselected(false);
     tab->set_alpha(1);
   }
 }
 
 int TabStrip::GetMiniTabCount() const {
   int mini_count = 0;
-  for (size_t i = 0; i < tab_data_.size(); ++i) {
-    if (tab_data_[i].tab->data().mini)
+  for (int i = 0; i < tab_count(); ++i) {
+    if (base_tab_at_tab_index(i)->data().mini)
       mini_count++;
     else
       return mini_count;
   }
   return mini_count;
 }
 
 int TabStrip::GetNanoTabCount() const {
   int nano_count = 0;
-  for (size_t i = 0; i < tab_data_.size(); ++i) {
-    if (tab_data_[i].tab->data().app)
+  for (int i = 0; i < tab_count(); ++i) {
+    if (base_tab_at_tab_index(i)->data().app)
       nano_count++;
     else
       return nano_count;
   }
   return nano_count;
 }
 
 int TabStrip::GetAvailableWidthForTabs(Tab* last_tab) const {
   return last_tab->x() + last_tab->width();
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToView(this, tab, &point_in_tab_coords);
   return tab->HitTest(point_in_tab_coords);
 }
 
-void TabStrip::RemoveTab(Tab* tab) {
-  int tab_data_index = TabDataIndexOfTab(tab);
-
-  DCHECK(tab_data_index != -1);
-
-  // Remove the Tab from the TabStrip's list...
-  tab_data_.erase(tab_data_.begin() + tab_data_index);
-
-  delete tab;
-}
-
 void TabStrip::HandleGlobalMouseMoveEvent() {
   if (!IsCursorInTabStripZone()) {
     // Mouse moved outside the tab slop zone, start a timer to do a resize
     // layout after a short while...
     if (resize_layout_factory_.empty()) {
       MessageLoop::current()->PostDelayedTask(FROM_HERE,
           resize_layout_factory_.NewRunnableMethod(
               &TabStrip::ResizeLayoutTabs),
           kResizeTabsTimeMs);
     }
   } else {
     // Mouse moved quickly out of the tab strip and then into it again, so
     // cancel the timer so that the strip doesn't move when the mouse moves
     // back over it.
     resize_layout_factory_.RevokeAll();
   }
 }
 
 bool TabStrip::HasPhantomTabs() const {
-  for (int i = 0; i < GetTabCount(); ++i) {
+  for (int i = 0; i < tab_count(); ++i) {
     if (GetTabAtTabDataIndex(i)->data().phantom)
       return true;
   }
   return false;
 }
-
-int TabStrip::GetModelIndexOfTab(const Tab* tab) const {
-  for (int i = 0, model_index = 0; i < GetTabCount(); ++i) {
-    Tab* current_tab = GetTabAtTabDataIndex(i);
-    if (!current_tab->closing()) {
-      if (current_tab == tab)
-        return model_index;
-      model_index++;
-    }
-  }
-  return -1;
-}
-
-int TabStrip::ModelIndexToTabDataIndex(int model_index) const {
-  int current_model_index = 0;
-  for (size_t i = 0; i < tab_data_.size(); ++i) {
-    if (!tab_data_[i].tab->closing()) {
-      if (current_model_index == model_index)
-        return i;
-      current_model_index++;
-    }
-  }
-  return tab_data_.size();
-}
-
-int TabStrip::TabDataIndexOfTab(Tab* tab) const {
-  for (size_t i = 0; i < tab_data_.size(); ++i) {
-    if (tab_data_[i].tab == tab)
-      return i;
-  }
-  return -1;
-}
-
-void TabStrip::StartedDraggingTab(Tab* tab) {
-  tab->set_dragging(true);
-
-  // Stop any animations on the tab.
-  bounds_animator_.StopAnimatingView(tab);
-
-  // Move the tab to its ideal bounds.
-  GenerateIdealBounds();
-  int tab_data_index = TabDataIndexOfTab(tab);
-  DCHECK(tab_data_index != -1);
-  tab->SetBounds(tab_data_[tab_data_index].ideal_bounds);
-  SchedulePaint();
-}
-
-void TabStrip::StoppedDraggingTab(Tab* tab) {
-  int tab_data_index = TabDataIndexOfTab(tab);
-  if (tab_data_index == -1) {
-    // The tab was removed before the drag completed. Don't do anything.
-    return;
-  }
-
-  // Animate the view back to its correct position.
-  ResetAnimationState(true);
-  GenerateIdealBounds();
-  AnimateToIdealBounds();
-  bounds_animator_.AnimateViewTo(
-      tab,
-      tab_data_[TabDataIndexOfTab(tab)].ideal_bounds);
-
-  // Install a delegate to reset the dragging state when done. We have to leave
-  // dragging true for the tab otherwise it'll draw beneath the new tab button.
-  bounds_animator_.SetAnimationDelegate(tab,
-                                        new ResetDraggingStateDelegate(tab),
-                                        true);
-}