Make Textfield scroll continuously when dragging beyond edges.

ui/views/controls/textfield/textfield.cc

Index: ui/views/controls/textfield/textfield.cc
diff --git a/ui/views/controls/textfield/textfield.cc b/ui/views/controls/textfield/textfield.cc
index 68aa01ec3bd832958bcc74db80c22734a5f3398c..057c7536cd39468dce99b0339dd5556a2d557fcd 100644
--- a/ui/views/controls/textfield/textfield.cc
+++ b/ui/views/controls/textfield/textfield.cc
@@ -312,16 +312,16 @@ base::i18n::TextDirection Textfield::GetTextDirection() const {
   return GetRenderText()->GetTextDirection();
 }
 
+base::string16 Textfield::GetSelectedText() const {
+  return model_->GetSelectedText();
+}
+
 void Textfield::SelectAll(bool reversed) {
   model_->SelectAll(reversed);
   UpdateSelectionClipboard();
   UpdateAfterChange(false, true);
 }
 
-base::string16 Textfield::GetSelectedText() const {
-  return model_->GetSelectedText();
-}
-
 void Textfield::ClearSelection() {
   model_->ClearSelection();
   UpdateAfterChange(false, true);
@@ -552,35 +552,31 @@ bool Textfield::OnMousePressed(const ui::MouseEvent& event) {
 }
 
 bool Textfield::OnMouseDragged(const ui::MouseEvent& event) {
+  last_drag_location_ = event.location();
+
   // Don't adjust the cursor on a potential drag and drop, or if the mouse
   // movement from the last mouse click does not exceed the drag threshold.
   if (initiating_drag_ || !event.IsOnlyLeftMouseButton() ||
-      !ExceededDragThreshold(event.location() - last_click_location_)) {
+      !ExceededDragThreshold(last_drag_location_ - last_click_location_)) {
     return true;
   }
 
-  OnBeforeUserAction();
-  model_->MoveCursorTo(event.location(), true);
-  if (aggregated_clicks_ == 1) {
-    model_->SelectWord();
-    // Expand the selection so the initially selected word remains selected.
-    gfx::Range selection = GetRenderText()->selection();
-    const size_t min = std::min(selection.GetMin(),
-                                double_click_word_.GetMin());
-    const size_t max = std::max(selection.GetMax(),
-                                double_click_word_.GetMax());
-    const bool reversed = selection.is_reversed();
-    selection.set_start(reversed ? max : min);
-    selection.set_end(reversed ? min : max);
-    model_->SelectRange(selection);
+  // A timer is used to continuously scroll while selecting beyond side edges.
+  if (last_drag_location_.x() > 0 && last_drag_location_.x() < size().width()) {
+    drag_selection_timer_.Stop();
+    SelectThroughLastDragLocation();
+  } else if (!drag_selection_timer_.IsRunning()) {
+    drag_selection_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromMilliseconds(100), this,
+        &Textfield::SelectThroughLastDragLocation);
   }
-  UpdateAfterChange(false, true);
-  OnAfterUserAction();
+
   return true;
 }
 
 void Textfield::OnMouseReleased(const ui::MouseEvent& event) {
   OnBeforeUserAction();
+  drag_selection_timer_.Stop();
   // Cancel suspected drag initiations, the user was clicking in the selection.
   if (initiating_drag_)
     MoveCursorTo(event.location(), false);
@@ -1542,6 +1538,26 @@ void Textfield::MoveCursorTo(const gfx::Point& point, bool select) {
     UpdateAfterChange(false, true);
 }
 
+void Textfield::SelectThroughLastDragLocation() {
+  OnBeforeUserAction();
+  model_->MoveCursorTo(last_drag_location_, true);

[Peter Kasting, 2014/05/21 22:44:28]

How does this work with off-Textfield cursor locations?  Does it pretend the
textfield is infinitely wide, and then select to "where the mouse would be"?  If
so, doesn't this mean that the further off the side the user places the mouse
cursor, the more text will be selected on every timer tick?

It seems like, ideally, we'd have a high-framerate (60 Hz) animation that
scrolled-in-and-selected a small amount of new text each frame, regardless of
how far off the side the mouse cursor is.

[msw, 2014/05/21 23:15:10]

Yes, that's how it works currently, and I think it's reasonable. That's how
Blink and Mac/Win/GTK native textfields work, except that for some of those
(like the Win native textfield), the selection is updated on drag events, and
not on a regularly occurring timer.
I agree that we ultimately want a smoother animation, but think we'd want to
increase the rate of scrolling as the user moves the mouse further beyond the
edge (providing the same correlation as Blink and Mac/Win/GTK native textfields
and this behavior I'm adding).

However, the smoother animation would require non-trivial changes to RenderText
and Textfield (we'd need to update the display offset disjoint from the cursor
position), which might open a bigger can of worms. I think the current behavior
is straightforward and a good V1 compromise, and I'll leave the bug open for
animation smoothing.

+  if (aggregated_clicks_ == 1) {
+    model_->SelectWord();
+    // Expand the selection so the initially selected word remains selected.
+    gfx::Range selection = GetRenderText()->selection();
+    const size_t min = std::min(selection.GetMin(),
+                                double_click_word_.GetMin());
+    const size_t max = std::max(selection.GetMax(),
+                                double_click_word_.GetMax());
+    const bool reversed = selection.is_reversed();
+    selection.set_start(reversed ? max : min);
+    selection.set_end(reversed ? min : max);
+    model_->SelectRange(selection);
+  }
+  UpdateAfterChange(false, true);
+  OnAfterUserAction();
+}
+
 void Textfield::OnCaretBoundsChanged() {
   if (GetInputMethod())
     GetInputMethod()->OnCaretBoundsChanged(this);