Fix coordinates in tab detach &drag code and multi window resizer.

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_
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 90 matching lines @@
   void SetMoveBehavior(MoveBehavior behavior);
 
   // 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 to drag to the new location, in screen coordinates.
-  void Drag(const gfx::Point& screen_point);
+  void Drag(const gfx::Point& point_in_screen);
 
   // 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 112 matching lines @@
   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 |origin|.
   gfx::Point GetWindowCreatePoint(const gfx::Point& origin) const;
 
-  void UpdateDockInfo(const gfx::Point& screen_point);
+  void UpdateDockInfo(const gfx::Point& point_in_screen);
 
   // 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 |screen_point| is past a minimum elasticity threshold
+  // Tests whether |point_in_screen| is past a minimum elasticity threshold
   // required to start a drag.
-  bool CanStartDrag(const gfx::Point& screen_point) const;
+  bool CanStartDrag(const gfx::Point& point_in_screen) const;
 
   // Move the DraggedTabView according to the current mouse screen position,
   // potentially updating the source and other TabStrips.
-  void ContinueDragging(const gfx::Point& screen_point);
+  void ContinueDragging(const gfx::Point& point_in_screen);
 
   // 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);
+      const gfx::Point& point_in_screen);
 
   // 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);
+  void DragActiveTabStacked(const gfx::Point& point_in_screen);
 
   // Moves the active tab to the next/previous tab. Used when the next/previous
   // tab is stacked.
-  void MoveAttachedToNextStackedIndex(const gfx::Point& screen_point);
-  void MoveAttachedToPreviousStackedIndex(const gfx::Point& screen_point);
+  void MoveAttachedToNextStackedIndex(const gfx::Point& point_in_screen);
+  void MoveAttachedToPreviousStackedIndex(const gfx::Point& point_in_screen);
 
   // Handles dragging tabs while the tabs are attached.
-  void MoveAttached(const gfx::Point& screen_point);
+  void MoveAttached(const gfx::Point& point_in_screen);
 
   // Handles dragging while the tabs are detached.
-  void MoveDetached(const gfx::Point& screen_point);
+  void MoveDetached(const gfx::Point& point_in_screen);
 
   // If necessary starts the |move_stacked_timer_|. The timer is started if
   // close enough to an edge with stacked tabs.
   void StartMoveStackedTimerIfNecessary(
-      const gfx::Point& screen_point,
+      const gfx::Point& point_in_screen,
       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);
+  TabStrip* GetTabStripForPoint(const gfx::Point& point_in_screen);
 
   // Returns true if |tabstrip| contains the specified point in screen
   // coordinates.
   bool DoesTabStripContain(TabStrip* tabstrip,
-                           const gfx::Point& screen_point) const;
+                           const gfx::Point& point_in_screen) const;
 
   // Returns the DetachPosition given the specified location in screen
   // coordinates.
-  DetachPosition GetDetachPosition(const gfx::Point& screen_point);
+  DetachPosition GetDetachPosition(const gfx::Point& point_in_screen);
 
-  DockInfo GetDockInfoAtPoint(const gfx::Point& screen_point);
+  DockInfo GetDockInfoAtPoint(const gfx::Point& point_in_screen);
 
   // Attach the dragged Tab to the specified TabStrip.
-  void Attach(TabStrip* attached_tabstrip, const gfx::Point& screen_point);
+  void Attach(TabStrip* attached_tabstrip, const gfx::Point& point_in_screen);
 
   // Detach the dragged Tab from the current TabStrip.
   void Detach(ReleaseCapture release_capture);
 
   // Detaches the tabs being dragged, creates a new Browser to contain them and
   // runs a nested move loop.
-  void DetachIntoNewBrowserAndRunMoveLoop(const gfx::Point& screen_point);
+  void DetachIntoNewBrowserAndRunMoveLoop(const gfx::Point& point_in_screen);
 
   // Runs a nested message loop that handles moving the current Browser.
   void RunMoveLoop();
 
   // 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;
@@ skipping 19 matching lines @@
   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);
+  gfx::Point GetAttachedDragPoint(const gfx::Point& point_in_screen);
 
   // Finds the Tabs within the specified TabStrip that corresponds to the
   // WebContents of the dragged tabs. Returns an empty vector if not attached.
   std::vector<BaseTab*> GetTabsMatchingDraggedContents(TabStrip* tabstrip);
 
   // Returns the bounds for the tabs based on the attached tab strip. The
   // x-coordinate of each tab is offset by |x_offset|.
   std::vector<gfx::Rect> CalculateBoundsForDraggedTabs(int x_offset);
 
   // Does the work for EndDrag. If we actually started a drag and |how_end| is
@@ skipping 26 matching lines @@
 
   // 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 BringWindowUnderPointToFront(const gfx::Point& screen_point);
+  void BringWindowUnderPointToFront(const gfx::Point& point_in_screen);
 
   // 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|.
   TabContents* source_dragged_contents() {
     return source_tab_drag_data()->contents;
   }
 
   // Returns the Widget of the currently attached TabStrip's BrowserView.
   views::Widget* GetAttachedBrowserWidget();
 
   // Returns true if the tabs were originality one after the other in
   // |source_tabstrip_|.
   bool AreTabsConsecutive();
 
   // Creates and returns a new Browser to handle the drag.
   Browser* CreateBrowserForDrag(TabStrip* source,
-                                const gfx::Point& screen_point,
+                                const gfx::Point& point_in_screen,
                                 std::vector<gfx::Rect>* drag_bounds);
 
   // Returns the TabStripModel for the specified tabstrip.
   TabStripModel* GetModel(TabStrip* tabstrip) const;
 
   // Returns the location of the cursor. This is either the location of the
   // mouse or the location of the current touch point.
   gfx::Point GetCursorScreenPoint();
 
   // Returns true if moving the mouse only changes the visible tabs.
@@ skipping 13 matching lines @@
   // The TabStrip the dragged Tab is currently attached to, or NULL if the
   // dragged Tab is detached.
   TabStrip* attached_tabstrip_;
 
   // The visual representation of the dragged Tab.
   scoped_ptr<DraggedTabView> view_;
 
   // The position of the mouse (in screen coordinates) at the start of the drag
   // operation. This is used to calculate minimum elasticity before a
   // DraggedTabView is constructed.
-  gfx::Point start_screen_point_;
+  gfx::Point start_point_in_screen_;
 
   // This is the offset of the mouse from the top left of the Tab where
   // dragging begun. This is used to ensure that the dragged view is always
   // positioned at the correct location during the drag, and to ensure that the
   // detached window is created at the right location.
   gfx::Point mouse_offset_;
 
   // Offset of the mouse relative to the source tab.
   int source_tab_offset_;
 
@@ skipping 68 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_;
 
-  // Last location used.
-  gfx::Point last_screen_point_;
+  // Last location used in screen coordinates.
+  gfx::Point last_point_in_screen_;
 
   // 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_