More TabStrip refactoring.

chrome/browser/views/tabs/tab_strip.h

 // Copyright (c) 2010 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_VIEWS_TABS_TAB_STRIP_H_
 #define CHROME_BROWSER_VIEWS_TABS_TAB_STRIP_H_
 
-#include <vector>
-
 #include "app/animation_container.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/timer.h"
 #include "chrome/browser/views/tabs/base_tab_strip.h"
 #include "chrome/browser/views/tabs/tab.h"
 #include "gfx/point.h"
 #include "gfx/rect.h"
 #include "views/animation/bounds_animator.h"
 #include "views/controls/button/image_button.h"
 
-class DraggedTabController;
-
 namespace views {
 class ImageView;
 #if defined(OS_LINUX)
 class WidgetGtk;
 #elif defined(OS_WIN)
 class WidgetWin;
 #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 20 matching lines @@
   // Set whether the new tab button is enabled.
   void set_new_tab_button_enabled(bool enabled) {
     new_tab_button_enabled_ = enabled;
   }
 
   // Returns whether the new tab button is enabled.
   bool new_tab_button_enabled() {
     return new_tab_button_enabled_;
   }
 
-  // Destroys the active drag controller.
-  void DestroyDragController();
-
-  // Retrieves the ideal bounds for the Tab at the specified index.
-  gfx::Rect GetIdealBounds(int tab_data_index);
-
   // Creates the new tab button.
   void InitTabStripButtons();
 
   // Returns the bounds of the new tab button.
   gfx::Rect GetNewTabButtonBounds();
 
   // BaseTabStrip implementation:
   virtual int GetPreferredHeight();
   virtual void SetBackgroundOffset(const gfx::Point& offset);
   virtual bool IsPositionInWindowCaption(const gfx::Point& point);
   virtual void SetDraggedTabBounds(int tab_index,
                                    const gfx::Rect& tab_bounds);
-  virtual bool IsDragSessionActive() const;
   virtual bool IsAnimating() const;
   virtual TabStrip* AsTabStrip();
-  virtual void AddTabAt(int model_index,
-                        bool foreground,
-                        const TabRendererData& data);
   virtual void RemoveTabAt(int model_index, bool initiated_close);
   virtual void SelectTabAt(int old_model_index, int new_model_index);
-  virtual void MoveTab(int from_model_index, int to_model_index);
   virtual void TabTitleChangedNotLoading(int model_index);
   virtual void SetTabData(int model_index, const TabRendererData& data);
   virtual void StartHighlight(int model_index);
   virtual void StopAllHighlighting();
-  virtual BaseTabRenderer* GetBaseTabAtModelIndex(int model_index) const;
-  virtual BaseTabRenderer* GetBaseTabAtTabIndex(int tab_index) const;
-  virtual int GetModelIndexOfBaseTab(const BaseTabRenderer* tab) const;
   virtual BaseTabRenderer* CreateTabForDragging();
 
   // views::View overrides:
   virtual void PaintChildren(gfx::Canvas* canvas);
   virtual views::View* GetViewByID(int id) const;
   virtual void Layout();
   virtual gfx::Size GetPreferredSize();
   // NOTE: the drag and drop methods are invoked from FrameView. This is done to
   // allow for a drop region that extends outside the bounds of the TabStrip.
   virtual void OnDragEntered(const views::DropTargetEvent& event);
   virtual int OnDragUpdated(const views::DropTargetEvent& event);
   virtual void OnDragExited();
   virtual int OnPerformDrop(const views::DropTargetEvent& event);
   virtual bool GetAccessibleRole(AccessibilityTypes::Role* role);
   virtual views::View* GetViewForPoint(const gfx::Point& point);
   virtual void ThemeChanged();
 
   // BoundsAnimator::Observer overrides:
   virtual void OnBoundsAnimatorDone(views::BoundsAnimator* animator);
 
  protected:
-  // Creates a new tab.
+  // BaseTabStrip overrides:
   virtual Tab* CreateTab();
+  virtual void StartInsertTabAnimation(int model_index, bool foreground);
+  virtual void StartMoveTabAnimation();
+  virtual void StartedDraggingTab(BaseTabRenderer* tab);
+  virtual void StoppedDraggingTab(BaseTabRenderer* tab);
 
   // views::View implementation:
   virtual void ViewHierarchyChanged(bool is_add,
                                     views::View* parent,
                                     views::View* child);
-  virtual bool OnMouseDragged(const views::MouseEvent& event);
-  virtual void OnMouseReleased(const views::MouseEvent& event,
-                               bool canceled);
 
   // TabController overrides.
   virtual bool IsTabSelected(const BaseTabRenderer* btr) const;
-  virtual bool IsTabPinned(const BaseTabRenderer* btr) const;
-  virtual void MaybeStartDrag(BaseTabRenderer* btr,
-                              const views::MouseEvent& event);
-  virtual void ContinueDrag(const views::MouseEvent& event);
-  virtual bool EndDrag(bool canceled);
-  virtual bool HasAvailableDragActions() const;
 
   // views::ButtonListener implementation:
   virtual void ButtonPressed(views::Button* sender, const views::Event& event);
 
   // MessageLoop::Observer implementation:
 #if defined(OS_WIN)
   virtual void WillProcessMessage(const MSG& msg);
   virtual void DidProcessMessage(const MSG& msg);
 #else
   virtual void WillProcessEvent(GdkEvent* event);
@@ skipping 60 matching lines @@
     views::WidgetWin* arrow_window;
 #else
     views::WidgetGtk* arrow_window;
 #endif
     views::ImageView* arrow_view;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(DropInfo);
   };
 
-  // The Tabs we contain, and their last generated "good" bounds.
-  struct TabData {
-    Tab* tab;
-    gfx::Rect ideal_bounds;
-  };
-
   void Init();
 
   // Set the images for the new tab button.
   void LoadNewTabButtonImage();
 
   // Retrieves the Tab at the specified index. Remember, the specified index
   // is in terms of tab_data, *not* the model.
   Tab* GetTabAtTabDataIndex(int tab_data_index) const;
 
   // Returns the tab at the specified index. If a remove animation is on going
   // and the index is >= the index of the tab being removed, the index is
   // incremented. While a remove operation is on going the indices of the model
   // do not line up with the indices of the view. This method adjusts the index
   // accordingly.
   //
   // Use this instead of GetTabAtTabDataIndex if the index comes from the model.
   Tab* GetTabAtModelIndex(int model_index) const;
 
-  // Gets the number of Tabs in the collection.
-  // WARNING: this is the number of tabs displayed by the tabstrip, which if
-  // an animation is ongoing is not necessarily the same as the number of tabs
-  // in the model.
-  virtual int GetTabCount() const;
-
   // Returns the number of mini-tabs.
   int GetMiniTabCount() const;
 
   // Returns the number of nano-tabs.
   int GetNanoTabCount() const;
 
   // -- Tab Resize Layout -----------------------------------------------------
 
   // Returns the exact (unrounded) current width of each tab.
   void GetCurrentTabWidths(double* unselected_width,
@@ skipping 63 matching lines @@
   void AnimateToIdealBounds();
 
   // Returns true if a new tab inserted at specified index should start the
   // new tab animation. See description above AnimationType for details on
   // this animation.
   bool ShouldStartIntertTabAnimationAtEnd(int model_index, bool foreground);
 
   // Starts various types of TabStrip animations.
   void StartResizeLayoutAnimation();
   void StartInsertTabAnimationAtEnd();
-  void StartInsertTabAnimation(int model_index);
+  void StartInsertTabAnimationImpl(int model_index);
   void StartRemoveTabAnimation(int model_index);
   void StartMoveTabAnimation(int from_model_index,
                              int to_model_index);
   void StartMiniTabAnimation();
 
   // Stops any ongoing animations. If |layout| is true and an animation is
   // ongoing this does a layout.
-  void StopAnimating(bool layout);
+  virtual void StopAnimating(bool layout);
 
   // Resets all state related to animations. This is invoked when an animation
   // completes, prior to starting an animation or when we cancel an animation.
   // If |stop_new_tab_timer| is true, |new_tab_timer_| is stopped.
   void ResetAnimationState(bool stop_new_tab_timer);
 
   // Calculates the available width for tabs, assuming a Tab is to be closed.
   int GetAvailableWidthForTabs(Tab* last_tab) const;
 
   // 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);
 
-  // Cleans up the Tab from the TabStrip. This is called from the tab animation
-  // code and is not a general-purpose method.
-  void RemoveTab(Tab* tab);
-
   // Called from the message loop observer when a mouse movement has occurred
   // anywhere over our containing window.
   void HandleGlobalMouseMoveEvent();
 
   // Returns true if any of the tabs are phantom.
   bool HasPhantomTabs() const;
 
-  // Returns the index of the specified tab in the model coordiate system, or
-  // -1 if tab is closing or not in |tab_data_|.
-  int GetModelIndexOfTab(const Tab* tab) const;
-
-  // Returns the index into |tab_data_| corresponding to the index from the
-  // TabStripModel, or |tab_data_.size()| if there is no tab representing
-  // |model_index|.
-  int ModelIndexToTabDataIndex(int model_index) const;
-
-  // Returns the index into |tab_data_| corresponding to the specified tab, or
-  // -1 if the tab isn't in |tab_data_|.
-  int TabDataIndexOfTab(Tab* tab) const;
-
-  // See description above field for details.
-  void set_attaching_dragged_tab(bool value) { attaching_dragged_tab_ = value; }
-
-  // Used by DraggedTabController when the user starts or stops dragging a tab.
-  void StartedDraggingTab(Tab* tab);
-  void StoppedDraggingTab(Tab* tab);
-
   // -- Member Variables ------------------------------------------------------
 
   // A factory that is used to construct a delayed callback to the
   // ResizeLayoutTabsNow method.
   ScopedRunnableMethodFactory<TabStrip> resize_layout_factory_;
 
   // True if the TabStrip has already been added as a MessageLoop observer.
   bool added_as_message_loop_observer_;
 
   // True if a resize layout animation should be run a short delay after the
@@ skipping 25 matching lines @@
   // 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
   // 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 kNewTabButtonWidth = 28;
   static const int kNewTabButtonHeight = 18;
 
   // Valid for the lifetime of a drag over us.
   scoped_ptr<DropInfo> drop_info_;
 
-  // The controller for a drag initiated from a Tab. Valid for the lifetime of
-  // the drag session.
-  scoped_ptr<DraggedTabController> drag_controller_;
-
-  std::vector<TabData> tab_data_;
-
   // To ensure all tabs pulse at the same time they share the same animation
   // container. This is that animation container.
   scoped_refptr<AnimationContainer> animation_container_;
 
   views::BoundsAnimator bounds_animator_;
 
   // Used for stage 1 of new tab animation.
   base::OneShotTimer<TabStrip> new_tab_timer_;
 
   // Set for special animations.
   AnimationType animation_type_;
 
   // Whether the new tab button is being displayed.
   bool new_tab_button_enabled_;
 
   // If true, we're cancelling the animation.
   bool cancelling_animation_;
 
-  // Used by DraggedTabController when inserting a tab into our model.
-  bool attaching_dragged_tab_;
-
   DISALLOW_COPY_AND_ASSIGN(TabStrip);
 };
 
 #endif  // CHROME_BROWSER_VIEWS_TABS_TAB_STRIP_H_