Handful of tweaks for tab dragging with touch:

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 188 matching lines @@
 
 bool ShouldDetachIntoNewBrowser() {
 #if defined(USE_AURA)
   return true;
 #else
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kTabBrowserDragging);
 #endif
 }
 
+// Returns true if |bounds| contains the y-coordinate |y|. The y-coordinate
+// of |bounds| is adjusted by |vertical_adjustment|.
+bool DoesRectContainVerticalPointExpanded(
+    const gfx::Rect& bounds,
+    int vertical_adjustment,
+    int y) {
+  int upper_threshold = bounds.bottom() + vertical_adjustment;
+  int lower_threshold = bounds.y() - vertical_adjustment;
+  return y >= lower_threshold && y <= upper_threshold;
+}
+
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // DockDisplayer
 
 // DockDisplayer is responsible for giving the user a visual indication of a
 // possible dock position (as represented by DockInfo). DockDisplayer shows
 // a window with a DockView in it. Two animations are used that correspond to
 // the state of DockInfo::in_enable_area.
 class TabDragController::DockDisplayer : public ui::AnimationDelegate {
@@ skipping 101 matching lines @@
       attached_tab(NULL),
       pinned(false) {
 }
 
 TabDragController::TabDragData::~TabDragData() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabDragController, public:
 
+// static
+const int TabDragController::kTouchVerticalDetachMagnetism = 50;
+
+// static
+const int TabDragController::kVerticalDetachMagnetism = 15;
+
 TabDragController::TabDragController()
     : detach_into_browser_(ShouldDetachIntoNewBrowser()),
       source_tabstrip_(NULL),
       attached_tabstrip_(NULL),
       source_tab_offset_(0),
       offset_to_width_ratio_(0),
       old_focused_view_(NULL),
       last_move_screen_loc_(0),
       started_drag_(false),
       active_(true),
@@ skipping 377 matching lines @@
   int x_offset = abs(point_in_screen.x() - start_point_in_screen_.x());
   int y_offset = abs(point_in_screen.y() - start_point_in_screen_.y());
   return sqrt(pow(static_cast<float>(x_offset), 2) +
               pow(static_cast<float>(y_offset), 2)) > kMinimumDragDistance;
 }
 
 void TabDragController::ContinueDragging(const gfx::Point& point_in_screen) {
   DCHECK(!detach_into_browser_ || attached_tabstrip_);
 
   TabStrip* target_tabstrip = detach_behavior_ == DETACHABLE ?
-      GetTabStripForPoint(point_in_screen) : source_tabstrip_;
+      GetTargetTabStripForPoint(point_in_screen) : source_tabstrip_;
   bool tab_strip_changed = (target_tabstrip != attached_tabstrip_);
 
   if (attached_tabstrip_) {
     int move_delta = point_in_screen.x() - last_point_in_screen_.x();
     if (move_delta > 0)
       mouse_move_direction_ |= kMovedMouseRight;
     else if (move_delta < 0)
       mouse_move_direction_ |= kMovedMouseLeft;
   }
   last_point_in_screen_ = point_in_screen;
@@ skipping 15 matching lines @@
         base::TimeDelta::FromMilliseconds(kBringToFrontDelay),
         base::Bind(&TabDragController::BringWindowUnderPointToFront,
                    base::Unretained(this), point_in_screen));
   }
 
   UpdateDockInfo(point_in_screen);
 
   if (!is_dragging_window_) {
     if (attached_tabstrip_) {
       if (move_only()) {
-        DragActiveTabStacked(point_in_screen);
+        if (attached_tabstrip_->touch_layout_.get())
+          DragActiveTabStacked(point_in_screen);
       } else {
         MoveAttached(point_in_screen);
         if (tab_strip_changed) {
           // Move the corresponding window to the front. We do this after the
           // move as on windows activate triggers a synchronous paint.
           attached_tabstrip_->GetWidget()->Activate();
         }
       }
     } else {
       MoveDetached(point_in_screen);
@@ skipping 18 matching lines @@
     move_loop_widget_ = NULL;
 #endif
     views::Widget* browser_widget = GetAttachedBrowserWidget();
     // Need to release the drag controller before starting the move loop as it's
     // going to trigger capture lost, which cancels drag.
     attached_tabstrip_->ReleaseDragController();
     target_tabstrip->OwnDragController(this);
     // Disable animations so that we don't see a close animation on aero.
     browser_widget->SetVisibilityChangedAnimationsEnabled(false);
     // For aura we can't release capture, otherwise it'll cancel a gesture.
-    // Insteat we have to directly change capture.
+    // Instead we have to directly change capture.
 #if !defined(USE_ASH)
     browser_widget->ReleaseCapture();
 #else
     attached_tabstrip_->ReleaseDragController();
     target_tabstrip->GetWidget()->SetCapture(attached_tabstrip_);
 #endif
     // EndMoveLoop is going to snap the window back to its original location.
     // Hide it so users don't see this.
     browser_widget->Hide();
     browser_widget->EndMoveLoop();
@@ skipping 184 matching lines @@
     return dock_info_;
   }
 
   gfx::NativeView dragged_view = view_->GetWidget()->GetNativeView();
   dock_windows_.insert(dragged_view);
   DockInfo info = DockInfo::GetDockInfoAtPoint(point_in_screen, dock_windows_);
   dock_windows_.erase(dragged_view);
   return info;
 }
 
-TabStrip* TabDragController::GetTabStripForPoint(
+TabStrip* TabDragController::GetTargetTabStripForPoint(
     const gfx::Point& point_in_screen) {
+  if (move_only() && attached_tabstrip_) {
+    DCHECK_EQ(DETACHABLE, detach_behavior_);
+    // move_only() is intended for touch, in which case we only want to detach
+    // if the touch point moves significantly in the vertical distance.
+    gfx::Rect tabstrip_bounds = GetViewScreenBounds(attached_tabstrip_);
+    if (DoesRectContainVerticalPointExpanded(tabstrip_bounds,
+                                             kTouchVerticalDetachMagnetism,
+                                             point_in_screen.y()))
+      return attached_tabstrip_;
+  }
   gfx::NativeView dragged_view = NULL;
   if (view_.get())
     dragged_view = view_->GetWidget()->GetNativeView();
   else if (is_dragging_window_)
     dragged_view = attached_tabstrip_->GetWidget()->GetNativeView();
   if (dragged_view)
     dock_windows_.insert(dragged_view);
   gfx::NativeWindow local_window =
       DockInfo::GetLocalProcessWindowAtPoint(point_in_screen, dock_windows_);
   if (dragged_view)
@@ skipping 20 matching lines @@
       attached_tabstrip_ ? attached_tabstrip_ : source_tabstrip_;
   DCHECK(tab_strip);
 
   return other_tabstrip->controller()->IsCompatibleWith(tab_strip) ?
       other_tabstrip : NULL;
 }
 
 bool TabDragController::DoesTabStripContain(
     TabStrip* tabstrip,
     const gfx::Point& point_in_screen) const {
-  static const int kVerticalDetachMagnetism = 15;
   // Make sure the specified screen point is actually within the bounds of the
   // specified tabstrip...
   gfx::Rect tabstrip_bounds = GetViewScreenBounds(tabstrip);
-  if (point_in_screen.x() < tabstrip_bounds.right() &&
-      point_in_screen.x() >= tabstrip_bounds.x()) {
-    // TODO(beng): make this be relative to the start position of the mouse
-    // for the source TabStrip.
-    int upper_threshold = tabstrip_bounds.bottom() + kVerticalDetachMagnetism;
-    int lower_threshold = tabstrip_bounds.y() - kVerticalDetachMagnetism;
-    return point_in_screen.y() >= lower_threshold &&
-        point_in_screen.y() <= upper_threshold;
-  }
-  return false;
+  return point_in_screen.x() < tabstrip_bounds.right() &&
+      point_in_screen.x() >= tabstrip_bounds.x() &&
+      DoesRectContainVerticalPointExpanded(tabstrip_bounds,
+                                           kVerticalDetachMagnetism,
+                                           point_in_screen.y());
 }
 
 void TabDragController::Attach(TabStrip* attached_tabstrip,
                                const gfx::Point& point_in_screen) {
   DCHECK(!attached_tabstrip_);  // We should already have detached by the time
                                 // we get here.
 
   attached_tabstrip_ = attached_tabstrip;
 
   // And we don't need the dragged view.
@@ skipping 81 matching lines @@
   // Redirect all mouse events to the TabStrip so that the tab that originated
   // the drag can safely be deleted.
   if (detach_into_browser_ || attached_tabstrip_ == source_tabstrip_) {
     static_cast<views::internal::RootView*>(
         attached_tabstrip_->GetWidget()->GetRootView())->SetMouseHandler(
             attached_tabstrip_);
   }
 }
 
 void TabDragController::Detach(ReleaseCapture release_capture) {
+  // When the user detaches we assume they want to reorder.
+  move_behavior_ = REORDER;
+
   // Release ownership of the drag controller and mouse capture. When we
   // reattach ownership is transfered.
   if (detach_into_browser_) {
     attached_tabstrip_->ReleaseDragController();
     if (release_capture == RELEASE_CAPTURE)
       attached_tabstrip_->GetWidget()->ReleaseCapture();
   }
 
   mouse_move_direction_ = kMovedMouseLeft | kMovedMouseRight;
 
@@ skipping 92 matching lines @@
   attached_tabstrip_->SetTabBoundsForDrag(drag_bounds);
 
   browser->window()->Show();
   browser->window()->Activate();
   dragged_browser_view->GetWidget()->SetVisibilityChangedAnimationsEnabled(
       true);
   RunMoveLoop();
 }
 
 void TabDragController::RunMoveLoop() {
+  // If the user drags the whole window we'll assume they are going to attach to
+  // another window and therefor want to reorder.
+  move_behavior_ = REORDER;
+
   move_loop_widget_ = GetAttachedBrowserWidget();
   DCHECK(move_loop_widget_);
   move_loop_widget_->AddObserver(this);
   is_dragging_window_ = true;
   bool destroyed = false;
   destroyed_ = &destroyed;
-  // Running the move loop releases mouse capture on windows, which triggers
+#if !defined(USE_ASH)
+  // Running the move loop releases mouse capture on Windows, which triggers
   // destroying the drag loop. Release mouse capture ourself before this while
   // the DragController isn't owned by the TabStrip.
   attached_tabstrip_->ReleaseDragController();
   attached_tabstrip_->GetWidget()->ReleaseCapture();
   attached_tabstrip_->OwnDragController(this);
+#endif
   views::Widget::MoveLoopResult result = move_loop_widget_->RunMoveLoop();
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::NotificationService::NoDetails());
 
   if (destroyed)
     return;
   destroyed_ = NULL;
   // Under chromeos we immediately set the |move_loop_widget_| to NULL.
@@ skipping 628 matching lines @@
     gfx::Point touch_point;
     bool got_touch_point = widget_window->GetRootWindow()->
         gesture_recognizer()->GetLastTouchPointForTarget(widget_window,
                                                          &touch_point);
     DCHECK(got_touch_point);
     return touch_point;
   }
 #endif
   return gfx::Screen::GetCursorScreenPoint();
 }