Gets tab dragging to work in touch mode.

chrome/browser/ui/views/tabs/default_tab_drag_controller.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_DEFAULT_TAB_DRAG_CONTROLLER_H_
 #define CHROME_BROWSER_UI_VIEWS_TABS_DEFAULT_TAB_DRAG_CONTROLLER_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 49 matching lines @@
   // See description above fields for details on these.
   bool active() const { return active_; }
   const TabStrip* attached_tabstrip() const { return attached_tabstrip_; }
 
  private:
   class DockDisplayer;
   friend class DockDisplayer;
 
   typedef std::set<gfx::NativeView> DockWindows;
 
+  // Used to indicate the direction the mouse has moved when attached.
+  static const int kMovedMouseLeft  = 1 << 0;
+  static const int kMovedMouseRight = 1 << 1;
+
   // Enumeration of the ways a drag session can end.
   enum EndDragType {
     // Drag session exited normally: the user released the mouse.
     NORMAL,
 
     // The drag session was canceled (alt-tab during drag, escape ...)
     CANCELED,
 
     // The tab (NavigationController) was destroyed during the drag.
     TAB_DESTROYED
@@ skipping 84 matching lines @@
   // Tests whether the position of the mouse is past a minimum elasticity
   // threshold required to start a drag.
   bool CanStartDrag() const;
 
   // Move the DraggedTabView according to the current mouse screen position,
   // potentially updating the source and other TabStrips.
   void ContinueDragging();
 
   // Handles dragging for a touch tabstrip when the tabs are stacked. Doesn't
   // actually reorder the tabs in anyway, just changes what's visible.
-  void MoveAttachedStacked(const gfx::Point& screen_point);
+  void DragActiveTabStacked(const gfx::Point& screen_point);
+
+  // Moves the active tab to the next/previous tab. Used when the next/previous
+  // tab is stacked.
+  void MoveAttachedToNextStackedIndex();
+  void MoveAttachedToPreviousStackedIndex();
 
   // Handles dragging tabs while the tabs are attached.
   void MoveAttached(const gfx::Point& screen_point);
 
   // Handles dragging while the tabs are detached.
   void MoveDetached(const gfx::Point& screen_point);
 
+  // If necessary starts the |move_stacked_timer_|. The timer is started if
+  // close enough to an edge with stacked tabs.
+  void StartMoveStackedTimerIfNecessary(int delay_ms);
+
 #if defined(OS_WIN) && !defined(USE_AURA)
   // Returns the compatible TabStrip that is under the specified point (screen
   // coordinates), or NULL if there is none.
   TabStrip* GetTabStripForPoint(const gfx::Point& screen_point);
 #endif
 
   DockInfo GetDockInfoAtPoint(const gfx::Point& screen_point);
 
   // Returns the specified |tabstrip| if it contains the specified point
   // (screen coordinates), NULL if it does not.
   TabStrip* GetTabStripIfItContains(TabStrip* tabstrip,
                                     const gfx::Point& screen_point) const;
 
   // Attach the dragged Tab to the specified TabStrip.
   void Attach(TabStrip* attached_tabstrip, const gfx::Point& screen_point);
 
   // Detach the dragged Tab from the current TabStrip.
   void Detach();
 
+  // Determines the index to insert tabs at. |dragged_bounds| is the bounds of
+  // the tabs being dragged, |start| the index of the tab to start looking from
+  // and |delta| the amount to increment (1 or -1).
+  int GetInsertionIndexFrom(const gfx::Rect& dragged_bounds,
+                            int start,
+                            int delta) const;
+
   // Returns the index where the dragged WebContents should be inserted into
   // |attached_tabstrip_| given the DraggedTabView's bounds |dragged_bounds| in
   // coordinates relative to |attached_tabstrip_| and has had the mirroring
   // transformation applied.
   // NOTE: this is invoked from |Attach| before the tabs have been inserted.
   int GetInsertionIndexForDraggedBounds(const gfx::Rect& dragged_bounds) const;
 
+  // Returns true if |dragged_bounds| is close enough to the next stacked tab
+  // so that the active tab should be dragged there.
+  bool ShouldDragToNextStackedTab(const gfx::Rect& dragged_bounds,
+                                  int index) const;
+
+  // Returns true if |dragged_bounds| is close enough to the previous stacked
+  // tab so that the active tab should be dragged there.
+  bool ShouldDragToPreviousStackedTab(const gfx::Rect& dragged_bounds,
+                                      int index) const;
+
+  // Used by GetInsertionIndexForDraggedBounds() when the tabstrip is stacked.
+  int GetInsertionIndexForDraggedBoundsStacked(
+      const gfx::Rect& dragged_bounds) const;
+
   // Retrieve the bounds of the DraggedTabView relative to the attached
   // TabStrip. |tab_strip_point| is in the attached TabStrip's coordinate
   // system.
   gfx::Rect GetDraggedViewTabStripBounds(const gfx::Point& tab_strip_point);
 
   // Get the position of the dragged tab view relative to the attached tab
   // strip with the mirroring transform applied.
   gfx::Point GetAttachedDragPoint(const gfx::Point& screen_point);
 
   // Finds the Tabs within the specified TabStrip that corresponds to the
@@ skipping 121 matching lines @@
 
   DockWindows dock_windows_;
 
   std::vector<DockDisplayer*> dock_controllers_;
 
   // Timer used to bring the window under the cursor to front. If the user
   // stops moving the mouse for a brief time over a browser window, it is
   // brought to front.
   base::OneShotTimer<DefaultTabDragController> bring_to_front_timer_;
 
+  // Timer used to move the stacked tabs. See comment aboue
+  // StartMoveStackedTimerIfNecessary().
+  base::OneShotTimer<DefaultTabDragController> move_stacked_timer_;
+
   // Did the mouse move enough that we started a drag?
   bool started_drag_;
 
   // Is the drag active?
   bool active_;
 
   DragData drag_data_;
 
   // Index of the source tab in drag_data_.
   size_t source_tab_index_;
 
   // True until |MoveAttached| is invoked once.
   bool initial_move_;
 
   // The selection model before the drag started. See comment above Init() for
   // details.
   TabStripSelectionModel initial_selection_model_;
 
   // The selection model of |attached_tabstrip_| before the tabs were attached.
   TabStripSelectionModel selection_model_before_attach_;
 
   // Initial x-coordinates of the tabs when the drag started. Only used for
   // touch mode.
   std::vector<int> initial_tab_positions_;
 
   // TODO(sky): clean up.
   bool move_only_;
 
+  // Updated as the mouse is moved when attached. Indicates whether the mouse
+  // has ever moved to the left or right. If the tabs are ever detached this
+  // is set to kMovedMouseRight | kMovedMouseLeft.
+  int mouse_move_direction_;
+
+  // Coordinate last used in MoveAttached().
+  gfx::Point last_screen_point_;
+
   DISALLOW_COPY_AND_ASSIGN(DefaultTabDragController);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TABS_DEFAULT_TAB_DRAG_CONTROLLER_H_