Changes the tabstrip dragging code to use coordinates from the events

chrome/browser/ui/views/tabs/tab_drag_controller.cc

 // 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.
 
 #include "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/callback.h"
@@ skipping 371 matching lines @@
     const std::vector<BaseTab*>& tabs,
     const gfx::Point& mouse_offset,
     int source_tab_offset,
     const TabStripSelectionModel& initial_selection_model,
     DetachBehavior detach_behavior,
     MoveBehavior move_behavior) {
   DCHECK(!tabs.empty());
   DCHECK(std::find(tabs.begin(), tabs.end(), source_tab) != tabs.end());
   source_tabstrip_ = source_tabstrip;
   source_tab_offset_ = source_tab_offset;
-  start_screen_point_ = GetCursorScreenPoint();
+  // TODO: make sure this works with RTL.
+  start_screen_point_ = gfx::Point(source_tab_offset, mouse_offset.y());
+  views::View::ConvertPointToScreen(source_tab, &start_screen_point_);
   mouse_offset_ = mouse_offset;
   detach_behavior_ = detach_behavior;
   move_behavior_ = move_behavior;
   last_screen_point_ = start_screen_point_;
   if (move_only()) {
     last_move_screen_loc_ = start_screen_point_.x();
     initial_tab_positions_ = source_tabstrip->GetTabXCoordinates();
   }
   if (detach_into_browser_)
     GetModel(source_tabstrip_)->AddObserver(this);
@@ skipping 19 matching lines @@
 bool TabDragController::IsAttachedTo(TabStrip* tab_strip) {
   return (instance_ && instance_->active() &&
           instance_->attached_tabstrip() == tab_strip);
 }
 
 // static
 bool TabDragController::IsActive() {
   return instance_ && instance_->active();
 }
 
-void TabDragController::Drag() {
+void TabDragController::Drag(const gfx::Point& screen_point) {
   bring_to_front_timer_.Stop();
   move_stacked_timer_.Stop();
 
   if (waiting_for_run_loop_to_exit_)
     return;
 
   if (!started_drag_) {
-    if (!CanStartDrag())
+    if (!CanStartDrag(screen_point))
       return;  // User hasn't dragged far enough yet.
 
     started_drag_ = true;
     SaveFocus();
     Attach(source_tabstrip_, gfx::Point());
     if (detach_into_browser_ && static_cast<int>(drag_data_.size()) ==
         GetModel(source_tabstrip_)->count()) {
       RunMoveLoop();  // Runs a nested loop, returning when done.
       return;
     }
   }
 
-  ContinueDragging();
+  ContinueDragging(screen_point);
 }
 
 void TabDragController::EndDrag(bool canceled) {
   EndDragImpl(canceled && source_tabstrip_ ? CANCELED : NORMAL);
 }
 
 void TabDragController::InitTabDragData(BaseTab* tab,
                                         TabDragData* drag_data) {
   drag_data->source_model_index =
       source_tabstrip_->GetModelIndexOfBaseTab(tab);
@@ skipping 121 matching lines @@
   // to the way they were. This is the most reliable way to do this since no
   // single view or window reliably receives events throughout all the various
   // kinds of tab dragging.
   if (ui::EventTypeFromNative(event) == ui::ET_KEY_PRESSED &&
       ui::KeyboardCodeFromNative(event) == ui::VKEY_ESCAPE) {
     EndDrag(true);
   }
 }
 
 void TabDragController::OnWidgetMoved(views::Widget* widget) {
-  Drag();
+  // TODO: this needs to query event.
+  Drag(gfx::Screen::GetCursorScreenPoint());
 }
 
 void TabDragController::TabStripEmpty() {
   DCHECK(detach_into_browser_);
   GetModel(source_tabstrip_)->RemoveObserver(this);
   // NULL out source_tabstrip_ so that we don't attempt to add back to it (in
   // the case of a revert).
   source_tabstrip_ = NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabDragController, private:
 
 void TabDragController::InitWindowCreatePoint() {
   // window_create_point_ is only used in CompleteDrag() (through
   // GetWindowCreatePoint() to get the start point of the docked window) when
   // the attached_tabstrip_ is NULL and all the window's related bound
   // information are obtained from source_tabstrip_. So, we need to get the
   // first_tab based on source_tabstrip_, not attached_tabstrip_. Otherwise,
   // the window_create_point_ is not in the correct coordinate system. Please
   // refer to http://crbug.com/6223 comment #15 for detailed information.
   views::View* first_tab = source_tabstrip_->tab_at(0);
   views::View::ConvertPointToWidget(first_tab, &first_source_tab_point_);
   window_create_point_ = first_source_tab_point_;
   window_create_point_.Offset(mouse_offset_.x(), mouse_offset_.y());
 }
 
-gfx::Point TabDragController::GetWindowCreatePoint() const {
-  gfx::Point cursor_point = GetCursorScreenPoint();
+gfx::Point TabDragController::GetWindowCreatePoint(
+    const gfx::Point& origin) const {
   if (dock_info_.type() != DockInfo::NONE && dock_info_.in_enable_area()) {
     // If we're going to dock, we need to return the exact coordinate,
     // otherwise we may attempt to maximize on the wrong monitor.
-    return cursor_point;
+    return origin;
   }
+
   // If the cursor is outside the monitor area, move it inside. For example,
   // dropping a tab onto the task bar on Windows produces this situation.
-  gfx::Rect work_area = gfx::Screen::GetMonitorNearestPoint(
-      cursor_point).work_area();
+  gfx::Rect work_area = gfx::Screen::GetMonitorNearestPoint(origin).work_area();
+  gfx::Point create_point(origin);
   if (!work_area.IsEmpty()) {
-    if (cursor_point.x() < work_area.x())
-      cursor_point.set_x(work_area.x());
-    else if (cursor_point.x() > work_area.right())
-      cursor_point.set_x(work_area.right());
-    if (cursor_point.y() < work_area.y())
-      cursor_point.set_y(work_area.y());
-    else if (cursor_point.y() > work_area.bottom())
-      cursor_point.set_y(work_area.bottom());
+    if (create_point.x() < work_area.x())
+      create_point.set_x(work_area.x());
+    else if (create_point.x() > work_area.right())
+      create_point.set_x(work_area.right());
+    if (create_point.y() < work_area.y())
+      create_point.set_y(work_area.y());
+    else if (create_point.y() > work_area.bottom())
+      create_point.set_y(work_area.bottom());
   }
-  return gfx::Point(cursor_point.x() - window_create_point_.x(),
-                    cursor_point.y() - window_create_point_.y());
+  return gfx::Point(create_point.x() - window_create_point_.x(),
+                    create_point.y() - window_create_point_.y());
 }
 
 void TabDragController::UpdateDockInfo(const gfx::Point& screen_point) {
   // Update the DockInfo for the current mouse coordinates.
   DockInfo dock_info = GetDockInfoAtPoint(screen_point);
   if (!dock_info.equals(dock_info_)) {
     // DockInfo for current position differs.
     if (dock_info_.type() != DockInfo::NONE &&
         !dock_controllers_.empty()) {
       // Hide old visual indicator.
@@ skipping 24 matching lines @@
   old_focused_view_ = source_tabstrip_->GetFocusManager()->GetFocusedView();
   source_tabstrip_->GetFocusManager()->SetFocusedView(source_tabstrip_);
 }
 
 void TabDragController::RestoreFocus() {
   if (old_focused_view_ && attached_tabstrip_ == source_tabstrip_)
     old_focused_view_->GetFocusManager()->SetFocusedView(old_focused_view_);
   old_focused_view_ = NULL;
 }
 
-bool TabDragController::CanStartDrag() const {
+bool TabDragController::CanStartDrag(const gfx::Point& screen_point) const {
   // Determine if the mouse has moved beyond a minimum elasticity distance in
   // any direction from the starting point.
   static const int kMinimumDragDistance = 10;
-  gfx::Point screen_point = GetCursorScreenPoint();
   int x_offset = abs(screen_point.x() - start_screen_point_.x());
   int y_offset = abs(screen_point.y() - start_screen_point_.y());
   return sqrt(pow(static_cast<float>(x_offset), 2) +
               pow(static_cast<float>(y_offset), 2)) > kMinimumDragDistance;
 }
 
-void TabDragController::ContinueDragging() {
+void TabDragController::ContinueDragging(const gfx::Point& screen_point) {
   DCHECK(!detach_into_browser_ || attached_tabstrip_);
 
-  // Note that the coordinates given to us by |drag_event| are basically
-  // useless, since they're in source_tab_ coordinates. On the surface, you'd
-  // think we could just convert them to screen coordinates, however in the
-  // situation where we're dragging the last tab in a window when multiple
-  // windows are open, the coordinates of |source_tab_| are way off in
-  // hyperspace since the window was moved there instead of being closed so
-  // that we'd keep receiving events. And our ConvertPointToScreen methods
-  // aren't really multi-screen aware. So really it's just safer to get the
-  // actual position of the mouse cursor directly from Windows here, which is
-  // guaranteed to be correct regardless of monitor config.
-  gfx::Point screen_point = GetCursorScreenPoint();
-
   TabStrip* target_tabstrip = detach_behavior_ == DETACHABLE ?
       GetTabStripForPoint(screen_point) : source_tabstrip_;
   bool tab_strip_changed = (target_tabstrip != attached_tabstrip_);
 
+  if (attached_tabstrip_) {
+    int move_delta = screen_point.x() - last_screen_point_.x();
+    if (move_delta > 0)
+      mouse_move_direction_ |= kMovedMouseRight;
+    else if (move_delta < 0)
+      mouse_move_direction_ |= kMovedMouseLeft;
+  }
+  last_screen_point_ = screen_point;
+
   if (tab_strip_changed) {
     if (detach_into_browser_ &&
         DragBrowserToNewTabStrip(target_tabstrip, screen_point) ==
         DRAG_BROWSER_RESULT_STOP) {
       return;
     } else if (!detach_into_browser_) {
       if (attached_tabstrip_)
         Detach();
       if (target_tabstrip)
         Attach(target_tabstrip, screen_point);
     }
   }
   if (view_.get() || is_dragging_window_) {
-    bring_to_front_timer_.Start(FROM_HERE,
-        base::TimeDelta::FromMilliseconds(kBringToFrontDelay), this,
-        &TabDragController::BringWindowUnderMouseToFront);
+    static_cast<base::Timer*>(&bring_to_front_timer_)->Start(FROM_HERE,
+        base::TimeDelta::FromMilliseconds(kBringToFrontDelay),
+        base::Bind(&TabDragController::BringWindowUnderPointToFront,
+                   base::Unretained(this), screen_point));
   }
 
   UpdateDockInfo(screen_point);
 
   if (!is_dragging_window_) {
     if (attached_tabstrip_) {
       if (move_only()) {
         DragActiveTabStacked(screen_point);
       } else {
         MoveAttached(screen_point);
@@ skipping 39 matching lines @@
     browser_widget->EndMoveLoop();
 
     // Ideally we would always swap the tabs now, but on windows it seems that
     // running the move loop implicitly activates the window when done, leading
     // to all sorts of flicker. So, on windows, instead we process the move
     // after the loop completes. But on chromeos, we can do tab swapping now to
     // avoid the tab flashing issue(crbug.com/116329).
 #if defined(USE_ASH)
     is_dragging_window_ = false;
     Detach();
-    gfx::Point screen_point(GetCursorScreenPoint());
     Attach(target_tabstrip, screen_point);
     // Move the tabs into position.
     MoveAttached(screen_point);
     attached_tabstrip_->GetWidget()->Activate();
 #else
     tab_strip_to_attach_to_after_exit_ = target_tabstrip;
 #endif
 
     waiting_for_run_loop_to_exit_ = true;
     end_run_loop_behavior_ = END_RUN_LOOP_CONTINUE_DRAGGING;
     return DRAG_BROWSER_RESULT_STOP;
   }
   Detach();
   Attach(target_tabstrip, screen_point);
   return DRAG_BROWSER_RESULT_CONTINUE;
 }
 
 void TabDragController::DragActiveTabStacked(
     const gfx::Point& screen_point) {
   if (attached_tabstrip_->tab_count() !=
       static_cast<int>(initial_tab_positions_.size()))
     return;  // TODO: should cancel drag if this happens.
 
   int delta = screen_point.x() - start_screen_point_.x();
   attached_tabstrip_->DragActiveTab(initial_tab_positions_, delta);
 }
 
-void TabDragController::MoveAttachedToNextStackedIndex() {
+void TabDragController::MoveAttachedToNextStackedIndex(
+    const gfx::Point& screen_point) {
   int index = attached_tabstrip_->touch_layout_->active_index();
   if (index + 1 >= attached_tabstrip_->tab_count())
     return;
 
   GetModel(attached_tabstrip_)->MoveSelectedTabsTo(index + 1);
-  StartMoveStackedTimerIfNecessary(kMoveAttachedSubsequentDelay);
+  StartMoveStackedTimerIfNecessary(screen_point, kMoveAttachedSubsequentDelay);
 }
 
-void TabDragController::MoveAttachedToPreviousStackedIndex() {
+void TabDragController::MoveAttachedToPreviousStackedIndex(
+    const gfx::Point& screen_point) {
   int index = attached_tabstrip_->touch_layout_->active_index();
   if (index <= attached_tabstrip_->GetMiniTabCount())
     return;
 
   GetModel(attached_tabstrip_)->MoveSelectedTabsTo(index - 1);
-  StartMoveStackedTimerIfNecessary(kMoveAttachedSubsequentDelay);
+  StartMoveStackedTimerIfNecessary(screen_point, kMoveAttachedSubsequentDelay);
 }
 
 void TabDragController::MoveAttached(const gfx::Point& screen_point) {
   DCHECK(attached_tabstrip_);
   DCHECK(!view_.get());
   DCHECK(!is_dragging_window_);
 
-  int move_delta = screen_point.x() - last_screen_point_.x();
-  if (move_delta > 0)
-    mouse_move_direction_ |= kMovedMouseRight;
-  else if (move_delta < 0)
-    mouse_move_direction_ |= kMovedMouseLeft;
-  last_screen_point_ = screen_point;
-
   gfx::Point dragged_view_point = GetAttachedDragPoint(screen_point);
 
   // Determine the horizontal move threshold. This is dependent on the width
   // of tabs. The smaller the tabs compared to the standard size, the smaller
   // the threshold.
   int threshold = kHorizontalMoveThreshold;
   if (!attached_tabstrip_->touch_layout_.get()) {
     double unselected, selected;
     attached_tabstrip_->GetCurrentTabWidths(&unselected, &selected);
     double ratio = unselected / Tab::GetStandardSize().width();
@@ skipping 37 matching lines @@
       last_move_screen_loc_ = screen_point.x();
     }
   }
 
   if (!did_layout) {
     attached_tabstrip_->LayoutDraggedTabsAt(
         tabs, source_tab_drag_data()->attached_tab, dragged_view_point,
         initial_move_);
   }
 
-  StartMoveStackedTimerIfNecessary(kMoveAttachedInitialDelay);
+  StartMoveStackedTimerIfNecessary(screen_point, kMoveAttachedInitialDelay);
 
   initial_move_ = false;
 }
 
 void TabDragController::MoveDetached(const gfx::Point& screen_point) {
   DCHECK(!attached_tabstrip_);
   DCHECK(view_.get());
   DCHECK(!is_dragging_window_);
 
   // Move the View. There are no changes to the model if we're detached.
   view_->MoveTo(screen_point);
 }
 
-void TabDragController::StartMoveStackedTimerIfNecessary(int delay_ms) {
+void TabDragController::StartMoveStackedTimerIfNecessary(
+    const gfx::Point& screen_point,
+    int delay_ms) {
   DCHECK(attached_tabstrip_);
 
   TouchTabStripLayout* touch_layout = attached_tabstrip_->touch_layout_.get();
   if (!touch_layout)
     return;
 
-  gfx::Point screen_point = GetCursorScreenPoint();
   gfx::Point dragged_view_point = GetAttachedDragPoint(screen_point);
   gfx::Rect bounds = GetDraggedViewTabStripBounds(dragged_view_point);
   int index = touch_layout->active_index();
   if (ShouldDragToNextStackedTab(bounds, index)) {
-    move_stacked_timer_.Start(
+    static_cast<base::Timer*>(&move_stacked_timer_)->Start(
         FROM_HERE,
-        base::TimeDelta::FromMilliseconds(delay_ms), this,
-        &TabDragController::MoveAttachedToNextStackedIndex);
+        base::TimeDelta::FromMilliseconds(delay_ms),
+        base::Bind(&TabDragController::MoveAttachedToNextStackedIndex,
+                   base::Unretained(this), screen_point));
   } else if (ShouldDragToPreviousStackedTab(bounds, index)) {
-    move_stacked_timer_.Start(
+    static_cast<base::Timer*>(&move_stacked_timer_)->Start(
         FROM_HERE,
-        base::TimeDelta::FromMilliseconds(delay_ms), this,
-        &TabDragController::MoveAttachedToPreviousStackedIndex);
+        base::TimeDelta::FromMilliseconds(delay_ms),
+        base::Bind(&TabDragController::MoveAttachedToPreviousStackedIndex,
+                   base::Unretained(this), screen_point));
   }
 }
 
 TabDragController::DetachPosition TabDragController::GetDetachPosition(
     const gfx::Point& screen_point) {
   DCHECK(attached_tabstrip_);
   gfx::Point attached_point(screen_point);
   views::View::ConvertPointToView(NULL, attached_tabstrip_, &attached_point);
   if (attached_point.x() < 0)
     return DETACH_BEFORE;
@@ skipping 316 matching lines @@
   if (move_loop_widget_) {
     move_loop_widget_->RemoveObserver(this);
     move_loop_widget_ = NULL;
   }
   is_dragging_window_ = false;
   waiting_for_run_loop_to_exit_ = false;
   if (end_run_loop_behavior_ == END_RUN_LOOP_CONTINUE_DRAGGING) {
     end_run_loop_behavior_ = END_RUN_LOOP_STOP_DRAGGING;
     if (tab_strip_to_attach_to_after_exit_) {
       Detach();
-      gfx::Point screen_point(GetCursorScreenPoint());
+      // TODO: this needs to query the event.
+      gfx::Point screen_point(gfx::Screen::GetCursorScreenPoint());
       Attach(tab_strip_to_attach_to_after_exit_, screen_point);
       // Move the tabs into position.
       MoveAttached(screen_point);
       attached_tabstrip_->GetWidget()->Activate();
       tab_strip_to_attach_to_after_exit_ = NULL;
     }
     DCHECK(attached_tabstrip_);
     attached_tabstrip_->GetWidget()->SetMouseCapture(attached_tabstrip_);
   } else if (active_) {
     EndDrag(result == views::Widget::MOVE_LOOP_CANCELED);
@@ skipping 371 matching lines @@
           break;
 
         default:
           NOTREACHED();
           break;
       }
     }
     // Compel the model to construct a new window for the detached WebContents.
     views::Widget* widget = source_tabstrip_->GetWidget();
     gfx::Rect window_bounds(widget->GetRestoredBounds());
-    window_bounds.set_origin(GetWindowCreatePoint());
+    window_bounds.set_origin(GetWindowCreatePoint(last_screen_point_));
     // When modifying the following if statement, please make sure not to
     // introduce issue listed in http://crbug.com/6223 comment #11.
     bool rtl_ui = base::i18n::IsRTL();
     bool has_dock_position = (dock_info_.type() != DockInfo::NONE);
     if (rtl_ui && has_dock_position) {
       // Mirror X axis so the docked tab is aligned using the mouse click as
       // the top-right corner.
       window_bounds.set_x(window_bounds.x() - window_bounds.width());
     }
     Browser* new_browser =
@@ skipping 54 matching lines @@
   }
   // DraggedTabView takes ownership of the renderers.
   view_.reset(new DraggedTabView(renderers, renderer_bounds, mouse_offset_,
                                  content_bounds.size(), photobooth));
 #else
   // Aura always hits the |detach_into_browser_| path.
   NOTREACHED();
 #endif
 }
 
-gfx::Point TabDragController::GetCursorScreenPoint() const {
-  // TODO(sky): see if we can convert to using Screen every where.
-#if defined(OS_WIN) && !defined(USE_AURA)
-  DWORD pos = GetMessagePos();
-  return gfx::Point(pos);
-#else
-  return gfx::Screen::GetCursorScreenPoint();
-#endif
-}
-
 gfx::Rect TabDragController::GetViewScreenBounds(
     views::View* view) const {
   gfx::Point view_topleft;
   views::View::ConvertPointToScreen(view, &view_topleft);
   gfx::Rect view_screen_bounds = view->GetLocalBounds();
   view_screen_bounds.Offset(view_topleft.x(), view_topleft.y());
   return view_screen_bounds;
 }
 
 void TabDragController::HideFrame() {
@@ skipping 33 matching lines @@
 
   std::vector<DockDisplayer*>::iterator i =
       std::find(dock_controllers_.begin(), dock_controllers_.end(),
                 controller);
   if (i != dock_controllers_.end())
     dock_controllers_.erase(i);
   else
     NOTREACHED();
 }
 
-void TabDragController::BringWindowUnderMouseToFront() {
+void TabDragController::BringWindowUnderPointToFront(
+    const gfx::Point& screen_point) {
   // If we're going to dock to another window, bring it to the front.
   gfx::NativeWindow window = dock_info_.window();
   if (!window) {
     views::View* dragged_view;
     if (view_.get())
       dragged_view = view_.get();
     else
       dragged_view = attached_tabstrip_;
     gfx::NativeView dragged_native_view =
         dragged_view->GetWidget()->GetNativeView();
     dock_windows_.insert(dragged_native_view);
-    window = DockInfo::GetLocalProcessWindowAtPoint(GetCursorScreenPoint(),
-                                                    dock_windows_);
+    window =
+        DockInfo::GetLocalProcessWindowAtPoint(screen_point, dock_windows_);
     dock_windows_.erase(dragged_native_view);
   }
   if (window) {
     views::Widget* widget_window = views::Widget::GetWidgetForNativeView(
         window);
     if (widget_window)
       widget_window->StackAtTop();
     else
       return;
 
@@ skipping 53 matching lines @@
     }
 
     default:
       break; // Nothing to do for DETACH_ABOVE_OR_BELOW.
   }
 
   SetTrackedByWorkspace(browser->window()->GetNativeHandle(), false);
   browser->window()->SetBounds(new_bounds);
   return browser;
 }