Revert of Move TouchSelectionController from content to ui

content/browser/renderer_host/input/touch_selection_controller_unittest.cc

Index: content/browser/renderer_host/input/touch_selection_controller_unittest.cc
diff --git a/content/browser/renderer_host/input/touch_selection_controller_unittest.cc b/content/browser/renderer_host/input/touch_selection_controller_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..11d793da5ff9391670a2d4ea26f6060f2061f7ac
--- /dev/null
+++ b/content/browser/renderer_host/input/touch_selection_controller_unittest.cc
@@ -0,0 +1,845 @@
+// 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 "content/browser/renderer_host/input/touch_selection_controller.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/test/motion_event_test_utils.h"
+
+using ui::test::MockMotionEvent;
+
+namespace content {
+namespace {
+
+const int kDefaultTapTimeoutMs = 200;
+const float kDefaulTapSlop = 10.f;
+
+class MockTouchHandleDrawable : public TouchHandleDrawable {
+ public:
+  explicit MockTouchHandleDrawable(bool* contains_point)
+      : intersects_rect_(contains_point) {}
+  ~MockTouchHandleDrawable() override {}
+  void SetEnabled(bool enabled) override {}
+  void SetOrientation(TouchHandleOrientation orientation) override {}
+  void SetAlpha(float alpha) override {}
+  void SetFocus(const gfx::PointF& position) override {}
+  bool IntersectsWith(const gfx::RectF& rect) const override {
+    return *intersects_rect_;
+  }
+
+ private:
+  bool* intersects_rect_;
+};
+
+}  // namespace
+
+class TouchSelectionControllerTest : public testing::Test,
+                                     public TouchSelectionControllerClient {
+ public:
+  TouchSelectionControllerTest()
+      : last_event_(SELECTION_CLEARED),
+        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,
+        base::TimeDelta::FromMilliseconds(kDefaultTapTimeoutMs),
+        kDefaulTapSlop));
+  }
+
+  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;
+  }
+
+  virtual void MoveRangeSelectionExtent(const gfx::PointF& extent) override {
+    selection_moved_ = true;
+    selection_end_ = extent;
+  }
+
+  void OnSelectionEvent(SelectionEventType event,
+                        const gfx::PointF& end_position) override {
+    last_event_ = event;
+    last_event_start_ = end_position;
+  }
+
+  scoped_ptr<TouchHandleDrawable> CreateDrawable() override {
+    return scoped_ptr<TouchHandleDrawable>(
+        new MockTouchHandleDrawable(&dragging_enabled_));
+  }
+
+  void SetAnimationEnabled(bool enabled) { animation_enabled_ = enabled; }
+  void SetDraggingEnabled(bool enabled) { dragging_enabled_ = enabled; }
+
+  void ClearSelection() {
+    controller_->OnSelectionBoundsChanged(cc::ViewportSelectionBound(),
+                                          cc::ViewportSelectionBound());
+  }
+
+  void ClearInsertion() { ClearSelection(); }
+
+  void ChangeInsertion(const gfx::RectF& rect, bool visible) {
+    cc::ViewportSelectionBound bound;
+    bound.type = cc::SELECTION_BOUND_CENTER;
+    bound.edge_top = rect.origin();
+    bound.edge_bottom = rect.bottom_left();
+    bound.visible = visible;
+    controller_->OnSelectionBoundsChanged(bound, bound);
+  }
+
+  void ChangeSelection(const gfx::RectF& start_rect,
+                       bool start_visible,
+                       const gfx::RectF& end_rect,
+                       bool end_visible) {
+    cc::ViewportSelectionBound start_bound, end_bound;
+    start_bound.type = cc::SELECTION_BOUND_LEFT;
+    end_bound.type = cc::SELECTION_BOUND_RIGHT;
+    start_bound.edge_top = start_rect.origin();
+    start_bound.edge_bottom = start_rect.bottom_left();
+    end_bound.edge_top = end_rect.origin();
+    end_bound.edge_bottom = end_rect.bottom_left();
+    start_bound.visible = start_visible;
+    end_bound.visible = end_visible;
+    controller_->OnSelectionBoundsChanged(start_bound, end_bound);
+  }
+
+  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_; }
+  SelectionEventType GetLastEventType() const { return last_event_; }
+  const gfx::PointF& GetLastEventAnchor() const { return last_event_start_; }
+
+  TouchSelectionController& controller() { return *controller_; }
+
+ private:
+  gfx::PointF last_event_start_;
+  gfx::PointF caret_position_;
+  gfx::PointF selection_start_;
+  gfx::PointF selection_end_;
+  SelectionEventType last_event_;
+  bool caret_moved_;
+  bool selection_moved_;
+  bool selection_points_swapped_;
+  bool needs_animate_;
+  bool animation_enabled_;
+  bool dragging_enabled_;
+  scoped_ptr<TouchSelectionController> controller_;
+};
+
+TEST_F(TouchSelectionControllerTest, InsertionBasic) {
+  gfx::RectF insertion_rect(5, 5, 0, 10);
+  bool visible = true;
+
+  // Insertion events are ignored until automatic showing is enabled.
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
+  controller().OnTapEvent();
+
+  // Insertion events are ignored until the selection region is marked editable.
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
+
+  controller().OnTapEvent();
+  controller().OnSelectionEditable(true);
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
+
+  insertion_rect.Offset(1, 0);
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(INSERTION_MOVED, GetLastEventType());
+  EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
+
+  insertion_rect.Offset(0, 1);
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(INSERTION_MOVED, GetLastEventType());
+  EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
+
+  ClearInsertion();
+  EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
+}
+
+TEST_F(TouchSelectionControllerTest, InsertionClearedWhenNoLongerEditable) {
+  gfx::RectF insertion_rect(5, 5, 0, 10);
+  bool visible = true;
+  controller().OnTapEvent();
+  controller().OnSelectionEditable(true);
+
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
+
+  controller().OnSelectionEditable(false);
+  EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
+}
+
+TEST_F(TouchSelectionControllerTest, InsertionStaysHiddenIfEmptyRegionTapped) {
+  gfx::RectF insertion_rect(5, 5, 0, 10);
+  bool visible = true;
+  controller().OnSelectionEditable(true);
+
+  // Taps should be ignored if they're in an empty editable region.
+  controller().OnTapEvent();
+  controller().OnSelectionEmpty(true);
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
+
+  // Once the region becomes editable, taps should show the insertion handle.
+  controller().OnTapEvent();
+  controller().OnSelectionEmpty(false);
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
+
+  // Reset the selection.
+  controller().HideAndDisallowShowingAutomatically();
+  EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
+
+  // Long-pressing should show the handle even if the editable region is empty.
+  insertion_rect.Offset(2, -2);
+  controller().OnLongPressEvent();
+  controller().OnSelectionEmpty(true);
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
+
+  // Single Tap on an empty edit field should clear insertion handle.
+  controller().OnTapEvent();
+  EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
+}
+
+TEST_F(TouchSelectionControllerTest, InsertionAppearsAfterTapFollowingTyping) {
+  gfx::RectF insertion_rect(5, 5, 0, 10);
+  bool visible = true;
+
+  // Simulate the user tapping an empty text field.
+  controller().OnTapEvent();
+  controller().OnSelectionEditable(true);
+  controller().OnSelectionEmpty(true);
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
+
+  // 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(), GetLastEventAnchor());
+
+  // 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_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
+}
+
+TEST_F(TouchSelectionControllerTest, InsertionToSelectionTransition) {
+  controller().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_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  ChangeInsertion(end_rect, visible);
+  EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(end_rect.bottom_left(), GetLastEventAnchor());
+
+  controller().HideAndDisallowShowingAutomatically();
+  EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
+
+  controller().OnTapEvent();
+  ChangeInsertion(end_rect, visible);
+  EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(end_rect.bottom_left(), GetLastEventAnchor());
+}
+
+TEST_F(TouchSelectionControllerTest, InsertionDragged) {
+  base::TimeTicks event_time = base::TimeTicks::Now();
+  controller().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_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  // 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());
+
+  // 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());
+
+  // 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();
+  controller().OnTapEvent();
+  controller().OnSelectionEditable(true);
+  SetDraggingEnabled(true);
+
+  gfx::RectF start_rect(10, 0, 0, 10);
+  bool visible = true;
+  ChangeInsertion(start_rect, visible);
+  EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
+
+  MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event));
+  //TODO(AKV): this test case has to be modified once crbug.com/394093 is fixed.
+  EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
+
+  event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event));
+  EXPECT_EQ(INSERTION_TAPPED, GetLastEventType());
+
+  // Reset the insertion.
+  ClearInsertion();
+  controller().OnTapEvent();
+  ChangeInsertion(start_rect, visible);
+  ASSERT_EQ(INSERTION_SHOWN, GetLastEventType());
+
+  // 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_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
+
+  // Reset the insertion.
+  ClearInsertion();
+  controller().OnTapEvent();
+  ChangeInsertion(start_rect, visible);
+  ASSERT_EQ(INSERTION_SHOWN, GetLastEventType());
+
+  // 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_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
+
+  // Reset the insertion.
+  ClearInsertion();
+  controller().OnTapEvent();
+  ChangeInsertion(start_rect, visible);
+  ASSERT_EQ(INSERTION_SHOWN, GetLastEventType());
+
+  // 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_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
+}
+
+TEST_F(TouchSelectionControllerTest, InsertionNotResetByRepeatedTapOrPress) {
+  base::TimeTicks event_time = base::TimeTicks::Now();
+  controller().OnTapEvent();
+  controller().OnSelectionEditable(true);
+  SetDraggingEnabled(true);
+
+  gfx::RectF anchor_rect(10, 0, 0, 10);
+  bool visible = true;
+  ChangeInsertion(anchor_rect, visible);
+  EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
+
+  // Tapping again shouldn't reset the active insertion point.
+  controller().OnTapEvent();
+  MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event));
+  EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
+  EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
+
+  event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event));
+  EXPECT_EQ(INSERTION_TAPPED, GetLastEventType());
+  EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
+
+  anchor_rect.Offset(5, 15);
+  ChangeInsertion(anchor_rect, visible);
+  EXPECT_EQ(INSERTION_MOVED, GetLastEventType());
+  EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
+
+  // Pressing shouldn't reset the active insertion point.
+  controller().OnLongPressEvent();
+  controller().OnSelectionEmpty(true);
+  event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event));
+  EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
+  EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
+
+  event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
+  EXPECT_TRUE(controller().WillHandleTouchEvent(event));
+  EXPECT_EQ(INSERTION_TAPPED, GetLastEventType());
+  EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
+}
+
+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(), GetLastEventAnchor());
+
+  controller().OnLongPressEvent();
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  start_rect.Offset(1, 0);
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  // Selection movement does not currently trigger a separate event.
+  EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
+
+  ClearSelection();
+  EXPECT_EQ(SELECTION_CLEARED, GetLastEventType());
+  EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
+}
+
+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();
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  // A long press triggering a new selection should re-send the SELECTION_SHOWN
+  // event notification.
+  start_rect.Offset(10, 10);
+  controller().OnLongPressEvent();
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+}
+
+TEST_F(TouchSelectionControllerTest, SelectionDragged) {
+  base::TimeTicks event_time = base::TimeTicks::Now();
+  controller().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_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  // 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_EQ(SELECTION_DRAG_STARTED, GetLastEventType());
+  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_EQ(SELECTION_DRAG_STOPPED, GetLastEventType());
+  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();
+
+  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_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  // 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_EQ(SELECTION_DRAG_STARTED, GetLastEventType());
+  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_EQ(SELECTION_DRAG_STOPPED, GetLastEventType());
+  EXPECT_FALSE(GetAndResetSelectionMoved());
+}
+
+TEST_F(TouchSelectionControllerTest, SelectionDraggedToSwitchBaseAndExtent) {
+  base::TimeTicks event_time = base::TimeTicks::Now();
+  controller().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_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  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_EQ(SELECTION_DRAG_STARTED, GetLastEventType());
+  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_EQ(SELECTION_DRAG_STOPPED, GetLastEventType());
+  EXPECT_FALSE(GetAndResetSelectionMoved());
+
+  end_rect += gfx::Vector2dF(0, 5);
+  ChangeSelection(start_rect, visible, end_rect, visible);
+
+  // 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_EQ(SELECTION_DRAG_STARTED, GetLastEventType());
+  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_EQ(SELECTION_DRAG_STOPPED, GetLastEventType());
+  EXPECT_FALSE(GetAndResetSelectionMoved());
+
+  start_rect += gfx::Vector2dF(0, 5);
+  ChangeSelection(start_rect, visible, end_rect, visible);
+
+  // 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_EQ(SELECTION_DRAG_STARTED, GetLastEventType());
+  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_EQ(SELECTION_DRAG_STOPPED, GetLastEventType());
+  EXPECT_FALSE(GetAndResetSelectionMoved());
+
+  start_rect += gfx::Vector2dF(0, 5);
+  ChangeSelection(start_rect, visible, end_rect, visible);
+
+  // 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_EQ(SELECTION_DRAG_STARTED, GetLastEventType());
+  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_EQ(SELECTION_DRAG_STOPPED, GetLastEventType());
+  EXPECT_FALSE(GetAndResetSelectionMoved());
+}
+
+TEST_F(TouchSelectionControllerTest, Animation) {
+  controller().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);
+  controller().OnTapEvent();
+  visible = true;
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_FALSE(GetAndResetNeedsAnimate());
+}
+
+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());
+
+  controller().SetTemporarilyHidden(true);
+  EXPECT_TRUE(GetAndResetNeedsAnimate());
+
+  visible = false;
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_FALSE(GetAndResetNeedsAnimate());
+
+  visible = true;
+  ChangeInsertion(insertion_rect, visible);
+  EXPECT_FALSE(GetAndResetNeedsAnimate());
+
+  controller().SetTemporarilyHidden(false);
+  EXPECT_TRUE(GetAndResetNeedsAnimate());
+}
+
+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();
+  ChangeSelection(start_rect, visible, end_rect, visible);
+
+  // Selection should not be cleared if the selection bounds have not changed.
+  controller().OnTapEvent();
+  EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  controller().OnTapEvent();
+  ClearSelection();
+  EXPECT_EQ(SELECTION_CLEARED, GetLastEventType());
+  EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
+}
+
+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 have be activated, as it wasn't yet allowed.
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
+
+  // Now explicitly allow showing from the previously supplied bounds.
+  controller().AllowShowingFromCurrentSelection();
+  EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  // Repeated calls to show from the current selection should be ignored.
+  controller().AllowShowingFromCurrentSelection();
+  EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
+
+  // Trying to show from an empty selection will have no result.
+  ClearSelection();
+  EXPECT_EQ(SELECTION_CLEARED, GetLastEventType());
+  controller().AllowShowingFromCurrentSelection();
+  EXPECT_EQ(SELECTION_CLEARED, GetLastEventType());
+
+  // 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_EQ(INSERTION_SHOWN, GetLastEventType());
+  EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
+}
+
+}  // namespace content