Attempt 3 at a better touch tabstrip. There is still a bunch to do,

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"
 
 #include <algorithm>
 #include <iterator>
 #include <vector>
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/tabs/tab_strip_selection_model.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_controller.h"
+#include "chrome/browser/ui/views/tabs/touch_tab_strip_layout.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/base/animation/throb_animation.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/touch/touch_mode_support.h"
@@ skipping 46 matching lines @@
 
 // Size of the drop indicator.
 static int drop_indicator_width;
 static int drop_indicator_height;
 
 static inline int Round(double x) {
   // Why oh why is this not in a standard header?
   return static_cast<int>(floor(x + 0.5));
 }
 
-// Max width reserved for stacked tabs along a particular edge.
-static const double kMaxEdgeStackWidth = 24;
+// Max number of stacked tabs.
+static const int kMaxStackedCount = 4;
+
+// Padding between stacked tabs.
+static const int kStackedPadding = 6;
 
 namespace {
 
 // 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(BaseTab* tab) : tab_(tab) {
   }
@@ skipping 276 matching lines @@
 
 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 ui::AnimationContainer()),
       attaching_dragged_tab_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(bounds_animator_(this)),
-      first_visible_tab_index_(0),
-      num_visible_tabs_(0),
-      stacking_(TouchModeSupport::IsTouchOptimized()) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(bounds_animator_(this)) {
   Init();
 }
 
 TabStrip::~TabStrip() {
   // The animations may reference the tabs. Shut down the animation before we
   // delete the tabs.
   StopAnimating(false);
 
   DestroyDragController();
 
@@ skipping 18 matching lines @@
 
 void TabStrip::StartHighlight(int model_index) {
   tab_at(model_index)->StartPulse();
 }
 
 void TabStrip::StopAllHighlighting() {
   for (int i = 0; i < tab_count(); ++i)
     tab_at(i)->StopPulse();
 }
 
-void TabStrip::AddTabAt(int model_index, const TabRendererData& data) {
+void TabStrip::AddTabAt(int model_index,
+                        const TabRendererData& data,
+                        bool is_active) {
   BaseTab* tab = CreateTab();
   tab->SetData(data);
   UpdateTabsClosingMap(model_index, 1);
   tabs_.Add(tab, model_index);
   AddChildView(tab);
+
+  if (touch_layout_.get()) {
+    GenerateIdealBoundsForMiniTabs(NULL);
+    int add_types = 0;
+    if (data.mini)
+      add_types |= TouchTabStripLayout::kAddTypeMini;
+    if (is_active)
+      add_types |= TouchTabStripLayout::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();
 }
 
-void TabStrip::MoveTab(int from_model_index, int to_model_index) {
+void TabStrip::MoveTab(int from_model_index,
+                       int to_model_index,
+                       const TabRendererData& data) {
   DCHECK_GT(tabs_.view_size(), 0);
   BaseTab* last_tab = tab_at(tab_count() - 1);
-  tabs_.Move(from_model_index, to_model_index);
+  tab_at(from_model_index)->SetData(data);
+  if (touch_layout_.get()) {
+    tabs_.Move(from_model_index, to_model_index);
+    int mini_tab_count = 0;
+    int start_x = GenerateIdealBoundsForMiniTabs(&mini_tab_count);
+    touch_layout_->MoveTab(
+        from_model_index, to_model_index, controller_->GetActiveIndex(),
+        start_x, mini_tab_count);
+  } else {
+    tabs_.Move(from_model_index, to_model_index);
+  }
   StartMoveTabAnimation();
   if (TabDragController::IsAttachedTo(this) &&
       (last_tab != tab_at(tab_count() - 1) || last_tab->dragging())) {
     newtab_button_->SetVisible(false);
   }
 }
 
 void TabStrip::RemoveTabAt(int model_index) {
-  if (stacking_) {
-    int count = tab_count() - 1;
-    if (first_visible_tab_index_ + num_visible_tabs_ > count)
-      first_visible_tab_index_ = std::max(0, first_visible_tab_index_ - 1);
+  if (touch_layout_.get()) {
+    BaseTab* 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);
   }
-
-  if (in_tab_close_ && model_index != GetModelCount())
-    StartMouseInitiatedRemoveTabAnimation(model_index);
-  else
-    StartRemoveTabAnimation(model_index);
 }
 
 void TabStrip::SetTabData(int model_index, const TabRendererData& data) {
   BaseTab* tab = tab_at(model_index);
   bool mini_state_changed = tab->data().mini != data.mini;
   tab->SetData(data);
 
   if (mini_state_changed) {
+    if (touch_layout_.get()) {
+      int mini_tab_count = 0;
+      int start_x = GenerateIdealBoundsForMiniTabs(&mini_tab_count);
+      touch_layout_->SetXAndMiniCount(start_x, mini_tab_count);
+    }
     if (GetWidget() && GetWidget()->IsVisible())
       StartMiniTabAnimation();
     else
       DoLayout();
   }
 }
 
 void TabStrip::PrepareForCloseAt(int model_index) {
   if (!in_tab_close_ && IsAnimating()) {
     // Cancel any current animations. We do this as remove uses the current
@@ skipping 16 matching lines @@
       available_width_for_tabs_ -= kMiniToNonMiniGap;
     }
   }
 
   in_tab_close_ = true;
   AddMessageLoopObserver();
 }
 
 void TabStrip::SetSelection(const TabStripSelectionModel& old_selection,
                             const TabStripSelectionModel& new_selection) {
-  // Make sure the active tab is visible.
-  EnsureModelIndexIsVisible(new_selection.active());
-
-  // 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() && (!in_tab_close_ || tiny_tabs)) {
-    DoLayout();
+  if (touch_layout_.get()) {
+    touch_layout_->SetActiveIndex(new_selection.active());
+    SchedulePaint();
+    AnimateToIdealBounds();
   } else {
-    SchedulePaint();
+    // 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() && (!in_tab_close_ || tiny_tabs)) {
+      DoLayout();
+    } else {
+      SchedulePaint();
+    }
   }
 
   TabStripSelectionModel::SelectedIndices no_longer_selected;
   std::insert_iterator<TabStripSelectionModel::SelectedIndices>
       it(no_longer_selected, no_longer_selected.begin());
   std::set_difference(old_selection.selected_indices().begin(),
                       old_selection.selected_indices().end(),
                       new_selection.selected_indices().begin(),
                       new_selection.selected_indices().end(),
                       it);
@@ skipping 37 matching lines @@
 
 bool TabStrip::IsActiveDropTarget() const {
   for (int i = 0; i < tab_count(); ++i) {
     BaseTab* tab = tab_at(i);
     if (tab->dragging())
       return true;
   }
   return false;
 }
 
-bool TabStrip::IsStacking() const {
-  return stacking_;
-}
-
 const TabStripSelectionModel& TabStrip::GetSelectionModel() {
   return controller_->GetSelectionModel();
 }
 
+bool TabStrip::SupportsMultipleSelection() {
+  // TODO: currently only allow single selection in touch layout mode.
+  return touch_layout_.get() == NULL;
+}
+
 void TabStrip::SelectTab(BaseTab* tab) {
   int model_index = GetModelIndexOfBaseTab(tab);
   if (IsValidModelIndex(model_index))
     controller_->SelectTab(model_index);
 }
 
 void TabStrip::ExtendSelectionTo(BaseTab* tab) {
   int model_index = GetModelIndexOfBaseTab(tab);
   if (IsValidModelIndex(model_index))
     controller_->ExtendSelectionTo(model_index);
@@ skipping 217 matching lines @@
 
 void TabStrip::PaintChildren(gfx::Canvas* canvas) {
   // 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;
   bool is_dragging = false;
   int active_tab_index = -1;
+  bool stacking = touch_layout_.get() != NULL;
 
   PaintClosingTabs(canvas, tab_count());
 
   for (int i = tab_count() - 1; i >= 0; --i) {
     Tab* tab = tab_at(i);
-    if (tab->dragging() && !stacking_) {
+    if (tab->dragging() && !stacking) {
       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 (!stacking)
           tab->Paint(canvas);
       } else {
         // TODO(scottmg): Multiple selection may be incorrect in touch mode.
         selected_tabs.push_back(tab);
       }
     } else {
       active_tab = tab;
       active_tab_index = i;
     }
     PaintClosingTabs(canvas, i);
   }
 
   // Draw from the left and then the right if we're in touch mode.
-  if (stacking_ && active_tab_index >= 0) {
+  if (stacking && active_tab_index >= 0) {
     for (int i = 0; i < active_tab_index; ++i) {
       Tab* tab = tab_at(i);
       tab->Paint(canvas);
     }
 
     for (int i = tab_count() - 1; i > active_tab_index; --i) {
       Tab* tab = tab_at(i);
       tab->Paint(canvas);
     }
   }
@@ skipping 49 matching lines @@
 
 std::string TabStrip::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::Size TabStrip::GetPreferredSize() {
   // 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 = Tab::GetMinimumSelectedSize().width();
-  needed_width += kNewTabButtonHOffset - kTabHOffset;
-  needed_width += newtab_button_bounds_.width();
+  int needed_width = Tab::GetMinimumSelectedSize().width() - kTabHOffset +
+      new_tab_button_width();
   return gfx::Size(needed_width, Tab::GetMinimumUnselectedSize().height());
 }
 
 void TabStrip::OnDragEntered(const DropTargetEvent& event) {
   // Force animations to stop, otherwise it makes the index calculation tricky.
   StopAnimating(true);
 
   UpdateDropIndex(event);
 }
 
@@ skipping 24 matching lines @@
   controller()->PerformDrop(drop_before, drop_index, url);
 
   return GetDropEffect(event);
 }
 
 void TabStrip::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_PAGETABLIST;
 }
 
 views::View* TabStrip::GetEventHandlerForPoint(const gfx::Point& point) {
-  // Return any view that isn't a Tab or this TabStrip immediately. We don't
-  // want to interfere.
-  views::View* v = View::GetEventHandlerForPoint(point);
-  if (v && v != this && v->GetClassName() != Tab::kViewClassName)
-    return v;
+  if (!touch_layout_.get()) {
+    // Return any view that isn't a Tab or this TabStrip immediately. We don't
+    // want to interfere.
+    views::View* v = View::GetEventHandlerForPoint(point);
+    if (v && v != this && v->GetClassName() != Tab::kViewClassName)
+      return v;
 
-  // The view order doesn't match the ordering we paint in. |tabs_| contains
-  // the overall order.
-  for (int i = 0; i < tab_count(); ++i) {
-    Tab* next_tab = i < (tab_count() - 1) ? tab_at(i + 1) : NULL;
-    if (next_tab && next_tab->IsActive() && IsPointInTab(next_tab, point))
-      return next_tab;
-    Tab* tab = tab_at(i);
-    if (IsPointInTab(tab, point))
-      return tab;
+    // The display order doesn't necessarily match the child list order, so we
+    // walk the display list hit-testing Tabs. Since the active 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.
+    for (int i = 0; i < tab_count(); ++i) {
+      Tab* next_tab = i < (tab_count() - 1) ? tab_at(i + 1) : NULL;
+      if (next_tab && next_tab->IsActive() && IsPointInTab(next_tab, point))
+        return next_tab;
+      if (IsPointInTab(tab_at(i), point))
+        return tab_at(i);
+    }
+  } else {
+    int active_tab_index = touch_layout_->active_index();
+    if (active_tab_index != -1) {
+      Tab* tab = FindTabForEvent(point, active_tab_index, -1);
+      if (!tab)
+        tab = FindTabForEvent(point, active_tab_index + 1, 1);
+      if (tab) {
+        gfx::Point point_in_tab_coords(point);
+        View::ConvertPointToView(this, tab, &point_in_tab_coords);
+        return tab->GetEventHandlerForPoint(point_in_tab_coords);
+      }
+    }
   }
-
   return this;
 }
 
 int TabStrip::GetMiniTabCount() const {
   int mini_count = 0;
-  for (int i = 0; i < tab_count(); ++i) {
-    if (tab_at(i)->data().mini)
-      mini_count++;
-    else
-      return mini_count;
-  }
+  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 views::Event& event) {
   if (sender == newtab_button_)
     controller()->CreateNewTab();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, protected:
 
-void TabStrip::ViewHierarchyChanged(bool is_add,
-                                    views::View* parent,
-                                    views::View* child) {
-  if (is_add && child == this)
-    InitTabStripButtons();
-}
-
 // 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 {
@@ skipping 24 matching lines @@
   *unselected_width = current_unselected_width_;
   *selected_width = current_selected_width_;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
   newtab_button_bounds_.SetRect(0, 0, kNewTabButtonWidth, kNewTabButtonHeight);
+  newtab_button_ = new NewTabButton(this, this);
+  newtab_button_->SetTooltipText(
+      l10n_util::GetStringUTF16(IDS_TOOLTIP_NEW_TAB));
+  newtab_button_->SetAccessibleName(
+      l10n_util::GetStringUTF16(IDS_ACCNAME_NEWTAB));
+  AddChildView(newtab_button_);
   if (drop_indicator_width == 0) {
     // Direction doesn't matter, both images are the same size.
     SkBitmap* drop_image = GetDropArrowImage(true);
     drop_indicator_width = drop_image->width();
     drop_indicator_height = drop_image->height();
   }
-}
-
-void TabStrip::InitTabStripButtons() {
-  newtab_button_ = new NewTabButton(this, this);
-  newtab_button_->SetTooltipText(
-      l10n_util::GetStringUTF16(IDS_TOOLTIP_NEW_TAB));
-  newtab_button_->SetAccessibleName(
-      l10n_util::GetStringUTF16(IDS_ACCNAME_NEWTAB));
-  AddChildView(newtab_button_);
+  if (TouchModeSupport::IsTouchOptimized()) {
+    touch_layout_.reset(new TouchTabStripLayout(
+                            Tab::GetStandardSize(),
+                            kTabHOffset,
+                            kStackedPadding,
+                            kMaxStackedCount,
+                            &tabs_));
+  }
 }
 
 BaseTab* TabStrip::CreateTab() {
   Tab* tab = new Tab(this);
   tab->set_animation_container(animation_container_.get());
   return tab;
 }
 
 void TabStrip::StartInsertTabAnimation(int model_index) {
   PrepareForAnimation();
@@ skipping 26 matching lines @@
 
 void TabStrip::StartRemoveTabAnimation(int model_index) {
   PrepareForAnimation();
 
   // Mark the tab as closing.
   BaseTab* tab = tab_at(model_index);
   tab->set_closing(true);
 
   RemoveTabFromViewModel(model_index);
 
+  ScheduleRemoveTabAnimation(tab);
+}
+
+void TabStrip::ScheduleRemoveTabAnimation(BaseTab* tab) {
   // Start an animation for the tabs.
   GenerateIdealBounds();
   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
@@ skipping 16 matching lines @@
 
   bounds_animator_.Cancel();
 
   if (layout)
     DoLayout();
 }
 
 void TabStrip::AnimateToIdealBounds() {
   for (int i = 0; i < tab_count(); ++i) {
     Tab* tab = tab_at(i);
-    if (!tab->closing() && !tab->dragging())
+    if (!tab->dragging())
       bounds_animator_.AnimateViewTo(tab, ideal_bounds(i));
   }
 
   bounds_animator_.AnimateViewTo(newtab_button_, newtab_button_bounds_);
 }
 
 bool TabStrip::ShouldHighlightCloseButtonAfterRemove() {
   return in_tab_close_;
 }
 
 void TabStrip::DoLayout() {
   last_layout_size_ = size();
 
   StopAnimating(false);
 
+  if (touch_layout_.get())
+    touch_layout_->SetWidth(size().width() - new_tab_button_width());
+
   GenerateIdealBounds();
 
   views::ViewModelUtils::SetViewBoundsToIdealBounds(tabs_);
 
   SchedulePaint();
 
-  // It is possible we don't have a new tab button yet.
-  if (newtab_button_) {
-    if (SizeTabButtonToTopOfTabStrip()) {
-      newtab_button_bounds_.set_height(
-          kNewTabButtonHeight + kNewTabButtonVOffset);
-      newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
-                                        views::ImageButton::ALIGN_BOTTOM);
-    } else {
-      newtab_button_bounds_.set_height(kNewTabButtonHeight);
-      newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
-                                        views::ImageButton::ALIGN_TOP);
-    }
-    newtab_button_->SetBoundsRect(newtab_button_bounds_);
+  if (SizeTabButtonToTopOfTabStrip()) {
+    newtab_button_bounds_.set_height(
+        kNewTabButtonHeight + kNewTabButtonVOffset);
+    newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
+                                      views::ImageButton::ALIGN_BOTTOM);
+  } else {
+    newtab_button_bounds_.set_height(kNewTabButtonHeight);
+    newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
+                                      views::ImageButton::ALIGN_TOP);
   }
+  newtab_button_->SetBoundsRect(newtab_button_bounds_);
 }
 
 void TabStrip::LayoutDraggedTabsAt(const std::vector<BaseTab*>& tabs,
                                    BaseTab* active_tab,
                                    const gfx::Point& location,
                                    bool initial_drag) {
-  if (stacking_) {
-    LayoutDraggedTabsAtWithStacking(active_tab, location);
+  if (touch_layout_.get()) {
+    touch_layout_->DragActiveTab(location.x() - active_tab->bounds().x());
+    DoLayout();
     return;
   }
   // Immediately hide the new tab button if the last tab is being dragged.
   if (tab_at(tab_count() - 1)->dragging())
     newtab_button_->SetVisible(false);
   std::vector<gfx::Rect> bounds;
   CalculateBoundsForDraggedTabs(tabs, &bounds);
   DCHECK_EQ(tabs.size(), bounds.size());
   int active_tab_model_index = GetModelIndexOfBaseTab(active_tab);
   int active_tab_index = static_cast<int>(
@@ skipping 10 matching lines @@
     if ((initial_drag &&
          GetModelIndexOfBaseTab(tabs[i]) != consecutive_index) ||
         bounds_animator_.IsAnimating(tabs[i])) {
       bounds_animator_.SetTargetBounds(tabs[i], new_bounds);
     } else {
       tab->SetBoundsRect(new_bounds);
     }
   }
 }
 
-void TabStrip::LayoutDraggedTabsAtWithStacking(
-    BaseTab* active_tab,
-    const gfx::Point& location) {
-  // TODO: this is wrong.
-  active_tab->SetX(location.x());
-}
-
 void TabStrip::CalculateBoundsForDraggedTabs(const std::vector<BaseTab*>& tabs,
                                              std::vector<gfx::Rect>* bounds) {
   int x = 0;
   for (size_t i = 0; i < tabs.size(); ++i) {
     BaseTab* 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);
@@ skipping 121 matching lines @@
   // dragging true for the tab otherwise it'll draw beneath the new tab button.
   bounds_animator_.SetAnimationDelegate(
       tab, new ResetDraggingStateDelegate(tab), true);
 }
 
 void TabStrip::OwnDragController(TabDragController* controller) {
   drag_controller_.reset(controller);
 }
 
 void TabStrip::DestroyDragController() {
-  if (newtab_button_)
-    newtab_button_->SetVisible(true);
+  newtab_button_->SetVisible(true);
   drag_controller_.reset();
 }
 
 TabDragController* TabStrip::ReleaseDragController() {
   return drag_controller_.release();
 }
 
-int TabStrip::NumNonClosingTabs(int index1, int index2) const {
-  int count = 0;
-  for (int i = index1; i < index2; ++i) {
-    if (!tab_at(i)->closing())
-      count++;
-  }
-  return count;
-}
-
-void TabStrip::UpdateNumVisibleTabs(int non_closing_tab_count,
-                                    int width,
-                                    double tab_size) {
-  num_visible_tabs_ = (width + kTabHOffset) / (tab_size + kTabHOffset);
-  num_visible_tabs_ = std::max(1, num_visible_tabs_);
-  // Make sure the first_visible_tab_index_ is valid.
-  // TODO: this isn't quite right, it doesn't take into account closing tabs.
-  first_visible_tab_index_ =
-      std::min(first_visible_tab_index_, non_closing_tab_count -
-               num_visible_tabs_);
-  first_visible_tab_index_ = std::max(0, first_visible_tab_index_);
-}
-
-void TabStrip::EnsureModelIndexIsVisible(int model_index) {
-  if (!stacking_ || model_index == TabStripSelectionModel::kUnselectedIndex)
-    return;
-
-  int original = first_visible_tab_index_;
-  int active_index = model_index;
-  if (active_index < first_visible_tab_index_)
-    first_visible_tab_index_ = active_index;
-  else if (active_index >= first_visible_tab_index_ + num_visible_tabs_)
-    first_visible_tab_index_ = active_index - num_visible_tabs_ + 1;
-
-  if (original != first_visible_tab_index_) {
-    PrepareForAnimation();
-    GenerateIdealBounds();
-    AnimateToIdealBounds();
-  }
-}
-
 void TabStrip::GetDesiredTabWidths(int tab_count,
                                    int mini_tab_count,
                                    double* unselected_width,
                                    double* selected_width) const {
   DCHECK(tab_count >= 0 && mini_tab_count >= 0 && mini_tab_count <= tab_count);
   const double min_unselected_width = Tab::GetMinimumUnselectedSize().width();
   const double min_selected_width = Tab::GetMinimumSelectedSize().width();
 
   *unselected_width = min_unselected_width;
   *selected_width = min_selected_width;
 
   if (tab_count == 0) {
     // Return immediately to avoid divide-by-zero below.
     return;
   }
 
   // Determine how much space we can actually allocate to tabs.
   int available_width;
   if (available_width_for_tabs_ < 0) {
-    available_width = width();
-    available_width -= (kNewTabButtonHOffset + newtab_button_bounds_.width());
+    available_width = width() - new_tab_button_width();
   } else {
     // Interesting corner case: if |available_width_for_tabs_| > the result
     // of the calculation in the conditional arm above, the strip is in
     // overflow.  We can either use the specified width or the true available
     // width here; the first preserves the consistent "leave the last tab under
     // the user's mouse so they can close many tabs" behavior at the cost of
     // prolonging the glitchy appearance of the overflow state, while the second
     // gets us out of overflow as soon as possible but forces the user to move
     // their mouse for a few tabs' worth of closing.  We choose visual
     // imperfection over behavioral imperfection and select the first option.
@@ skipping 249 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 non_closing_tab_count = 0;
-  int mini_tab_count = 0;
-  for (int i = 0; i < tab_count(); ++i) {
-    BaseTab* tab = tab_at(i);
-    if (!tab->closing()) {
-      ++non_closing_tab_count;
-      if (tab->data().mini)
-        mini_tab_count++;
-    }
+  int new_tab_y = SizeTabButtonToTopOfTabStrip() ? 0 : kNewTabButtonVOffset;
+
+  if (touch_layout_.get()) {
+    if (tabs_.view_size() == 0)
+      return;
+
+    int new_tab_x = tabs_.ideal_bounds(tabs_.view_size() - 1).right() +
+        kNewTabButtonHOffset;
+    newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
+    return;
   }
 
   double unselected, selected;
-  GetDesiredTabWidths(non_closing_tab_count, mini_tab_count, &unselected,
-                      &selected);
-
+  GetDesiredTabWidths(tab_count(), GetMiniTabCount(), &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) {
+  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);
-    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 += kMiniToNonMiniGap;
-        }
-        if (tab->IsActive())
-          tab_width = selected;
-      }
-      double end_of_tab = tab_x + tab_width;
-      int rounded_tab_x = Round(tab_x);
-      set_ideal_bounds(i,
-          gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
-                    tab_height));
-      tab_x = end_of_tab + kTabHOffset;
-      last_was_mini = tab->data().mini;
-    }
-  }
-
-  // If we're in stacking mode, update the positions now that we have
-  // appropriate widths.
-  if (stacking_ && tab_x - kTabHOffset >
-      width() - newtab_button_bounds_.width()) {
-    tab_x = GenerateIdealBoundsWithStacking(
-        mini_tab_count, non_closing_tab_count, tab_x, selected);
+    DCHECK(!tab->data().mini);
+    double tab_width = tab->IsActive() ? selected : unselected;
+    double end_of_tab = tab_x + tab_width;
+    int rounded_tab_x = Round(tab_x);
+    set_ideal_bounds(
+        i,
+        gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
+                  tab_height));
+    tab_x = end_of_tab + kTabHOffset;
   }
 
   // Update bounds of new tab button.
   int new_tab_x;
-  int new_tab_y = SizeTabButtonToTopOfTabStrip() ? 0 : kNewTabButtonVOffset;
   if (abs(Round(unselected) - Tab::GetStandardSize().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 - kTabHOffset) + kNewTabButtonHOffset;
   }
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
 }
 
-double TabStrip::GenerateIdealBoundsWithStacking(int mini_tab_count,
-                                                 int non_closing_tab_count,
-                                                 double new_tab_x,
-                                                 double selected_size) {
-  if (non_closing_tab_count == mini_tab_count)
-    return new_tab_x;
+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));
+    next_x += mini_width + kTabHOffset;
+  }
+  if (index > 0 && index < tab_count())
+    next_x += kMiniToNonMiniGap;
+  if (first_non_mini_index)
+    *first_non_mini_index = index;
+  return next_x;
+}
 
-  // Pinned tabs always have their desired size, and don't stack. We rely on
-  // GenerateIdealBounds to have positioned pinned tabs already, so don't move
-  // them.
-  int tab_index = 0;
-  double next_x = 0;
-  for (; tab_index < tab_count(); ++tab_index) {
-    BaseTab* tab = tab_at(tab_index);
-    if (!tab->closing() && !tab->data().mini) {
-      next_x = ideal_bounds(tab_index).x();
-      break;
-    }
-  }
-  if (tab_index == tab_count())
-    return new_tab_x;
-
-  // Always reserve kMaxEdgeStackWidth on each side for stacking. We don't
-  // later try to adjust as it can lead to tabs bouncing around.
-  int available_width = width() -
-      (kNewTabButtonHOffset + newtab_button_bounds_.width()) - next_x -
-      2 * kMaxEdgeStackWidth;
-  if (available_width <= 0)
-    return new_tab_x;
-  UpdateNumVisibleTabs(non_closing_tab_count, available_width, selected_size);
-  int stacked_leading_index = tab_index;
-  int stacked_trailing_index = first_visible_tab_index_;
-  for (int visible_count = 0;
-       stacked_trailing_index < tab_count() &&
-           visible_count < num_visible_tabs_; ++stacked_trailing_index) {
-    if (!tab_at(stacked_trailing_index)->closing())
-      visible_count++;
-  }
-  int stacked_leading_count =
-      NumNonClosingTabs(stacked_leading_index, first_visible_tab_index_);
-  int stacked_trailing_count =
-      NumNonClosingTabs(stacked_trailing_index, tab_count());
-
-  // Stacked tabs to the left.
-  if (stacked_leading_count > 0) {
-    double stacked_offset =
-        kMaxEdgeStackWidth / static_cast<double>(stacked_leading_count);
-    for (; tab_index < first_visible_tab_index_; ++tab_index) {
-      if (tab_at(tab_index)->closing())
-        continue;
-      gfx::Rect bounds = ideal_bounds(tab_index);
-      bounds.set_x(next_x);
-      set_ideal_bounds(tab_index, bounds);
-      next_x += stacked_offset;
-    }
-  } else {
-    tab_index = first_visible_tab_index_;
-  }
-
-  if (stacked_leading_count > 0 && stacked_trailing_count == 0) {
-    // If there are no stacked tabs on the right and there is extra space, give
-    // it to the last stacked tab on the left.
-    next_x += available_width + kMaxEdgeStackWidth -
-        (num_visible_tabs_ * selected_size +
-         std::max(num_visible_tabs_ - 1, 0) * kTabHOffset);
-  }
-
-  // Totally visible tabs.
-  for (int visible_count = 0;
-       tab_index < tab_count() && visible_count < num_visible_tabs_;
-       tab_index++) {
-    if (tab_at(tab_index)->closing())
-      continue;
-    gfx::Rect bounds = ideal_bounds(tab_index);
-    bounds.set_x(next_x);
-    next_x = bounds.right() + kTabHOffset;
-    set_ideal_bounds(tab_index, bounds);
-    visible_count++;
-  }
-
-  // Stacked tabs to the right.
-  if (stacked_trailing_count == 0)
-    return next_x;
-
-  double stacked_offset =
-      kMaxEdgeStackWidth / static_cast<double>(stacked_trailing_count);
-  next_x = width() - (kNewTabButtonHOffset + newtab_button_bounds_.width()) -
-      (stacked_trailing_count - 1) * stacked_offset - selected_size;
-  for (; tab_index < tab_count(); ++tab_index) {
-    if (tab_at(tab_index)->closing())
-      continue;
-    gfx::Rect bounds = ideal_bounds(tab_index);
-    bounds.set_x(next_x);
-    set_ideal_bounds(tab_index, bounds);
-    next_x += stacked_offset;
-  }
-
-  return next_x + kTabHOffset;
+int TabStrip::new_tab_button_width() const {
+  return kNewTabButtonWidth + kNewTabButtonHOffset;
 }
 
 void TabStrip::StartResizeLayoutAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMiniTabAnimation() {
   in_tab_close_ = false;
@@ skipping 47 matching lines @@
       new RemoveTabDelegate(this, tab_closing),
       true);
 }
 
 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);
 }
+
+int TabStrip::GetStartXForNormalTabs() const {
+  int mini_tab_count = GetMiniTabCount();
+  if (mini_tab_count == 0)
+    return 0;
+  return mini_tab_count * (Tab::GetMiniWidth() + kTabHOffset) +
+      kMiniToNonMiniGap;
+}
+
+Tab* TabStrip::FindTabForEvent(const gfx::Point& point, int start, int delta) {
+  for (int i = start; i >= 0 && i < tab_count(); i += delta) {
+    if (IsPointInTab(tab_at(i), point))
+      return tab_at(i);
+  }
+  return NULL;
+}