| // 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 "base/macros.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "ui/events/test/motion_event_test_utils.h" |
| #include "ui/touch_selection/touch_selection_controller_test_api.h" |
| |
| using testing::ElementsAre; |
| using testing::IsEmpty; |
| using ui::test::MockMotionEvent; |
| |
| namespace ui { |
| namespace { |
| |
| const int kDefaultTapTimeoutMs = 200; |
| const float kDefaulTapSlop = 10.f; |
| const gfx::PointF kIgnoredPoint(0, 0); |
| |
| class MockTouchHandleDrawable : public TouchHandleDrawable { |
| public: |
| explicit MockTouchHandleDrawable(bool* contains_point) |
| : intersects_rect_(contains_point) {} |
| ~MockTouchHandleDrawable() override {} |
| void SetEnabled(bool enabled) override {} |
| void SetOrientation(ui::TouchHandleOrientation orientation, |
| bool mirror_vertical, |
| bool mirror_horizontal) override {} |
| void SetOrigin(const gfx::PointF& origin) override {} |
| void SetAlpha(float alpha) override {} |
| gfx::RectF GetVisibleBounds() const override { |
| return *intersects_rect_ ? gfx::RectF(-1000, -1000, 2000, 2000) |
| : gfx::RectF(-1000, -1000, 0, 0); |
| } |
| float GetDrawableHorizontalPaddingRatio() const override { return 0; } |
| |
| private: |
| bool* intersects_rect_; |
| |
| DISALLOW_COPY_AND_ASSIGN(MockTouchHandleDrawable); |
| }; |
| |
| } // namespace |
| |
| 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 { |
| 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; } |
| |
| void MoveCaret(const gfx::PointF& position) override { |
| caret_moved_ = true; |
| caret_position_ = position; |
| } |
| |
| void SelectBetweenCoordinates(const gfx::PointF& base, |
| const gfx::PointF& extent) override { |
| if (base == selection_end_ && extent == selection_start_) |
| selection_points_swapped_ = true; |
| |
| selection_start_ = base; |
| selection_end_ = extent; |
| } |
| |
| void MoveRangeSelectionExtent(const gfx::PointF& extent) override { |
| selection_moved_ = true; |
| selection_end_ = extent; |
| } |
| |
| void OnSelectionEvent(SelectionEventType event) override { |
| events_.push_back(event); |
| 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() { |
| 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()); |
| } |
| |
| void ClearInsertion() { ClearSelection(); } |
| |
| void ChangeInsertion(const gfx::RectF& rect, bool visible) { |
| SelectionBound bound; |
| bound.set_type(SelectionBound::CENTER); |
| bound.SetEdge(rect.origin(), rect.bottom_left()); |
| bound.set_visible(visible); |
| controller_->OnSelectionBoundsChanged(bound, bound); |
| } |
| |
| void ChangeSelection(const gfx::RectF& start_rect, |
| bool start_visible, |
| const gfx::RectF& end_rect, |
| bool end_visible) { |
| SelectionBound start_bound, end_bound; |
| 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(base::TimeTicks(), |
| kIgnoredPoint)); |
| } |
| |
| void OnTapEvent() { |
| ASSERT_FALSE(controller().WillHandleTapEvent(kIgnoredPoint, 1)); |
| } |
| |
| void OnDoubleTapEvent() { |
| ASSERT_FALSE(controller().WillHandleTapEvent(kIgnoredPoint, 2)); |
| } |
| |
| void Animate() { |
| base::TimeTicks now = base::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; |
| } |
| |
| bool GetAndResetCaretMoved() { |
| bool moved = caret_moved_; |
| caret_moved_ = false; |
| return moved; |
| } |
| |
| bool GetAndResetSelectionMoved() { |
| bool moved = selection_moved_; |
| selection_moved_ = false; |
| return moved; |
| } |
| |
| bool GetAndResetSelectionPointsSwapped() { |
| bool swapped = selection_points_swapped_; |
| selection_points_swapped_ = false; |
| return swapped; |
| } |
| |
| const gfx::PointF& GetLastCaretPosition() const { return caret_position_; } |
| const gfx::PointF& GetLastSelectionStart() const { return selection_start_; } |
| const gfx::PointF& GetLastSelectionEnd() const { return selection_end_; } |
| const gfx::PointF& GetLastEventStart() const { return last_event_start_; } |
| const gfx::PointF& GetLastEventEnd() const { return last_event_end_; } |
| const gfx::RectF& GetLastEventBoundsRect() const { |
| return last_event_bounds_rect_; |
| } |
| |
| 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.max_tap_duration = |
| 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_; |
| bool needs_animate_; |
| bool animation_enabled_; |
| bool dragging_enabled_; |
| scoped_ptr<TouchSelectionController> controller_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TouchSelectionControllerTest); |
| }; |
| |
| TEST_F(TouchSelectionControllerTest, InsertionBasic) { |
| gfx::RectF insertion_rect(5, 5, 0, 10); |
| bool visible = true; |
| |
| // Insertion handles are not shown until automatic showing is enabled. |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_ESTABLISHED)); |
| EXPECT_EQ(gfx::PointF(), GetLastEventStart()); |
| OnTapEvent(); |
| |
| // Insertion handles are not shown until the selection region is |
| // marked editable. |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| EXPECT_EQ(gfx::PointF(), GetLastEventStart()); |
| |
| OnTapEvent(); |
| controller().OnSelectionEditable(true); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| |
| insertion_rect.Offset(1, 0); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_MOVED)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| |
| insertion_rect.Offset(0, 1); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_MOVED)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| |
| ClearInsertion(); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_DISSOLVED, INSERTION_HANDLE_CLEARED)); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, InsertionClearedWhenNoLongerEditable) { |
| gfx::RectF insertion_rect(5, 5, 0, 10); |
| bool visible = true; |
| OnTapEvent(); |
| controller().OnSelectionEditable(true); |
| |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| |
| controller().OnSelectionEditable(false); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_CLEARED)); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, InsertionWithNoShowOnTapForEmptyEditable) { |
| gfx::RectF insertion_rect(5, 5, 0, 10); |
| bool visible = true; |
| controller().OnSelectionEditable(true); |
| |
| // Taps on an empty editable region should be ignored if the controller is |
| // created with |show_on_tap_for_empty_editable| set to false. |
| OnTapEvent(); |
| controller().OnSelectionEmpty(true); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_EQ(gfx::PointF(), GetLastEventStart()); |
| |
| // Once the region becomes non-empty, taps should show the insertion handle. |
| OnTapEvent(); |
| controller().OnSelectionEmpty(false); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| |
| // Reset the selection. |
| controller().HideAndDisallowShowingAutomatically(); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_CLEARED)); |
| |
| // Long-pressing should show the handle even if the editable region is empty. |
| insertion_rect.Offset(2, -2); |
| OnLongPressEvent(); |
| controller().OnSelectionEmpty(true); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| |
| // Single Tap on an empty edit field should clear insertion handle. |
| OnTapEvent(); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_CLEARED)); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, InsertionWithShowOnTapForEmptyEditable) { |
| AllowShowingOnTapForEmptyEditable(); |
| |
| gfx::RectF insertion_rect(5, 5, 0, 10); |
| bool visible = true; |
| controller().OnSelectionEditable(true); |
| |
| // Taps on an empty editable region should show the insertion handle if the |
| // controller is created with |show_on_tap_for_empty_editable| set to true. |
| OnTapEvent(); |
| controller().OnSelectionEmpty(true); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| |
| // Additional taps should not hide the insertion handle in this case. |
| OnTapEvent(); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, InsertionAppearsAfterTapFollowingTyping) { |
| gfx::RectF insertion_rect(5, 5, 0, 10); |
| bool visible = true; |
| |
| // Simulate the user tapping an empty text field. |
| OnTapEvent(); |
| controller().OnSelectionEditable(true); |
| controller().OnSelectionEmpty(true); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_EQ(gfx::PointF(), GetLastEventStart()); |
| |
| // Simulate the cursor moving while a user is typing. |
| insertion_rect.Offset(10, 0); |
| controller().OnSelectionEmpty(false); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_EQ(gfx::PointF(), GetLastEventStart()); |
| |
| // If the user taps the *same* position as the cursor at the end of the text |
| // entry, the handle should appear. |
| OnTapEvent(); |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, InsertionToSelectionTransition) { |
| OnLongPressEvent(); |
| 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(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(INSERTION_HANDLE_CLEARED, SELECTION_HANDLES_SHOWN)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| |
| ChangeInsertion(end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_HANDLES_CLEARED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(end_rect.bottom_left(), GetLastEventStart()); |
| |
| controller().HideAndDisallowShowingAutomatically(); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_CLEARED)); |
| |
| OnTapEvent(); |
| ChangeInsertion(end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(end_rect.bottom_left(), GetLastEventStart()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, InsertionDragged) { |
| base::TimeTicks event_time = base::TimeTicks::Now(); |
| OnTapEvent(); |
| controller().OnSelectionEditable(true); |
| |
| // The touch sequence should not be handled if insertion 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(10, 0, 0, line_height); |
| bool visible = true; |
| ChangeInsertion(start_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| |
| // The touch sequence should be handled only if the drawable reports a hit. |
| EXPECT_FALSE(controller().WillHandleTouchEvent(event)); |
| SetDraggingEnabled(true); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_FALSE(GetAndResetCaretMoved()); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED)); |
| |
| // The MoveCaret() result should reflect the movement. |
| // The reported position is offset from the center of |start_rect|. |
| gfx::PointF start_offset = start_rect.CenterPoint(); |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_TRUE(GetAndResetCaretMoved()); |
| EXPECT_EQ(start_offset + gfx::Vector2dF(0, 5), GetLastCaretPosition()); |
| |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 5, 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_TRUE(GetAndResetCaretMoved()); |
| EXPECT_EQ(start_offset + gfx::Vector2dF(5, 5), GetLastCaretPosition()); |
| |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 10, 10); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_TRUE(GetAndResetCaretMoved()); |
| EXPECT_EQ(start_offset + gfx::Vector2dF(10, 10), GetLastCaretPosition()); |
| |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_FALSE(GetAndResetCaretMoved()); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STOPPED)); |
| |
| // 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, InsertionTapped) { |
| base::TimeTicks event_time = base::TimeTicks::Now(); |
| OnTapEvent(); |
| controller().OnSelectionEditable(true); |
| SetDraggingEnabled(true); |
| |
| gfx::RectF start_rect(10, 0, 0, 10); |
| bool visible = true; |
| ChangeInsertion(start_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| |
| MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED)); |
| |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_TAPPED, |
| INSERTION_HANDLE_DRAG_STOPPED)); |
| |
| // Reset the insertion. |
| ClearInsertion(); |
| OnTapEvent(); |
| ChangeInsertion(start_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_DISSOLVED, INSERTION_HANDLE_CLEARED, |
| SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| |
| // No tap should be signalled if the time between DOWN and UP was too long. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, |
| event_time + base::TimeDelta::FromSeconds(1), |
| 0, |
| 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED, |
| INSERTION_HANDLE_DRAG_STOPPED)); |
| |
| // Reset the insertion. |
| ClearInsertion(); |
| OnTapEvent(); |
| ChangeInsertion(start_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_DISSOLVED, INSERTION_HANDLE_CLEARED, |
| SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| |
| // No tap should be signalled if the drag was too long. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 100, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 100, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED, |
| INSERTION_HANDLE_DRAG_STOPPED)); |
| |
| // Reset the insertion. |
| ClearInsertion(); |
| OnTapEvent(); |
| ChangeInsertion(start_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_DISSOLVED, INSERTION_HANDLE_CLEARED, |
| SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| |
| // No tap should be signalled if the touch sequence is cancelled. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| event = MockMotionEvent(MockMotionEvent::ACTION_CANCEL, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED, |
| INSERTION_HANDLE_DRAG_STOPPED)); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, InsertionNotResetByRepeatedTapOrPress) { |
| base::TimeTicks event_time = base::TimeTicks::Now(); |
| OnTapEvent(); |
| controller().OnSelectionEditable(true); |
| SetDraggingEnabled(true); |
| |
| gfx::RectF anchor_rect(10, 0, 0, 10); |
| bool visible = true; |
| ChangeInsertion(anchor_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); |
| |
| // Tapping again shouldn't reset the active insertion point. |
| OnTapEvent(); |
| MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_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_HANDLE_TAPPED, |
| INSERTION_HANDLE_DRAG_STOPPED)); |
| EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); |
| |
| anchor_rect.Offset(5, 15); |
| ChangeInsertion(anchor_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_MOVED)); |
| EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); |
| |
| // Pressing shouldn't reset the active insertion point. |
| OnLongPressEvent(); |
| controller().OnSelectionEmpty(true); |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_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_HANDLE_TAPPED, |
| INSERTION_HANDLE_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()); |
| |
| OnLongPressEvent(); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_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_HANDLES_MOVED)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd()); |
| |
| ClearSelection(); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_CLEARED)); |
| EXPECT_EQ(gfx::PointF(), GetLastEventStart()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, SelectionAllowedByDoubleTap) { |
| gfx::RectF start_rect(5, 5, 0, 10); |
| gfx::RectF end_rect(50, 5, 0, 10); |
| bool visible = true; |
| |
| OnDoubleTapEvent(); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, SelectionAllowedByDoubleTapOnEditable) { |
| gfx::RectF start_rect(5, 5, 0, 10); |
| gfx::RectF end_rect(50, 5, 0, 10); |
| bool visible = true; |
| |
| controller().OnSelectionEditable(true); |
| |
| // If the user double tap selects text in an editable region, the first tap |
| // will register insertion and the second tap selection. |
| OnTapEvent(); |
| ChangeInsertion(start_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| |
| OnDoubleTapEvent(); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(INSERTION_HANDLE_CLEARED, SELECTION_HANDLES_SHOWN)); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, SelectionAllowsEmptyUpdateAfterLongPress) { |
| gfx::RectF start_rect(5, 5, 0, 10); |
| gfx::RectF end_rect(50, 5, 0, 10); |
| bool visible = true; |
| |
| OnLongPressEvent(); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| |
| // There may be several empty updates after a longpress due to the |
| // asynchronous response. These empty updates should not prevent the selection |
| // handles from (eventually) activating. |
| ClearSelection(); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| |
| ClearSelection(); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, SelectionRepeatedLongPress) { |
| 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_ESTABLISHED, SELECTION_HANDLES_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_HANDLES_SHOWN |
| // event notification. |
| start_rect.Offset(10, 10); |
| OnLongPressEvent(); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_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(); |
| OnLongPressEvent(); |
| |
| // 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); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| |
| // The touch sequence should be handled only if the drawable reports a hit. |
| EXPECT_FALSE(controller().WillHandleTouchEvent(event)); |
| SetDraggingEnabled(true); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| |
| // The SelectBetweenCoordinates() result should reflect the movement. Note |
| // that the start coordinate will always reflect the "fixed" handle's |
| // position, in this case the position from |end_rect|. |
| // Note that the reported position is offset from the center of the |
| // input rects (i.e., the middle of the corresponding text line). |
| gfx::PointF fixed_offset = end_rect.CenterPoint(); |
| gfx::PointF start_offset = start_rect.CenterPoint(); |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_EQ(fixed_offset, GetLastSelectionStart()); |
| EXPECT_EQ(start_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd()); |
| |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 5, 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_EQ(fixed_offset, GetLastSelectionStart()); |
| EXPECT_EQ(start_offset + gfx::Vector2dF(5, 5), GetLastSelectionEnd()); |
| |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 10, 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_EQ(fixed_offset, GetLastSelectionStart()); |
| EXPECT_EQ(start_offset + gfx::Vector2dF(10, 5), GetLastSelectionEnd()); |
| |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_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(); |
| OnLongPressEvent(); |
| |
| 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_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| |
| // The ACTION_DOWN should lock to the closest handle. |
| gfx::PointF end_offset = end_rect.CenterPoint(); |
| gfx::PointF fixed_offset = start_rect.CenterPoint(); |
| float touch_down_x = (end_offset.x() + fixed_offset.x()) / 2 + 1.f; |
| MockMotionEvent event( |
| MockMotionEvent::ACTION_DOWN, event_time, touch_down_x, 0); |
| SetDraggingEnabled(true); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| |
| // Even though the ACTION_MOVE is over the start handle, it should continue |
| // targetting the end handle that consumed the ACTION_DOWN. |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_EQ(fixed_offset, GetLastSelectionStart()); |
| EXPECT_EQ(end_offset - gfx::Vector2dF(touch_down_x, 0), |
| GetLastSelectionEnd()); |
| |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, SelectionDraggedToSwitchBaseAndExtent) { |
| base::TimeTicks event_time = base::TimeTicks::Now(); |
| OnLongPressEvent(); |
| |
| 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_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| |
| SetDraggingEnabled(true); |
| |
| // Move the extent, not triggering a swap of points. |
| MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, |
| end_rect.x(), end_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); |
| |
| gfx::PointF base_offset = start_rect.CenterPoint(); |
| gfx::PointF extent_offset = end_rect.CenterPoint(); |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, |
| end_rect.x(), end_rect.bottom() + 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); |
| EXPECT_EQ(base_offset, GetLastSelectionStart()); |
| 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_HANDLE_DRAG_STOPPED)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| |
| end_rect += gfx::Vector2dF(0, 5); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| |
| // Move the base, triggering a swap of points. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, |
| start_rect.x(), start_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| EXPECT_TRUE(GetAndResetSelectionPointsSwapped()); |
| |
| base_offset = end_rect.CenterPoint(); |
| extent_offset = start_rect.CenterPoint(); |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, |
| start_rect.x(), start_rect.bottom() + 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); |
| EXPECT_EQ(base_offset, GetLastSelectionStart()); |
| 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_HANDLE_DRAG_STOPPED)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| |
| start_rect += gfx::Vector2dF(0, 5); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| |
| // Move the same point again, not triggering a swap of points. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, |
| start_rect.x(), start_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); |
| |
| base_offset = end_rect.CenterPoint(); |
| extent_offset = start_rect.CenterPoint(); |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, |
| start_rect.x(), start_rect.bottom() + 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); |
| EXPECT_EQ(base_offset, GetLastSelectionStart()); |
| 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_HANDLE_DRAG_STOPPED)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| |
| start_rect += gfx::Vector2dF(0, 5); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| |
| // Move the base, triggering a swap of points. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, |
| end_rect.x(), end_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| EXPECT_TRUE(GetAndResetSelectionPointsSwapped()); |
| |
| base_offset = start_rect.CenterPoint(); |
| extent_offset = end_rect.CenterPoint(); |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, |
| end_rect.x(), end_rect.bottom() + 5); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); |
| EXPECT_EQ(base_offset, GetLastSelectionStart()); |
| 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_HANDLE_DRAG_STOPPED)); |
| EXPECT_FALSE(GetAndResetSelectionMoved()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, SelectionDragExtremeLineSize) { |
| base::TimeTicks event_time = base::TimeTicks::Now(); |
| OnLongPressEvent(); |
| |
| 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_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| EXPECT_EQ(small_line_rect.bottom_left(), GetLastEventStart()); |
| |
| // Start dragging the handle on the small line. |
| MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, |
| small_line_rect.x(), small_line_rect.y()); |
| SetDraggingEnabled(true); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| // The drag coordinate for large lines should be capped to a reasonable |
| // offset, allowing seamless transition to neighboring lines with different |
| // sizes. The drag coordinate for small lines should have an offset |
| // commensurate with the small line size. |
| EXPECT_EQ(large_line_rect.bottom_left() - gfx::Vector2dF(0, 8.f), |
| GetLastSelectionStart()); |
| EXPECT_EQ(small_line_rect.CenterPoint(), GetLastSelectionEnd()); |
| |
| small_line_rect += gfx::Vector2dF(25.f, 0); |
| event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, |
| small_line_rect.x(), small_line_rect.y()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_TRUE(GetAndResetSelectionMoved()); |
| EXPECT_EQ(small_line_rect.CenterPoint(), GetLastSelectionEnd()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, Animation) { |
| OnTapEvent(); |
| controller().OnSelectionEditable(true); |
| |
| gfx::RectF insertion_rect(5, 5, 0, 10); |
| |
| bool visible = true; |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_FALSE(GetAndResetNeedsAnimate()); |
| |
| visible = false; |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_TRUE(GetAndResetNeedsAnimate()); |
| |
| visible = true; |
| ChangeInsertion(insertion_rect, visible); |
| EXPECT_TRUE(GetAndResetNeedsAnimate()); |
| |
| // If the handles are explicity hidden, no animation should be triggered. |
| controller().HideAndDisallowShowingAutomatically(); |
| EXPECT_FALSE(GetAndResetNeedsAnimate()); |
| |
| // 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_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| |
| // Selection should not be cleared if the selection bounds have not changed. |
| OnTapEvent(); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| |
| OnTapEvent(); |
| ClearSelection(); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_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. |
| OnLongPressEvent(); |
| OnTapEvent(); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_ESTABLISHED)); |
| |
| // Subsequent longpress selections will be allowed. |
| OnLongPressEvent(); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_SHOWN)); |
| |
| // Tapping again shouldn't have any effect on subsequent selection events. |
| OnTapEvent(); |
| end_rect.Offset(10, 10); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| ClearSelection(); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_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. |
| OnLongPressEvent(); |
| |
| // Now explicitly allow showing from the previously supplied bounds. |
| controller().AllowShowingFromCurrentSelection(); |
| EXPECT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_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_DISSOLVED, SELECTION_HANDLES_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(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN)); |
| EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, HandlesShowOnTapInsideRect) { |
| bool visible = false; |
| 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(), ElementsAre(SELECTION_ESTABLISHED)); |
| |
| // A point outside the rect should not be handled. |
| EXPECT_FALSE(controller().WillHandleTapEvent(outer_point, 1)); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| |
| // A point inside the rect should be handled. |
| EXPECT_TRUE(controller().WillHandleTapEvent(inner_point, 1)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_SHOWN)); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, HandlesShowOnLongPressInsideRect) { |
| bool visible = false; |
| 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(), ElementsAre(SELECTION_ESTABLISHED)); |
| |
| // A point outside the rect should not be handled. |
| EXPECT_FALSE( |
| controller().WillHandleLongPressEvent(base::TimeTicks(), outer_point)); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| |
| // A point inside the rect should be handled. |
| EXPECT_TRUE( |
| controller().WillHandleLongPressEvent(base::TimeTicks(), inner_point)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_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_ESTABLISHED, SELECTION_HANDLES_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_HANDLE_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_HANDLE_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_ESTABLISHED, SELECTION_HANDLES_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_ESTABLISHED, SELECTION_HANDLES_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()); |
| } |
| |
| // When there is a selection on the page and long-press drag is performed |
| // somewhere that has nothing to select, long-press drag selector should not get |
| // activated so the page can scroll. |
| TEST_F(TouchSelectionControllerTest, LongPressDragScroll) { |
| EnableLongPressDragSelection(); |
| TouchSelectionControllerTestApi test_controller(&controller()); |
| |
| gfx::RectF start_rect(10, 0, 0, 10); |
| gfx::RectF end_rect(20, 0, 0, 10); |
| gfx::PointF touch_point(0, 0); |
| bool visible = true; |
| MockMotionEvent event; |
| |
| // Pre-select something. |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_ESTABLISHED)); |
| |
| // Start the touch sequence and perform the long-press out of the existing |
| // selection. |
| EXPECT_FALSE(controller().WillHandleTouchEvent( |
| event.PressPoint(touch_point.x(), touch_point.y()))); |
| OnLongPressEvent(); |
| |
| // Drag down. Selection controller should not consume the touch-move event. |
| touch_point.Offset(0, 2 * kDefaulTapSlop); |
| EXPECT_FALSE(controller().WillHandleTouchEvent( |
| event.MovePoint(0, touch_point.x(), touch_point.y()))); |
| |
| // Begin page scroll and update the selection. Selection handles should not be |
| // shown which means long-press drag selector is not activated. |
| controller().OnScrollBeginEvent(); |
| start_rect.Offset(0, 2 * kDefaulTapSlop); |
| end_rect.Offset(0, 2 * kDefaulTapSlop); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), IsEmpty()); |
| |
| // Release the touch sequence. |
| EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint())); |
| } |
| |
| 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_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| EXPECT_EQ(gfx::RectF(5, 5, 45, 10), controller().GetRectBetweenBounds()); |
| |
| // The result of |GetRectBetweenBounds| should be available within the |
| // |OnSelectionEvent| callback, as stored by |GetLastEventBoundsRect()|. |
| EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); |
| |
| start_rect.Offset(1, 0); |
| ChangeSelection(start_rect, visible, end_rect, visible); |
| ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds()); |
| EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); |
| |
| // If only one bound is visible, the selection bounding rect should reflect |
| // only the visible bound. |
| ChangeSelection(start_rect, visible, end_rect, false); |
| ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| EXPECT_EQ(start_rect, controller().GetRectBetweenBounds()); |
| EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); |
| |
| ChangeSelection(start_rect, false, end_rect, visible); |
| ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| EXPECT_EQ(end_rect, controller().GetRectBetweenBounds()); |
| EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); |
| |
| // If both bounds are visible, the full bounding rect should be returned. |
| ChangeSelection(start_rect, false, end_rect, false); |
| ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds()); |
| EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); |
| |
| ClearSelection(); |
| ASSERT_THAT(GetAndResetEvents(), |
| ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_CLEARED)); |
| EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds()); |
| } |
| |
| TEST_F(TouchSelectionControllerTest, SelectionNoOrientationChangeWhenSwapped) { |
| TouchSelectionControllerTestApi test_controller(&controller()); |
| base::TimeTicks event_time = base::TimeTicks::Now(); |
| OnLongPressEvent(); |
| |
| 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_ESTABLISHED, SELECTION_HANDLES_SHOWN)); |
| EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| |
| SetDraggingEnabled(true); |
| |
| // Simulate moving the base, not triggering a swap of points. |
| MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, |
| start_rect.x(), start_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| |
| gfx::RectF offset_rect = end_rect; |
| offset_rect.Offset(gfx::Vector2dF(-10, 0)); |
| ChangeSelection(offset_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| |
| event_time += base::TimeDelta::FromMilliseconds(2 * kDefaultTapTimeoutMs); |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, |
| offset_rect.x(), offset_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED)); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| |
| // Simulate moving the base, triggering a swap of points. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, |
| offset_rect.x(), offset_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| |
| offset_rect.Offset(gfx::Vector2dF(20, 0)); |
| ChangeSelection(end_rect, visible, offset_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| |
| event_time += base::TimeDelta::FromMilliseconds(2 * kDefaultTapTimeoutMs); |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, |
| offset_rect.x(), offset_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED)); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| |
| // Simulate moving the anchor, not triggering a swap of points. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, |
| offset_rect.x(), offset_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| |
| offset_rect.Offset(gfx::Vector2dF(-5, 0)); |
| ChangeSelection(end_rect, visible, offset_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| |
| event_time += base::TimeDelta::FromMilliseconds(2 * kDefaultTapTimeoutMs); |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, |
| offset_rect.x(), offset_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED)); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| |
| // Simulate moving the anchor, triggering a swap of points. |
| event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, |
| offset_rect.x(), offset_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED)); |
| |
| offset_rect.Offset(gfx::Vector2dF(-15, 0)); |
| ChangeSelection(offset_rect, visible, end_rect, visible); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED)); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| |
| event_time += base::TimeDelta::FromMilliseconds(2 * kDefaultTapTimeoutMs); |
| event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, |
| offset_rect.x(), offset_rect.bottom()); |
| EXPECT_TRUE(controller().WillHandleTouchEvent(event)); |
| EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED)); |
| EXPECT_EQ(test_controller.GetStartHandleOrientation(), |
| TouchHandleOrientation::LEFT); |
| EXPECT_EQ(test_controller.GetEndHandleOrientation(), |
| TouchHandleOrientation::RIGHT); |
| } |
| |
| } // namespace ui |