Support longpress drag selection

ui/touch_selection/touch_selection_controller_unittest.cc

 // Copyright 2014 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 "ui/touch_selection/touch_selection_controller.h"
 
 #include <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/test/motion_event_test_utils.h"
 
+using base::TimeTicks;
 using testing::ElementsAre;
 using testing::IsEmpty;
 using ui::test::MockMotionEvent;
 
 namespace ui {
 namespace {
 
 const int kDefaultTapTimeoutMs = 200;
 const float kDefaulTapSlop = 10.f;
 
@@ skipping 118 matching lines @@
     start_bound.set_type(SelectionBound::LEFT);
     end_bound.set_type(SelectionBound::RIGHT);
     start_bound.SetEdge(start_rect.origin(), start_rect.bottom_left());
     end_bound.SetEdge(end_rect.origin(), end_rect.bottom_left());
     start_bound.set_visible(start_visible);
     end_bound.set_visible(end_visible);
     controller_->OnSelectionBoundsChanged(start_bound, end_bound);
   }
 
   void Animate() {
-    base::TimeTicks now = base::TimeTicks::Now();
+    TimeTicks now = TimeTicks::Now();
     while (needs_animate_) {
       needs_animate_ = controller_->Animate(now);
       now += base::TimeDelta::FromMilliseconds(16);
     }
   }
 
   bool GetAndResetNeedsAnimate() {
     bool needs_animate = needs_animate_;
     Animate();
     return needs_animate;
@@ skipping 116 matching lines @@
   ChangeInsertion(insertion_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN));
   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
 
   // Reset the selection.
   controller().HideAndDisallowShowingAutomatically();
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED));
 
   // Long-pressing should show the handle even if the editable region is empty.
   insertion_rect.Offset(2, -2);
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), insertion_rect.bottom_left());
   controller().OnSelectionEmpty(true);
   ChangeInsertion(insertion_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN));
   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
 
   // Single Tap on an empty edit field should clear insertion handle.
   controller().OnTapEvent();
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED));
 }
 
@@ skipping 37 matching lines @@
 
   // If the user taps the *same* position as the cursor at the end of the text
   // entry, the handle should appear.
   controller().OnTapEvent();
   ChangeInsertion(insertion_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN));
   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
 }
 
 TEST_F(TouchSelectionControllerTest, InsertionToSelectionTransition) {
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), gfx::PointF());
   controller().OnSelectionEditable(true);
 
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   bool visible = true;
 
   ChangeInsertion(start_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN));
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
 
@@ skipping 162 matching lines @@
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_TAPPED,
                                                INSERTION_DRAG_STOPPED));
   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
 
   anchor_rect.Offset(5, 15);
   ChangeInsertion(anchor_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_MOVED));
   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
 
   // Pressing shouldn't reset the active insertion point.
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), gfx::PointF());
   controller().OnSelectionEmpty(true);
   event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STARTED));
   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
 
   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_TAPPED,
                                                INSERTION_DRAG_STOPPED));
   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
 }
 
 TEST_F(TouchSelectionControllerTest, SelectionBasic) {
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   bool visible = true;
 
   // Selection events are ignored until automatic showing is enabled.
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_EQ(gfx::PointF(), GetLastEventStart());
 
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), start_rect.bottom_left());
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
 
   start_rect.Offset(1, 0);
   ChangeSelection(start_rect, visible, end_rect, visible);
   // Selection movement does not currently trigger a separate event.
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED));
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
   EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd());
 
   ClearSelection();
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED));
   EXPECT_EQ(gfx::PointF(), GetLastEventStart());
 }
 
 TEST_F(TouchSelectionControllerTest, SelectionRepeatedLongPress) {
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   bool visible = true;
 
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), start_rect.bottom_left());
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
   EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd());
 
   // A long press triggering a new selection should re-send the SELECTION_SHOWN
   // event notification.
   start_rect.Offset(10, 10);
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), start_rect.bottom_left());
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
   EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd());
 }
 
 TEST_F(TouchSelectionControllerTest, SelectionDragged) {
   base::TimeTicks event_time = base::TimeTicks::Now();
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(event_time, gfx::PointF());
 
   // The touch sequence should not be handled if selection is not active.
   MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
   EXPECT_FALSE(controller().WillHandleTouchEvent(event));
 
   float line_height = 10.f;
   gfx::RectF start_rect(0, 0, 0, line_height);
   gfx::RectF end_rect(50, 0, 0, line_height);
   bool visible = true;
   ChangeSelection(start_rect, visible, end_rect, visible);
@@ skipping 37 matching lines @@
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED));
   EXPECT_FALSE(GetAndResetSelectionMoved());
 
   // Once the drag is complete, no more touch events should be consumed until
   // the next ACTION_DOWN.
   EXPECT_FALSE(controller().WillHandleTouchEvent(event));
 }
 
 TEST_F(TouchSelectionControllerTest, SelectionDraggedWithOverlap) {
   base::TimeTicks event_time = base::TimeTicks::Now();
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(event_time, gfx::PointF());
 
   float line_height = 10.f;
   gfx::RectF start_rect(0, 0, 0, line_height);
   gfx::RectF end_rect(50, 0, 0, line_height);
   bool visible = true;
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
 
   // The ACTION_DOWN should lock to the closest handle.
@@ skipping 17 matching lines @@
             GetLastSelectionEnd());
 
   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED));
   EXPECT_FALSE(GetAndResetSelectionMoved());
 }
 
 TEST_F(TouchSelectionControllerTest, SelectionDraggedToSwitchBaseAndExtent) {
   base::TimeTicks event_time = base::TimeTicks::Now();
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(event_time, gfx::PointF());
 
   float line_height = 10.f;
   gfx::RectF start_rect(50, line_height, 0, line_height);
   gfx::RectF end_rect(100, line_height, 0, line_height);
   bool visible = true;
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
 
   SetDraggingEnabled(true);
@@ skipping 98 matching lines @@
   EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd());
 
   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED));
   EXPECT_FALSE(GetAndResetSelectionMoved());
 }
 
 TEST_F(TouchSelectionControllerTest, SelectionDragExtremeLineSize) {
   base::TimeTicks event_time = base::TimeTicks::Now();
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(event_time, gfx::PointF());
 
   float small_line_height = 1.f;
   float large_line_height = 50.f;
   gfx::RectF small_line_rect(0, 0, 0, small_line_height);
   gfx::RectF large_line_rect(50, 50, 0, large_line_height);
   bool visible = true;
   ChangeSelection(small_line_rect, visible, large_line_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
   EXPECT_EQ(small_line_rect.bottom_left(), GetLastEventStart());
 
@@ skipping 51 matching lines @@
 
 TEST_F(TouchSelectionControllerTest, TemporarilyHidden) {
   controller().OnTapEvent();
   controller().OnSelectionEditable(true);
 
   gfx::RectF insertion_rect(5, 5, 0, 10);
 
   bool visible = true;
   ChangeInsertion(insertion_rect, visible);
   EXPECT_FALSE(GetAndResetNeedsAnimate());
+  EXPECT_TRUE(controller().GetStartVisibleForTesting());
+  EXPECT_TRUE(controller().GetEndVisibleForTesting());
 
   controller().SetTemporarilyHidden(true);
   EXPECT_TRUE(GetAndResetNeedsAnimate());
+  EXPECT_FALSE(controller().GetStartVisibleForTesting());
+  EXPECT_FALSE(controller().GetEndVisibleForTesting());
 
   visible = false;
   ChangeInsertion(insertion_rect, visible);
   EXPECT_FALSE(GetAndResetNeedsAnimate());
+  EXPECT_FALSE(controller().GetStartVisibleForTesting());
 
   visible = true;
   ChangeInsertion(insertion_rect, visible);
   EXPECT_FALSE(GetAndResetNeedsAnimate());
+  EXPECT_FALSE(controller().GetStartVisibleForTesting());
 
   controller().SetTemporarilyHidden(false);
   EXPECT_TRUE(GetAndResetNeedsAnimate());
+  EXPECT_TRUE(controller().GetStartVisibleForTesting());
 }
 
 TEST_F(TouchSelectionControllerTest, SelectionClearOnTap) {
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   bool visible = true;
 
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), start_rect.bottom_left());
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
 
   // Selection should not be cleared if the selection bounds have not changed.
   controller().OnTapEvent();
   EXPECT_THAT(GetAndResetEvents(), IsEmpty());
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
 
   controller().OnTapEvent();
   ClearSelection();
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED));
   EXPECT_EQ(gfx::PointF(), GetLastEventStart());
 }
 
 TEST_F(TouchSelectionControllerTest, NoSelectionAfterLongpressThenTap) {
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   bool visible = true;
 
   // Tap-triggered selections should not be allowed.
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), start_rect.bottom_left());
   controller().OnTapEvent();
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), IsEmpty());
 
   // Subsequent longpress selections will be allowed.
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), start_rect.bottom_left());
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
 
   // Tapping again shouldn't have any effect on subsequent selection events.
   controller().OnTapEvent();
   end_rect.Offset(10, 10);
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED));
   ClearSelection();
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED));
 }
 
 TEST_F(TouchSelectionControllerTest, AllowShowingFromCurrentSelection) {
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   bool visible = true;
 
   // The selection should not be activated, as it wasn't yet allowed.
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_EQ(gfx::PointF(), GetLastEventStart());
 
   // A longpress should have no immediate effect.
-  controller().OnLongPressEvent();
+  controller().OnLongPressEvent(TimeTicks::Now(), start_rect.bottom_left());
 
   // Now explicitly allow showing from the previously supplied bounds.
   controller().AllowShowingFromCurrentSelection();
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
 
   // Repeated calls to show from the current selection should be ignored.
   controller().AllowShowingFromCurrentSelection();
   EXPECT_THAT(GetAndResetEvents(), IsEmpty());
   EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
 
   // Trying to show from an empty selection will have no result.
   ClearSelection();
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED));
   controller().AllowShowingFromCurrentSelection();
   EXPECT_THAT(GetAndResetEvents(), IsEmpty());
 
   // Showing the insertion handle should also be supported.
   controller().OnSelectionEditable(true);
   controller().OnSelectionEmpty(false);
   controller().HideAndDisallowShowingAutomatically();
   gfx::RectF insertion_rect(5, 5, 0, 10);
   ChangeInsertion(insertion_rect, visible);
   controller().AllowShowingFromCurrentSelection();
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN));
   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
 }
 
+TEST_F(TouchSelectionControllerTest, LongPressDrag) {

[mfomitchev, 2015/05/13 20:52:25]

Can we also add a test that the handles reappear if the user lifts the finger
after a long press without any drag motion?

[jdduke (slow), 2015/05/14 18:29:27]

Done.

+  gfx::RectF start_rect(-50, 0, 0, 10);
+  gfx::RectF end_rect(50, 0, 0, 10);
+  bool visible = true;
+
+  // Start a touch sequence.
+  MockMotionEvent event;
+  EXPECT_FALSE(controller().WillHandleTouchEvent(event.PressPoint(0, 0)));
+
+  // Activate a longpress-triggered selection.
+  controller().OnLongPressEvent(event.GetEventTime(), gfx::PointF());
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
+
+  // The handles should remain invisible while the touch release and longpress
+  // drag gesture are pending.
+  EXPECT_FALSE(controller().GetStartVisibleForTesting());
+  EXPECT_FALSE(controller().GetEndVisibleForTesting());
+
+  // The selection coordinates should reflect the drag movement.
+  gfx::PointF fixed_offset = start_rect.CenterPoint();
+  gfx::PointF end_offset = end_rect.CenterPoint();
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event.MovePoint(0, 0, 0)));
+  EXPECT_THAT(GetAndResetEvents(), IsEmpty());
+
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event.MovePoint(0, 0, 10)));

[mfomitchev, 2015/05/13 20:52:25]

Can we use kDefaulTapSlop instead of ints here?

[jdduke (slow), 2015/05/14 18:29:27]

Done.

+  EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED));
+  EXPECT_EQ(fixed_offset, GetLastSelectionStart());
+  EXPECT_EQ(end_offset, GetLastSelectionEnd());
+
+  // Movement after the start of drag will be relative to the moved endpoint.
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event.MovePoint(0, 0, 20)));
+  EXPECT_TRUE(GetAndResetSelectionMoved());
+  EXPECT_EQ(end_offset + gfx::Vector2dF(0, 10), GetLastSelectionEnd());
+
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event.MovePoint(0, 10, 20)));
+  EXPECT_TRUE(GetAndResetSelectionMoved());
+  EXPECT_EQ(end_offset + gfx::Vector2dF(10, 10), GetLastSelectionEnd());
+
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event.MovePoint(0, 20, 20)));
+  EXPECT_TRUE(GetAndResetSelectionMoved());
+  EXPECT_EQ(end_offset + gfx::Vector2dF(20, 10), GetLastSelectionEnd());
+
+  // The handles should still be hidden.
+  EXPECT_FALSE(controller().GetStartVisibleForTesting());
+  EXPECT_FALSE(controller().GetEndVisibleForTesting());
+
+  // Releasing the touch sequence should end the drag and show the handles.
+  EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint()));
+  EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED));
+  EXPECT_TRUE(controller().GetStartVisibleForTesting());
+  EXPECT_TRUE(controller().GetEndVisibleForTesting());
+}
+
 }  // namespace ui