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),
+      layout_type_stacked_(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::SetLayoutTypeStacked(bool layout_type_stacked) {
+  if (layout_type_stacked == layout_type_stacked_)
     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;
+  layout_type_stacked_ = layout_type_stacked;
   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 539 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);
+    SetLayoutTypeStacked(false);
     controller_->LayoutTypeMaybeChanged();
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, views::View overrides:
 
 void TabStrip::Layout() {
   // Only do a layout if our size changed.
   if (last_layout_size_ == size())
@@ skipping 10 matching lines @@
   // |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 = layout_type_stacked_ || 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 314 matching lines @@
 }
 
 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);
+        SetLayoutTypeStacked(true);
         controller_->LayoutTypeMaybeChanged();
       }
       break;
 
     case ui::ET_GESTURE_LONG_PRESS:
       if (drag_controller_.get())
         drag_controller_->SetMoveBehavior(TabDragController::REORDER);
       break;
 
     case ui::ET_GESTURE_LONG_TAP: {
@@ skipping 506 matching lines @@
   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);
+          SetLayoutTypeStacked(false);
           controller_->LayoutTypeMaybeChanged();
         }
       }
       break;
 
     case ui::ET_MOUSE_MOVED: {
 #if defined(USE_ASH)
       // Ash does not synthesize mouse events from touch events.
       SetResetToShrinkOnExit(true);
 #else
@@ skipping 19 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);
+        SetLayoutTypeStacked(true);
         controller_->LayoutTypeMaybeChanged();
       }
       break;
     }
 
     default:
       break;
   }
 }
 
@@ skipping 538 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 (!layout_type_stacked_)
     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())
     return;
 
-  if (value && layout_type_ == TAB_STRIP_LAYOUT_SHRINK)
+  if (value && !layout_type_stacked_)
     value = false;  // We're already at TAB_STRIP_LAYOUT_SHRINK.
 
   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 {

[sky, 2014/05/21 22:57:19]

I think you can remove this and just use adjust_layout_.

[varkha, 2014/05/23 17:43:23]

Done.

   if (!adjust_layout_)
     return false;
   return chrome::GetHostDesktopTypeForNativeView(
       GetWidget()->GetNativeView()) == chrome::HOST_DESKTOP_TYPE_ASH;
 }