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"
@@ skipping 25 matching lines @@
   }
 
  private:
   bool* intersects_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTouchHandleDrawable);
 };
 
 }  // namespace
 
+class TouchSelectionControllerTestApi {
+ public:
+  explicit TouchSelectionControllerTestApi(TouchSelectionController* controller)
+      : controller_(controller) {}
+  ~TouchSelectionControllerTestApi() {}
+
+  bool GetStartVisible() const { return controller_->GetStartVisible(); }
+  bool GetEndVisible() const { return controller_->GetEndVisible(); }
+
+ private:
+  TouchSelectionController* controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(TouchSelectionControllerTestApi);
+};
+
 class TouchSelectionControllerTest : public testing::Test,
                                      public TouchSelectionControllerClient {
  public:
   TouchSelectionControllerTest()
       : caret_moved_(false),
         selection_moved_(false),
         selection_points_swapped_(false),
         needs_animate_(false),
         animation_enabled_(true),
         dragging_enabled_(false) {}
 
   ~TouchSelectionControllerTest() override {}
 
   // testing::Test implementation.
 
   void SetUp() override {
-    // Default touch selection controller is created with
-    // |show_on_tap_for_empty_editable| flag set to false. Use
-    // |AllowShowingOnTapForEmptyEditable()| function to override it.
-    bool show_on_tap_for_empty_editable = false;
-    controller_.reset(new TouchSelectionController(
-        this,
-        base::TimeDelta::FromMilliseconds(kDefaultTapTimeoutMs),
-        kDefaulTapSlop,
-        show_on_tap_for_empty_editable));
+    controller_.reset(new TouchSelectionController(this, DefaultConfig()));
   }
 
   void TearDown() override { controller_.reset(); }
 
   // TouchSelectionControllerClient implementation.
 
   bool SupportsAnimation() const override { return animation_enabled_; }
 
   void SetNeedsAnimate() override { needs_animate_ = true; }
 
@@ skipping 21 matching lines @@
     last_event_start_ = controller_->GetStartPosition();
     last_event_end_ = controller_->GetEndPosition();
     last_event_bounds_rect_ = controller_->GetRectBetweenBounds();
   }
 
   scoped_ptr<TouchHandleDrawable> CreateDrawable() override {
     return make_scoped_ptr(new MockTouchHandleDrawable(&dragging_enabled_));
   }
 
   void AllowShowingOnTapForEmptyEditable() {
-    bool show_on_tap_for_empty_editable = true;
-    controller_.reset(new TouchSelectionController(
-        this,
-        base::TimeDelta::FromMilliseconds(kDefaultTapTimeoutMs),
-        kDefaulTapSlop,
-        show_on_tap_for_empty_editable));
+    TouchSelectionController::Config config = DefaultConfig();
+    config.show_on_tap_for_empty_editable = true;
+    controller_.reset(new TouchSelectionController(this, config));
+  }
+
+  void EnableLongPressDragSelection() {
+    TouchSelectionController::Config config = DefaultConfig();
+    config.enable_longpress_drag_selection = true;
+    controller_.reset(new TouchSelectionController(this, config));
   }
 
   void SetAnimationEnabled(bool enabled) { animation_enabled_ = enabled; }
   void SetDraggingEnabled(bool enabled) { dragging_enabled_ = enabled; }
 
   void ClearSelection() {
     controller_->OnSelectionBoundsChanged(SelectionBound(),
                                           SelectionBound());
   }
 
@@ skipping 15 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 OnLongPressEvent() {
-    ASSERT_FALSE(controller().WillHandleLongPressEvent(kIgnoredPoint));
+    ASSERT_FALSE(controller().WillHandleLongPressEvent(base::TimeTicks(),
+                                                       kIgnoredPoint));
   }
 
   void OnTapEvent() {
     ASSERT_FALSE(controller().WillHandleTapEvent(kIgnoredPoint));
   }
 
   void Animate() {
     base::TimeTicks now = base::TimeTicks::Now();
     while (needs_animate_) {
       needs_animate_ = controller_->Animate(now);
@@ skipping 36 matching lines @@
 
   std::vector<SelectionEventType> GetAndResetEvents() {
     std::vector<SelectionEventType> events;
     events.swap(events_);
     return events;
   }
 
   TouchSelectionController& controller() { return *controller_; }
 
  private:
+  TouchSelectionController::Config DefaultConfig() {
+    // Both |show_on_tap_for_empty_editable| and
+    // |enable_longpress_drag_selection| are set to false by default, and should
+    // be overriden for explicit testing.
+    TouchSelectionController::Config config;
+    config.tap_timeout =
+        base::TimeDelta::FromMilliseconds(kDefaultTapTimeoutMs);
+    config.tap_slop = kDefaulTapSlop;
+    config.show_on_tap_for_empty_editable = false;
+    config.enable_longpress_drag_selection = false;
+    return config;
+  }
+
   gfx::PointF last_event_start_;
   gfx::PointF last_event_end_;
   gfx::PointF caret_position_;
   gfx::PointF selection_start_;
   gfx::PointF selection_end_;
   gfx::RectF last_event_bounds_rect_;
   std::vector<SelectionEventType> events_;
   bool caret_moved_;
   bool selection_moved_;
   bool selection_points_swapped_;
@@ skipping 676 matching lines @@
 
   // If the client doesn't support animation, no animation should be triggered.
   SetAnimationEnabled(false);
   OnTapEvent();
   visible = true;
   ChangeInsertion(insertion_rect, visible);
   EXPECT_FALSE(GetAndResetNeedsAnimate());
 }
 
 TEST_F(TouchSelectionControllerTest, TemporarilyHidden) {
+  TouchSelectionControllerTestApi test_controller(&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(test_controller.GetStartVisible());
+  EXPECT_TRUE(test_controller.GetEndVisible());
 
   controller().SetTemporarilyHidden(true);
   EXPECT_TRUE(GetAndResetNeedsAnimate());
+  EXPECT_FALSE(test_controller.GetStartVisible());
+  EXPECT_FALSE(test_controller.GetEndVisible());
 
   visible = false;
   ChangeInsertion(insertion_rect, visible);
   EXPECT_FALSE(GetAndResetNeedsAnimate());
+  EXPECT_FALSE(test_controller.GetStartVisible());
 
   visible = true;
   ChangeInsertion(insertion_rect, visible);
   EXPECT_FALSE(GetAndResetNeedsAnimate());
+  EXPECT_FALSE(test_controller.GetStartVisible());
 
   controller().SetTemporarilyHidden(false);
   EXPECT_TRUE(GetAndResetNeedsAnimate());
+  EXPECT_TRUE(test_controller.GetStartVisible());
 }
 
 TEST_F(TouchSelectionControllerTest, SelectionClearOnTap) {
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   bool visible = true;
 
   OnLongPressEvent();
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
@@ skipping 98 matching lines @@
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   gfx::PointF inner_point(25, 10);
   gfx::PointF outer_point(100, 100);
 
   // Establish a selection without handles from 5 to 50 with height 10.
   ChangeSelection(start_rect, visible, end_rect, visible);
   EXPECT_THAT(GetAndResetEvents(), IsEmpty());
 
   // A point outside the rect should not be handled.
-  EXPECT_FALSE(controller().WillHandleLongPressEvent(outer_point));
+  EXPECT_FALSE(
+      controller().WillHandleLongPressEvent(base::TimeTicks(), outer_point));
   EXPECT_THAT(GetAndResetEvents(), IsEmpty());
 
   // A point inside the rect should be handled.
-  EXPECT_TRUE(controller().WillHandleLongPressEvent(inner_point));
+  EXPECT_TRUE(
+      controller().WillHandleLongPressEvent(base::TimeTicks(), inner_point));
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
 }
 
+TEST_F(TouchSelectionControllerTest, LongPressDrag) {
+  EnableLongPressDragSelection();
+  TouchSelectionControllerTestApi test_controller(&controller());
+
+  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.
+  OnLongPressEvent();
+  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(test_controller.GetStartVisible());
+  EXPECT_FALSE(test_controller.GetEndVisible());
+
+  // 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, kDefaulTapSlop)));
+  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, 2 * kDefaulTapSlop)));
+  EXPECT_TRUE(GetAndResetSelectionMoved());
+  EXPECT_EQ(end_offset + gfx::Vector2dF(0, kDefaulTapSlop),
+            GetLastSelectionEnd());
+
+  EXPECT_TRUE(controller().WillHandleTouchEvent(
+      event.MovePoint(0, kDefaulTapSlop, 2 * kDefaulTapSlop)));
+  EXPECT_TRUE(GetAndResetSelectionMoved());
+  EXPECT_EQ(end_offset + gfx::Vector2dF(kDefaulTapSlop, kDefaulTapSlop),
+            GetLastSelectionEnd());
+
+  EXPECT_TRUE(controller().WillHandleTouchEvent(
+      event.MovePoint(0, 2 * kDefaulTapSlop, 2 * kDefaulTapSlop)));
+  EXPECT_TRUE(GetAndResetSelectionMoved());
+  EXPECT_EQ(end_offset + gfx::Vector2dF(2 * kDefaulTapSlop, kDefaulTapSlop),
+            GetLastSelectionEnd());
+
+  // The handles should still be hidden.
+  EXPECT_FALSE(test_controller.GetStartVisible());
+  EXPECT_FALSE(test_controller.GetEndVisible());
+
+  // 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(test_controller.GetStartVisible());
+  EXPECT_TRUE(test_controller.GetEndVisible());
+}
+
+TEST_F(TouchSelectionControllerTest, LongPressNoDrag) {
+  EnableLongPressDragSelection();
+  TouchSelectionControllerTestApi test_controller(&controller());
+
+  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.
+  OnLongPressEvent();
+  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(test_controller.GetStartVisible());
+  EXPECT_FALSE(test_controller.GetEndVisible());
+
+  // If no drag movement occurs, the handles should reappear after the touch
+  // is released.
+  EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint()));
+  EXPECT_THAT(GetAndResetEvents(), IsEmpty());
+  EXPECT_TRUE(test_controller.GetStartVisible());
+  EXPECT_TRUE(test_controller.GetEndVisible());
+}
+
+TEST_F(TouchSelectionControllerTest, NoLongPressDragIfDisabled) {
+  // The TouchSelectionController disables longpress drag selection by default.
+  TouchSelectionControllerTestApi test_controller(&controller());
+
+  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.
+  OnLongPressEvent();
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
+  EXPECT_TRUE(test_controller.GetStartVisible());
+  EXPECT_TRUE(test_controller.GetEndVisible());
+
+  // Subsequent motion of the same touch sequence after longpress shouldn't
+  // trigger drag selection.
+  EXPECT_FALSE(controller().WillHandleTouchEvent(event.MovePoint(0, 0, 0)));
+  EXPECT_THAT(GetAndResetEvents(), IsEmpty());
+
+  EXPECT_FALSE(controller().WillHandleTouchEvent(
+      event.MovePoint(0, 0, kDefaulTapSlop * 10)));
+  EXPECT_THAT(GetAndResetEvents(), IsEmpty());
+
+  // Releasing the touch sequence should have no effect.
+  EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint()));
+  EXPECT_THAT(GetAndResetEvents(), IsEmpty());
+  EXPECT_TRUE(test_controller.GetStartVisible());
+  EXPECT_TRUE(test_controller.GetEndVisible());
+}
+
 TEST_F(TouchSelectionControllerTest, RectBetweenBounds) {
   gfx::RectF start_rect(5, 5, 0, 10);
   gfx::RectF end_rect(50, 5, 0, 10);
   bool visible = true;
 
   EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds());
 
   OnLongPressEvent();
   ChangeSelection(start_rect, visible, end_rect, visible);
   ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
@@ skipping 26 matching lines @@
   ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED));
   EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds());
   EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
 
   ClearSelection();
   ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED));
   EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds());
 }
 
 }  // namespace ui