Change how the insertion point for tab drags is calculated.

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 "ash/accelerators/accelerator_commands.h"
@@ skipping 1228 matching lines @@
     }
     DCHECK(attached_tabstrip_);
     attached_tabstrip_->GetWidget()->SetCapture(attached_tabstrip_);
   } else if (active_) {
     EndDrag(result == views::Widget::MOVE_LOOP_CANCELED ?
             END_DRAG_CANCEL : END_DRAG_COMPLETE);
   }
 }
 
 int TabDragController::GetInsertionIndexFrom(const gfx::Rect& dragged_bounds,
-                                             int start,
-                                             int delta) const {
-  for (int i = start, tab_count = attached_tabstrip_->tab_count();
-       i >= 0 && i < tab_count; i += delta) {
+                                             int start) const {
+  const int last_tab = attached_tabstrip_->tab_count() - 1;
+  // Make the actual "drag insertion point" be just after the leading edge of
+  // the first dragged tab.  This is closer to where the user thinks of the tab
+  // as "starting" than just dragged_bounds.x(), especially with narrow tabs.
+  const int dragged_x = dragged_bounds.x() + Tab::leading_width_for_drag();
+  if (start < 0 || start > last_tab ||
+      dragged_x < attached_tabstrip_->ideal_bounds(start).x())
+    return -1;
+
+  for (int i = start; i <= last_tab; ++i) {
     const gfx::Rect& ideal_bounds = attached_tabstrip_->ideal_bounds(i);
-    gfx::Rect left_half, right_half;
-    ideal_bounds.SplitVertically(&left_half, &right_half);
-    if (dragged_bounds.x() >= right_half.x() &&
-        dragged_bounds.x() < right_half.right()) {
+    if (dragged_x < (ideal_bounds.x() + (ideal_bounds.width() / 2)))
+      return i;
+  }
+
+  return (dragged_x < attached_tabstrip_->ideal_bounds(last_tab).right()) ?
+      (last_tab + 1) : -1;
+}
+
+int TabDragController::GetInsertionIndexFromReversed(
+    const gfx::Rect& dragged_bounds,
+    int start) const {
+  // Make the actual "drag insertion point" be just after the leading edge of
+  // the first dragged tab.  This is closer to where the user thinks of the tab
+  // as "starting" than just dragged_bounds.x(), especially with narrow tabs.
+  const int dragged_x = dragged_bounds.x() + Tab::leading_width_for_drag();
+  if (start < 0 || start >= attached_tabstrip_->tab_count() ||
+      dragged_x >= attached_tabstrip_->ideal_bounds(start).right())
+    return -1;
+
+  for (int i = start; i >= 0; --i) {
+    const gfx::Rect& ideal_bounds = attached_tabstrip_->ideal_bounds(i);
+    if (dragged_x >= (ideal_bounds.x() + (ideal_bounds.width() / 2)))
       return i + 1;
-    } else if (dragged_bounds.x() >= left_half.x() &&
-               dragged_bounds.x() < left_half.right()) {
-      return i;
-    }
   }
-  return -1;
+
+  return (dragged_x >= attached_tabstrip_->ideal_bounds(0).x()) ? 0 : -1;
 }
 
 int TabDragController::GetInsertionIndexForDraggedBounds(
     const gfx::Rect& dragged_bounds) const {
   int index = -1;
   if (attached_tabstrip_->touch_layout_.get()) {
     index = GetInsertionIndexForDraggedBoundsStacked(dragged_bounds);
     if (index != -1) {
       // Only move the tab to the left/right if the user actually moved the
       // mouse that way. This is necessary as tabs with stacked tabs
       // before/after them have multiple drag positions.
       int active_index = attached_tabstrip_->touch_layout_->active_index();
       if ((index < active_index &&
            (mouse_move_direction_ & kMovedMouseLeft) == 0) ||
           (index > active_index &&
            (mouse_move_direction_ & kMovedMouseRight) == 0)) {
         index = active_index;
       }
     }
   } else {
-    index = GetInsertionIndexFrom(dragged_bounds, 0, 1);
+    index = GetInsertionIndexFrom(dragged_bounds, 0);
   }
   if (index == -1) {
     int tab_count = attached_tabstrip_->tab_count();
     int right_tab_x = tab_count == 0 ? 0 :
         attached_tabstrip_->ideal_bounds(tab_count - 1).right();
     if (dragged_bounds.right() > right_tab_x) {
       index = GetModel(attached_tabstrip_)->count();
     } else {
       index = 0;
     }
@@ skipping 15 matching lines @@
     int index) const {
   if (index + 1 >= attached_tabstrip_->tab_count() ||
       !attached_tabstrip_->touch_layout_->IsStacked(index + 1) ||
       (mouse_move_direction_ & kMovedMouseRight) == 0)
     return false;
 
   int active_x = attached_tabstrip_->ideal_bounds(index).x();
   int next_x = attached_tabstrip_->ideal_bounds(index + 1).x();
   int mid_x = std::min(next_x - kStackedDistance,
                        active_x + (next_x - active_x) / 4);
+  // TODO(pkasting): Should this add Tab::leading_width_for_drag() as
+  // GetInsertionIndexFrom() does?
   return dragged_bounds.x() >= mid_x;
 }
 
 bool TabDragController::ShouldDragToPreviousStackedTab(
     const gfx::Rect& dragged_bounds,
     int index) const {
   if (index - 1 < attached_tabstrip_->GetMiniTabCount() ||
       !attached_tabstrip_->touch_layout_->IsStacked(index - 1) ||
       (mouse_move_direction_ & kMovedMouseLeft) == 0)
     return false;
 
   int active_x = attached_tabstrip_->ideal_bounds(index).x();
   int previous_x = attached_tabstrip_->ideal_bounds(index - 1).x();
   int mid_x = std::max(previous_x + kStackedDistance,
                        active_x - (active_x - previous_x) / 4);
+  // TODO(pkasting): Should this add Tab::leading_width_for_drag() as
+  // GetInsertionIndexFrom() does?
   return dragged_bounds.x() <= mid_x;
 }
 
 int TabDragController::GetInsertionIndexForDraggedBoundsStacked(
     const gfx::Rect& dragged_bounds) const {
   StackedTabStripLayout* touch_layout = attached_tabstrip_->touch_layout_.get();
   int active_index = touch_layout->active_index();
   // Search from the active index to the front of the tabstrip. Do this as tabs
   // overlap each other from the active index.
-  int index = GetInsertionIndexFrom(dragged_bounds, active_index, -1);
+  int index = GetInsertionIndexFromReversed(dragged_bounds, active_index);
   if (index != active_index)
     return index;
   if (index == -1)
-    return GetInsertionIndexFrom(dragged_bounds, active_index + 1, 1);
+    return GetInsertionIndexFrom(dragged_bounds, active_index + 1);
 
   // The position to drag to corresponds to the active tab. If the next/previous
   // tab is stacked, then shorten the distance used to determine insertion
   // bounds. We do this as GetInsertionIndexFrom() uses the bounds of the
   // tabs. When tabs are stacked the next/previous tab is on top of the tab.
   if (active_index + 1 < attached_tabstrip_->tab_count() &&
       touch_layout->IsStacked(active_index + 1)) {
-    index = GetInsertionIndexFrom(dragged_bounds, active_index + 1, 1);
+    index = GetInsertionIndexFrom(dragged_bounds, active_index + 1);
     if (index == -1 && ShouldDragToNextStackedTab(dragged_bounds, active_index))
       index = active_index + 1;
     else if (index == -1)
       index = active_index;
   } else if (ShouldDragToPreviousStackedTab(dragged_bounds, active_index)) {
     index = active_index - 1;
   }
   return index;
 }
 
@@ skipping 553 matching lines @@
        it != browser_list->end(); ++it) {
     if ((*it)->tab_strip_model()->empty())
       exclude.insert((*it)->window()->GetNativeWindow());
   }
 #endif
   return GetLocalProcessWindowAtPoint(host_desktop_type_,
                                       screen_point,
                                       exclude);
 
 }