Misc. cleanup:

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"
@@ skipping 38 matching lines @@
 //      in response to dragged tabs.
 //
 ///////////////////////////////////////////////////////////////////////////////
 class TabStrip : public views::View,
                  public views::ButtonListener,
                  public views::MouseWatcherListener,
                  public TabController {
  public:
   static const char kViewClassName[];
 
+  // Horizontal offset for the new tab button to bring it closer to the
+  // rightmost tab.
+  static const int kNewTabButtonHorizontalOffset;
+
+  // The vertical offset of the tab strip button. This offset applies only to
+  // restored windows.
+  static const int kNewTabButtonVerticalOffset;
+
   explicit TabStrip(TabStripController* controller);
   virtual ~TabStrip();
 
   // Add and remove observers to changes within this TabStrip.
   void AddObserver(TabStripObserver* observer);
   void RemoveObserver(TabStripObserver* observer);
 
   // 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; }
@@ skipping 49 matching lines @@
 
   // Invoked when the title of a tab changes and the tab isn't loading.
   void TabTitleChangedNotLoading(int model_index);
 
   // Retrieves the ideal bounds for the Tab at the specified index.
   const gfx::Rect& ideal_bounds(int tab_data_index) {
     return tabs_.ideal_bounds(tab_data_index);
   }
 
   // Returns the Tab at |index|.
-  Tab* tab_at(int index) const;
+  Tab* tab_at(int index) const {
+    return static_cast<Tab*>(tabs_.view_at(index));
+  }
 
   // Returns the index of the specified tab in the model coordinate system, or
   // -1 if tab is closing or not valid.
   int GetModelIndexOfTab(const Tab* tab) const;
 
   // Gets the number of Tabs in the tab strip.
   int tab_count() const { return tabs_.view_size(); }
 
   // Cover method for TabStripController::GetCount.
   int GetModelCount() const;
@@ skipping 26 matching lines @@
   // window caption area of the browser window.
   bool IsPositionInWindowCaption(const gfx::Point& point);
 
   // Returns true if the specified rect (in TabStrip coordinates) intersects
   // the window caption area of the browser window.
   bool IsRectInWindowCaption(const gfx::Rect& rect);
 
   // Set the background offset used by inactive tabs to match the frame image.
   void SetBackgroundOffset(const gfx::Point& offset);
 
-  // Returns the new tab button. This is never NULL.
-  views::View* newtab_button();
-
   // Sets a painting style with miniature "tab indicator" rectangles at the top.
   void SetImmersiveStyle(bool enable);
 
   // Returns true if Tabs in this TabStrip are currently changing size or
   // position.
   bool IsAnimating() const;
 
   // Stops any ongoing animations. If |layout| is true and an animation is
   // ongoing this does a layout.
   void StopAnimating(bool layout);
@@ skipping 45 matching lines @@
   virtual void OnDragExited() OVERRIDE;
   virtual int OnPerformDrop(const ui::DropTargetEvent& event) OVERRIDE;
   virtual void GetAccessibleState(ui::AXViewState* state) OVERRIDE;
   virtual views::View* GetEventHandlerForRect(const gfx::Rect& rect) OVERRIDE;
   virtual views::View* GetTooltipHandlerForPoint(
       const gfx::Point& point) OVERRIDE;
 
   // Returns preferred height in immersive style.
   static int GetImmersiveHeight();
 
- protected:
-  // Horizontal gap between mini and non-mini-tabs.
-  static const int kMiniToNonMiniGap;
-
-  void set_ideal_bounds(int index, const gfx::Rect& bounds) {
-    tabs_.set_ideal_bounds(index, bounds);
-  }
-
-  // Returns the number of mini-tabs.
-  int GetMiniTabCount() const;
-
-  // views::ButtonListener implementation:
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) OVERRIDE;
-
-  // View overrides.
-  virtual const views::View* GetViewByID(int id) const OVERRIDE;
-  virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
-  virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE;
-  virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
-  virtual void OnMouseCaptureLost() OVERRIDE;
-  virtual void OnMouseMoved(const ui::MouseEvent& event) OVERRIDE;
-  virtual void OnMouseEntered(const ui::MouseEvent& event) OVERRIDE;
-
-  // ui::EventHandler overrides.
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
-
  private:
-  typedef std::map<int, std::vector<Tab*> > TabsClosingMap;
+  typedef std::vector<Tab*> Tabs;
+  typedef std::map<int, Tabs> TabsClosingMap;
+  typedef std::pair<TabsClosingMap::iterator,
+                    Tabs::iterator> FindClosingTabResult;
 
   class RemoveTabDelegate;
 
   friend class TabDragController;
   friend class TabDragControllerTest;
   FRIEND_TEST_ALL_PREFIXES(TabDragControllerTest, GestureEndShouldEndDragTest);
   friend class TabStripTest;
   FRIEND_TEST_ALL_PREFIXES(TabStripTest, TabHitTestMaskWhenStacked);
   FRIEND_TEST_ALL_PREFIXES(TabStripTest, ClippedTabCloseButton);
 
@@ skipping 25 matching lines @@
     // The URL for the drop event.
     GURL url;
 
     // Whether the MIME type of the file pointed to by |url| is supported.
     bool file_supported;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(DropInfo);
   };
 
+  // Horizontal gap between mini and non-mini-tabs.
+  static const int kMiniToNonMiniGap;
+
+  // 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.
+  static const int kNewTabButtonAssetWidth;
+  static const int kNewTabButtonAssetHeight;
+
   void Init();
 
   // Creates and returns a new tab. The caller owners the returned tab.
   Tab* CreateTab();
 
   // Invoked from |AddTabAt| after the newly created tab has been inserted.
   void StartInsertTabAnimation(int model_index);
 
   // Invoked from |MoveTab| after |tab_data_| has been updated to animate the
   // move.
@@ skipping 18 matching lines @@
   void DoLayout();
 
   // Drags the active tab by |delta|. |initial_positions| is the x-coordinates
   // of the tabs when the drag started.
   void DragActiveTab(const std::vector<int>& initial_positions, int delta);
 
   // Sets the ideal bounds x-coordinates to |positions|.
   void SetIdealBoundsFromPositions(const std::vector<int>& positions);
 
   // Stacks the dragged tabs. This is used if the drag operation is
-  // MOVE_VISIBILE_TABS and the tabs don't fill the tabstrip. When this happens
+  // MOVE_VISIBLE_TABS and the tabs don't fill the tabstrip. When this happens
   // the active tab follows the mouse and the other tabs stack around it.
   void StackDraggedTabs(int delta);
 
   // Returns true if dragging has resulted in temporarily stacking the tabs.
   bool IsStackingDraggedTabs() const;
 
   // Invoked during drag to layout the tabs being dragged in |tabs| at
   // |location|. If |initial_drag| is true, this is the initial layout after the
   // user moved the mouse far enough to trigger a drag.
-  void LayoutDraggedTabsAt(const std::vector<Tab*>& tabs,
+  void LayoutDraggedTabsAt(const Tabs& tabs,
                            Tab* active_tab,
                            const gfx::Point& location,
                            bool initial_drag);
 
   // Calculates the bounds needed for each of the tabs, placing the result in
   // |bounds|.
-  void CalculateBoundsForDraggedTabs(const std::vector<Tab*>& tabs,
+  void CalculateBoundsForDraggedTabs(const Tabs& tabs,
                                      std::vector<gfx::Rect>* bounds);
 
   // Returns the size needed for the specified tabs. This is invoked during drag
   // and drop to calculate offsets and positioning.
-  int GetSizeNeededForTabs(const std::vector<Tab*>& tabs);
+  int GetSizeNeededForTabs(const Tabs& tabs);
+
+  // Returns the number of mini-tabs.
+  int GetMiniTabCount() const;
+
+  // Returns the last tab in the strip.
+  const Tab* GetLastVisibleTab() const;

[Peter Kasting, 2014/06/17 03:16:18]

In the future, this function will also check tab visibility, hence pulling it
out to its own helper.

 
   // Adds the tab at |index| to |tabs_closing_map_| and removes the tab from
   // |tabs_|.
   void RemoveTabFromViewModel(int index);
 
   // Cleans up the Tab from the TabStrip. This is called from the tab animation
   // code and is not a general-purpose method.
   void RemoveAndDeleteTab(Tab* tab);
 
   // Adjusts the indices of all tabs in |tabs_closing_map_| whose index is
   // >= |index| to have a new index of |index + delta|.
   void UpdateTabsClosingMap(int index, int delta);
 
   // Used by TabDragController when the user starts or stops dragging tabs.
-  void StartedDraggingTabs(const std::vector<Tab*>& tabs);
+  void StartedDraggingTabs(const Tabs& tabs);
 
   // Invoked when TabDragController detaches a set of tabs.
   void DraggedTabsDetached();
 
   // Used by TabDragController when the user stops dragging tabs. |move_only| is
   // true if the move behavior is TabDragController::MOVE_VISIBILE_TABS.
   // |completed| is true if the drag operation completed successfully, false if
   // it was reverted.
-  void StoppedDraggingTabs(const std::vector<Tab*>& tabs,
+  void StoppedDraggingTabs(const Tabs& tabs,
                            const std::vector<int>& initial_positions,
                            bool move_only,
                            bool completed);
 
   // Invoked from StoppedDraggingTabs to cleanup |tab|. If |tab| is known
   // |is_first_tab| is set to true.
   void StoppedDraggingTab(Tab* tab, bool* is_first_tab);
 
   // Takes ownership of |controller|.
   void OwnDragController(TabDragController* controller);
 
   // Destroys the current TabDragController. This cancel the existing drag
   // operation.
   void DestroyDragController();
 
   // Releases ownership of the current TabDragController.
   TabDragController* ReleaseDragController();
 
+  // Finds |tab| in the |tab_closing_map_| and returns a pair of iterators
+  // indicating precisely where it is.
+  FindClosingTabResult FindClosingTab(const Tab* tab);
+
   // 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
   // |stacked_layout_|.
   void UpdateStackedLayoutFromMouseEvent(views::View* source,
                                          const ui::MouseEvent& event);
 
@@ skipping 61 matching lines @@
   // Generates the ideal bounds for each of the tabs as well as the new tab
   // button.
   void GenerateIdealBounds();
 
   // Generates the ideal bounds for the mini tabs. Returns the index to position
   // the first non-mini tab and sets |first_non_mini_index| to the index of the
   // first non-mini tab.
   int GenerateIdealBoundsForMiniTabs(int* first_non_mini_index);
 
   // Returns the width needed for the new tab button (and padding).
-  static int new_tab_button_width();
-
-  // Returns the vertical offset of the tab strip button. This offset applies
-  // only to restored windows.
-  static int button_v_offset();
+  static int new_tab_button_width() {
+    return kNewTabButtonAssetWidth + kNewTabButtonHorizontalOffset;
+  }
 
   // Returns the width of the area that contains tabs. This does not include
   // the width of the new tab button.
-  int tab_area_width() const;
+  int tab_area_width() const { return width() - new_tab_button_width(); }
 
   // Starts various types of TabStrip animations.
   void StartResizeLayoutAnimation();
   void StartMiniTabAnimation();
   void StartMouseInitiatedRemoveTabAnimation(int model_index);
 
   // Returns true if the specified point in TabStrip coords is within the
   // hit-test region of the specified Tab.
   bool IsPointInTab(Tab* tab, const gfx::Point& point_in_tabstrip_coords);
 
@@ skipping 24 matching lines @@
   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 stacked
   // layout is reset.
   void SetResetToShrinkOnExit(bool value);
 
+  // views::ButtonListener implementation:
+  virtual void ButtonPressed(views::Button* sender,
+                             const ui::Event& event) OVERRIDE;
+
+  // View overrides.
+  virtual const views::View* GetViewByID(int id) const OVERRIDE;
+  virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
+  virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE;
+  virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
+  virtual void OnMouseCaptureLost() OVERRIDE;
+  virtual void OnMouseMoved(const ui::MouseEvent& event) OVERRIDE;
+  virtual void OnMouseEntered(const ui::MouseEvent& event) OVERRIDE;
+
+  // ui::EventHandler overrides.
+  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
+
   // -- 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 79 matching lines @@
   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_