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

chrome/browser/ui/views/tabs/tab_strip.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_VIEWS_TABS_TAB_STRIP_H_
 #define CHROME_BROWSER_UI_VIEWS_TABS_TAB_STRIP_H_
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/timer/timer.h"
-#include "chrome/browser/ui/tabs/tab_strip_layout_type.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_controller.h"
 #include "ui/gfx/animation/animation_container.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/animation/bounds_animator.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/mouse_watcher.h"
 #include "ui/views/view.h"
 #include "ui/views/view_model.h"
@@ skipping 33 matching lines @@
  public:
   static const char kViewClassName[];
 
   explicit TabStrip(TabStripController* controller);
   virtual ~TabStrip();
 
   // Add and remove observers to changes within this TabStrip.
   void AddObserver(TabStripObserver* observer);
   void RemoveObserver(TabStripObserver* observer);
 
-  // Sets the layout type. If |adjust_layout| is true the layout type changes
-  // based on whether the user uses a mouse or touch device with the tabstrip.
-  // If |adjust_layout| is false the layout is fixed to |layout_type|.
-  void SetLayoutType(TabStripLayoutType layout_type, bool adjust_layout);
-  TabStripLayoutType layout_type() const { return layout_type_; }
+  // If |adjust_layout| is true the stacked layout changes based on whether the
+  // user uses a mouse or a touch device with the tabstrip.
+  void set_adjust_layout(bool adjust_layout) { adjust_layout_ = adjust_layout; }
+
+  // |stacked_layout_| defines what should happen when the tabs won't fit at
+  // their ideal size. When |stacked_layout_| is true the tabs are always sized
+  // to their ideal size and stacked on top of each other so that only a certain
+  // set of tabs are visible. This is used when the user uses a touch device.
+  // When |stacked_layout_| is false the tabs shrink to accommodate the
+  // available space. This is the default.
+  bool stacked_layout() const { return stacked_layout_; }
+
+  // Sets |stacked_layout_| and animates if necessary.
+  void SetStackedLayout(bool stacked_layout);
 
   // Returns the bounds of the new tab button.
   gfx::Rect GetNewTabButtonBounds();
 
   // Returns true if the new tab button should be sized to the top of the tab
   // strip.
   bool SizeTabButtonToTopOfTabStrip();
 
   // Starts highlighting the tab at the specified index.
   void StartHighlight(int model_index);
@@ skipping 326 matching lines @@
 
   // Releases ownership of the current TabDragController.
   TabDragController* ReleaseDragController();
 
   // Paints all the tabs in |tabs_closing_map_[index]|.
   void PaintClosingTabs(gfx::Canvas* canvas,
                         int index,
                         const views::CullSet& cull_set);
 
   // Invoked when a mouse event occurs over |source|. Potentially switches the
-  // layout type.
-  void UpdateLayoutTypeFromMouseEvent(views::View* source,
-                                      const ui::MouseEvent& event);
+  // |stacked_layout_|.
+  void UpdateStackedLayoutFromMouseEvent(views::View* source,
+                                         const ui::MouseEvent& event);
 
   // -- Tab Resize Layout -----------------------------------------------------
 
   // Returns the exact (unrounded) current width of each tab.
   void GetCurrentTabWidths(double* unselected_width,
                            double* selected_width) const;
 
   // Returns the exact (unrounded) desired width of each tab, based on the
   // desired strip width and number of tabs.  If
   // |width_of_tabs_for_mouse_close_| is nonnegative we use that value in
@@ skipping 101 matching lines @@
   // Returns the x-coordinates of the tabs.
   std::vector<int> GetTabXCoordinates();
 
   // Creates/Destroys |touch_layout_| as necessary.
   void SwapLayoutIfNecessary();
 
   // Returns true if |touch_layout_| is needed.
   bool NeedsTouchLayout() const;
 
   // Sets the value of |reset_to_shrink_on_exit_|. If true |mouse_watcher_| is
-  // used to track when the mouse truly exits the tabstrip and the layout type
-  // is reset.
+  // used to track when the mouse truly exits the tabstrip and the stacked
+  // layout is reset.
   void SetResetToShrinkOnExit(bool value);
 
-  // Should the layout dynamically adjust?
-  bool GetAdjustLayout() const;
-
   // -- Member Variables ------------------------------------------------------
 
   // There is a one-to-one mapping between each of the tabs in the
   // TabStripController (TabStripModel) and |tabs_|. Because we animate tab
   // removal there exists a period of time where a tab is displayed but not in
   // the model. When this occurs the tab is removed from |tabs_| and placed in
   // |tabs_closing_map_|. When the animation completes the tab is removed from
   // |tabs_closing_map_|. The painting code ensures both sets of tabs are
   // painted, and the event handling code ensures only tabs in |tabs_| are used.
   views::ViewModel tabs_;
@@ skipping 30 matching lines @@
   // Valid for the lifetime of a drag over us.
   scoped_ptr<DropInfo> drop_info_;
 
   // To ensure all tabs pulse at the same time they share the same animation
   // container. This is that animation container.
   scoped_refptr<gfx::AnimationContainer> animation_container_;
 
   // MouseWatcher is used for two things:
   // . When a tab is closed to reset the layout.
   // . When a mouse is used and the layout dynamically adjusts and is currently
-  //   TAB_STRIP_LAYOUT_STACKED.
+  //   stacked (|stacked_layout_| is true).
   scoped_ptr<views::MouseWatcher> mouse_watcher_;
 
   // The controller for a drag initiated from a Tab. Valid for the lifetime of
   // the drag session.
   scoped_ptr<TabDragController> drag_controller_;
 
   views::BoundsAnimator bounds_animator_;
 
   // Size we last layed out at.
   gfx::Size last_layout_size_;
 
-  TabStripLayoutType layout_type_;
+  // See description above stacked_layout().
+  bool stacked_layout_;
 
-  // See description above SetLayoutType().
+  // Should the layout dynamically adjust?
   bool adjust_layout_;
 
   // Only used while in touch mode.
   scoped_ptr<StackedTabStripLayout> touch_layout_;
 
-  // If true the layout type is set to TAB_STRIP_LAYOUT_SHRINK when the mouse
-  // exits the tabstrip (as determined using MouseWatcher).
+  // If true the |stacked_layout_| is set to false when the mouse exits the
+  // tabstrip (as determined using MouseWatcher).
   bool reset_to_shrink_on_exit_;
 
   // Location of the mouse at the time of the last move.
   gfx::Point last_mouse_move_location_;
 
   // Time of the last mouse move event.
   base::TimeTicks last_mouse_move_time_;
 
   // Number of mouse moves.
   int mouse_move_count_;
 
   // Timer used when a tab is closed and we need to relayout. Only used when a
   // tab close comes from a touch device.
   base::OneShotTimer<TabStrip> resize_layout_timer_;
 
   // True if tabs are painted as rectangular light-bars.
   bool immersive_style_;
 
   // Our observers.
   typedef ObserverList<TabStripObserver> TabStripObservers;
   TabStripObservers observers_;
 
   DISALLOW_COPY_AND_ASSIGN(TabStrip);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TABS_TAB_STRIP_H_