Removes --enable-stacked-tab-strip flag (Stacked Tabs)

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 493 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 gfx::AnimationContainer()),
       bounds_animator_(this),
-      layout_type_(TAB_STRIP_LAYOUT_SHRINK),
+      stacked_layout_(false),
       adjust_layout_(false),
       reset_to_shrink_on_exit_(false),
       mouse_move_count_(0),
       immersive_style_(false) {
   Init();
 }
 
 TabStrip::~TabStrip() {
   FOR_EACH_OBSERVER(TabStripObserver, observers_,
                     TabStripDeleted(this));
@@ skipping 15 matching lines @@
 }
 
 void TabStrip::AddObserver(TabStripObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void TabStrip::RemoveObserver(TabStripObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void TabStrip::SetLayoutType(TabStripLayoutType layout_type,
-                             bool adjust_layout) {
-  adjust_layout_ = adjust_layout;
-  if (layout_type == layout_type_)
+void TabStrip::SetStackedLayout(bool stacked_layout) {
+  if (stacked_layout == stacked_layout_)
     return;
 
   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;
   }
-  layout_type_ = layout_type;
+  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) {
     touch_layout_->SetActiveTabLocation(
         active_center - ideal_bounds(active_index).width() / 2);
     AnimateToIdealBounds();
   }
 }
 
@@ skipping 486 matching lines @@
 
   // Walk up the view hierarchy until we find a tab, or the TabStrip.
   while (view && view != this && view->id() != VIEW_ID_TAB)
     view = view->parent();
 
   return view && view->id() == VIEW_ID_TAB ? static_cast<Tab*>(view) : NULL;
 }
 
 void TabStrip::OnMouseEventInTab(views::View* source,
                                  const ui::MouseEvent& event) {
-  UpdateLayoutTypeFromMouseEvent(source, 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()))
     return true;
 
   int index = GetModelIndexOfTab(tab);
   if (index == -1)
     return true;  // Tab is closing, paint it all.
@@ skipping 32 matching lines @@
 }
 
 bool TabStrip::IsImmersiveStyle() const {
   return immersive_style_;
 }
 
 void TabStrip::MouseMovedOutOfHost() {
   ResizeLayoutTabs();
   if (reset_to_shrink_on_exit_) {
     reset_to_shrink_on_exit_ = false;
-    SetLayoutType(TAB_STRIP_LAYOUT_SHRINK, true);
-    controller_->LayoutTypeMaybeChanged();
+    SetStackedLayout(false);
+    controller_->StackedLayoutMaybeChanged();
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, views::View overrides:
 
 void TabStrip::Layout() {
   // Only do a layout if our size changed.
   if (last_layout_size_ == size())
     return;
   if (IsDragSessionActive())
     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;
   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 = (layout_type_ == TAB_STRIP_LAYOUT_STACKED) ||
-      IsStackingDraggedTabs();
+  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;
 
   if (inactive_tab_alpha < 255)
     canvas->SaveLayerAlpha(inactive_tab_alpha);
@@ skipping 278 matching lines @@
       } else {
         return NULL;
       }
     }
   }
 
   return View::GetViewByID(view_id);
 }
 
 bool TabStrip::OnMousePressed(const ui::MouseEvent& event) {
-  UpdateLayoutTypeFromMouseEvent(this, 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);
-  UpdateLayoutTypeFromMouseEvent(this, event);
+  UpdateStackedLayoutFromMouseEvent(this, event);
 }
 
 void TabStrip::OnMouseCaptureLost() {
   EndDrag(END_DRAG_CAPTURE_LOST);
 }
 
 void TabStrip::OnMouseMoved(const ui::MouseEvent& event) {
-  UpdateLayoutTypeFromMouseEvent(this, 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_) {
-        SetLayoutType(TAB_STRIP_LAYOUT_STACKED, true);
-        controller_->LayoutTypeMaybeChanged();
+        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);
@@ skipping 29 matching lines @@
       break;
   }
   event->SetHandled();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
-  // So we get enter/exit on children to switch layout type.
+  // 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,
                                 kNewTabButtonAssetHeight +
                                     kNewTabButtonVerticalOffset);
   newtab_button_ = new NewTabButton(this, this);
   newtab_button_->SetTooltipText(
       l10n_util::GetStringUTF16(IDS_TOOLTIP_NEW_TAB));
   newtab_button_->SetAccessibleName(
@@ skipping 428 matching lines @@
   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) {
     (*i)->Paint(canvas, cull_set);
   }
 }
 
-void TabStrip::UpdateLayoutTypeFromMouseEvent(views::View* source,
-                                              const ui::MouseEvent& event) {
-  if (!GetAdjustLayout())
+void TabStrip::UpdateStackedLayoutFromMouseEvent(views::View* source,
+                                                 const ui::MouseEvent& event) {
+  if (!adjust_layout_)
     return;
 
-  // The following code attempts to switch to TAB_STRIP_LAYOUT_SHRINK when the
-  // mouse exits the tabstrip (or the mouse is pressed on a stacked tab) and
-  // TAB_STRIP_LAYOUT_STACKED 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.
+  // 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()) {
         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))) {
-          SetLayoutType(TAB_STRIP_LAYOUT_SHRINK, true);
-          controller_->LayoutTypeMaybeChanged();
+          SetStackedLayout(false);
+          controller_->StackedLayoutMaybeChanged();
         }
       }
       break;
 
     case ui::ET_MOUSE_MOVED: {
 #if defined(USE_ASH)
       // Ash does not synthesize mouse events from touch events.
       SetResetToShrinkOnExit(true);
 #else
       gfx::Point location(event.location());
@@ skipping 18 matching lines @@
       break;
     }
 
     case ui::ET_MOUSE_RELEASED: {
       gfx::Point location(event.location());
       ConvertPointToTarget(source, this, &location);
       last_mouse_move_location_ = location;
       mouse_move_count_ = 0;
       last_mouse_move_time_ = base::TimeTicks();
       if ((event.flags() & ui::EF_FROM_TOUCH) == ui::EF_FROM_TOUCH) {
-        SetLayoutType(TAB_STRIP_LAYOUT_STACKED, true);
-        controller_->LayoutTypeMaybeChanged();
+        SetStackedLayout(true);
+        controller_->StackedLayoutMaybeChanged();
       }
       break;
     }
 
     default:
       break;
   }
 }
 
 void TabStrip::GetCurrentTabWidths(double* unselected_width,
@@ skipping 537 matching lines @@
     touch_layout_->SetActiveIndex(controller_->GetActiveIndex());
   } else {
     touch_layout_.reset();
   }
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 bool TabStrip::NeedsTouchLayout() const {
-  if (layout_type_ == TAB_STRIP_LAYOUT_SHRINK)
+  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();
   return (Tab::GetTouchWidth() * normal_count +
           kTabHorizontalOffset * (normal_count - 1)) > available_width;
 }
 
 void TabStrip::SetResetToShrinkOnExit(bool value) {
-  if (!GetAdjustLayout())
+  if (!adjust_layout_)
     return;
 
-  if (value && layout_type_ == TAB_STRIP_LAYOUT_SHRINK)
-    value = false;  // We're already at TAB_STRIP_LAYOUT_SHRINK.
+  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();
 }
-
-bool TabStrip::GetAdjustLayout() const {
-  if (!adjust_layout_)
-    return false;
-  return chrome::GetHostDesktopTypeForNativeView(
-      GetWidget()->GetNativeView()) == chrome::HOST_DESKTOP_TYPE_ASH;
-}