Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1040)

Side by Side Diff: ui/touch_selection/touch_selection_controller_unittest.cc

Issue 1239583003: Update touch selection notification names, add ESTABLISHED. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Changed boolean member to track SELECTION_ESTABLISHED instead of DISSOLVED. Created 5 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "ui/touch_selection/touch_selection_controller.h" 5 #include "ui/touch_selection/touch_selection_controller.h"
6 6
7 #include <vector> 7 #include <vector>
8 8
9 #include "testing/gmock/include/gmock/gmock.h" 9 #include "testing/gmock/include/gmock/gmock.h"
10 #include "testing/gtest/include/gtest/gtest.h" 10 #include "testing/gtest/include/gtest/gtest.h"
(...skipping 235 matching lines...) Expand 10 before | Expand all | Expand 10 after
246 bool dragging_enabled_; 246 bool dragging_enabled_;
247 scoped_ptr<TouchSelectionController> controller_; 247 scoped_ptr<TouchSelectionController> controller_;
248 248
249 DISALLOW_COPY_AND_ASSIGN(TouchSelectionControllerTest); 249 DISALLOW_COPY_AND_ASSIGN(TouchSelectionControllerTest);
250 }; 250 };
251 251
252 TEST_F(TouchSelectionControllerTest, InsertionBasic) { 252 TEST_F(TouchSelectionControllerTest, InsertionBasic) {
253 gfx::RectF insertion_rect(5, 5, 0, 10); 253 gfx::RectF insertion_rect(5, 5, 0, 10);
254 bool visible = true; 254 bool visible = true;
255 255
256 // Insertion events are ignored until automatic showing is enabled. 256 // Insertion handles are not shown until automatic showing is enabled.
257 ChangeInsertion(insertion_rect, visible);
258 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_ESTABLISHED));
259 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
260 OnTapEvent();
261
262 // Insertion handles are not shown until the selection region is
263 // marked editable.
257 ChangeInsertion(insertion_rect, visible); 264 ChangeInsertion(insertion_rect, visible);
258 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 265 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
259 EXPECT_EQ(gfx::PointF(), GetLastEventStart()); 266 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
260 OnTapEvent();
261
262 // Insertion events are ignored until the selection region is marked editable.
263 ChangeInsertion(insertion_rect, visible);
264 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
265 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
266 267
267 OnTapEvent(); 268 OnTapEvent();
268 controller().OnSelectionEditable(true); 269 controller().OnSelectionEditable(true);
269 ChangeInsertion(insertion_rect, visible); 270 ChangeInsertion(insertion_rect, visible);
270 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 271 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_SHOWN));
271 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 272 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
272 273
273 insertion_rect.Offset(1, 0); 274 insertion_rect.Offset(1, 0);
274 ChangeInsertion(insertion_rect, visible); 275 ChangeInsertion(insertion_rect, visible);
275 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_MOVED)); 276 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_MOVED));
276 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 277 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
277 278
278 insertion_rect.Offset(0, 1); 279 insertion_rect.Offset(0, 1);
279 ChangeInsertion(insertion_rect, visible); 280 ChangeInsertion(insertion_rect, visible);
280 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_MOVED)); 281 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_MOVED));
281 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 282 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
282 283
283 ClearInsertion(); 284 ClearInsertion();
284 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED)); 285 EXPECT_THAT(GetAndResetEvents(),
286 ElementsAre(SELECTION_DISSOLVED, INSERTION_HANDLE_CLEARED));
285 } 287 }
286 288
287 TEST_F(TouchSelectionControllerTest, InsertionClearedWhenNoLongerEditable) { 289 TEST_F(TouchSelectionControllerTest, InsertionClearedWhenNoLongerEditable) {
288 gfx::RectF insertion_rect(5, 5, 0, 10); 290 gfx::RectF insertion_rect(5, 5, 0, 10);
289 bool visible = true; 291 bool visible = true;
290 OnTapEvent(); 292 OnTapEvent();
291 controller().OnSelectionEditable(true); 293 controller().OnSelectionEditable(true);
292 294
293 ChangeInsertion(insertion_rect, visible); 295 ChangeInsertion(insertion_rect, visible);
294 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 296 EXPECT_THAT(GetAndResetEvents(),
297 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
295 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 298 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
296 299
297 controller().OnSelectionEditable(false); 300 controller().OnSelectionEditable(false);
298 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED)); 301 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_CLEARED));
299 } 302 }
300 303
301 TEST_F(TouchSelectionControllerTest, InsertionWithNoShowOnTapForEmptyEditable) { 304 TEST_F(TouchSelectionControllerTest, InsertionWithNoShowOnTapForEmptyEditable) {
302 gfx::RectF insertion_rect(5, 5, 0, 10); 305 gfx::RectF insertion_rect(5, 5, 0, 10);
303 bool visible = true; 306 bool visible = true;
304 controller().OnSelectionEditable(true); 307 controller().OnSelectionEditable(true);
305 308
306 // Taps on an empty editable region should be ignored if the controller is 309 // Taps on an empty editable region should be ignored if the controller is
307 // created with |show_on_tap_for_empty_editable| set to false. 310 // created with |show_on_tap_for_empty_editable| set to false.
308 OnTapEvent(); 311 OnTapEvent();
309 controller().OnSelectionEmpty(true); 312 controller().OnSelectionEmpty(true);
310 ChangeInsertion(insertion_rect, visible); 313 ChangeInsertion(insertion_rect, visible);
311 EXPECT_EQ(gfx::PointF(), GetLastEventStart()); 314 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
312 315
313 // Once the region becomes non-empty, taps should show the insertion handle. 316 // Once the region becomes non-empty, taps should show the insertion handle.
314 OnTapEvent(); 317 OnTapEvent();
315 controller().OnSelectionEmpty(false); 318 controller().OnSelectionEmpty(false);
316 ChangeInsertion(insertion_rect, visible); 319 ChangeInsertion(insertion_rect, visible);
317 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 320 EXPECT_THAT(GetAndResetEvents(),
321 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
318 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 322 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
319 323
320 // Reset the selection. 324 // Reset the selection.
321 controller().HideAndDisallowShowingAutomatically(); 325 controller().HideAndDisallowShowingAutomatically();
322 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED)); 326 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_CLEARED));
323 327
324 // Long-pressing should show the handle even if the editable region is empty. 328 // Long-pressing should show the handle even if the editable region is empty.
325 insertion_rect.Offset(2, -2); 329 insertion_rect.Offset(2, -2);
326 OnLongPressEvent(); 330 OnLongPressEvent();
327 controller().OnSelectionEmpty(true); 331 controller().OnSelectionEmpty(true);
328 ChangeInsertion(insertion_rect, visible); 332 ChangeInsertion(insertion_rect, visible);
329 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 333 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_SHOWN));
330 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 334 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
331 335
332 // Single Tap on an empty edit field should clear insertion handle. 336 // Single Tap on an empty edit field should clear insertion handle.
333 OnTapEvent(); 337 OnTapEvent();
334 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED)); 338 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_CLEARED));
335 } 339 }
336 340
337 TEST_F(TouchSelectionControllerTest, InsertionWithShowOnTapForEmptyEditable) { 341 TEST_F(TouchSelectionControllerTest, InsertionWithShowOnTapForEmptyEditable) {
338 AllowShowingOnTapForEmptyEditable(); 342 AllowShowingOnTapForEmptyEditable();
339 343
340 gfx::RectF insertion_rect(5, 5, 0, 10); 344 gfx::RectF insertion_rect(5, 5, 0, 10);
341 bool visible = true; 345 bool visible = true;
342 controller().OnSelectionEditable(true); 346 controller().OnSelectionEditable(true);
343 347
344 // Taps on an empty editable region should show the insertion handle if the 348 // Taps on an empty editable region should show the insertion handle if the
345 // controller is created with |show_on_tap_for_empty_editable| set to true. 349 // controller is created with |show_on_tap_for_empty_editable| set to true.
346 OnTapEvent(); 350 OnTapEvent();
347 controller().OnSelectionEmpty(true); 351 controller().OnSelectionEmpty(true);
348 ChangeInsertion(insertion_rect, visible); 352 ChangeInsertion(insertion_rect, visible);
349 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 353 EXPECT_THAT(GetAndResetEvents(),
354 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
350 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 355 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
351 356
352 // Additional taps should not hide the insertion handle in this case. 357 // Additional taps should not hide the insertion handle in this case.
353 OnTapEvent(); 358 OnTapEvent();
354 ChangeInsertion(insertion_rect, visible); 359 ChangeInsertion(insertion_rect, visible);
355 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 360 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
356 } 361 }
357 362
358 TEST_F(TouchSelectionControllerTest, InsertionAppearsAfterTapFollowingTyping) { 363 TEST_F(TouchSelectionControllerTest, InsertionAppearsAfterTapFollowingTyping) {
359 gfx::RectF insertion_rect(5, 5, 0, 10); 364 gfx::RectF insertion_rect(5, 5, 0, 10);
360 bool visible = true; 365 bool visible = true;
361 366
362 // Simulate the user tapping an empty text field. 367 // Simulate the user tapping an empty text field.
363 OnTapEvent(); 368 OnTapEvent();
364 controller().OnSelectionEditable(true); 369 controller().OnSelectionEditable(true);
365 controller().OnSelectionEmpty(true); 370 controller().OnSelectionEmpty(true);
366 ChangeInsertion(insertion_rect, visible); 371 ChangeInsertion(insertion_rect, visible);
367 EXPECT_EQ(gfx::PointF(), GetLastEventStart()); 372 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
368 373
369 // Simulate the cursor moving while a user is typing. 374 // Simulate the cursor moving while a user is typing.
370 insertion_rect.Offset(10, 0); 375 insertion_rect.Offset(10, 0);
371 controller().OnSelectionEmpty(false); 376 controller().OnSelectionEmpty(false);
372 ChangeInsertion(insertion_rect, visible); 377 ChangeInsertion(insertion_rect, visible);
373 EXPECT_EQ(gfx::PointF(), GetLastEventStart()); 378 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
374 379
375 // If the user taps the *same* position as the cursor at the end of the text 380 // If the user taps the *same* position as the cursor at the end of the text
376 // entry, the handle should appear. 381 // entry, the handle should appear.
377 OnTapEvent(); 382 OnTapEvent();
378 ChangeInsertion(insertion_rect, visible); 383 ChangeInsertion(insertion_rect, visible);
379 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 384 EXPECT_THAT(GetAndResetEvents(),
385 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
380 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 386 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
381 } 387 }
382 388
383 TEST_F(TouchSelectionControllerTest, InsertionToSelectionTransition) { 389 TEST_F(TouchSelectionControllerTest, InsertionToSelectionTransition) {
384 OnLongPressEvent(); 390 OnLongPressEvent();
385 controller().OnSelectionEditable(true); 391 controller().OnSelectionEditable(true);
386 392
387 gfx::RectF start_rect(5, 5, 0, 10); 393 gfx::RectF start_rect(5, 5, 0, 10);
388 gfx::RectF end_rect(50, 5, 0, 10); 394 gfx::RectF end_rect(50, 5, 0, 10);
389 bool visible = true; 395 bool visible = true;
390 396
391 ChangeInsertion(start_rect, visible); 397 ChangeInsertion(start_rect, visible);
392 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 398 EXPECT_THAT(GetAndResetEvents(),
399 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
393 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 400 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
394 401
395 ChangeSelection(start_rect, visible, end_rect, visible); 402 ChangeSelection(start_rect, visible, end_rect, visible);
396 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED, 403 EXPECT_THAT(GetAndResetEvents(),
397 SELECTION_SHOWN)); 404 ElementsAre(INSERTION_HANDLE_CLEARED, SELECTION_HANDLES_SHOWN));
398 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 405 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
399 406
400 ChangeInsertion(end_rect, visible); 407 ChangeInsertion(end_rect, visible);
401 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED, 408 EXPECT_THAT(GetAndResetEvents(),
402 INSERTION_SHOWN)); 409 ElementsAre(SELECTION_HANDLES_CLEARED, INSERTION_HANDLE_SHOWN));
403 EXPECT_EQ(end_rect.bottom_left(), GetLastEventStart()); 410 EXPECT_EQ(end_rect.bottom_left(), GetLastEventStart());
404 411
405 controller().HideAndDisallowShowingAutomatically(); 412 controller().HideAndDisallowShowingAutomatically();
406 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED)); 413 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_CLEARED));
407 414
408 OnTapEvent(); 415 OnTapEvent();
409 ChangeInsertion(end_rect, visible); 416 ChangeInsertion(end_rect, visible);
410 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 417 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_SHOWN));
411 EXPECT_EQ(end_rect.bottom_left(), GetLastEventStart()); 418 EXPECT_EQ(end_rect.bottom_left(), GetLastEventStart());
412 } 419 }
413 420
414 TEST_F(TouchSelectionControllerTest, InsertionDragged) { 421 TEST_F(TouchSelectionControllerTest, InsertionDragged) {
415 base::TimeTicks event_time = base::TimeTicks::Now(); 422 base::TimeTicks event_time = base::TimeTicks::Now();
416 OnTapEvent(); 423 OnTapEvent();
417 controller().OnSelectionEditable(true); 424 controller().OnSelectionEditable(true);
418 425
419 // The touch sequence should not be handled if insertion is not active. 426 // The touch sequence should not be handled if insertion is not active.
420 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); 427 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
421 EXPECT_FALSE(controller().WillHandleTouchEvent(event)); 428 EXPECT_FALSE(controller().WillHandleTouchEvent(event));
422 429
423 float line_height = 10.f; 430 float line_height = 10.f;
424 gfx::RectF start_rect(10, 0, 0, line_height); 431 gfx::RectF start_rect(10, 0, 0, line_height);
425 bool visible = true; 432 bool visible = true;
426 ChangeInsertion(start_rect, visible); 433 ChangeInsertion(start_rect, visible);
427 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 434 EXPECT_THAT(GetAndResetEvents(),
435 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
428 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 436 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
429 437
430 // The touch sequence should be handled only if the drawable reports a hit. 438 // The touch sequence should be handled only if the drawable reports a hit.
431 EXPECT_FALSE(controller().WillHandleTouchEvent(event)); 439 EXPECT_FALSE(controller().WillHandleTouchEvent(event));
432 SetDraggingEnabled(true); 440 SetDraggingEnabled(true);
433 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 441 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
434 EXPECT_FALSE(GetAndResetCaretMoved()); 442 EXPECT_FALSE(GetAndResetCaretMoved());
435 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STARTED)); 443 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED));
436 444
437 // The MoveCaret() result should reflect the movement. 445 // The MoveCaret() result should reflect the movement.
438 // The reported position is offset from the center of |start_rect|. 446 // The reported position is offset from the center of |start_rect|.
439 gfx::PointF start_offset = start_rect.CenterPoint(); 447 gfx::PointF start_offset = start_rect.CenterPoint();
440 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 5); 448 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 5);
441 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 449 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
442 EXPECT_TRUE(GetAndResetCaretMoved()); 450 EXPECT_TRUE(GetAndResetCaretMoved());
443 EXPECT_EQ(start_offset + gfx::Vector2dF(0, 5), GetLastCaretPosition()); 451 EXPECT_EQ(start_offset + gfx::Vector2dF(0, 5), GetLastCaretPosition());
444 452
445 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 5, 5); 453 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 5, 5);
446 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 454 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
447 EXPECT_TRUE(GetAndResetCaretMoved()); 455 EXPECT_TRUE(GetAndResetCaretMoved());
448 EXPECT_EQ(start_offset + gfx::Vector2dF(5, 5), GetLastCaretPosition()); 456 EXPECT_EQ(start_offset + gfx::Vector2dF(5, 5), GetLastCaretPosition());
449 457
450 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 10, 10); 458 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 10, 10);
451 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 459 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
452 EXPECT_TRUE(GetAndResetCaretMoved()); 460 EXPECT_TRUE(GetAndResetCaretMoved());
453 EXPECT_EQ(start_offset + gfx::Vector2dF(10, 10), GetLastCaretPosition()); 461 EXPECT_EQ(start_offset + gfx::Vector2dF(10, 10), GetLastCaretPosition());
454 462
455 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5); 463 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
456 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 464 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
457 EXPECT_FALSE(GetAndResetCaretMoved()); 465 EXPECT_FALSE(GetAndResetCaretMoved());
458 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STOPPED)); 466 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STOPPED));
459 467
460 // Once the drag is complete, no more touch events should be consumed until 468 // Once the drag is complete, no more touch events should be consumed until
461 // the next ACTION_DOWN. 469 // the next ACTION_DOWN.
462 EXPECT_FALSE(controller().WillHandleTouchEvent(event)); 470 EXPECT_FALSE(controller().WillHandleTouchEvent(event));
463 } 471 }
464 472
465 TEST_F(TouchSelectionControllerTest, InsertionTapped) { 473 TEST_F(TouchSelectionControllerTest, InsertionTapped) {
466 base::TimeTicks event_time = base::TimeTicks::Now(); 474 base::TimeTicks event_time = base::TimeTicks::Now();
467 OnTapEvent(); 475 OnTapEvent();
468 controller().OnSelectionEditable(true); 476 controller().OnSelectionEditable(true);
469 SetDraggingEnabled(true); 477 SetDraggingEnabled(true);
470 478
471 gfx::RectF start_rect(10, 0, 0, 10); 479 gfx::RectF start_rect(10, 0, 0, 10);
472 bool visible = true; 480 bool visible = true;
473 ChangeInsertion(start_rect, visible); 481 ChangeInsertion(start_rect, visible);
474 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 482 EXPECT_THAT(GetAndResetEvents(),
483 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
475 484
476 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); 485 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
477 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 486 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
478 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STARTED)); 487 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED));
479 488
480 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0); 489 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
481 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 490 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
482 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_TAPPED, 491 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_TAPPED,
483 INSERTION_DRAG_STOPPED)); 492 INSERTION_HANDLE_DRAG_STOPPED));
484 493
485 // Reset the insertion. 494 // Reset the insertion.
486 ClearInsertion(); 495 ClearInsertion();
487 OnTapEvent(); 496 OnTapEvent();
488 ChangeInsertion(start_rect, visible); 497 ChangeInsertion(start_rect, visible);
489 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED, 498 EXPECT_THAT(GetAndResetEvents(),
490 INSERTION_SHOWN)); 499 ElementsAre(SELECTION_DISSOLVED, INSERTION_HANDLE_CLEARED,
500 SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
491 501
492 // No tap should be signalled if the time between DOWN and UP was too long. 502 // No tap should be signalled if the time between DOWN and UP was too long.
493 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); 503 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
494 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 504 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
495 event = MockMotionEvent(MockMotionEvent::ACTION_UP, 505 event = MockMotionEvent(MockMotionEvent::ACTION_UP,
496 event_time + base::TimeDelta::FromSeconds(1), 506 event_time + base::TimeDelta::FromSeconds(1),
497 0, 507 0,
498 0); 508 0);
499 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 509 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
500 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STARTED, 510 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED,
501 INSERTION_DRAG_STOPPED)); 511 INSERTION_HANDLE_DRAG_STOPPED));
502 512
503 // Reset the insertion. 513 // Reset the insertion.
504 ClearInsertion(); 514 ClearInsertion();
505 OnTapEvent(); 515 OnTapEvent();
506 ChangeInsertion(start_rect, visible); 516 ChangeInsertion(start_rect, visible);
507 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED, 517 EXPECT_THAT(GetAndResetEvents(),
508 INSERTION_SHOWN)); 518 ElementsAre(SELECTION_DISSOLVED, INSERTION_HANDLE_CLEARED,
519 SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
509 520
510 // No tap should be signalled if the drag was too long. 521 // No tap should be signalled if the drag was too long.
511 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); 522 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
512 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 523 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
513 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 100, 0); 524 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 100, 0);
514 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 525 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
515 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 100, 0); 526 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 100, 0);
516 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 527 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
517 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STARTED, 528 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED,
518 INSERTION_DRAG_STOPPED)); 529 INSERTION_HANDLE_DRAG_STOPPED));
519 530
520 // Reset the insertion. 531 // Reset the insertion.
521 ClearInsertion(); 532 ClearInsertion();
522 OnTapEvent(); 533 OnTapEvent();
523 ChangeInsertion(start_rect, visible); 534 ChangeInsertion(start_rect, visible);
524 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_CLEARED, 535 EXPECT_THAT(GetAndResetEvents(),
525 INSERTION_SHOWN)); 536 ElementsAre(SELECTION_DISSOLVED, INSERTION_HANDLE_CLEARED,
537 SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
526 538
527 // No tap should be signalled if the touch sequence is cancelled. 539 // No tap should be signalled if the touch sequence is cancelled.
528 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); 540 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
529 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 541 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
530 event = MockMotionEvent(MockMotionEvent::ACTION_CANCEL, event_time, 0, 0); 542 event = MockMotionEvent(MockMotionEvent::ACTION_CANCEL, event_time, 0, 0);
531 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 543 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
532 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STARTED, 544 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED,
533 INSERTION_DRAG_STOPPED)); 545 INSERTION_HANDLE_DRAG_STOPPED));
534 } 546 }
535 547
536 TEST_F(TouchSelectionControllerTest, InsertionNotResetByRepeatedTapOrPress) { 548 TEST_F(TouchSelectionControllerTest, InsertionNotResetByRepeatedTapOrPress) {
537 base::TimeTicks event_time = base::TimeTicks::Now(); 549 base::TimeTicks event_time = base::TimeTicks::Now();
538 OnTapEvent(); 550 OnTapEvent();
539 controller().OnSelectionEditable(true); 551 controller().OnSelectionEditable(true);
540 SetDraggingEnabled(true); 552 SetDraggingEnabled(true);
541 553
542 gfx::RectF anchor_rect(10, 0, 0, 10); 554 gfx::RectF anchor_rect(10, 0, 0, 10);
543 bool visible = true; 555 bool visible = true;
544 ChangeInsertion(anchor_rect, visible); 556 ChangeInsertion(anchor_rect, visible);
545 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 557 EXPECT_THAT(GetAndResetEvents(),
558 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
546 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); 559 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
547 560
548 // Tapping again shouldn't reset the active insertion point. 561 // Tapping again shouldn't reset the active insertion point.
549 OnTapEvent(); 562 OnTapEvent();
550 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); 563 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
551 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 564 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
552 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STARTED)); 565 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED));
553 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); 566 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
554 567
555 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0); 568 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
556 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 569 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
557 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_TAPPED, 570 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_TAPPED,
558 INSERTION_DRAG_STOPPED)); 571 INSERTION_HANDLE_DRAG_STOPPED));
559 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); 572 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
560 573
561 anchor_rect.Offset(5, 15); 574 anchor_rect.Offset(5, 15);
562 ChangeInsertion(anchor_rect, visible); 575 ChangeInsertion(anchor_rect, visible);
563 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_MOVED)); 576 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_MOVED));
564 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); 577 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
565 578
566 // Pressing shouldn't reset the active insertion point. 579 // Pressing shouldn't reset the active insertion point.
567 OnLongPressEvent(); 580 OnLongPressEvent();
568 controller().OnSelectionEmpty(true); 581 controller().OnSelectionEmpty(true);
569 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); 582 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
570 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 583 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
571 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_DRAG_STARTED)); 584 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_DRAG_STARTED));
572 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); 585 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
573 586
574 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0); 587 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
575 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 588 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
576 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_TAPPED, 589 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_HANDLE_TAPPED,
577 INSERTION_DRAG_STOPPED)); 590 INSERTION_HANDLE_DRAG_STOPPED));
578 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart()); 591 EXPECT_EQ(anchor_rect.bottom_left(), GetLastEventStart());
579 } 592 }
580 593
581 TEST_F(TouchSelectionControllerTest, SelectionBasic) { 594 TEST_F(TouchSelectionControllerTest, SelectionBasic) {
582 gfx::RectF start_rect(5, 5, 0, 10); 595 gfx::RectF start_rect(5, 5, 0, 10);
583 gfx::RectF end_rect(50, 5, 0, 10); 596 gfx::RectF end_rect(50, 5, 0, 10);
584 bool visible = true; 597 bool visible = true;
585 598
586 // Selection events are ignored until automatic showing is enabled. 599 // Selection events are ignored until automatic showing is enabled.
587 ChangeSelection(start_rect, visible, end_rect, visible); 600 ChangeSelection(start_rect, visible, end_rect, visible);
588 EXPECT_EQ(gfx::PointF(), GetLastEventStart()); 601 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
589 602
590 OnLongPressEvent(); 603 OnLongPressEvent();
591 ChangeSelection(start_rect, visible, end_rect, visible); 604 ChangeSelection(start_rect, visible, end_rect, visible);
592 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 605 EXPECT_THAT(GetAndResetEvents(),
606 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
593 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 607 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
594 608
595 start_rect.Offset(1, 0); 609 start_rect.Offset(1, 0);
596 ChangeSelection(start_rect, visible, end_rect, visible); 610 ChangeSelection(start_rect, visible, end_rect, visible);
597 // Selection movement does not currently trigger a separate event. 611 // Selection movement does not currently trigger a separate event.
598 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 612 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
599 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 613 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
600 EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd()); 614 EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd());
601 615
602 ClearSelection(); 616 ClearSelection();
603 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED)); 617 EXPECT_THAT(GetAndResetEvents(),
618 ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_CLEARED));
604 EXPECT_EQ(gfx::PointF(), GetLastEventStart()); 619 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
605 } 620 }
606 621
607 TEST_F(TouchSelectionControllerTest, SelectionAllowsEmptyUpdateAfterLongPress) { 622 TEST_F(TouchSelectionControllerTest, SelectionAllowsEmptyUpdateAfterLongPress) {
608 gfx::RectF start_rect(5, 5, 0, 10); 623 gfx::RectF start_rect(5, 5, 0, 10);
609 gfx::RectF end_rect(50, 5, 0, 10); 624 gfx::RectF end_rect(50, 5, 0, 10);
610 bool visible = true; 625 bool visible = true;
611 626
612 OnLongPressEvent(); 627 OnLongPressEvent();
613 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 628 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
614 629
615 // There may be several empty updates after a longpress due to the 630 // There may be several empty updates after a longpress due to the
616 // asynchronous response. These empty updates should not prevent the selection 631 // asynchronous response. These empty updates should not prevent the selection
617 // handles from (eventually) activating. 632 // handles from (eventually) activating.
618 ClearSelection(); 633 ClearSelection();
619 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 634 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
620 635
621 ClearSelection(); 636 ClearSelection();
622 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 637 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
623 638
624 ChangeSelection(start_rect, visible, end_rect, visible); 639 ChangeSelection(start_rect, visible, end_rect, visible);
625 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 640 EXPECT_THAT(GetAndResetEvents(),
641 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
626 } 642 }
627 643
628 TEST_F(TouchSelectionControllerTest, SelectionRepeatedLongPress) { 644 TEST_F(TouchSelectionControllerTest, SelectionRepeatedLongPress) {
629 gfx::RectF start_rect(5, 5, 0, 10); 645 gfx::RectF start_rect(5, 5, 0, 10);
630 gfx::RectF end_rect(50, 5, 0, 10); 646 gfx::RectF end_rect(50, 5, 0, 10);
631 bool visible = true; 647 bool visible = true;
632 648
633 OnLongPressEvent(); 649 OnLongPressEvent();
634 ChangeSelection(start_rect, visible, end_rect, visible); 650 ChangeSelection(start_rect, visible, end_rect, visible);
635 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 651 EXPECT_THAT(GetAndResetEvents(),
652 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
636 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 653 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
637 EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd()); 654 EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd());
638 655
639 // A long press triggering a new selection should re-send the SELECTION_SHOWN 656 // A long press triggering a new selection should re-send the
657 // SELECTION_HANDLES_SHOWN
640 // event notification. 658 // event notification.
641 start_rect.Offset(10, 10); 659 start_rect.Offset(10, 10);
642 OnLongPressEvent(); 660 OnLongPressEvent();
643 ChangeSelection(start_rect, visible, end_rect, visible); 661 ChangeSelection(start_rect, visible, end_rect, visible);
644 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 662 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_SHOWN));
645 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 663 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
646 EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd()); 664 EXPECT_EQ(end_rect.bottom_left(), GetLastEventEnd());
647 } 665 }
648 666
649 TEST_F(TouchSelectionControllerTest, SelectionDragged) { 667 TEST_F(TouchSelectionControllerTest, SelectionDragged) {
650 base::TimeTicks event_time = base::TimeTicks::Now(); 668 base::TimeTicks event_time = base::TimeTicks::Now();
651 OnLongPressEvent(); 669 OnLongPressEvent();
652 670
653 // The touch sequence should not be handled if selection is not active. 671 // The touch sequence should not be handled if selection is not active.
654 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0); 672 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 0, 0);
655 EXPECT_FALSE(controller().WillHandleTouchEvent(event)); 673 EXPECT_FALSE(controller().WillHandleTouchEvent(event));
656 674
657 float line_height = 10.f; 675 float line_height = 10.f;
658 gfx::RectF start_rect(0, 0, 0, line_height); 676 gfx::RectF start_rect(0, 0, 0, line_height);
659 gfx::RectF end_rect(50, 0, 0, line_height); 677 gfx::RectF end_rect(50, 0, 0, line_height);
660 bool visible = true; 678 bool visible = true;
661 ChangeSelection(start_rect, visible, end_rect, visible); 679 ChangeSelection(start_rect, visible, end_rect, visible);
662 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 680 EXPECT_THAT(GetAndResetEvents(),
681 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
663 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 682 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
664 683
665 // The touch sequence should be handled only if the drawable reports a hit. 684 // The touch sequence should be handled only if the drawable reports a hit.
666 EXPECT_FALSE(controller().WillHandleTouchEvent(event)); 685 EXPECT_FALSE(controller().WillHandleTouchEvent(event));
667 SetDraggingEnabled(true); 686 SetDraggingEnabled(true);
668 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 687 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
669 EXPECT_FALSE(GetAndResetSelectionMoved()); 688 EXPECT_FALSE(GetAndResetSelectionMoved());
670 689
671 // The SelectBetweenCoordinates() result should reflect the movement. Note 690 // The SelectBetweenCoordinates() result should reflect the movement. Note
672 // that the start coordinate will always reflect the "fixed" handle's 691 // that the start coordinate will always reflect the "fixed" handle's
673 // position, in this case the position from |end_rect|. 692 // position, in this case the position from |end_rect|.
674 // Note that the reported position is offset from the center of the 693 // Note that the reported position is offset from the center of the
675 // input rects (i.e., the middle of the corresponding text line). 694 // input rects (i.e., the middle of the corresponding text line).
676 gfx::PointF fixed_offset = end_rect.CenterPoint(); 695 gfx::PointF fixed_offset = end_rect.CenterPoint();
677 gfx::PointF start_offset = start_rect.CenterPoint(); 696 gfx::PointF start_offset = start_rect.CenterPoint();
678 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 5); 697 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 5);
679 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 698 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
680 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED)); 699 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED));
681 EXPECT_TRUE(GetAndResetSelectionMoved()); 700 EXPECT_TRUE(GetAndResetSelectionMoved());
682 EXPECT_EQ(fixed_offset, GetLastSelectionStart()); 701 EXPECT_EQ(fixed_offset, GetLastSelectionStart());
683 EXPECT_EQ(start_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd()); 702 EXPECT_EQ(start_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd());
684 703
685 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 5, 5); 704 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 5, 5);
686 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 705 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
687 EXPECT_TRUE(GetAndResetSelectionMoved()); 706 EXPECT_TRUE(GetAndResetSelectionMoved());
688 EXPECT_EQ(fixed_offset, GetLastSelectionStart()); 707 EXPECT_EQ(fixed_offset, GetLastSelectionStart());
689 EXPECT_EQ(start_offset + gfx::Vector2dF(5, 5), GetLastSelectionEnd()); 708 EXPECT_EQ(start_offset + gfx::Vector2dF(5, 5), GetLastSelectionEnd());
690 709
691 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 10, 5); 710 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 10, 5);
692 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 711 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
693 EXPECT_TRUE(GetAndResetSelectionMoved()); 712 EXPECT_TRUE(GetAndResetSelectionMoved());
694 EXPECT_EQ(fixed_offset, GetLastSelectionStart()); 713 EXPECT_EQ(fixed_offset, GetLastSelectionStart());
695 EXPECT_EQ(start_offset + gfx::Vector2dF(10, 5), GetLastSelectionEnd()); 714 EXPECT_EQ(start_offset + gfx::Vector2dF(10, 5), GetLastSelectionEnd());
696 715
697 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5); 716 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
698 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 717 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
699 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED)); 718 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED));
700 EXPECT_FALSE(GetAndResetSelectionMoved()); 719 EXPECT_FALSE(GetAndResetSelectionMoved());
701 720
702 // Once the drag is complete, no more touch events should be consumed until 721 // Once the drag is complete, no more touch events should be consumed until
703 // the next ACTION_DOWN. 722 // the next ACTION_DOWN.
704 EXPECT_FALSE(controller().WillHandleTouchEvent(event)); 723 EXPECT_FALSE(controller().WillHandleTouchEvent(event));
705 } 724 }
706 725
707 TEST_F(TouchSelectionControllerTest, SelectionDraggedWithOverlap) { 726 TEST_F(TouchSelectionControllerTest, SelectionDraggedWithOverlap) {
708 base::TimeTicks event_time = base::TimeTicks::Now(); 727 base::TimeTicks event_time = base::TimeTicks::Now();
709 OnLongPressEvent(); 728 OnLongPressEvent();
710 729
711 float line_height = 10.f; 730 float line_height = 10.f;
712 gfx::RectF start_rect(0, 0, 0, line_height); 731 gfx::RectF start_rect(0, 0, 0, line_height);
713 gfx::RectF end_rect(50, 0, 0, line_height); 732 gfx::RectF end_rect(50, 0, 0, line_height);
714 bool visible = true; 733 bool visible = true;
715 ChangeSelection(start_rect, visible, end_rect, visible); 734 ChangeSelection(start_rect, visible, end_rect, visible);
716 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 735 EXPECT_THAT(GetAndResetEvents(),
736 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
717 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 737 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
718 738
719 // The ACTION_DOWN should lock to the closest handle. 739 // The ACTION_DOWN should lock to the closest handle.
720 gfx::PointF end_offset = end_rect.CenterPoint(); 740 gfx::PointF end_offset = end_rect.CenterPoint();
721 gfx::PointF fixed_offset = start_rect.CenterPoint(); 741 gfx::PointF fixed_offset = start_rect.CenterPoint();
722 float touch_down_x = (end_offset.x() + fixed_offset.x()) / 2 + 1.f; 742 float touch_down_x = (end_offset.x() + fixed_offset.x()) / 2 + 1.f;
723 MockMotionEvent event( 743 MockMotionEvent event(
724 MockMotionEvent::ACTION_DOWN, event_time, touch_down_x, 0); 744 MockMotionEvent::ACTION_DOWN, event_time, touch_down_x, 0);
725 SetDraggingEnabled(true); 745 SetDraggingEnabled(true);
726 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 746 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
727 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED)); 747 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED));
728 EXPECT_FALSE(GetAndResetSelectionMoved()); 748 EXPECT_FALSE(GetAndResetSelectionMoved());
729 749
730 // Even though the ACTION_MOVE is over the start handle, it should continue 750 // Even though the ACTION_MOVE is over the start handle, it should continue
731 // targetting the end handle that consumed the ACTION_DOWN. 751 // targetting the end handle that consumed the ACTION_DOWN.
732 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 0); 752 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 0, 0);
733 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 753 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
734 EXPECT_TRUE(GetAndResetSelectionMoved()); 754 EXPECT_TRUE(GetAndResetSelectionMoved());
735 EXPECT_EQ(fixed_offset, GetLastSelectionStart()); 755 EXPECT_EQ(fixed_offset, GetLastSelectionStart());
736 EXPECT_EQ(end_offset - gfx::Vector2dF(touch_down_x, 0), 756 EXPECT_EQ(end_offset - gfx::Vector2dF(touch_down_x, 0),
737 GetLastSelectionEnd()); 757 GetLastSelectionEnd());
738 758
739 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0); 759 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 0, 0);
740 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 760 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
741 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED)); 761 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED));
742 EXPECT_FALSE(GetAndResetSelectionMoved()); 762 EXPECT_FALSE(GetAndResetSelectionMoved());
743 } 763 }
744 764
745 TEST_F(TouchSelectionControllerTest, SelectionDraggedToSwitchBaseAndExtent) { 765 TEST_F(TouchSelectionControllerTest, SelectionDraggedToSwitchBaseAndExtent) {
746 base::TimeTicks event_time = base::TimeTicks::Now(); 766 base::TimeTicks event_time = base::TimeTicks::Now();
747 OnLongPressEvent(); 767 OnLongPressEvent();
748 768
749 float line_height = 10.f; 769 float line_height = 10.f;
750 gfx::RectF start_rect(50, line_height, 0, line_height); 770 gfx::RectF start_rect(50, line_height, 0, line_height);
751 gfx::RectF end_rect(100, line_height, 0, line_height); 771 gfx::RectF end_rect(100, line_height, 0, line_height);
752 bool visible = true; 772 bool visible = true;
753 ChangeSelection(start_rect, visible, end_rect, visible); 773 ChangeSelection(start_rect, visible, end_rect, visible);
754 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 774 EXPECT_THAT(GetAndResetEvents(),
775 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
755 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 776 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
756 777
757 SetDraggingEnabled(true); 778 SetDraggingEnabled(true);
758 779
759 // Move the extent, not triggering a swap of points. 780 // Move the extent, not triggering a swap of points.
760 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 781 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time,
761 end_rect.x(), end_rect.bottom()); 782 end_rect.x(), end_rect.bottom());
762 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 783 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
763 EXPECT_FALSE(GetAndResetSelectionMoved()); 784 EXPECT_FALSE(GetAndResetSelectionMoved());
764 EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); 785 EXPECT_FALSE(GetAndResetSelectionPointsSwapped());
765 786
766 gfx::PointF base_offset = start_rect.CenterPoint(); 787 gfx::PointF base_offset = start_rect.CenterPoint();
767 gfx::PointF extent_offset = end_rect.CenterPoint(); 788 gfx::PointF extent_offset = end_rect.CenterPoint();
768 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 789 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time,
769 end_rect.x(), end_rect.bottom() + 5); 790 end_rect.x(), end_rect.bottom() + 5);
770 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 791 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
771 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED)); 792 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED));
772 EXPECT_TRUE(GetAndResetSelectionMoved()); 793 EXPECT_TRUE(GetAndResetSelectionMoved());
773 EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); 794 EXPECT_FALSE(GetAndResetSelectionPointsSwapped());
774 EXPECT_EQ(base_offset, GetLastSelectionStart()); 795 EXPECT_EQ(base_offset, GetLastSelectionStart());
775 EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd()); 796 EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd());
776 797
777 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5); 798 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
778 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 799 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
779 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED)); 800 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED));
780 EXPECT_FALSE(GetAndResetSelectionMoved()); 801 EXPECT_FALSE(GetAndResetSelectionMoved());
781 802
782 end_rect += gfx::Vector2dF(0, 5); 803 end_rect += gfx::Vector2dF(0, 5);
783 ChangeSelection(start_rect, visible, end_rect, visible); 804 ChangeSelection(start_rect, visible, end_rect, visible);
784 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 805 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
785 806
786 // Move the base, triggering a swap of points. 807 // Move the base, triggering a swap of points.
787 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 808 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time,
788 start_rect.x(), start_rect.bottom()); 809 start_rect.x(), start_rect.bottom());
789 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 810 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
790 EXPECT_FALSE(GetAndResetSelectionMoved()); 811 EXPECT_FALSE(GetAndResetSelectionMoved());
791 EXPECT_TRUE(GetAndResetSelectionPointsSwapped()); 812 EXPECT_TRUE(GetAndResetSelectionPointsSwapped());
792 813
793 base_offset = end_rect.CenterPoint(); 814 base_offset = end_rect.CenterPoint();
794 extent_offset = start_rect.CenterPoint(); 815 extent_offset = start_rect.CenterPoint();
795 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 816 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time,
796 start_rect.x(), start_rect.bottom() + 5); 817 start_rect.x(), start_rect.bottom() + 5);
797 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 818 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
798 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED)); 819 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED));
799 EXPECT_TRUE(GetAndResetSelectionMoved()); 820 EXPECT_TRUE(GetAndResetSelectionMoved());
800 EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); 821 EXPECT_FALSE(GetAndResetSelectionPointsSwapped());
801 EXPECT_EQ(base_offset, GetLastSelectionStart()); 822 EXPECT_EQ(base_offset, GetLastSelectionStart());
802 EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd()); 823 EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd());
803 824
804 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5); 825 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
805 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 826 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
806 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED)); 827 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED));
807 EXPECT_FALSE(GetAndResetSelectionMoved()); 828 EXPECT_FALSE(GetAndResetSelectionMoved());
808 829
809 start_rect += gfx::Vector2dF(0, 5); 830 start_rect += gfx::Vector2dF(0, 5);
810 ChangeSelection(start_rect, visible, end_rect, visible); 831 ChangeSelection(start_rect, visible, end_rect, visible);
811 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 832 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
812 833
813 // Move the same point again, not triggering a swap of points. 834 // Move the same point again, not triggering a swap of points.
814 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 835 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time,
815 start_rect.x(), start_rect.bottom()); 836 start_rect.x(), start_rect.bottom());
816 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 837 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
817 EXPECT_FALSE(GetAndResetSelectionMoved()); 838 EXPECT_FALSE(GetAndResetSelectionMoved());
818 EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); 839 EXPECT_FALSE(GetAndResetSelectionPointsSwapped());
819 840
820 base_offset = end_rect.CenterPoint(); 841 base_offset = end_rect.CenterPoint();
821 extent_offset = start_rect.CenterPoint(); 842 extent_offset = start_rect.CenterPoint();
822 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 843 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time,
823 start_rect.x(), start_rect.bottom() + 5); 844 start_rect.x(), start_rect.bottom() + 5);
824 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 845 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
825 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED)); 846 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED));
826 EXPECT_TRUE(GetAndResetSelectionMoved()); 847 EXPECT_TRUE(GetAndResetSelectionMoved());
827 EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); 848 EXPECT_FALSE(GetAndResetSelectionPointsSwapped());
828 EXPECT_EQ(base_offset, GetLastSelectionStart()); 849 EXPECT_EQ(base_offset, GetLastSelectionStart());
829 EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd()); 850 EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd());
830 851
831 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5); 852 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
832 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 853 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
833 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED)); 854 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED));
834 EXPECT_FALSE(GetAndResetSelectionMoved()); 855 EXPECT_FALSE(GetAndResetSelectionMoved());
835 856
836 start_rect += gfx::Vector2dF(0, 5); 857 start_rect += gfx::Vector2dF(0, 5);
837 ChangeSelection(start_rect, visible, end_rect, visible); 858 ChangeSelection(start_rect, visible, end_rect, visible);
838 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 859 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
839 860
840 // Move the base, triggering a swap of points. 861 // Move the base, triggering a swap of points.
841 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time, 862 event = MockMotionEvent(MockMotionEvent::ACTION_DOWN, event_time,
842 end_rect.x(), end_rect.bottom()); 863 end_rect.x(), end_rect.bottom());
843 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 864 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
844 EXPECT_FALSE(GetAndResetSelectionMoved()); 865 EXPECT_FALSE(GetAndResetSelectionMoved());
845 EXPECT_TRUE(GetAndResetSelectionPointsSwapped()); 866 EXPECT_TRUE(GetAndResetSelectionPointsSwapped());
846 867
847 base_offset = start_rect.CenterPoint(); 868 base_offset = start_rect.CenterPoint();
848 extent_offset = end_rect.CenterPoint(); 869 extent_offset = end_rect.CenterPoint();
849 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 870 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time,
850 end_rect.x(), end_rect.bottom() + 5); 871 end_rect.x(), end_rect.bottom() + 5);
851 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 872 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
852 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED)); 873 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED));
853 EXPECT_TRUE(GetAndResetSelectionMoved()); 874 EXPECT_TRUE(GetAndResetSelectionMoved());
854 EXPECT_FALSE(GetAndResetSelectionPointsSwapped()); 875 EXPECT_FALSE(GetAndResetSelectionPointsSwapped());
855 EXPECT_EQ(base_offset, GetLastSelectionStart()); 876 EXPECT_EQ(base_offset, GetLastSelectionStart());
856 EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd()); 877 EXPECT_EQ(extent_offset + gfx::Vector2dF(0, 5), GetLastSelectionEnd());
857 878
858 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5); 879 event = MockMotionEvent(MockMotionEvent::ACTION_UP, event_time, 10, 5);
859 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 880 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
860 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED)); 881 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED));
861 EXPECT_FALSE(GetAndResetSelectionMoved()); 882 EXPECT_FALSE(GetAndResetSelectionMoved());
862 } 883 }
863 884
864 TEST_F(TouchSelectionControllerTest, SelectionDragExtremeLineSize) { 885 TEST_F(TouchSelectionControllerTest, SelectionDragExtremeLineSize) {
865 base::TimeTicks event_time = base::TimeTicks::Now(); 886 base::TimeTicks event_time = base::TimeTicks::Now();
866 OnLongPressEvent(); 887 OnLongPressEvent();
867 888
868 float small_line_height = 1.f; 889 float small_line_height = 1.f;
869 float large_line_height = 50.f; 890 float large_line_height = 50.f;
870 gfx::RectF small_line_rect(0, 0, 0, small_line_height); 891 gfx::RectF small_line_rect(0, 0, 0, small_line_height);
871 gfx::RectF large_line_rect(50, 50, 0, large_line_height); 892 gfx::RectF large_line_rect(50, 50, 0, large_line_height);
872 bool visible = true; 893 bool visible = true;
873 ChangeSelection(small_line_rect, visible, large_line_rect, visible); 894 ChangeSelection(small_line_rect, visible, large_line_rect, visible);
874 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 895 EXPECT_THAT(GetAndResetEvents(),
896 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
875 EXPECT_EQ(small_line_rect.bottom_left(), GetLastEventStart()); 897 EXPECT_EQ(small_line_rect.bottom_left(), GetLastEventStart());
876 898
877 // Start dragging the handle on the small line. 899 // Start dragging the handle on the small line.
878 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time, 900 MockMotionEvent event(MockMotionEvent::ACTION_DOWN, event_time,
879 small_line_rect.x(), small_line_rect.y()); 901 small_line_rect.x(), small_line_rect.y());
880 SetDraggingEnabled(true); 902 SetDraggingEnabled(true);
881 EXPECT_TRUE(controller().WillHandleTouchEvent(event)); 903 EXPECT_TRUE(controller().WillHandleTouchEvent(event));
882 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED)); 904 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED));
883 // The drag coordinate for large lines should be capped to a reasonable 905 // The drag coordinate for large lines should be capped to a reasonable
884 // offset, allowing seamless transition to neighboring lines with different 906 // offset, allowing seamless transition to neighboring lines with different
885 // sizes. The drag coordinate for small lines should have an offset 907 // sizes. The drag coordinate for small lines should have an offset
886 // commensurate with the small line size. 908 // commensurate with the small line size.
887 EXPECT_EQ(large_line_rect.bottom_left() - gfx::Vector2dF(0, 8.f), 909 EXPECT_EQ(large_line_rect.bottom_left() - gfx::Vector2dF(0, 8.f),
888 GetLastSelectionStart()); 910 GetLastSelectionStart());
889 EXPECT_EQ(small_line_rect.CenterPoint(), GetLastSelectionEnd()); 911 EXPECT_EQ(small_line_rect.CenterPoint(), GetLastSelectionEnd());
890 912
891 small_line_rect += gfx::Vector2dF(25.f, 0); 913 small_line_rect += gfx::Vector2dF(25.f, 0);
892 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time, 914 event = MockMotionEvent(MockMotionEvent::ACTION_MOVE, event_time,
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
960 EXPECT_TRUE(test_controller.GetStartVisible()); 982 EXPECT_TRUE(test_controller.GetStartVisible());
961 } 983 }
962 984
963 TEST_F(TouchSelectionControllerTest, SelectionClearOnTap) { 985 TEST_F(TouchSelectionControllerTest, SelectionClearOnTap) {
964 gfx::RectF start_rect(5, 5, 0, 10); 986 gfx::RectF start_rect(5, 5, 0, 10);
965 gfx::RectF end_rect(50, 5, 0, 10); 987 gfx::RectF end_rect(50, 5, 0, 10);
966 bool visible = true; 988 bool visible = true;
967 989
968 OnLongPressEvent(); 990 OnLongPressEvent();
969 ChangeSelection(start_rect, visible, end_rect, visible); 991 ChangeSelection(start_rect, visible, end_rect, visible);
970 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 992 EXPECT_THAT(GetAndResetEvents(),
993 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
971 994
972 // Selection should not be cleared if the selection bounds have not changed. 995 // Selection should not be cleared if the selection bounds have not changed.
973 OnTapEvent(); 996 OnTapEvent();
974 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 997 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
975 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 998 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
976 999
977 OnTapEvent(); 1000 OnTapEvent();
978 ClearSelection(); 1001 ClearSelection();
979 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED)); 1002 EXPECT_THAT(GetAndResetEvents(),
1003 ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_CLEARED));
980 EXPECT_EQ(gfx::PointF(), GetLastEventStart()); 1004 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
981 } 1005 }
982 1006
983 TEST_F(TouchSelectionControllerTest, NoSelectionAfterLongpressThenTap) { 1007 TEST_F(TouchSelectionControllerTest, NoSelectionAfterLongpressThenTap) {
984 gfx::RectF start_rect(5, 5, 0, 10); 1008 gfx::RectF start_rect(5, 5, 0, 10);
985 gfx::RectF end_rect(50, 5, 0, 10); 1009 gfx::RectF end_rect(50, 5, 0, 10);
986 bool visible = true; 1010 bool visible = true;
987 1011
988 // Tap-triggered selections should not be allowed. 1012 // Tap-triggered selections should not be allowed.
989 OnLongPressEvent(); 1013 OnLongPressEvent();
990 OnTapEvent(); 1014 OnTapEvent();
991 ChangeSelection(start_rect, visible, end_rect, visible); 1015 ChangeSelection(start_rect, visible, end_rect, visible);
992 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1016 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_ESTABLISHED));
993 1017
994 // Subsequent longpress selections will be allowed. 1018 // Subsequent longpress selections will be allowed.
995 OnLongPressEvent(); 1019 OnLongPressEvent();
996 ChangeSelection(start_rect, visible, end_rect, visible); 1020 ChangeSelection(start_rect, visible, end_rect, visible);
997 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 1021 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_SHOWN));
998 1022
999 // Tapping again shouldn't have any effect on subsequent selection events. 1023 // Tapping again shouldn't have any effect on subsequent selection events.
1000 OnTapEvent(); 1024 OnTapEvent();
1001 end_rect.Offset(10, 10); 1025 end_rect.Offset(10, 10);
1002 ChangeSelection(start_rect, visible, end_rect, visible); 1026 ChangeSelection(start_rect, visible, end_rect, visible);
1003 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 1027 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
1004 ClearSelection(); 1028 ClearSelection();
1005 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED)); 1029 EXPECT_THAT(GetAndResetEvents(),
1030 ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_CLEARED));
1006 } 1031 }
1007 1032
1008 TEST_F(TouchSelectionControllerTest, AllowShowingFromCurrentSelection) { 1033 TEST_F(TouchSelectionControllerTest, AllowShowingFromCurrentSelection) {
1009 gfx::RectF start_rect(5, 5, 0, 10); 1034 gfx::RectF start_rect(5, 5, 0, 10);
1010 gfx::RectF end_rect(50, 5, 0, 10); 1035 gfx::RectF end_rect(50, 5, 0, 10);
1011 bool visible = true; 1036 bool visible = true;
1012 1037
1013 // The selection should not be activated, as it wasn't yet allowed. 1038 // The selection should not be activated, as it wasn't yet allowed.
1014 ChangeSelection(start_rect, visible, end_rect, visible); 1039 ChangeSelection(start_rect, visible, end_rect, visible);
1015 EXPECT_EQ(gfx::PointF(), GetLastEventStart()); 1040 EXPECT_EQ(gfx::PointF(), GetLastEventStart());
1016 1041
1017 // A longpress should have no immediate effect. 1042 // A longpress should have no immediate effect.
1018 OnLongPressEvent(); 1043 OnLongPressEvent();
1019 1044
1020 // Now explicitly allow showing from the previously supplied bounds. 1045 // Now explicitly allow showing from the previously supplied bounds.
1021 controller().AllowShowingFromCurrentSelection(); 1046 controller().AllowShowingFromCurrentSelection();
1022 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 1047 EXPECT_THAT(GetAndResetEvents(),
1048 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
1023 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 1049 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
1024 1050
1025 // Repeated calls to show from the current selection should be ignored. 1051 // Repeated calls to show from the current selection should be ignored.
1026 controller().AllowShowingFromCurrentSelection(); 1052 controller().AllowShowingFromCurrentSelection();
1027 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1053 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
1028 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 1054 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
1029 1055
1030 // Trying to show from an empty selection will have no result. 1056 // Trying to show from an empty selection will have no result.
1031 ClearSelection(); 1057 ClearSelection();
1032 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED)); 1058 EXPECT_THAT(GetAndResetEvents(),
1059 ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_CLEARED));
1033 controller().AllowShowingFromCurrentSelection(); 1060 controller().AllowShowingFromCurrentSelection();
1034 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1061 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
1035 1062
1036 // Showing the insertion handle should also be supported. 1063 // Showing the insertion handle should also be supported.
1037 controller().OnSelectionEditable(true); 1064 controller().OnSelectionEditable(true);
1038 controller().OnSelectionEmpty(false); 1065 controller().OnSelectionEmpty(false);
1039 controller().HideAndDisallowShowingAutomatically(); 1066 controller().HideAndDisallowShowingAutomatically();
1040 gfx::RectF insertion_rect(5, 5, 0, 10); 1067 gfx::RectF insertion_rect(5, 5, 0, 10);
1041 ChangeInsertion(insertion_rect, visible); 1068 ChangeInsertion(insertion_rect, visible);
1042 controller().AllowShowingFromCurrentSelection(); 1069 controller().AllowShowingFromCurrentSelection();
1043 EXPECT_THAT(GetAndResetEvents(), ElementsAre(INSERTION_SHOWN)); 1070 EXPECT_THAT(GetAndResetEvents(),
1071 ElementsAre(SELECTION_ESTABLISHED, INSERTION_HANDLE_SHOWN));
1044 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart()); 1072 EXPECT_EQ(insertion_rect.bottom_left(), GetLastEventStart());
1045 } 1073 }
1046 1074
1047 TEST_F(TouchSelectionControllerTest, HandlesShowOnTapInsideRect) { 1075 TEST_F(TouchSelectionControllerTest, HandlesShowOnTapInsideRect) {
1048 bool visible = false; 1076 bool visible = false;
1049 gfx::RectF start_rect(5, 5, 0, 10); 1077 gfx::RectF start_rect(5, 5, 0, 10);
1050 gfx::RectF end_rect(50, 5, 0, 10); 1078 gfx::RectF end_rect(50, 5, 0, 10);
1051 gfx::PointF inner_point(25, 10); 1079 gfx::PointF inner_point(25, 10);
1052 gfx::PointF outer_point(100, 100); 1080 gfx::PointF outer_point(100, 100);
1053 1081
1054 // Establish a selection without handles from 5 to 50 with height 10. 1082 // Establish a selection without handles from 5 to 50 with height 10.
1055 ChangeSelection(start_rect, visible, end_rect, visible); 1083 ChangeSelection(start_rect, visible, end_rect, visible);
1056 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1084 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_ESTABLISHED));
1057 1085
1058 // A point outside the rect should not be handled. 1086 // A point outside the rect should not be handled.
1059 EXPECT_FALSE(controller().WillHandleTapEvent(outer_point)); 1087 EXPECT_FALSE(controller().WillHandleTapEvent(outer_point));
1060 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1088 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
1061 1089
1062 // A point inside the rect should be handled. 1090 // A point inside the rect should be handled.
1063 EXPECT_TRUE(controller().WillHandleTapEvent(inner_point)); 1091 EXPECT_TRUE(controller().WillHandleTapEvent(inner_point));
1064 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 1092 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_SHOWN));
1065 } 1093 }
1066 1094
1067 TEST_F(TouchSelectionControllerTest, HandlesShowOnLongPressInsideRect) { 1095 TEST_F(TouchSelectionControllerTest, HandlesShowOnLongPressInsideRect) {
1068 bool visible = false; 1096 bool visible = false;
1069 gfx::RectF start_rect(5, 5, 0, 10); 1097 gfx::RectF start_rect(5, 5, 0, 10);
1070 gfx::RectF end_rect(50, 5, 0, 10); 1098 gfx::RectF end_rect(50, 5, 0, 10);
1071 gfx::PointF inner_point(25, 10); 1099 gfx::PointF inner_point(25, 10);
1072 gfx::PointF outer_point(100, 100); 1100 gfx::PointF outer_point(100, 100);
1073 1101
1074 // Establish a selection without handles from 5 to 50 with height 10. 1102 // Establish a selection without handles from 5 to 50 with height 10.
1075 ChangeSelection(start_rect, visible, end_rect, visible); 1103 ChangeSelection(start_rect, visible, end_rect, visible);
1076 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1104 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_ESTABLISHED));
1077 1105
1078 // A point outside the rect should not be handled. 1106 // A point outside the rect should not be handled.
1079 EXPECT_FALSE( 1107 EXPECT_FALSE(
1080 controller().WillHandleLongPressEvent(base::TimeTicks(), outer_point)); 1108 controller().WillHandleLongPressEvent(base::TimeTicks(), outer_point));
1081 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1109 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
1082 1110
1083 // A point inside the rect should be handled. 1111 // A point inside the rect should be handled.
1084 EXPECT_TRUE( 1112 EXPECT_TRUE(
1085 controller().WillHandleLongPressEvent(base::TimeTicks(), inner_point)); 1113 controller().WillHandleLongPressEvent(base::TimeTicks(), inner_point));
1086 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 1114 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_SHOWN));
1087 } 1115 }
1088 1116
1089 TEST_F(TouchSelectionControllerTest, LongPressDrag) { 1117 TEST_F(TouchSelectionControllerTest, LongPressDrag) {
1090 EnableLongPressDragSelection(); 1118 EnableLongPressDragSelection();
1091 TouchSelectionControllerTestApi test_controller(&controller()); 1119 TouchSelectionControllerTestApi test_controller(&controller());
1092 1120
1093 gfx::RectF start_rect(-50, 0, 0, 10); 1121 gfx::RectF start_rect(-50, 0, 0, 10);
1094 gfx::RectF end_rect(50, 0, 0, 10); 1122 gfx::RectF end_rect(50, 0, 0, 10);
1095 bool visible = true; 1123 bool visible = true;
1096 1124
1097 // Start a touch sequence. 1125 // Start a touch sequence.
1098 MockMotionEvent event; 1126 MockMotionEvent event;
1099 EXPECT_FALSE(controller().WillHandleTouchEvent(event.PressPoint(0, 0))); 1127 EXPECT_FALSE(controller().WillHandleTouchEvent(event.PressPoint(0, 0)));
1100 1128
1101 // Activate a longpress-triggered selection. 1129 // Activate a longpress-triggered selection.
1102 OnLongPressEvent(); 1130 OnLongPressEvent();
1103 ChangeSelection(start_rect, visible, end_rect, visible); 1131 ChangeSelection(start_rect, visible, end_rect, visible);
1104 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 1132 EXPECT_THAT(GetAndResetEvents(),
1133 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
1105 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 1134 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
1106 1135
1107 // The handles should remain invisible while the touch release and longpress 1136 // The handles should remain invisible while the touch release and longpress
1108 // drag gesture are pending. 1137 // drag gesture are pending.
1109 EXPECT_FALSE(test_controller.GetStartVisible()); 1138 EXPECT_FALSE(test_controller.GetStartVisible());
1110 EXPECT_FALSE(test_controller.GetEndVisible()); 1139 EXPECT_FALSE(test_controller.GetEndVisible());
1111 1140
1112 // The selection coordinates should reflect the drag movement. 1141 // The selection coordinates should reflect the drag movement.
1113 gfx::PointF fixed_offset = start_rect.CenterPoint(); 1142 gfx::PointF fixed_offset = start_rect.CenterPoint();
1114 gfx::PointF end_offset = end_rect.CenterPoint(); 1143 gfx::PointF end_offset = end_rect.CenterPoint();
1115 EXPECT_TRUE(controller().WillHandleTouchEvent(event.MovePoint(0, 0, 0))); 1144 EXPECT_TRUE(controller().WillHandleTouchEvent(event.MovePoint(0, 0, 0)));
1116 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1145 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
1117 1146
1118 EXPECT_TRUE( 1147 EXPECT_TRUE(
1119 controller().WillHandleTouchEvent(event.MovePoint(0, 0, kDefaulTapSlop))); 1148 controller().WillHandleTouchEvent(event.MovePoint(0, 0, kDefaulTapSlop)));
1120 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STARTED)); 1149 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STARTED));
1121 EXPECT_EQ(fixed_offset, GetLastSelectionStart()); 1150 EXPECT_EQ(fixed_offset, GetLastSelectionStart());
1122 EXPECT_EQ(end_offset, GetLastSelectionEnd()); 1151 EXPECT_EQ(end_offset, GetLastSelectionEnd());
1123 1152
1124 // Movement after the start of drag will be relative to the moved endpoint. 1153 // Movement after the start of drag will be relative to the moved endpoint.
1125 EXPECT_TRUE(controller().WillHandleTouchEvent( 1154 EXPECT_TRUE(controller().WillHandleTouchEvent(
1126 event.MovePoint(0, 0, 2 * kDefaulTapSlop))); 1155 event.MovePoint(0, 0, 2 * kDefaulTapSlop)));
1127 EXPECT_TRUE(GetAndResetSelectionMoved()); 1156 EXPECT_TRUE(GetAndResetSelectionMoved());
1128 EXPECT_EQ(end_offset + gfx::Vector2dF(0, kDefaulTapSlop), 1157 EXPECT_EQ(end_offset + gfx::Vector2dF(0, kDefaulTapSlop),
1129 GetLastSelectionEnd()); 1158 GetLastSelectionEnd());
1130 1159
1131 EXPECT_TRUE(controller().WillHandleTouchEvent( 1160 EXPECT_TRUE(controller().WillHandleTouchEvent(
1132 event.MovePoint(0, kDefaulTapSlop, 2 * kDefaulTapSlop))); 1161 event.MovePoint(0, kDefaulTapSlop, 2 * kDefaulTapSlop)));
1133 EXPECT_TRUE(GetAndResetSelectionMoved()); 1162 EXPECT_TRUE(GetAndResetSelectionMoved());
1134 EXPECT_EQ(end_offset + gfx::Vector2dF(kDefaulTapSlop, kDefaulTapSlop), 1163 EXPECT_EQ(end_offset + gfx::Vector2dF(kDefaulTapSlop, kDefaulTapSlop),
1135 GetLastSelectionEnd()); 1164 GetLastSelectionEnd());
1136 1165
1137 EXPECT_TRUE(controller().WillHandleTouchEvent( 1166 EXPECT_TRUE(controller().WillHandleTouchEvent(
1138 event.MovePoint(0, 2 * kDefaulTapSlop, 2 * kDefaulTapSlop))); 1167 event.MovePoint(0, 2 * kDefaulTapSlop, 2 * kDefaulTapSlop)));
1139 EXPECT_TRUE(GetAndResetSelectionMoved()); 1168 EXPECT_TRUE(GetAndResetSelectionMoved());
1140 EXPECT_EQ(end_offset + gfx::Vector2dF(2 * kDefaulTapSlop, kDefaulTapSlop), 1169 EXPECT_EQ(end_offset + gfx::Vector2dF(2 * kDefaulTapSlop, kDefaulTapSlop),
1141 GetLastSelectionEnd()); 1170 GetLastSelectionEnd());
1142 1171
1143 // The handles should still be hidden. 1172 // The handles should still be hidden.
1144 EXPECT_FALSE(test_controller.GetStartVisible()); 1173 EXPECT_FALSE(test_controller.GetStartVisible());
1145 EXPECT_FALSE(test_controller.GetEndVisible()); 1174 EXPECT_FALSE(test_controller.GetEndVisible());
1146 1175
1147 // Releasing the touch sequence should end the drag and show the handles. 1176 // Releasing the touch sequence should end the drag and show the handles.
1148 EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint())); 1177 EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint()));
1149 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_DRAG_STOPPED)); 1178 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLE_DRAG_STOPPED));
1150 EXPECT_TRUE(test_controller.GetStartVisible()); 1179 EXPECT_TRUE(test_controller.GetStartVisible());
1151 EXPECT_TRUE(test_controller.GetEndVisible()); 1180 EXPECT_TRUE(test_controller.GetEndVisible());
1152 } 1181 }
1153 1182
1154 TEST_F(TouchSelectionControllerTest, LongPressNoDrag) { 1183 TEST_F(TouchSelectionControllerTest, LongPressNoDrag) {
1155 EnableLongPressDragSelection(); 1184 EnableLongPressDragSelection();
1156 TouchSelectionControllerTestApi test_controller(&controller()); 1185 TouchSelectionControllerTestApi test_controller(&controller());
1157 1186
1158 gfx::RectF start_rect(-50, 0, 0, 10); 1187 gfx::RectF start_rect(-50, 0, 0, 10);
1159 gfx::RectF end_rect(50, 0, 0, 10); 1188 gfx::RectF end_rect(50, 0, 0, 10);
1160 bool visible = true; 1189 bool visible = true;
1161 1190
1162 // Start a touch sequence. 1191 // Start a touch sequence.
1163 MockMotionEvent event; 1192 MockMotionEvent event;
1164 EXPECT_FALSE(controller().WillHandleTouchEvent(event.PressPoint(0, 0))); 1193 EXPECT_FALSE(controller().WillHandleTouchEvent(event.PressPoint(0, 0)));
1165 1194
1166 // Activate a longpress-triggered selection. 1195 // Activate a longpress-triggered selection.
1167 OnLongPressEvent(); 1196 OnLongPressEvent();
1168 ChangeSelection(start_rect, visible, end_rect, visible); 1197 ChangeSelection(start_rect, visible, end_rect, visible);
1169 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 1198 EXPECT_THAT(GetAndResetEvents(),
1199 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
1170 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 1200 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
1171 1201
1172 // The handles should remain invisible while the touch release and longpress 1202 // The handles should remain invisible while the touch release and longpress
1173 // drag gesture are pending. 1203 // drag gesture are pending.
1174 EXPECT_FALSE(test_controller.GetStartVisible()); 1204 EXPECT_FALSE(test_controller.GetStartVisible());
1175 EXPECT_FALSE(test_controller.GetEndVisible()); 1205 EXPECT_FALSE(test_controller.GetEndVisible());
1176 1206
1177 // If no drag movement occurs, the handles should reappear after the touch 1207 // If no drag movement occurs, the handles should reappear after the touch
1178 // is released. 1208 // is released.
1179 EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint())); 1209 EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint()));
(...skipping 10 matching lines...) Expand all
1190 gfx::RectF end_rect(50, 0, 0, 10); 1220 gfx::RectF end_rect(50, 0, 0, 10);
1191 bool visible = true; 1221 bool visible = true;
1192 1222
1193 // Start a touch sequence. 1223 // Start a touch sequence.
1194 MockMotionEvent event; 1224 MockMotionEvent event;
1195 EXPECT_FALSE(controller().WillHandleTouchEvent(event.PressPoint(0, 0))); 1225 EXPECT_FALSE(controller().WillHandleTouchEvent(event.PressPoint(0, 0)));
1196 1226
1197 // Activate a longpress-triggered selection. 1227 // Activate a longpress-triggered selection.
1198 OnLongPressEvent(); 1228 OnLongPressEvent();
1199 ChangeSelection(start_rect, visible, end_rect, visible); 1229 ChangeSelection(start_rect, visible, end_rect, visible);
1200 EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 1230 EXPECT_THAT(GetAndResetEvents(),
1231 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
1201 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart()); 1232 EXPECT_EQ(start_rect.bottom_left(), GetLastEventStart());
1202 EXPECT_TRUE(test_controller.GetStartVisible()); 1233 EXPECT_TRUE(test_controller.GetStartVisible());
1203 EXPECT_TRUE(test_controller.GetEndVisible()); 1234 EXPECT_TRUE(test_controller.GetEndVisible());
1204 1235
1205 // Subsequent motion of the same touch sequence after longpress shouldn't 1236 // Subsequent motion of the same touch sequence after longpress shouldn't
1206 // trigger drag selection. 1237 // trigger drag selection.
1207 EXPECT_FALSE(controller().WillHandleTouchEvent(event.MovePoint(0, 0, 0))); 1238 EXPECT_FALSE(controller().WillHandleTouchEvent(event.MovePoint(0, 0, 0)));
1208 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1239 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
1209 1240
1210 EXPECT_FALSE(controller().WillHandleTouchEvent( 1241 EXPECT_FALSE(controller().WillHandleTouchEvent(
1211 event.MovePoint(0, 0, kDefaulTapSlop * 10))); 1242 event.MovePoint(0, 0, kDefaulTapSlop * 10)));
1212 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1243 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
1213 1244
1214 // Releasing the touch sequence should have no effect. 1245 // Releasing the touch sequence should have no effect.
1215 EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint())); 1246 EXPECT_FALSE(controller().WillHandleTouchEvent(event.ReleasePoint()));
1216 EXPECT_THAT(GetAndResetEvents(), IsEmpty()); 1247 EXPECT_THAT(GetAndResetEvents(), IsEmpty());
1217 EXPECT_TRUE(test_controller.GetStartVisible()); 1248 EXPECT_TRUE(test_controller.GetStartVisible());
1218 EXPECT_TRUE(test_controller.GetEndVisible()); 1249 EXPECT_TRUE(test_controller.GetEndVisible());
1219 } 1250 }
1220 1251
1221 TEST_F(TouchSelectionControllerTest, RectBetweenBounds) { 1252 TEST_F(TouchSelectionControllerTest, RectBetweenBounds) {
1222 gfx::RectF start_rect(5, 5, 0, 10); 1253 gfx::RectF start_rect(5, 5, 0, 10);
1223 gfx::RectF end_rect(50, 5, 0, 10); 1254 gfx::RectF end_rect(50, 5, 0, 10);
1224 bool visible = true; 1255 bool visible = true;
1225 1256
1226 EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds()); 1257 EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds());
1227 1258
1228 OnLongPressEvent(); 1259 OnLongPressEvent();
1229 ChangeSelection(start_rect, visible, end_rect, visible); 1260 ChangeSelection(start_rect, visible, end_rect, visible);
1230 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN)); 1261 ASSERT_THAT(GetAndResetEvents(),
1262 ElementsAre(SELECTION_ESTABLISHED, SELECTION_HANDLES_SHOWN));
1231 EXPECT_EQ(gfx::RectF(5, 5, 45, 10), controller().GetRectBetweenBounds()); 1263 EXPECT_EQ(gfx::RectF(5, 5, 45, 10), controller().GetRectBetweenBounds());
1232 1264
1233 // The result of |GetRectBetweenBounds| should be available within the 1265 // The result of |GetRectBetweenBounds| should be available within the
1234 // |OnSelectionEvent| callback, as stored by |GetLastEventBoundsRect()|. 1266 // |OnSelectionEvent| callback, as stored by |GetLastEventBoundsRect()|.
1235 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); 1267 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
1236 1268
1237 start_rect.Offset(1, 0); 1269 start_rect.Offset(1, 0);
1238 ChangeSelection(start_rect, visible, end_rect, visible); 1270 ChangeSelection(start_rect, visible, end_rect, visible);
1239 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 1271 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
1240 EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds()); 1272 EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds());
1241 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); 1273 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
1242 1274
1243 // If only one bound is visible, the selection bounding rect should reflect 1275 // If only one bound is visible, the selection bounding rect should reflect
1244 // only the visible bound. 1276 // only the visible bound.
1245 ChangeSelection(start_rect, visible, end_rect, false); 1277 ChangeSelection(start_rect, visible, end_rect, false);
1246 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 1278 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
1247 EXPECT_EQ(start_rect, controller().GetRectBetweenBounds()); 1279 EXPECT_EQ(start_rect, controller().GetRectBetweenBounds());
1248 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); 1280 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
1249 1281
1250 ChangeSelection(start_rect, false, end_rect, visible); 1282 ChangeSelection(start_rect, false, end_rect, visible);
1251 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 1283 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
1252 EXPECT_EQ(end_rect, controller().GetRectBetweenBounds()); 1284 EXPECT_EQ(end_rect, controller().GetRectBetweenBounds());
1253 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); 1285 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
1254 1286
1255 // If both bounds are visible, the full bounding rect should be returned. 1287 // If both bounds are visible, the full bounding rect should be returned.
1256 ChangeSelection(start_rect, false, end_rect, false); 1288 ChangeSelection(start_rect, false, end_rect, false);
1257 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED)); 1289 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_HANDLES_MOVED));
1258 EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds()); 1290 EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds());
1259 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds()); 1291 EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
1260 1292
1261 ClearSelection(); 1293 ClearSelection();
1262 ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED)); 1294 ASSERT_THAT(GetAndResetEvents(),
1295 ElementsAre(SELECTION_DISSOLVED, SELECTION_HANDLES_CLEARED));
1263 EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds()); 1296 EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds());
1264 } 1297 }
1265 1298
1266 } // namespace ui 1299 } // namespace ui
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698