Misc. cleanup:

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 88 matching lines @@
 
 // See UpdateLayoutTypeFromMouseEvent() for a description of these.
 #if !defined(USE_ASH)
 const int kMouseMoveTimeMS = 200;
 const int kMouseMoveCountBeforeConsiderReal = 3;
 #endif
 
 // Amount of time we delay before resizing after a close from a touch.
 const int kTouchResizeLayoutTimeMS = 2000;
 
-// Horizontal offset for the new tab button to bring it closer to the
-// rightmost tab.
-const int kNewTabButtonHorizontalOffset = -11;
-
-// Vertical offset for the new tab button to bring it closer to the
-// rightmost tab.
-const int kNewTabButtonVerticalOffset = 7;
-
 // Amount the left edge of a tab is offset from the rectangle of the tab's
 // favicon/title/close box.  Related to the width of IDR_TAB_ACTIVE_LEFT.
 // Affects the size of the "V" between adjacent tabs.
 const int kTabHorizontalOffset = -26;
 
-// The size of the new tab button must be hardcoded because we need to be
-// able to lay it out before we are able to get its image from the
-// ui::ThemeProvider.  It also makes sense to do this, because the size of the
-// new tab button should not need to be calculated dynamically.
-const int kNewTabButtonAssetWidth = 34;
-const int kNewTabButtonAssetHeight = 18;
-
 // Amount to adjust the clip by when the tab is stacked before the active index.
 const int kStackedTabLeftClip = 20;
 
 // Amount to adjust the clip by when the tab is stacked after the active index.
 const int kStackedTabRightClip = 20;
 
 base::string16 GetClipboardText() {
   if (!ui::Clipboard::IsSupportedClipboardType(ui::CLIPBOARD_TYPE_SELECTION))
     return base::string16();
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
   CHECK(clipboard);
   base::string16 clipboard_text;
   clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &clipboard_text);
   return clipboard_text;
 }
 
 // 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(Tab* tab);
+  virtual ~ResetDraggingStateDelegate();
 
-  virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE {
-    tab_->set_dragging(false);
-  }
-
-  virtual void AnimationCanceled(const gfx::Animation* animation) OVERRIDE {
-    tab_->set_dragging(false);
-  }
+  virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE;
+  virtual void AnimationCanceled(const gfx::Animation* animation) OVERRIDE;
 
  private:
   Tab* tab_;
 
   DISALLOW_COPY_AND_ASSIGN(ResetDraggingStateDelegate);
 };
 
+ResetDraggingStateDelegate::ResetDraggingStateDelegate(Tab* tab) : tab_(tab) {
+}
+
+ResetDraggingStateDelegate::~ResetDraggingStateDelegate() {
+}
+
+void ResetDraggingStateDelegate::AnimationEnded(
+    const gfx::Animation* animation) {
+  tab_->set_dragging(false);
+}
+
+void ResetDraggingStateDelegate::AnimationCanceled(
+    const gfx::Animation* animation) {
+  AnimationEnded(animation);
+}
+
 // If |dest| contains the point |point_in_source| the event handler from |dest|
 // is returned. Otherwise NULL is returned.
 views::View* ConvertPointToViewAndGetEventHandler(
     views::View* source,
     views::View* dest,
     const gfx::Point& point_in_source) {
   gfx::Point dest_point(point_in_source);
   views::View::ConvertPointToTarget(source, dest, &dest_point);
   return dest->HitTestPoint(dest_point) ?
       dest->GetEventHandlerForPoint(dest_point) : NULL;
@@ skipping 182 matching lines @@
   // The new tab background is mirrored in RTL mode, but the theme background
   // should never be mirrored. Mirror it here to compensate.
   float x_scale = 1.0f;
   int x = GetMirroredX() + background_offset_.x();
   if (base::i18n::IsRTL()) {
     x_scale = -1.0f;
     // Offset by |width| such that the same region is painted as if there was no
     // flip.
     x += width;
   }
-  canvas.TileImageInt(*background, x, kNewTabButtonVerticalOffset + offset_y,
+  canvas.TileImageInt(*background, x,
+                      TabStrip::kNewTabButtonVerticalOffset + offset_y,
                       x_scale, 1.0f, 0, 0, width, height);
 
   if (alpha != 255) {
     SkPaint paint;
     paint.setColor(SkColorSetARGB(alpha, 255, 255, 255));
     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
     paint.setStyle(SkPaint::kFill_Style);
     canvas.DrawRect(gfx::Rect(0, 0, width, height), paint);
   }
 
@@ skipping 46 matching lines @@
   virtual ~NewTabButtonTargeter() {}
 
  private:
   // views::MaskedViewTargeter:
   virtual bool GetHitTestMask(const views::View* view,
                               gfx::Path* mask) const OVERRIDE {
     DCHECK(mask);
     DCHECK_EQ(view, masked_view());
 
     SkScalar w = SkIntToScalar(view->width());
-    SkScalar v_offset = SkIntToScalar(kNewTabButtonVerticalOffset);
+    SkScalar v_offset = SkIntToScalar(TabStrip::kNewTabButtonVerticalOffset);
 
     // These values are defined by the shape of the new tab image. Should that
     // image ever change, these values will need to be updated. They're so
     // custom it's not really worth defining constants for.
     // These values are correct for regular and USE_ASH versions of the image.
     mask->moveTo(0, v_offset + 1);
     mask->lineTo(w - 7, v_offset + 1);
     mask->lineTo(w - 4, v_offset + 4);
     mask->lineTo(w, v_offset + 16);
     mask->lineTo(w - 1, v_offset + 17);
@@ skipping 41 matching lines @@
       tab_(tab) {
 }
 
 void TabStrip::RemoveTabDelegate::AnimationEnded(
     const gfx::Animation* animation) {
   CompleteRemove();
 }
 
 void TabStrip::RemoveTabDelegate::AnimationCanceled(
     const gfx::Animation* animation) {
-  CompleteRemove();
+  AnimationEnded(animation);
 }
 
 void TabStrip::RemoveTabDelegate::CompleteRemove() {
   DCHECK(tab_->closing());
   tabstrip_->RemoveAndDeleteTab(tab_);
   HighlightCloseButton();
 }
 
 void TabStrip::RemoveTabDelegate::HighlightCloseButton() {
   if (tabstrip_->IsDragSessionActive() ||
       !tabstrip_->ShouldHighlightCloseButtonAfterRemove()) {
     // This function is not required (and indeed may crash!) for removes
     // spawned by non-mouse closes and drag-detaches.
     return;
   }
 
   views::Widget* widget = tabstrip_->GetWidget();
   // This can be null during shutdown. See http://crbug.com/42737.
   if (!widget)
     return;
 
   widget->SynthesizeMouseMoveEvent();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 // static
 const char TabStrip::kViewClassName[] = "TabStrip";
-
-// static
+const int TabStrip::kNewTabButtonHorizontalOffset = -11;
+const int TabStrip::kNewTabButtonVerticalOffset = 7;
 const int TabStrip::kMiniToNonMiniGap = 3;
+const int TabStrip::kNewTabButtonAssetWidth = 34;
+const int TabStrip::kNewTabButtonAssetHeight = 18;
 
 TabStrip::TabStrip(TabStripController* controller)
     : controller_(controller),
       newtab_button_(NULL),
       current_unselected_width_(Tab::GetStandardSize().width()),
       current_selected_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       in_tab_close_(false),
       animation_container_(new gfx::AnimationContainer()),
       bounds_animator_(this),
@@ skipping 40 matching lines @@
   const int active_index = controller_->GetActiveIndex();
   int active_center = 0;
   if (active_index != -1) {
     active_center = ideal_bounds(active_index).x() +
         ideal_bounds(active_index).width() / 2;
   }
   stacked_layout_ = stacked_layout;
   SetResetToShrinkOnExit(false);
   SwapLayoutIfNecessary();
   // When transitioning to stacked try to keep the active tab centered.
-  if (touch_layout_.get() && active_index != -1) {
+  if (touch_layout_ && active_index != -1) {
     touch_layout_->SetActiveTabLocation(
         active_center - ideal_bounds(active_index).width() / 2);
     AnimateToIdealBounds();
   }
 }
 
 gfx::Rect TabStrip::GetNewTabButtonBounds() {
   return newtab_button_->bounds();
 }
 
@@ skipping 23 matching lines @@
   if (drag_controller_.get() && !drag_controller_->is_mutating() &&
       drag_controller_->is_dragging_window()) {
     EndDrag(END_DRAG_COMPLETE);
   }
   Tab* tab = CreateTab();
   tab->SetData(data);
   UpdateTabsClosingMap(model_index, 1);
   tabs_.Add(tab, model_index);
   AddChildView(tab);
 
-  if (touch_layout_.get()) {
+  if (touch_layout_) {
     GenerateIdealBoundsForMiniTabs(NULL);
     int add_types = 0;
     if (data.mini)
       add_types |= StackedTabStripLayout::kAddTypeMini;
     if (is_active)
       add_types |= StackedTabStripLayout::kAddTypeActive;
     touch_layout_->AddTab(model_index, add_types, GetStartXForNormalTabs());
   }
 
   // Don't animate the first tab, it looks weird, and don't animate anything
   // if the containing window isn't visible yet.
   if (tab_count() > 1 && GetWidget() && GetWidget()->IsVisible())
     StartInsertTabAnimation(model_index);
   else
     DoLayout();
 
   SwapLayoutIfNecessary();
 
   FOR_EACH_OBSERVER(TabStripObserver, observers_,
                     TabStripAddedTabAt(this, model_index));
 }
 
 void TabStrip::MoveTab(int from_model_index,
                        int to_model_index,
                        const TabRendererData& data) {
   DCHECK_GT(tabs_.view_size(), 0);
-  Tab* last_tab = tab_at(tab_count() - 1);
+  const Tab* last_tab = GetLastVisibleTab();
   tab_at(from_model_index)->SetData(data);
-  if (touch_layout_.get()) {
+  if (touch_layout_) {
     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())) {
+      (last_tab != GetLastVisibleTab() || last_tab->dragging())) {
     newtab_button_->SetVisible(false);
   }
   SwapLayoutIfNecessary();
 
   FOR_EACH_OBSERVER(TabStripObserver, observers_,
                     TabStripMovedTab(this, from_model_index, to_model_index));
 }
 
 void TabStrip::RemoveTabAt(int model_index) {
-  if (touch_layout_.get()) {
+  if (touch_layout_) {
     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();
 
   FOR_EACH_OBSERVER(TabStripObserver, observers_,
                     TabStripRemovedTabAt(this, model_index));
 }
 
 void TabStrip::SetTabData(int model_index, const TabRendererData& data) {
   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()) {
+    if (touch_layout_) {
       int mini_tab_count = 0;
       int start_x = GenerateIdealBoundsForMiniTabs(&mini_tab_count);
       touch_layout_->SetXAndMiniCount(start_x, mini_tab_count);
     }
     if (GetWidget() && GetWidget()->IsVisible())
       StartMiniTabAnimation();
     else
       DoLayout();
   }
   SwapLayoutIfNecessary();
 }
 
 void TabStrip::PrepareForCloseAt(int model_index, CloseTabSource source) {
   if (!in_tab_close_ && IsAnimating()) {
     // Cancel any current animations. We do this as remove uses the current
     // ideal bounds and we need to know ideal bounds is in a good state.
     StopAnimating(true);
   }
 
   if (!GetWidget())
     return;
 
   int model_count = GetModelCount();
-  if (model_index + 1 != model_count && model_count > 1) {
+  if (model_count > 1 && model_index != model_count - 1) {
     // The user is about to close a tab other than the last tab. Set
     // available_width_for_tabs_ so that if we do a layout we don't position a
     // tab past the end of the second to last tab. We do this so that as the
     // user closes tabs with the mouse a tab continues to fall under the mouse.
     Tab* last_tab = tab_at(model_count - 1);
     Tab* tab_being_removed = tab_at(model_index);
     available_width_for_tabs_ = last_tab->x() + last_tab->width() -
         tab_being_removed->width() - kTabHorizontalOffset;
     if (model_index == 0 && tab_being_removed->data().mini &&
         !tab_at(1)->data().mini) {
       available_width_for_tabs_ -= kMiniToNonMiniGap;
     }
   }
 
   in_tab_close_ = true;
   resize_layout_timer_.Stop();
   if (source == CLOSE_TAB_FROM_TOUCH) {
     StartResizeLayoutTabsFromTouchTimer();
   } else {
     AddMessageLoopObserver();
   }
 }
 
 void TabStrip::SetSelection(const ui::ListSelectionModel& old_selection,
                             const ui::ListSelectionModel& new_selection) {
-  if (touch_layout_.get()) {
+  if (touch_layout_) {
     touch_layout_->SetActiveIndex(new_selection.active());
     // Only start an animation if we need to. Otherwise clicking on an
     // unselected tab and dragging won't work because dragging is only allowed
     // if not animating.
     if (!views::ViewModelUtils::IsAtIdealBounds(tabs_))
       AnimateToIdealBounds();
     SchedulePaint();
   } else {
     // We have "tiny tabs" if the tabs are so tiny that the unselected ones are
     // a different size to the selected ones.
@@ skipping 12 matching lines @@
   for (size_t i = 0; i < no_longer_selected.size(); ++i)
     tab_at(no_longer_selected[i])->StopMiniTabTitleAnimation();
 }
 
 void TabStrip::TabTitleChangedNotLoading(int model_index) {
   Tab* tab = tab_at(model_index);
   if (tab->data().mini && !tab->IsActive())
     tab->StartMiniTabTitleAnimation();
 }
 
-Tab* TabStrip::tab_at(int index) const {
-  return static_cast<Tab*>(tabs_.view_at(index));
-}
-
 int TabStrip::GetModelIndexOfTab(const Tab* tab) const {
   return tabs_.GetIndexOfView(tab);
 }
 
 int TabStrip::GetModelCount() const {
   return controller_->GetCount();
 }
 
 bool TabStrip::IsValidModelIndex(int model_index) const {
   return controller_->IsValidIndex(model_index);
@@ skipping 52 matching lines @@
   // processed for them.
   return false;
 }
 
 void TabStrip::SetBackgroundOffset(const gfx::Point& offset) {
   for (int i = 0; i < tab_count(); ++i)
     tab_at(i)->set_background_offset(offset);
   newtab_button_->set_background_offset(offset);
 }
 
-views::View* TabStrip::newtab_button() {
-  return newtab_button_;
-}
-
 void TabStrip::SetImmersiveStyle(bool enable) {
   if (immersive_style_ == enable)
     return;
   immersive_style_ = enable;
 }
 
 bool TabStrip::IsAnimating() const {
   return bounds_animator_.IsAnimating();
 }
 
@@ skipping 11 matching lines @@
   if (drop_info_.get() && drop_info_->url == url)
     drop_info_->file_supported = supported;
 }
 
 const ui::ListSelectionModel& TabStrip::GetSelectionModel() {
   return controller_->GetSelectionModel();
 }
 
 bool TabStrip::SupportsMultipleSelection() {
   // TODO: currently only allow single selection in touch layout mode.
-  return touch_layout_.get() == NULL;
+  return touch_layout_ == NULL;
 }
 
 void TabStrip::SelectTab(Tab* tab) {
   int model_index = GetModelIndexOfTab(tab);
   if (IsValidModelIndex(model_index))
     controller_->SelectTab(model_index);
 }
 
 void TabStrip::ExtendSelectionTo(Tab* tab) {
   int model_index = GetModelIndexOfTab(tab);
@@ skipping 11 matching lines @@
   int model_index = GetModelIndexOfTab(tab);
   if (IsValidModelIndex(model_index))
     controller_->AddSelectionFromAnchorTo(model_index);
 }
 
 void TabStrip::CloseTab(Tab* tab, CloseTabSource source) {
   if (tab->closing()) {
     // If the tab is already closing, close the next tab. We do this so that the
     // user can rapidly close tabs by clicking the close button and not have
     // the animations interfere with that.
-    for (TabsClosingMap::const_iterator i(tabs_closing_map_.begin());
-         i != tabs_closing_map_.end(); ++i) {
-      std::vector<Tab*>::const_iterator j =
-          std::find(i->second.begin(), i->second.end(), tab);
-      if (j != i->second.end()) {
-        if (i->first + 1 < GetModelCount())
-          controller_->CloseTab(i->first + 1, source);
-        return;
-      }
-    }
-    // If we get here, it means a tab has been marked as closing but isn't in
-    // the set of known closing tabs.
-    NOTREACHED();
+    const int closed_tab_index = FindClosingTab(tab).first->first;
+    if (closed_tab_index < GetModelCount())
+      controller_->CloseTab(closed_tab_index, source);
     return;
   }
   int model_index = GetModelIndexOfTab(tab);
   if (IsValidModelIndex(model_index))
     controller_->CloseTab(model_index, source);
 }
 
 void TabStrip::ShowContextMenuForTab(Tab* tab,
                                      const gfx::Point& p,
                                      ui::MenuSourceType source_type) {
@@ skipping 36 matching lines @@
 
   // Do not do any dragging of tabs when using the super short immersive style.
   if (IsImmersiveStyle())
     return;
 
   int model_index = GetModelIndexOfTab(tab);
   if (!IsValidModelIndex(model_index)) {
     CHECK(false);
     return;
   }
-  std::vector<Tab*> tabs;
+  Tabs 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) {
     Tab* other_tab = tab_at(i);
     if (IsTabSelected(other_tab)) {
       tabs.push_back(other_tab);
       if (other_tab == tab) {
@@ skipping 15 matching lines @@
       TabDragController::DETACHABLE;
   TabDragController::MoveBehavior move_behavior =
       TabDragController::REORDER;
   // Use MOVE_VISIBILE_TABS in the following conditions:
   // . Mouse event generated from touch and the left button is down (the right
   //   button corresponds to a long press, which we want to reorder).
   // . Gesture begin and control key isn't down.
   // . Real mouse event and control is down. This is mostly for testing.
   DCHECK(event.type() == ui::ET_MOUSE_PRESSED ||
          event.type() == ui::ET_GESTURE_BEGIN);
-  if (touch_layout_.get() &&
+  if (touch_layout_ &&
       ((event.type() == ui::ET_MOUSE_PRESSED &&
         (((event.flags() & ui::EF_FROM_TOUCH) &&
           static_cast<const ui::MouseEvent&>(event).IsLeftMouseButton()) ||
          (!(event.flags() & ui::EF_FROM_TOUCH) &&
           static_cast<const ui::MouseEvent&>(event).IsControlDown()))) ||
        (event.type() == ui::ET_GESTURE_BEGIN && !event.IsControlDown()))) {
     move_behavior = TabDragController::MOVE_VISIBILE_TABS;
   }
 
   drag_controller_.reset(new TabDragController);
@@ skipping 34 matching lines @@
   return view && view->id() == VIEW_ID_TAB ? static_cast<Tab*>(view) : NULL;
 }
 
 void TabStrip::OnMouseEventInTab(views::View* source,
                                  const ui::MouseEvent& event) {
   UpdateStackedLayoutFromMouseEvent(source, event);
 }
 
 bool TabStrip::ShouldPaintTab(const Tab* tab, gfx::Rect* clip) {
   // Only touch layout needs to restrict the clip.
-  if (!(touch_layout_.get() || IsStackingDraggedTabs()))
+  if (!touch_layout_ && !IsStackingDraggedTabs())
     return true;
 
   int index = GetModelIndexOfTab(tab);
   if (index == -1)
     return true;  // Tab is closing, paint it all.
 
   int active_index = IsStackingDraggedTabs() ?
       controller_->GetActiveIndex() : touch_layout_->active_index();
   if (active_index == tab_count())
     active_index--;
 
   if (index < active_index) {
     if (tab_at(index)->x() == tab_at(index + 1)->x())
       return false;
 
     if (tab_at(index)->x() > tab_at(index + 1)->x())
       return true;  // Can happen during dragging.
 
-    clip->SetRect(0, 0, tab_at(index + 1)->x() - tab_at(index)->x() +
-                      kStackedTabLeftClip,
-                  tab_at(index)->height());
+    clip->SetRect(
+        0, 0, tab_at(index + 1)->x() - tab_at(index)->x() + kStackedTabLeftClip,
+        tab_at(index)->height());
   } else if (index > active_index && index > 0) {
     const gfx::Rect& tab_bounds(tab_at(index)->bounds());
     const gfx::Rect& previous_tab_bounds(tab_at(index - 1)->bounds());
     if (tab_bounds.x() == previous_tab_bounds.x())
       return false;
 
     if (tab_bounds.x() < previous_tab_bounds.x())
       return true;  // Can happen during dragging.
 
     if (previous_tab_bounds.right() + kTabHorizontalOffset != tab_bounds.x()) {
@@ skipping 29 matching lines @@
     return;
   DoLayout();
 }
 
 void TabStrip::PaintChildren(gfx::Canvas* canvas,
                              const views::CullSet& cull_set) {
   // The view order doesn't match the paint order (tabs_ contains the tab
   // ordering). Additionally we need to paint the tabs that are closing in
   // |tabs_closing_map_|.
   Tab* active_tab = NULL;
-  std::vector<Tab*> tabs_dragging;
-  std::vector<Tab*> selected_tabs;
+  Tabs tabs_dragging;
+  Tabs selected_tabs;
   int selected_tab_count = 0;
   bool is_dragging = false;
   int active_tab_index = -1;
-  // Since |touch_layout_| is created based on number of tabs and width we use
-  // the ideal state to determine if we should paint stacked. This minimizes
-  // painting changes as we switch between the two.
-  const bool stacking = stacked_layout_ || IsStackingDraggedTabs();
 
   const chrome::HostDesktopType host_desktop_type =
       chrome::GetHostDesktopTypeForNativeView(GetWidget()->GetNativeView());
   const int inactive_tab_alpha =
-      host_desktop_type == chrome::HOST_DESKTOP_TYPE_ASH ?
-      kInactiveTabAndNewTabButtonAlphaAsh :
-      kInactiveTabAndNewTabButtonAlpha;
+      (host_desktop_type == chrome::HOST_DESKTOP_TYPE_ASH) ?
+      kInactiveTabAndNewTabButtonAlphaAsh : kInactiveTabAndNewTabButtonAlpha;
 
   if (inactive_tab_alpha < 255)
     canvas->SaveLayerAlpha(inactive_tab_alpha);
 
   PaintClosingTabs(canvas, tab_count(), cull_set);
 
   for (int i = tab_count() - 1; i >= 0; --i) {
     Tab* tab = tab_at(i);
     if (tab->IsSelected())
       selected_tab_count++;
-    if (tab->dragging() && !stacking) {
+    if (tab->dragging() && !stacked_layout_) {
       is_dragging = true;
       if (tab->IsActive()) {
         active_tab = tab;
         active_tab_index = i;
       } else {
         tabs_dragging.push_back(tab);
       }
     } else if (!tab->IsActive()) {
       if (!tab->IsSelected()) {
-        if (!stacking)
+        if (!stacked_layout_)
           tab->Paint(canvas, cull_set);
       } else {
         selected_tabs.push_back(tab);
       }
     } else {
       active_tab = tab;
       active_tab_index = i;
     }
     PaintClosingTabs(canvas, i, cull_set);
   }
 
   // Draw from the left and then the right if we're in touch mode.
-  if (stacking && active_tab_index >= 0) {
+  if (stacked_layout_ && active_tab_index >= 0) {
     for (int i = 0; i < active_tab_index; ++i) {
       Tab* tab = tab_at(i);
       tab->Paint(canvas, cull_set);
     }
 
     for (int i = tab_count() - 1; i > active_tab_index; --i) {
       Tab* tab = tab_at(i);
       tab->Paint(canvas, cull_set);
     }
   }
@@ skipping 43 matching lines @@
 const char* TabStrip::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::Size TabStrip::GetPreferredSize() const {
   // For stacked tabs the minimum size is calculated as the size needed to
   // handle showing any number of tabs. Otherwise report the minimum width as
   // the size required for a single selected tab plus the new tab button. Don't
   // base it on the actual number of tabs because it's undesirable to have the
   // minimum window size change when a new tab is opened.
-  int needed_width;
-  if (touch_layout_.get() || adjust_layout_) {
-    needed_width = Tab::GetTouchWidth() +
-        (2 * kStackedPadding * kMaxStackedCount);
-  } else {
-    needed_width = Tab::GetMinimumSelectedSize().width();
-  }
-  needed_width += new_tab_button_width();
-  if (immersive_style_)
-    return gfx::Size(needed_width, Tab::GetImmersiveHeight());
-  return gfx::Size(needed_width, Tab::GetMinimumUnselectedSize().height());
+  const int needed_tab_width = (touch_layout_ || adjust_layout_) ?
+      (Tab::GetTouchWidth() + (2 * kStackedPadding * kMaxStackedCount)) :
+      Tab::GetMinimumSelectedSize().width();
+  return gfx::Size(needed_tab_width + new_tab_button_width(), immersive_style_ ?
+      Tab::GetImmersiveHeight() : Tab::GetMinimumUnselectedSize().height());
 }
 
 void TabStrip::OnDragEntered(const DropTargetEvent& event) {
   // Force animations to stop, otherwise it makes the index calculation tricky.
   StopAnimating(true);
 
   UpdateDropIndex(event);
 
   GURL url;
   base::string16 title;
@@ skipping 53 matching lines @@
 
 void TabStrip::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_TAB_LIST;
 }
 
 views::View* TabStrip::GetEventHandlerForRect(const gfx::Rect& rect) {
   if (!views::UsePointBasedTargeting(rect))
     return View::GetEventHandlerForRect(rect);
   const gfx::Point point(rect.CenterPoint());
 
-  if (!touch_layout_.get()) {
+  if (!touch_layout_) {
     // Return any view that isn't a Tab or this TabStrip immediately. We don't
     // want to interfere.
     views::View* v = View::GetEventHandlerForRect(rect);
     if (v && v != this && strcmp(v->GetClassName(), Tab::kViewClassName))
       return v;
 
     views::View* tab = FindTabHitByPoint(point);
     if (tab)
       return tab;
   } else {
     if (newtab_button_->visible()) {
       views::View* view =
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }
 
 views::View* TabStrip::GetTooltipHandlerForPoint(const gfx::Point& point) {
   if (!HitTestPoint(point))
     return NULL;
 
-  if (!touch_layout_.get()) {
+  if (!touch_layout_) {
     // Return any view that isn't a Tab or this TabStrip immediately. We don't
     // want to interfere.
     views::View* v = View::GetTooltipHandlerForPoint(point);
     if (v && v != this && strcmp(v->GetClassName(), Tab::kViewClassName))
       return v;
 
     views::View* tab = FindTabHitByPoint(point);
     if (tab)
       return tab;
   } else {
     if (newtab_button_->visible()) {
       views::View* view =
           ConvertPointToViewAndGetTooltipHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetTooltipHandler(this, tab, point);
   }
   return this;
 }
 
 // static
 int TabStrip::GetImmersiveHeight() {
   return Tab::GetImmersiveHeight();
 }
 
-int TabStrip::GetMiniTabCount() const {
-  int mini_count = 0;
-  while (mini_count < tab_count() && tab_at(mini_count)->data().mini)
-    mini_count++;
-  return mini_count;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// TabStrip, views::ButtonListener implementation:
-
-void TabStrip::ButtonPressed(views::Button* sender, const ui::Event& event) {
-  if (sender == newtab_button_) {
-    content::RecordAction(UserMetricsAction("NewTab_Button"));
-    UMA_HISTOGRAM_ENUMERATION("Tab.NewTab", TabStripModel::NEW_TAB_BUTTON,
-                              TabStripModel::NEW_TAB_ENUM_COUNT);
-    if (event.IsMouseEvent()) {
-      const ui::MouseEvent& mouse = static_cast<const ui::MouseEvent&>(event);
-      if (mouse.IsOnlyMiddleMouseButton()) {
-        base::string16 clipboard_text = GetClipboardText();
-        if (!clipboard_text.empty())
-          controller()->CreateNewTabWithLocation(clipboard_text);
-        return;
-      }
-    }
-
-    controller()->CreateNewTab();
-    if (event.type() == ui::ET_GESTURE_TAP)
-      TouchUMA::RecordGestureAction(TouchUMA::GESTURE_NEWTAB_TAP);
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// TabStrip, protected:
-
-// Overridden to support automation. See automation_proxy_uitest.cc.
-const views::View* TabStrip::GetViewByID(int view_id) const {
-  if (tab_count() > 0) {
-    if (view_id == VIEW_ID_TAB_LAST) {
-      return tab_at(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 < tab_count()) {
-        return tab_at(index);
-      } else {
-        return NULL;
-      }
-    }
-  }
-
-  return View::GetViewByID(view_id);
-}
-
-bool TabStrip::OnMousePressed(const ui::MouseEvent& event) {
-  UpdateStackedLayoutFromMouseEvent(this, event);
-  // We can't return true here, else clicking in an empty area won't drag the
-  // window.
-  return false;
-}
-
-bool TabStrip::OnMouseDragged(const ui::MouseEvent& event) {
-  ContinueDrag(this, event);
-  return true;
-}
-
-void TabStrip::OnMouseReleased(const ui::MouseEvent& event) {
-  EndDrag(END_DRAG_COMPLETE);
-  UpdateStackedLayoutFromMouseEvent(this, event);
-}
-
-void TabStrip::OnMouseCaptureLost() {
-  EndDrag(END_DRAG_CAPTURE_LOST);
-}
-
-void TabStrip::OnMouseMoved(const ui::MouseEvent& event) {
-  UpdateStackedLayoutFromMouseEvent(this, event);
-}
-
-void TabStrip::OnMouseEntered(const ui::MouseEvent& event) {
-  SetResetToShrinkOnExit(true);
-}
-
-void TabStrip::OnGestureEvent(ui::GestureEvent* event) {
-  SetResetToShrinkOnExit(false);
-  switch (event->type()) {
-    case ui::ET_GESTURE_SCROLL_END:
-    case ui::ET_SCROLL_FLING_START:
-    case ui::ET_GESTURE_END:
-      EndDrag(END_DRAG_COMPLETE);
-      if (adjust_layout_) {
-        SetStackedLayout(true);
-        controller_->StackedLayoutMaybeChanged();
-      }
-      break;
-
-    case ui::ET_GESTURE_LONG_PRESS:
-      if (drag_controller_.get())
-        drag_controller_->SetMoveBehavior(TabDragController::REORDER);
-      break;
-
-    case ui::ET_GESTURE_LONG_TAP: {
-      EndDrag(END_DRAG_CANCEL);
-      gfx::Point local_point = event->location();
-      Tab* tab = FindTabForEvent(local_point);
-      if (tab) {
-        ConvertPointToScreen(this, &local_point);
-        ShowContextMenuForTab(tab, local_point, ui::MENU_SOURCE_TOUCH);
-      }
-      break;
-    }
-
-    case ui::ET_GESTURE_SCROLL_UPDATE:
-      ContinueDrag(this, *event);
-      break;
-
-    case ui::ET_GESTURE_BEGIN:
-      EndDrag(END_DRAG_CANCEL);
-      break;
-
-    case ui::ET_GESTURE_TAP: {
-      const int active_index = controller_->GetActiveIndex();
-      DCHECK_NE(-1, active_index);
-      Tab* active_tab = tab_at(active_index);
-      TouchUMA::GestureActionType action = TouchUMA::GESTURE_TABNOSWITCH_TAP;
-      if (active_tab->tab_activated_with_last_gesture_begin())
-        action = TouchUMA::GESTURE_TABSWITCH_TAP;
-      TouchUMA::RecordGestureAction(action);
-      break;
-    }
-
-    default:
-      break;
-  }
-  event->SetHandled();
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
   // So we get enter/exit on children to switch stacked layout on and off.
   set_notify_enter_exit_on_child(true);
   newtab_button_bounds_.SetRect(0,
                                 0,
                                 kNewTabButtonAssetWidth,
@@ skipping 63 matching lines @@
   RemoveTabFromViewModel(model_index);
 
   ScheduleRemoveTabAnimation(tab);
 }
 
 void TabStrip::ScheduleRemoveTabAnimation(Tab* tab) {
   // Start an animation for the tabs.
   GenerateIdealBounds();
   AnimateToIdealBounds();
 
-  // Animate the tab being closed to 0x0.
+  // Animate the tab being closed to zero width.
   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);
 
   // Don't animate the new tab button when dragging tabs. Otherwise it looks
@@ skipping 19 matching lines @@
   return in_tab_close_;
 }
 
 void TabStrip::DoLayout() {
   last_layout_size_ = size();
 
   StopAnimating(false);
 
   SwapLayoutIfNecessary();
 
-  if (touch_layout_.get())
-    touch_layout_->SetWidth(size().width() - new_tab_button_width());
+  if (touch_layout_)
+    touch_layout_->SetWidth(tab_area_width());
 
   GenerateIdealBounds();
 
   views::ViewModelUtils::SetViewBoundsToIdealBounds(tabs_);
 
   SchedulePaint();
 
   bounds_animator_.StopAnimatingView(newtab_button_);
   newtab_button_->SetBoundsRect(newtab_button_bounds_);
 }
 
 void TabStrip::DragActiveTab(const std::vector<int>& initial_positions,
                              int delta) {
   DCHECK_EQ(tab_count(), static_cast<int>(initial_positions.size()));
-  if (!touch_layout_.get()) {
+  if (!touch_layout_) {
     StackDraggedTabs(delta);
     return;
   }
   SetIdealBoundsFromPositions(initial_positions);
   touch_layout_->DragActiveTab(delta);
   DoLayout();
 }
 
 void TabStrip::SetIdealBoundsFromPositions(const std::vector<int>& positions) {
   if (static_cast<size_t>(tab_count()) != positions.size())
     return;
 
   for (int i = 0; i < tab_count(); ++i) {
     gfx::Rect bounds(ideal_bounds(i));
     bounds.set_x(positions[i]);
-    set_ideal_bounds(i, bounds);
+    tabs_.set_ideal_bounds(i, bounds);
   }
 }
 
 void TabStrip::StackDraggedTabs(int delta) {
-  DCHECK(!touch_layout_.get());
+  DCHECK(!touch_layout_);
   GenerateIdealBounds();
   const int active_index = controller_->GetActiveIndex();
   DCHECK_NE(-1, active_index);
   if (delta < 0) {
     // Drag the tabs to the left, stacking tabs before the active tab.
     const int adjusted_delta =
         std::min(ideal_bounds(active_index).x() -
                      kStackedPadding * std::min(active_index, kMaxStackedCount),
                  -delta);
     for (int i = 0; i <= active_index; ++i) {
       const int min_x = std::min(i, kMaxStackedCount) * kStackedPadding;
       gfx::Rect new_bounds(ideal_bounds(i));
       new_bounds.set_x(std::max(min_x, new_bounds.x() - adjusted_delta));
-      set_ideal_bounds(i, new_bounds);
+      tabs_.set_ideal_bounds(i, new_bounds);
     }
     const bool is_active_mini = tab_at(active_index)->data().mini;
     const int active_width = ideal_bounds(active_index).width();
     for (int i = active_index + 1; i < tab_count(); ++i) {
       const int max_x = ideal_bounds(active_index).x() +
           (kStackedPadding * std::min(i - active_index, kMaxStackedCount));
       gfx::Rect new_bounds(ideal_bounds(i));
       int new_x = std::max(new_bounds.x() + delta, max_x);
       if (new_x == max_x && !tab_at(i)->data().mini && !is_active_mini &&
           new_bounds.width() != active_width)
         new_x += (active_width - new_bounds.width());
       new_bounds.set_x(new_x);
-      set_ideal_bounds(i, new_bounds);
+      tabs_.set_ideal_bounds(i, new_bounds);
     }
   } else {
     // Drag the tabs to the right, stacking tabs after the active tab.
     const int last_tab_width = ideal_bounds(tab_count() - 1).width();
-    const int last_tab_x = width() - new_tab_button_width() - last_tab_width;
+    const int last_tab_x = tab_area_width() - last_tab_width;
     if (active_index == tab_count() - 1 &&
         ideal_bounds(tab_count() - 1).x() == last_tab_x)
       return;
     const int adjusted_delta =
         std::min(last_tab_x -
                      kStackedPadding * std::min(tab_count() - active_index - 1,
                                                 kMaxStackedCount) -
                      ideal_bounds(active_index).x(),
                  delta);
     for (int last_index = tab_count() - 1, i = last_index; i >= active_index;
          --i) {
       const int max_x = last_tab_x -
           std::min(tab_count() - i - 1, kMaxStackedCount) * kStackedPadding;
       gfx::Rect new_bounds(ideal_bounds(i));
       int new_x = std::min(max_x, new_bounds.x() + adjusted_delta);
       // Because of rounding not all tabs are the same width. Adjust the
       // position to accommodate this, otherwise the stacking is off.
       if (new_x == max_x && !tab_at(i)->data().mini &&
           new_bounds.width() != last_tab_width)
         new_x += (last_tab_width - new_bounds.width());
       new_bounds.set_x(new_x);
-      set_ideal_bounds(i, new_bounds);
+      tabs_.set_ideal_bounds(i, new_bounds);
     }
     for (int i = active_index - 1; i >= 0; --i) {
       const int min_x = ideal_bounds(active_index).x() -
           std::min(active_index - i, kMaxStackedCount) * kStackedPadding;
       gfx::Rect new_bounds(ideal_bounds(i));
       new_bounds.set_x(std::min(min_x, new_bounds.x() + delta));
-      set_ideal_bounds(i, new_bounds);
+      tabs_.set_ideal_bounds(i, new_bounds);
     }
     if (ideal_bounds(tab_count() - 1).right() >= newtab_button_->x())
       newtab_button_->SetVisible(false);
   }
   views::ViewModelUtils::SetViewBoundsToIdealBounds(tabs_);
   SchedulePaint();
 }
 
 bool TabStrip::IsStackingDraggedTabs() const {
   return drag_controller_.get() && drag_controller_->started_drag() &&
       (drag_controller_->move_behavior() ==
        TabDragController::MOVE_VISIBILE_TABS);
 }
 
-void TabStrip::LayoutDraggedTabsAt(const std::vector<Tab*>& tabs,
+void TabStrip::LayoutDraggedTabsAt(const Tabs& tabs,
                                    Tab* active_tab,
                                    const gfx::Point& location,
                                    bool initial_drag) {
   // Immediately hide the new tab button if the last tab is being dragged.
-  if (tab_at(tab_count() - 1)->dragging())
+  if (GetLastVisibleTab()->dragging())
     newtab_button_->SetVisible(false);
   std::vector<gfx::Rect> bounds;
   CalculateBoundsForDraggedTabs(tabs, &bounds);
   DCHECK_EQ(tabs.size(), bounds.size());
   int active_tab_model_index = GetModelIndexOfTab(active_tab);
   int active_tab_index = static_cast<int>(
       std::find(tabs.begin(), tabs.end(), active_tab) - tabs.begin());
   for (size_t i = 0; i < tabs.size(); ++i) {
     Tab* tab = tabs[i];
     gfx::Rect new_bounds = bounds[i];
     new_bounds.Offset(location.x(), location.y());
     int consecutive_index =
         active_tab_model_index - (active_tab_index - static_cast<int>(i));
     // If this is the initial layout during a drag and the tabs aren't
     // consecutive animate the view into position. Do the same if the tab is
     // already animating (which means we previously caused it to animate).
     if ((initial_drag &&
          GetModelIndexOfTab(tabs[i]) != consecutive_index) ||
         bounds_animator_.IsAnimating(tabs[i])) {
       bounds_animator_.SetTargetBounds(tabs[i], new_bounds);
     } else {
       tab->SetBoundsRect(new_bounds);
     }
   }
 }
 
-void TabStrip::CalculateBoundsForDraggedTabs(const std::vector<Tab*>& tabs,
+void TabStrip::CalculateBoundsForDraggedTabs(const Tabs& tabs,
                                              std::vector<gfx::Rect>* bounds) {
   int x = 0;
   for (size_t i = 0; i < tabs.size(); ++i) {
     Tab* tab = tabs[i];
     if (i > 0 && tab->data().mini != tabs[i - 1]->data().mini)
       x += kMiniToNonMiniGap;
     gfx::Rect new_bounds = tab->bounds();
     new_bounds.set_origin(gfx::Point(x, 0));
     bounds->push_back(new_bounds);
     x += tab->width() + kTabHorizontalOffset;
   }
 }
 
-int TabStrip::GetSizeNeededForTabs(const std::vector<Tab*>& tabs) {
+int TabStrip::GetSizeNeededForTabs(const Tabs& tabs) {
   int width = 0;
   for (size_t i = 0; i < tabs.size(); ++i) {
     Tab* tab = tabs[i];
     width += tab->width();
     if (i > 0 && tab->data().mini != tabs[i - 1]->data().mini)
       width += kMiniToNonMiniGap;
   }
   if (tabs.size() > 0)
     width += kTabHorizontalOffset * static_cast<int>(tabs.size() - 1);
   return width;
 }
 
+int TabStrip::GetMiniTabCount() const {
+  int mini_count = 0;
+  while (mini_count < tab_count() && tab_at(mini_count)->data().mini)
+    mini_count++;
+  return mini_count;
+}
+
+const Tab* TabStrip::GetLastVisibleTab() const {
+  return tab_at(tab_count() - 1);
+}
+
 void TabStrip::RemoveTabFromViewModel(int index) {
   // We still need to paint the tab until we actually remove it. Put it
   // in tabs_closing_map_ so we can find it.
   tabs_closing_map_[index].push_back(tab_at(index));
   UpdateTabsClosingMap(index + 1, -1);
   tabs_.Remove(index);
 }
 
 void TabStrip::RemoveAndDeleteTab(Tab* tab) {
   scoped_ptr<Tab> deleter(tab);
-  for (TabsClosingMap::iterator i(tabs_closing_map_.begin());
-       i != tabs_closing_map_.end(); ++i) {
-    std::vector<Tab*>::iterator j =
-        std::find(i->second.begin(), i->second.end(), tab);
-    if (j != i->second.end()) {
-      i->second.erase(j);
-      if (i->second.empty())
-        tabs_closing_map_.erase(i);
-      return;
-    }
-  }
-  NOTREACHED();
+  FindClosingTabResult res(FindClosingTab(tab));
+  res.first->second.erase(res.second);
+  if (res.first->second.empty())
+    tabs_closing_map_.erase(res.first);
 }
 
 void TabStrip::UpdateTabsClosingMap(int index, int delta) {
   if (tabs_closing_map_.empty())
     return;
 
   if (delta == -1 &&
       tabs_closing_map_.find(index - 1) != tabs_closing_map_.end() &&
       tabs_closing_map_.find(index) != tabs_closing_map_.end()) {
-    const std::vector<Tab*>& tabs(tabs_closing_map_[index]);
+    const Tabs& tabs(tabs_closing_map_[index]);
     tabs_closing_map_[index - 1].insert(
         tabs_closing_map_[index - 1].end(), tabs.begin(), tabs.end());
   }
   TabsClosingMap updated_map;
   for (TabsClosingMap::iterator i(tabs_closing_map_.begin());
        i != tabs_closing_map_.end(); ++i) {
     if (i->first > index)
       updated_map[i->first + delta] = i->second;
     else if (i->first < index)
       updated_map[i->first] = i->second;
   }
   if (delta > 0 && tabs_closing_map_.find(index) != tabs_closing_map_.end())
     updated_map[index + delta] = tabs_closing_map_[index];
   tabs_closing_map_.swap(updated_map);
 }
 
-void TabStrip::StartedDraggingTabs(const std::vector<Tab*>& tabs) {
+void TabStrip::StartedDraggingTabs(const Tabs& tabs) {
   // Let the controller know that the user started dragging tabs.
   controller()->OnStartedDraggingTabs();
 
   // Hide the new tab button immediately if we didn't originate the drag.
   if (!drag_controller_.get())
     newtab_button_->SetVisible(false);
 
   PrepareForAnimation();
 
   // Reset dragging state of existing tabs.
@@ skipping 17 matching lines @@
   SchedulePaint();
 }
 
 void TabStrip::DraggedTabsDetached() {
   // Let the controller know that the user is not dragging this tabstrip's tabs
   // anymore.
   controller()->OnStoppedDraggingTabs();
   newtab_button_->SetVisible(true);
 }
 
-void TabStrip::StoppedDraggingTabs(const std::vector<Tab*>& tabs,
+void TabStrip::StoppedDraggingTabs(const Tabs& tabs,
                                    const std::vector<int>& initial_positions,
                                    bool move_only,
                                    bool completed) {
   // Let the controller know that the user stopped dragging tabs.
   controller()->OnStoppedDraggingTabs();
 
   newtab_button_->SetVisible(true);
-  if (move_only && touch_layout_.get()) {
-    if (completed) {
+  if (move_only && touch_layout_) {
+    if (completed)
       touch_layout_->SizeToFit();
-    } else {
+    else
       SetIdealBoundsFromPositions(initial_positions);
-    }
   }
   bool is_first_tab = true;
   for (size_t i = 0; i < tabs.size(); ++i)
     StoppedDraggingTab(tabs[i], &is_first_tab);
 }
 
 void TabStrip::StoppedDraggingTab(Tab* tab, bool* is_first_tab) {
   int tab_data_index = GetModelIndexOfTab(tab);
   if (tab_data_index == -1) {
     // The tab was removed before the drag completed. Don't do anything.
@@ skipping 29 matching lines @@
 
 void TabStrip::DestroyDragController() {
   newtab_button_->SetVisible(true);
   drag_controller_.reset();
 }
 
 TabDragController* TabStrip::ReleaseDragController() {
   return drag_controller_.release();
 }
 
+TabStrip::FindClosingTabResult TabStrip::FindClosingTab(const Tab* tab) {
+  DCHECK(tab->closing());
+  for (TabsClosingMap::iterator i(tabs_closing_map_.begin());
+       i != tabs_closing_map_.end(); ++i) {
+    Tabs::iterator j = std::find(i->second.begin(), i->second.end(), tab);
+    if (j != i->second.end())
+      return FindClosingTabResult(i, j);
+  }
+  NOTREACHED();
+  return FindClosingTabResult(tabs_closing_map_.end(), Tabs::iterator());
+}
+
 void TabStrip::PaintClosingTabs(gfx::Canvas* canvas,
                                 int index,
                                 const views::CullSet& cull_set) {
   if (tabs_closing_map_.find(index) == tabs_closing_map_.end())
     return;
 
-  const std::vector<Tab*>& tabs = tabs_closing_map_[index];
-  for (std::vector<Tab*>::const_reverse_iterator i(tabs.rbegin());
-       i != tabs.rend(); ++i) {
+  const Tabs& tabs = tabs_closing_map_[index];
+  for (Tabs::const_reverse_iterator i(tabs.rbegin()); i != tabs.rend(); ++i)
     (*i)->Paint(canvas, cull_set);
-  }
 }
 
 void TabStrip::UpdateStackedLayoutFromMouseEvent(views::View* source,
                                                  const ui::MouseEvent& event) {
   if (!adjust_layout_)
     return;
 
   // The following code attempts to switch to shrink (not stacked) layout when
   // the mouse exits the tabstrip (or the mouse is pressed on a stacked tab) and
   // to stacked layout when a touch device is used. This is made problematic by
   // windows generating mouse move events that do not clearly indicate the move
   // is the result of a touch device. This assumes a real mouse is used if
   // |kMouseMoveCountBeforeConsiderReal| mouse move events are received within
   // the time window |kMouseMoveTimeMS|.  At the time we get a mouse press we
   // know whether its from a touch device or not, but we don't layout then else
   // everything shifts. Instead we wait for the release.
   //
   // TODO(sky): revisit this when touch events are really plumbed through.
 
   switch (event.type()) {
     case ui::ET_MOUSE_PRESSED:
       mouse_move_count_ = 0;
       last_mouse_move_time_ = base::TimeTicks();
       SetResetToShrinkOnExit((event.flags() & ui::EF_FROM_TOUCH) == 0);
-      if (reset_to_shrink_on_exit_ && touch_layout_.get()) {
+      if (reset_to_shrink_on_exit_ && touch_layout_) {
         gfx::Point tab_strip_point(event.location());
         views::View::ConvertPointToTarget(source, this, &tab_strip_point);
         Tab* tab = FindTabForEvent(tab_strip_point);
         if (tab && touch_layout_->IsStacked(GetModelIndexOfTab(tab))) {
           SetStackedLayout(false);
           controller_->StackedLayoutMaybeChanged();
         }
       }
       break;
 
@@ skipping 106 matching lines @@
   // When there are multiple tabs, we'll have one selected and some unselected
   // tabs.  If the desired width was between the minimum sizes of these types,
   // try to shrink the tabs with the smaller minimum.  For example, if we have
   // a strip of width 10 with 4 tabs, the desired width per tab will be 2.5.  If
   // selected tabs have a minimum width of 4 and unselected tabs have a minimum
   // width of 1, the above code would set *unselected_width = 2.5,
   // *selected_width = 4, which results in a total width of 11.5.  Instead, we
   // want to set *unselected_width = 2, *selected_width = 4, for a total width
   // of 10.
   if (tab_count > 1) {
-    if ((min_unselected_width < min_selected_width) &&
-        (desired_tab_width < min_selected_width)) {
+    if (desired_tab_width < min_selected_width) {
       // Unselected width = (total width - selected width) / (num_tabs - 1)
       *unselected_width = std::max(static_cast<double>(
           available_width - total_offset - min_selected_width) /
           static_cast<double>(tab_count - 1), min_unselected_width);
-    } else if ((min_unselected_width > min_selected_width) &&
-               (desired_tab_width < min_unselected_width)) {
-      // Selected width = (total width - (unselected width * (num_tabs - 1)))
-      *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 (tab_count() == 0)
     return;
@@ skipping 205 matching lines @@
 void TabStrip::PrepareForAnimation() {
   if (!IsDragSessionActive() && !TabDragController::IsAttachedTo(this)) {
     for (int i = 0; i < tab_count(); ++i)
       tab_at(i)->set_dragging(false);
   }
 }
 
 void TabStrip::GenerateIdealBounds() {
   int new_tab_y = 0;
 
-  if (touch_layout_.get()) {
+  if (touch_layout_) {
     if (tabs_.view_size() == 0)
       return;
 
     int new_tab_x = tabs_.ideal_bounds(tabs_.view_size() - 1).right() +
         kNewTabButtonHorizontalOffset;
     newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
     return;
   }
 
-  double unselected, selected;
-  GetDesiredTabWidths(tab_count(), GetMiniTabCount(), &unselected, &selected);
-  current_unselected_width_ = unselected;
-  current_selected_width_ = selected;
+  GetDesiredTabWidths(tab_count(), GetMiniTabCount(),
+                      &current_unselected_width_, &current_selected_width_);
 
   // 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();
   int first_non_mini_index = 0;
   double tab_x = GenerateIdealBoundsForMiniTabs(&first_non_mini_index);
   for (int i = first_non_mini_index; i < tab_count(); ++i) {
     Tab* tab = tab_at(i);
     DCHECK(!tab->data().mini);
-    double tab_width = tab->IsActive() ? selected : unselected;
+    double tab_width =
+        tab->IsActive() ? current_selected_width_ : current_unselected_width_;
     double end_of_tab = tab_x + tab_width;
     int rounded_tab_x = Round(tab_x);
-    set_ideal_bounds(
+    tabs_.set_ideal_bounds(
         i,
         gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                   tab_height));
     tab_x = end_of_tab + kTabHorizontalOffset;
   }
 
   // Update bounds of new tab button.
   int new_tab_x;
-  if (abs(Round(unselected) - Tab::GetStandardSize().width()) > 1 &&
+  if ((Tab::GetStandardSize().width() - Round(current_unselected_width_)) > 1 &&
       !in_tab_close_) {
     // 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 - kTabHorizontalOffset) +
         kNewTabButtonHorizontalOffset;
   }
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
 }
 
 int TabStrip::GenerateIdealBoundsForMiniTabs(int* first_non_mini_index) {
   int next_x = 0;
   int mini_width = Tab::GetMiniWidth();
   int tab_height = Tab::GetStandardSize().height();
   int index = 0;
   for (; index < tab_count() && tab_at(index)->data().mini; ++index) {
-    set_ideal_bounds(index,
-                     gfx::Rect(next_x, 0, mini_width, tab_height));
+    tabs_.set_ideal_bounds(index, gfx::Rect(next_x, 0, mini_width, tab_height));
     next_x += mini_width + kTabHorizontalOffset;
   }
   if (index > 0 && index < tab_count())
     next_x += kMiniToNonMiniGap;
   if (first_non_mini_index)
     *first_non_mini_index = index;
   return next_x;
 }
 
-// static
-int TabStrip::new_tab_button_width() {
-  return kNewTabButtonAssetWidth + kNewTabButtonHorizontalOffset;
-}
-
-// static
-int TabStrip::button_v_offset() {
-  return kNewTabButtonVerticalOffset;
-}
-
-int TabStrip::tab_area_width() const {
-  return width() - new_tab_button_width();
-}
-
 void TabStrip::StartResizeLayoutAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMiniTabAnimation() {
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
 
   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.
   Tab* tab_closing = tab_at(model_index);
   int delta = tab_closing->width() + kTabHorizontalOffset;
   // 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) {
+  DCHECK_LT(model_index, tab_count() - 1);
+  if (tab_closing->data().mini && !tab_at(model_index + 1)->data().mini)
     delta += kMiniToNonMiniGap;
-  }
 
   for (int i = model_index + 1; i < tab_count(); ++i) {
     gfx::Rect bounds = ideal_bounds(i);
     bounds.set_x(bounds.x() - delta);
-    set_ideal_bounds(i, bounds);
+    tabs_.set_ideal_bounds(i, bounds);
   }
 
   newtab_button_bounds_.set_x(newtab_button_bounds_.x() - delta);
 
   PrepareForAnimation();
 
   tab_closing->set_closing(true);
 
   // We still need to paint the tab until we actually remove it. Put it in
   // tabs_closing_map_ so we can find it.
@@ skipping 22 matching lines @@
 
 int TabStrip::GetStartXForNormalTabs() const {
   int mini_tab_count = GetMiniTabCount();
   if (mini_tab_count == 0)
     return 0;
   return mini_tab_count * (Tab::GetMiniWidth() + kTabHorizontalOffset) +
       kMiniToNonMiniGap;
 }
 
 Tab* TabStrip::FindTabForEvent(const gfx::Point& point) {
-  if (touch_layout_.get()) {
+  if (touch_layout_) {
     int active_tab_index = touch_layout_->active_index();
     if (active_tab_index != -1) {
       Tab* tab = FindTabForEventFrom(point, active_tab_index, -1);
       if (!tab)
         tab = FindTabForEventFrom(point, active_tab_index + 1, 1);
       return tab;
-    } else if (tab_count()) {
+    }
+    if (tab_count())
       return FindTabForEventFrom(point, 0, 1);
-    }
   } else {
     for (int i = 0; i < tab_count(); ++i) {
       if (IsPointInTab(tab_at(i), point))
         return tab_at(i);
     }
   }
   return NULL;
 }
 
 Tab* TabStrip::FindTabForEventFrom(const gfx::Point& point,
@@ skipping 27 matching lines @@
 
 std::vector<int> TabStrip::GetTabXCoordinates() {
   std::vector<int> results;
   for (int i = 0; i < tab_count(); ++i)
     results.push_back(ideal_bounds(i).x());
   return results;
 }
 
 void TabStrip::SwapLayoutIfNecessary() {
   bool needs_touch = NeedsTouchLayout();
-  bool using_touch = touch_layout_.get() != NULL;
+  bool using_touch = touch_layout_ != NULL;
   if (needs_touch == using_touch)
     return;
 
   if (needs_touch) {
     gfx::Size tab_size(Tab::GetMinimumSelectedSize());
     tab_size.set_width(Tab::GetTouchWidth());
     touch_layout_.reset(new StackedTabStripLayout(
                             tab_size,
                             kTabHorizontalOffset,
                             kStackedPadding,
                             kMaxStackedCount,
                             &tabs_));
-    touch_layout_->SetWidth(width() - new_tab_button_width());
+    touch_layout_->SetWidth(tab_area_width());
     // This has to be after SetWidth() as SetWidth() is going to reset the
     // bounds of the mini-tabs (since StackedTabStripLayout doesn't yet know how
     // many mini-tabs there are).
     GenerateIdealBoundsForMiniTabs(NULL);
     touch_layout_->SetXAndMiniCount(GetStartXForNormalTabs(),
                                     GetMiniTabCount());
     touch_layout_->SetActiveIndex(controller_->GetActiveIndex());
   } else {
     touch_layout_.reset();
   }
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 bool TabStrip::NeedsTouchLayout() const {
   if (!stacked_layout_)
     return false;
 
   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();
+  int available_width = tab_area_width() - x;
   return (Tab::GetTouchWidth() * normal_count +
           kTabHorizontalOffset * (normal_count - 1)) > available_width;
 }
 
 void TabStrip::SetResetToShrinkOnExit(bool value) {
   if (!adjust_layout_)
     return;
 
   if (value && !stacked_layout_)
     value = false;  // We're already using shrink (not stacked) layout.
 
   if (value == reset_to_shrink_on_exit_)
     return;
 
   reset_to_shrink_on_exit_ = value;
   // Add an observer so we know when the mouse moves out of the tabstrip.
   if (reset_to_shrink_on_exit_)
     AddMessageLoopObserver();
   else
     RemoveMessageLoopObserver();
 }
+
+void TabStrip::ButtonPressed(views::Button* sender, const ui::Event& event) {
+  if (sender == newtab_button_) {
+    content::RecordAction(UserMetricsAction("NewTab_Button"));
+    UMA_HISTOGRAM_ENUMERATION("Tab.NewTab", TabStripModel::NEW_TAB_BUTTON,
+                              TabStripModel::NEW_TAB_ENUM_COUNT);
+    if (event.IsMouseEvent()) {
+      const ui::MouseEvent& mouse = static_cast<const ui::MouseEvent&>(event);
+      if (mouse.IsOnlyMiddleMouseButton()) {
+        base::string16 clipboard_text = GetClipboardText();
+        if (!clipboard_text.empty())
+          controller()->CreateNewTabWithLocation(clipboard_text);
+        return;
+      }
+    }
+
+    controller()->CreateNewTab();
+    if (event.type() == ui::ET_GESTURE_TAP)
+      TouchUMA::RecordGestureAction(TouchUMA::GESTURE_NEWTAB_TAP);
+  }
+}
+
+// Overridden to support automation. See automation_proxy_uitest.cc.
+const views::View* TabStrip::GetViewByID(int view_id) const {
+  if (tab_count() > 0) {
+    if (view_id == VIEW_ID_TAB_LAST)
+      return tab_at(tab_count() - 1);
+    if ((view_id >= VIEW_ID_TAB_0) && (view_id < VIEW_ID_TAB_LAST)) {
+      int index = view_id - VIEW_ID_TAB_0;
+      return (index >= 0 && index < tab_count()) ? tab_at(index) : NULL;
+    }
+  }
+
+  return View::GetViewByID(view_id);
+}
+
+bool TabStrip::OnMousePressed(const ui::MouseEvent& event) {
+  UpdateStackedLayoutFromMouseEvent(this, event);
+  // We can't return true here, else clicking in an empty area won't drag the
+  // window.
+  return false;
+}
+
+bool TabStrip::OnMouseDragged(const ui::MouseEvent& event) {
+  ContinueDrag(this, event);
+  return true;
+}
+
+void TabStrip::OnMouseReleased(const ui::MouseEvent& event) {
+  EndDrag(END_DRAG_COMPLETE);
+  UpdateStackedLayoutFromMouseEvent(this, event);
+}
+
+void TabStrip::OnMouseCaptureLost() {
+  EndDrag(END_DRAG_CAPTURE_LOST);
+}
+
+void TabStrip::OnMouseMoved(const ui::MouseEvent& event) {
+  UpdateStackedLayoutFromMouseEvent(this, event);
+}
+
+void TabStrip::OnMouseEntered(const ui::MouseEvent& event) {
+  SetResetToShrinkOnExit(true);
+}
+
+void TabStrip::OnGestureEvent(ui::GestureEvent* event) {
+  SetResetToShrinkOnExit(false);
+  switch (event->type()) {
+    case ui::ET_GESTURE_SCROLL_END:
+    case ui::ET_SCROLL_FLING_START:
+    case ui::ET_GESTURE_END:
+      EndDrag(END_DRAG_COMPLETE);
+      if (adjust_layout_) {
+        SetStackedLayout(true);
+        controller_->StackedLayoutMaybeChanged();
+      }
+      break;
+
+    case ui::ET_GESTURE_LONG_PRESS:
+      if (drag_controller_.get())
+        drag_controller_->SetMoveBehavior(TabDragController::REORDER);
+      break;
+
+    case ui::ET_GESTURE_LONG_TAP: {
+      EndDrag(END_DRAG_CANCEL);
+      gfx::Point local_point = event->location();
+      Tab* tab = FindTabForEvent(local_point);
+      if (tab) {
+        ConvertPointToScreen(this, &local_point);
+        ShowContextMenuForTab(tab, local_point, ui::MENU_SOURCE_TOUCH);
+      }
+      break;
+    }
+
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+      ContinueDrag(this, *event);
+      break;
+
+    case ui::ET_GESTURE_BEGIN:
+      EndDrag(END_DRAG_CANCEL);
+      break;
+
+    case ui::ET_GESTURE_TAP: {
+      const int active_index = controller_->GetActiveIndex();
+      DCHECK_NE(-1, active_index);
+      Tab* active_tab = tab_at(active_index);
+      TouchUMA::GestureActionType action = TouchUMA::GESTURE_TABNOSWITCH_TAP;
+      if (active_tab->tab_activated_with_last_gesture_begin())
+        action = TouchUMA::GESTURE_TABSWITCH_TAP;
+      TouchUMA::RecordGestureAction(action);
+      break;
+    }
+
+    default:
+      break;
+  }
+  event->SetHandled();
+}