src/content/browser/renderer_host/input/touch_selection_controller_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/input/touch_selection_controller.h"
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8 #include "ui/events/test/mock_motion_event.h"
   9
  10 using ui::test::MockMotionEvent;
  11
  12 namespace content {
  13 namespace {
  14
  15 const int kDefaultTapTimeoutMs = 200;
  16 const float kDefaulTapSlop = 10.f;
  17
  18 class MockTouchHandleDrawable : public TouchHandleDrawable {
  19  public:
  20   explicit MockTouchHandleDrawable(bool* contains_point)
  21       : intersects_rect_(contains_point) {}
  22   virtual ~MockTouchHandleDrawable() {}
  23   virtual void SetEnabled(bool enabled) OVERRIDE {}
  24   virtual void SetOrientation(TouchHandleOrientation orientation) OVERRIDE {}
  25   virtual void SetAlpha(float alpha) OVERRIDE {}
  26   virtual void SetFocus(const gfx::PointF& position) OVERRIDE {}
  27   virtual void SetVisible(bool visible) OVERRIDE {}
  28   virtual bool IntersectsWith(const gfx::RectF& rect) const OVERRIDE {
  29     return *intersects_rect_;
  30   }
  31
  32  private:
  33   bool* intersects_rect_;
  34 };
  35
  36 }  // namespace
  37
  38 class TouchSelectionControllerTest : public testing::Test,
  39                                      public TouchSelectionControllerClient {
  40  public:
  41   TouchSelectionControllerTest()
  42       : last_event_(SELECTION_CLEARED),
  43         caret_moved_(false),
  44         selection_moved_(false),
  45         needs_animate_(false),
  46         animation_enabled_(true),
  47         dragging_enabled_(false) {}
  48
  49   virtual ~TouchSelectionControllerTest() {}
  50
  51   // testing::Test implementation.
  52   virtual void SetUp() OVERRIDE {
  53     controller_.reset(new TouchSelectionController(
  54         this,
  55         base::TimeDelta::FromMilliseconds(kDefaultTapTimeoutMs),
  56         kDefaulTapSlop));
  57   }
  58
  59   virtual void TearDown() OVERRIDE { controller_.reset(); }
  60
  61   // TouchSelectionControllerClient implementation.
  62
  63   virtual bool SupportsAnimation() const OVERRIDE { return animation_enabled_; }
  64
  65   virtual void SetNeedsAnimate() OVERRIDE { needs_animate_ = true; }
  66
  67   virtual void MoveCaret(const gfx::PointF& position) OVERRIDE {
  68     caret_moved_ = true;
  69     caret_position_ = position;
  70   }
  71
  72   virtual void SelectBetweenCoordinates(const gfx::PointF& start,
  73                                         const gfx::PointF& end) OVERRIDE {
  74     selection_moved_ = true;
  75     selection_start_ = start;
  76     selection_end_ = end;
  77   }
  78
  79   virtual void OnSelectionEvent(SelectionEventType event,
  80                                 const gfx::PointF& end_position) OVERRIDE {
  81     last_event_ = event;
  82     last_event_start_ = end_position;
  83   }
  84
  85   virtual scoped_ptr<TouchHandleDrawable> CreateDrawable() OVERRIDE {
  86     return scoped_ptr<TouchHandleDrawable>(
  87         new MockTouchHandleDrawable(&dragging_enabled_));
  88   }
  89
  90   void SetAnimationEnabled(bool enabled) { animation_enabled_ = enabled; }
  91   void SetDraggingEnabled(bool enabled) { dragging_enabled_ = enabled; }
  92
  93   void ClearSelection() {
  94     controller_->OnSelectionBoundsChanged(cc::ViewportSelectionBound(),
  95                                           cc::ViewportSelectionBound());
  96   }
  97
  98   void ClearInsertion() { ClearSelection(); }
  99
 100   void ChangeInsertion(const gfx::RectF& rect, bool visible) {
 101     cc::ViewportSelectionBound bound;
 102     bound.type = cc::SELECTION_BOUND_CENTER;
 103     bound.edge_top = rect.origin();
 104     bound.edge_bottom = rect.bottom_left();
 105     bound.visible = visible;
 106     controller_->OnSelectionBoundsChanged(bound, bound);
 107   }
 108
 109   void ChangeSelection(const gfx::RectF& start_rect,
 110                        bool start_visible,
 111                        const gfx::RectF& end_rect,
 112                        bool end_visible) {
 113     cc::ViewportSelectionBound start_bound, end_bound;
 114     start_bound.type = cc::SELECTION_BOUND_LEFT;
 115     end_bound.type = cc::SELECTION_BOUND_RIGHT;
 116     start_bound.edge_top = start_rect.origin();
 117     start_bound.edge_bottom = start_rect.bottom_left();
 118     end_bound.edge_top = end_rect.origin();
 119     end_bound.edge_bottom = end_rect.bottom_left();
 120     start_bound.visible = start_visible;
 121     end_bound.visible = end_visible;
 122     controller_->OnSelectionBoundsChanged(start_bound, end_bound);
 123   }
 124
 125   void Animate() {
 126     base::TimeTicks now = base::TimeTicks::Now();
 127     while (needs_animate_) {
 128       needs_animate_ = controller_->Animate(now);
 129       now += base::TimeDelta::FromMilliseconds(16);
 130     }
 131   }
 132
 133   bool GetAndResetNeedsAnimate() {
 134     bool needs_animate = needs_animate_;
 135     Animate();
 136     return needs_animate;
 137   }
 138
 139   bool GetAndResetCaretMoved() {
 140     bool moved = caret_moved_;
 141     caret_moved_ = false;
 142     return moved;
 143   }
 144
 145   bool GetAndResetSelectionMoved() {
 146     bool moved = selection_moved_;
 147     selection_moved_ = false;
 148     return moved;
 149   }
 150
 151   const gfx::PointF& GetLastCaretPosition() const { return caret_position_; }
 152   const gfx::PointF& GetLastSelectionStart() const { return selection_start_; }
 153   const gfx::PointF& GetLastSelectionEnd() const { return selection_end_; }
 154   SelectionEventType GetLastEventType() const { return last_event_; }
 155   const gfx::PointF& GetLastEventAnchor() const { return last_event_start_; }
 156
 157   TouchSelectionController& controller() { return *controller_; }
 158
 159  private:
 160   gfx::PointF last_event_start_;
 161   gfx::PointF caret_position_;
 162   gfx::PointF selection_start_;
 163   gfx::PointF selection_end_;
 164   SelectionEventType last_event_;
 165   bool caret_moved_;
 166   bool selection_moved_;
 167   bool needs_animate_;
 168   bool animation_enabled_;
 169   bool dragging_enabled_;
 170   scoped_ptr<TouchSelectionController> controller_;
 171 };
 172
 173 TEST_F(TouchSelectionControllerTest, InsertionBasic) {
 174   gfx::RectF insertion_rect(5, 5, 0, 10);
 175   bool visible = true;
 176
 177   // Insertion events are ignored until automatic showing is enabled.
 178   ChangeInsertion(insertion_rect, visible);
 179   EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
 180   controller().OnTapEvent();
 181
 182   // Insertion events are ignored until the selection region is marked editable.
 183   ChangeInsertion(insertion_rect, visible);
 184   EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
 185
 186   controller().OnTapEvent();
 187   controller().OnSelectionEditable(true);
 188   ChangeInsertion(insertion_rect, visible);
 189   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 190   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
 191
 192   insertion_rect.Offset(1, 0);
 193   ChangeInsertion(insertion_rect, visible);
 194   EXPECT_EQ(INSERTION_MOVED, GetLastEventType());
 195   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
 196
 197   insertion_rect.Offset(0, 1);
 198   ChangeInsertion(insertion_rect, visible);
 199   EXPECT_EQ(INSERTION_MOVED, GetLastEventType());
 200   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
 201
 202   ClearInsertion();
 203   EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
 204 }
 205
 206 TEST_F(TouchSelectionControllerTest, InsertionClearedWhenNoLongerEditable) {
 207   gfx::RectF insertion_rect(5, 5, 0, 10);
 208   bool visible = true;
 209   controller().OnTapEvent();
 210   controller().OnSelectionEditable(true);
 211
 212   ChangeInsertion(insertion_rect, visible);
 213   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 214   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
 215
 216   controller().OnSelectionEditable(false);
 217   EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
 218 }
 219
 220 TEST_F(TouchSelectionControllerTest, InsertionStaysHiddenIfEmptyRegionTapped) {
 221   gfx::RectF insertion_rect(5, 5, 0, 10);
 222   bool visible = true;
 223   controller().OnSelectionEditable(true);
 224
 225   // Taps should be ignored if they're in an empty editable region.
 226   controller().OnTapEvent();
 227   controller().OnSelectionEmpty(true);
 228   ChangeInsertion(insertion_rect, visible);
 229   EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
 230
 231   // Once the region becomes editable, taps should show the insertion handle.
 232   controller().OnTapEvent();
 233   controller().OnSelectionEmpty(false);
 234   ChangeInsertion(insertion_rect, visible);
 235   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 236   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
 237
 238   // Reset the selection.
 239   controller().HideAndDisallowShowingAutomatically();
 240   EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
 241
 242   // Long-pressing should show the handle even if the editable region is empty.
 243   insertion_rect.Offset(2, -2);
 244   controller().OnLongPressEvent();
 245   controller().OnSelectionEmpty(true);
 246   ChangeInsertion(insertion_rect, visible);
 247   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 248   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
 249
 250   // Single Tap on an empty edit field should clear insertion handle.
 251   controller().OnTapEvent();
 252   EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
 253 }
 254
 255 TEST_F(TouchSelectionControllerTest, InsertionAppearsAfterTapFollowingTyping) {
 256   gfx::RectF insertion_rect(5, 5, 0, 10);
 257   bool visible = true;
 258
 259   // Simulate the user tapping an empty text field.
 260   controller().OnTapEvent();
 261   controller().OnSelectionEditable(true);
 262   controller().OnSelectionEmpty(true);
 263   ChangeInsertion(insertion_rect, visible);
 264   EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
 265
 266   // Simulate the cursor moving while a user is typing.
 267   insertion_rect.Offset(10, 0);
 268   controller().OnSelectionEmpty(false);
 269   ChangeInsertion(insertion_rect, visible);
 270   EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
 271
 272   // If the user taps the *same* position as the cursor at the end of the text
 273   // entry, the handle should appear.
 274   controller().OnTapEvent();
 275   ChangeInsertion(insertion_rect, visible);
 276   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 277   EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventAnchor());
 278 }
 279
 280 TEST_F(TouchSelectionControllerTest, InsertionToSelectionTransition) {
 281   controller().OnLongPressEvent();
 282   controller().OnSelectionEditable(true);
 283
 284   gfx::RectF start_rect(5, 5, 0, 10);
 285   gfx::RectF end_rect(50, 5, 0, 10);
 286   bool visible = true;
 287
 288   ChangeInsertion(start_rect, visible);
 289   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 290   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 291
 292   ChangeSelection(start_rect, visible, end_rect, visible);
 293   EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
 294   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 295
 296   ChangeInsertion(end_rect, visible);
 297   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 298   EXPECT_EQ(end_rect.bottom_left(), GetLastEventAnchor());
 299
 300   controller().HideAndDisallowShowingAutomatically();
 301   EXPECT_EQ(INSERTION_CLEARED, GetLastEventType());
 302
 303   controller().OnTapEvent();
 304   ChangeInsertion(end_rect, visible);
 305   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 306   EXPECT_EQ(end_rect.bottom_left(), GetLastEventAnchor());
 307 }
 308
 309 TEST_F(TouchSelectionControllerTest, InsertionDragged) {
 310   base::TimeTicks event_time = base::TimeTicks::Now();
 311   controller().OnTapEvent();
 312   controller().OnSelectionEditable(true);
 313
 314   // The touch sequence should not be handled if insertion is not active.
 315   MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
 316   EXPECT_FALSE(controller().WillHandleTouchEvent(event));
 317
 318   float line_height = 10.f;
 319   gfx::RectF start_rect(10, 0, 0, line_height);
 320   bool visible = true;
 321   ChangeInsertion(start_rect, visible);
 322   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 323   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 324
 325   // The touch sequence should be handled only if the drawable reports a hit.
 326   EXPECT_FALSE(controller().WillHandleTouchEvent(event));
 327   SetDraggingEnabled(true);
 328   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 329   EXPECT_FALSE(GetAndResetCaretMoved());
 330
 331   // The MoveCaret() result should reflect the movement.
 332   // The reported position is offset from the center of |start_rect|.
 333   gfx::PointF start_offset = start_rect.CenterPoint();
 334   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 5);
 335   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 336   EXPECT_TRUE(GetAndResetCaretMoved());
 337   EXPECT_EQ(start_offset + gfx::Vector2dF(0, 5), GetLastCaretPosition());
 338
 339   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 5, 5);
 340   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 341   EXPECT_TRUE(GetAndResetCaretMoved());
 342   EXPECT_EQ(start_offset + gfx::Vector2dF(5, 5), GetLastCaretPosition());
 343
 344   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 10, 10);
 345   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 346   EXPECT_TRUE(GetAndResetCaretMoved());
 347   EXPECT_EQ(start_offset + gfx::Vector2dF(10, 10), GetLastCaretPosition());
 348
 349   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
 350   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 351   EXPECT_FALSE(GetAndResetCaretMoved());
 352
 353   // Once the drag is complete, no more touch events should be consumed until
 354   // the next ACTION_DOWN.
 355   EXPECT_FALSE(controller().WillHandleTouchEvent(event));
 356 }
 357
 358 TEST_F(TouchSelectionControllerTest, InsertionTapped) {
 359   base::TimeTicks event_time = base::TimeTicks::Now();
 360   controller().OnTapEvent();
 361   controller().OnSelectionEditable(true);
 362   SetDraggingEnabled(true);
 363
 364   gfx::RectF start_rect(10, 0, 0, 10);
 365   bool visible = true;
 366   ChangeInsertion(start_rect, visible);
 367   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 368
 369   MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
 370   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 371   //TODO(AKV): this test case has to be modified once crbug.com/394093 is fixed.
 372   EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
 373
 374   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
 375   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 376   EXPECT_EQ(INSERTION_TAPPED, GetLastEventType());
 377
 378   // Reset the insertion.
 379   ClearInsertion();
 380   controller().OnTapEvent();
 381   ChangeInsertion(start_rect, visible);
 382   ASSERT_EQ(INSERTION_SHOWN, GetLastEventType());
 383
 384   // No tap should be signalled if the time between DOWN and UP was too long.
 385   event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
 386   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 387   event = MockMotionEvent(MockMotionEvent::ACTION_UP,
 388                           event_time + base::TimeDelta::FromSeconds(1),
 389                           0,
 390                           0);
 391   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 392   EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
 393
 394   // Reset the insertion.
 395   ClearInsertion();
 396   controller().OnTapEvent();
 397   ChangeInsertion(start_rect, visible);
 398   ASSERT_EQ(INSERTION_SHOWN, GetLastEventType());
 399
 400   // No tap should be signalled if the drag was too long.
 401   event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
 402   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 403   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 100, 0);
 404   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 405   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 100, 0);
 406   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 407   EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
 408
 409   // Reset the insertion.
 410   ClearInsertion();
 411   controller().OnTapEvent();
 412   ChangeInsertion(start_rect, visible);
 413   ASSERT_EQ(INSERTION_SHOWN, GetLastEventType());
 414
 415   // No tap should be signalled if the touch sequence is cancelled.
 416   event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
 417   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 418   event = MockMotionEvent(MockMotionEvent::ACTION_CANCEL, event_time, 0, 0);
 419   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 420   EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
 421 }
 422
 423 TEST_F(TouchSelectionControllerTest, InsertionNotResetByRepeatedTapOrPress) {
 424   base::TimeTicks event_time = base::TimeTicks::Now();
 425   controller().OnTapEvent();
 426   controller().OnSelectionEditable(true);
 427   SetDraggingEnabled(true);
 428
 429   gfx::RectF anchor_rect(10, 0, 0, 10);
 430   bool visible = true;
 431   ChangeInsertion(anchor_rect, visible);
 432   EXPECT_EQ(INSERTION_SHOWN, GetLastEventType());
 433   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
 434
 435   // Tapping again shouldn't reset the active insertion point.
 436   controller().OnTapEvent();
 437   MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
 438   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 439   EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
 440   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
 441
 442   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
 443   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 444   EXPECT_EQ(INSERTION_TAPPED, GetLastEventType());
 445   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
 446
 447   anchor_rect.Offset(5, 15);
 448   ChangeInsertion(anchor_rect, visible);
 449   EXPECT_EQ(INSERTION_MOVED, GetLastEventType());
 450   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
 451
 452   // Pressing shouldn't reset the active insertion point.
 453   controller().OnLongPressEvent();
 454   controller().OnSelectionEmpty(true);
 455   event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
 456   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 457   EXPECT_EQ(INSERTION_DRAG_STARTED, GetLastEventType());
 458   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
 459
 460   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
 461   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 462   EXPECT_EQ(INSERTION_TAPPED, GetLastEventType());
 463   EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventAnchor());
 464 }
 465
 466 TEST_F(TouchSelectionControllerTest, SelectionBasic) {
 467   gfx::RectF start_rect(5, 5, 0, 10);
 468   gfx::RectF end_rect(50, 5, 0, 10);
 469   bool visible = true;
 470
 471   // Selection events are ignored until automatic showing is enabled.
 472   ChangeSelection(start_rect, visible, end_rect, visible);
 473   EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
 474
 475   controller().OnLongPressEvent();
 476   ChangeSelection(start_rect, visible, end_rect, visible);
 477   EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
 478   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 479
 480   start_rect.Offset(1, 0);
 481   ChangeSelection(start_rect, visible, end_rect, visible);
 482   // Selection movement does not currently trigger a separate event.
 483   EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
 484
 485   ClearSelection();
 486   EXPECT_EQ(SELECTION_CLEARED, GetLastEventType());
 487   EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
 488 }
 489
 490 TEST_F(TouchSelectionControllerTest, SelectionRepeatedLongPress) {
 491   gfx::RectF start_rect(5, 5, 0, 10);
 492   gfx::RectF end_rect(50, 5, 0, 10);
 493   bool visible = true;
 494
 495   controller().OnLongPressEvent();
 496   ChangeSelection(start_rect, visible, end_rect, visible);
 497   EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
 498   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 499
 500   // A long press triggering a new selection should re-send the SELECTION_SHOWN
 501   // event notification.
 502   start_rect.Offset(10, 10);
 503   controller().OnLongPressEvent();
 504   ChangeSelection(start_rect, visible, end_rect, visible);
 505   EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
 506   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 507 }
 508
 509 TEST_F(TouchSelectionControllerTest, SelectionDragged) {
 510   base::TimeTicks event_time = base::TimeTicks::Now();
 511   controller().OnLongPressEvent();
 512
 513   // The touch sequence should not be handled if selection is not active.
 514   MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
 515   EXPECT_FALSE(controller().WillHandleTouchEvent(event));
 516
 517   float line_height = 10.f;
 518   gfx::RectF start_rect(0, 0, 0, line_height);
 519   gfx::RectF end_rect(50, 0, 0, line_height);
 520   bool visible = true;
 521   ChangeSelection(start_rect, visible, end_rect, visible);
 522   EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
 523   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 524
 525   // The touch sequence should be handled only if the drawable reports a hit.
 526   EXPECT_FALSE(controller().WillHandleTouchEvent(event));
 527   SetDraggingEnabled(true);
 528   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 529   EXPECT_FALSE(GetAndResetSelectionMoved());
 530
 531   // The SelectBetweenCoordinates() result should reflect the movement. Note
 532   // that the start coordinate will always reflect the "fixed" handle's
 533   // position, in this case the position from |end_rect|.
 534   // Note that the reported position is offset from the center of the
 535   // input rects (i.e., the middle of the corresponding text line).
 536   gfx::PointF fixed_offset = end_rect.CenterPoint();
 537   gfx::PointF start_offset = start_rect.CenterPoint();
 538   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 5);
 539   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 540   EXPECT_EQ(SELECTION_DRAG_STARTED, GetLastEventType());
 541   EXPECT_TRUE(GetAndResetSelectionMoved());
 542   EXPECT_EQ(fixed_offset, GetLastSelectionStart());
 543   EXPECT_EQ(start_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd());
 544
 545   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 5, 5);
 546   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 547   EXPECT_TRUE(GetAndResetSelectionMoved());
 548   EXPECT_EQ(fixed_offset, GetLastSelectionStart());
 549   EXPECT_EQ(start_offset + gfx::Vector2dF(5, 5), GetLastSelectionEnd());
 550
 551   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 10, 5);
 552   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 553   EXPECT_TRUE(GetAndResetSelectionMoved());
 554   EXPECT_EQ(fixed_offset, GetLastSelectionStart());
 555   EXPECT_EQ(start_offset + gfx::Vector2dF(10, 5), GetLastSelectionEnd());
 556
 557   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
 558   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 559   EXPECT_EQ(SELECTION_DRAG_STOPPED, GetLastEventType());
 560   EXPECT_FALSE(GetAndResetSelectionMoved());
 561
 562   // Once the drag is complete, no more touch events should be consumed until
 563   // the next ACTION_DOWN.
 564   EXPECT_FALSE(controller().WillHandleTouchEvent(event));
 565 }
 566
 567 TEST_F(TouchSelectionControllerTest, SelectionDraggedWithOverlap) {
 568   base::TimeTicks event_time = base::TimeTicks::Now();
 569   controller().OnLongPressEvent();
 570
 571   float line_height = 10.f;
 572   gfx::RectF start_rect(0, 0, 0, line_height);
 573   gfx::RectF end_rect(50, 0, 0, line_height);
 574   bool visible = true;
 575   ChangeSelection(start_rect, visible, end_rect, visible);
 576   EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
 577   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 578
 579   // The ACTION_DOWN should lock to the closest handle.
 580   gfx::PointF end_offset = end_rect.CenterPoint();
 581   gfx::PointF fixed_offset = start_rect.CenterPoint();
 582   float touch_down_x = (end_offset.x() + fixed_offset.x()) / 2 + 1.f;
 583   MockMotionEvent event(
 584       MockMotionEvent::ACTION_DOWN, event_time, touch_down_x, 0);
 585   SetDraggingEnabled(true);
 586   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 587   EXPECT_EQ(SELECTION_DRAG_STARTED, GetLastEventType());
 588   EXPECT_FALSE(GetAndResetSelectionMoved());
 589
 590   // Even though the ACTION_MOVE is over the start handle, it should continue
 591   // targetting the end handle that consumed the ACTION_DOWN.
 592   event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 0);
 593   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 594   EXPECT_TRUE(GetAndResetSelectionMoved());
 595   EXPECT_EQ(fixed_offset, GetLastSelectionStart());
 596   EXPECT_EQ(end_offset - gfx::Vector2dF(touch_down_x, 0),
 597             GetLastSelectionEnd());
 598
 599   event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
 600   EXPECT_TRUE(controller().WillHandleTouchEvent(event));
 601   EXPECT_EQ(SELECTION_DRAG_STOPPED, GetLastEventType());
 602   EXPECT_FALSE(GetAndResetSelectionMoved());
 603 }
 604
 605 TEST_F(TouchSelectionControllerTest, Animation) {
 606   controller().OnTapEvent();
 607   controller().OnSelectionEditable(true);
 608
 609   gfx::RectF insertion_rect(5, 5, 0, 10);
 610
 611   bool visible = true;
 612   ChangeInsertion(insertion_rect, visible);
 613   EXPECT_FALSE(GetAndResetNeedsAnimate());
 614
 615   visible = false;
 616   ChangeInsertion(insertion_rect, visible);
 617   EXPECT_TRUE(GetAndResetNeedsAnimate());
 618
 619   visible = true;
 620   ChangeInsertion(insertion_rect, visible);
 621   EXPECT_TRUE(GetAndResetNeedsAnimate());
 622
 623   // If the handles are explicity hidden, no animation should be triggered.
 624   controller().HideAndDisallowShowingAutomatically();
 625   EXPECT_FALSE(GetAndResetNeedsAnimate());
 626
 627   // If the client doesn't support animation, no animation should be triggered.
 628   SetAnimationEnabled(false);
 629   controller().OnTapEvent();
 630   visible = true;
 631   ChangeInsertion(insertion_rect, visible);
 632   EXPECT_FALSE(GetAndResetNeedsAnimate());
 633 }
 634
 635 TEST_F(TouchSelectionControllerTest, TemporarilyHidden) {
 636   controller().OnTapEvent();
 637   controller().OnSelectionEditable(true);
 638
 639   gfx::RectF insertion_rect(5, 5, 0, 10);
 640
 641   bool visible = true;
 642   ChangeInsertion(insertion_rect, visible);
 643   EXPECT_FALSE(GetAndResetNeedsAnimate());
 644
 645   controller().SetTemporarilyHidden(true);
 646   EXPECT_TRUE(GetAndResetNeedsAnimate());
 647
 648   visible = false;
 649   ChangeInsertion(insertion_rect, visible);
 650   EXPECT_FALSE(GetAndResetNeedsAnimate());
 651
 652   visible = true;
 653   ChangeInsertion(insertion_rect, visible);
 654   EXPECT_FALSE(GetAndResetNeedsAnimate());
 655
 656   controller().SetTemporarilyHidden(false);
 657   EXPECT_TRUE(GetAndResetNeedsAnimate());
 658 }
 659
 660 TEST_F(TouchSelectionControllerTest, SelectionClearOnTap) {
 661   gfx::RectF start_rect(5, 5, 0, 10);
 662   gfx::RectF end_rect(50, 5, 0, 10);
 663   bool visible = true;
 664
 665   controller().OnLongPressEvent();
 666   ChangeSelection(start_rect, visible, end_rect, visible);
 667
 668   // Selection should not be cleared if the selection bounds have not changed.
 669   controller().OnTapEvent();
 670   EXPECT_EQ(SELECTION_SHOWN, GetLastEventType());
 671   EXPECT_EQ(start_rect.bottom_left(), GetLastEventAnchor());
 672
 673   controller().OnTapEvent();
 674   ClearSelection();
 675   EXPECT_EQ(SELECTION_CLEARED, GetLastEventType());
 676   EXPECT_EQ(gfx::PointF(), GetLastEventAnchor());
 677 }
 678
 679 }  // namespace content