Changes the tabstrip dragging code to use coordinates from the events

chrome/browser/ui/views/tabs/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_TAB_DRAG_CONTROLLER_H_
 #define CHROME_BROWSER_UI_VIEWS_TABS_TAB_DRAG_CONTROLLER_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 87 matching lines @@
   // Returns true if there is a drag underway.
   static bool IsActive();
 
   // See description above fields for details on these.
   bool active() const { return active_; }
   const TabStrip* attached_tabstrip() const { return attached_tabstrip_; }
 
   // Returns true if a drag started.
   bool started_drag() const { return started_drag_; }
 
-  // Invoked as the mouse is dragged. If the mouse moves a sufficient distance
-  // before the mouse is released, a drag session is initiated.
-  void Drag();
+  // Invoked to drag to the new location, in screen coordinates.
+  void Drag(const gfx::Point& screen_point);
 
   // Complete the current drag session. If the drag session was canceled
   // because the user pressed escape or something interrupted it, |canceled|
   // is true and the drag is reverted.
   void EndDrag(bool canceled);
 
  private:
   class DockDisplayer;
   friend class DockDisplayer;
 
@@ skipping 103 matching lines @@
   virtual void OnWidgetMoved(views::Widget* widget) OVERRIDE;
 
   // Overriden from TabStripModelObserver:
   virtual void TabStripEmpty() OVERRIDE;
 
   // Initialize the offset used to calculate the position to create windows
   // in |GetWindowCreatePoint|. This should only be invoked from |Init|.
   void InitWindowCreatePoint();
 
   // Returns the point where a detached window should be created given the
-  // current mouse position.
-  gfx::Point GetWindowCreatePoint() const;
+  // current mouse position |origin|.
+  gfx::Point GetWindowCreatePoint(const gfx::Point& origin) const;
 
   void UpdateDockInfo(const gfx::Point& screen_point);
 
   // Saves focus in the window that the drag initiated from. Focus will be
   // restored appropriately if the drag ends within this same window.
   void SaveFocus();
 
   // Restore focus to the View that had focus before the drag was started, if
   // the drag ends within the same Window as it began.
   void RestoreFocus();
 
-  // Tests whether the position of the mouse is past a minimum elasticity
-  // threshold required to start a drag.
-  bool CanStartDrag() const;
+  // Tests whether |screen_point| is past a minimum elasticity threshold
+  // required to start a drag.
+  bool CanStartDrag(const gfx::Point& screen_point) const;
 
   // Move the DraggedTabView according to the current mouse screen position,
   // potentially updating the source and other TabStrips.
-  void ContinueDragging();
+  void ContinueDragging(const gfx::Point& screen_point);
 
   // Transitions dragging from |attached_tabstrip_| to |target_tabstrip|.
   // |target_tabstrip| is NULL if the mouse is not over a valid tab strip.  See
   // DragBrowserResultType for details of the return type.
   DragBrowserResultType DragBrowserToNewTabStrip(
       TabStrip* target_tabstrip,
       const gfx::Point& screen_point);
 
   // 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 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();
+  void MoveAttachedToNextStackedIndex(const gfx::Point& screen_point);
+  void MoveAttachedToPreviousStackedIndex(const gfx::Point& screen_point);
 
   // 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);
+  void StartMoveStackedTimerIfNecessary(
+      const gfx::Point& screen_point,
+      int delay_ms);
 
   // Returns the TabStrip for the specified window, or NULL if one doesn't exist
   // or isn't compatible.
   TabStrip* GetTabStripForWindow(gfx::NativeWindow window);
 
   // 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);
 
   // Returns true if |tabstrip| contains the specified point in screen
@@ skipping 83 matching lines @@
   // Finishes a succesful drag operation.
   void CompleteDrag();
 
   // Resets the delegates of the WebContents.
   void ResetDelegates();
 
   // Create the DraggedTabView.
   void CreateDraggedView(const std::vector<TabRendererData>& data,
                          const std::vector<gfx::Rect>& renderer_bounds);
 
-  // Utility for getting the mouse position in screen coordinates.
-  gfx::Point GetCursorScreenPoint() const;
-
   // Returns the bounds (in screen coordinates) of the specified View.
   gfx::Rect GetViewScreenBounds(views::View* tabstrip) const;
 
   // Hides the frame for the window that contains the TabStrip the current
   // drag session was initiated from.
   void HideFrame();
 
   // Closes a hidden frame at the end of a drag session.
   void CleanUpHiddenFrame();
 
   void DockDisplayerDestroyed(DockDisplayer* controller);
 
-  void BringWindowUnderMouseToFront();
+  void BringWindowUnderPointToFront(const gfx::Point& screen_point);
 
   // Convenience for getting the TabDragData corresponding to the tab the user
   // started dragging.
   TabDragData* source_tab_drag_data() {
     return &(drag_data_[source_tab_index_]);
   }
 
   // Convenience for |source_tab_drag_data()->contents|.
   TabContentsWrapper* source_dragged_contents() {
     return source_tab_drag_data()->contents;
@@ skipping 120 matching lines @@
   std::vector<int> initial_tab_positions_;
 
   DetachBehavior detach_behavior_;
   MoveBehavior move_behavior_;
 
   // 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().
+  // Last location used.
   gfx::Point last_screen_point_;
 
   // The following are needed when detaching into a browser
   // (|detach_into_browser_| is true).
 
   // Set to true if we've detached from a tabstrip and are running a nested
   // move message loop.
   bool is_dragging_window_;
 
   EndRunLoopBehavior end_run_loop_behavior_;
 
   // If true, we're waiting for a move loop to complete.
   bool waiting_for_run_loop_to_exit_;
 
   // The TabStrip to attach to after the move loop completes.
   TabStrip* tab_strip_to_attach_to_after_exit_;
 
   // Non-null for the duration of RunMoveLoop.
   views::Widget* move_loop_widget_;
 
   // If non-null set to true from destructor.
   bool* destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(TabDragController);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TABS_TAB_DRAG_CONTROLLER_H_