content/browser/renderer_host/input/touch_selection_controller_client_aura_browsertest.cc

   1 // Copyright 2015 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_client_aura.h"
   6
   7 #include "base/json/json_reader.h"
   8 #include "base/run_loop.h"
   9 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
  10 #include "content/browser/web_contents/web_contents_impl.h"
  11 #include "content/public/test/browser_test_utils.h"
  12 #include "content/public/test/content_browser_test.h"
  13 #include "content/public/test/content_browser_test_utils.h"
  14 #include "content/shell/browser/shell.h"
  15 #include "ui/aura/window.h"
  16 #include "ui/aura/window_tree_host.h"
  17 #include "ui/events/event_utils.h"
  18 #include "ui/events/test/event_generator.h"
  19 #include "ui/touch_selection/touch_selection_controller_test_api.h"
  20
  21 namespace content {
  22 namespace {
  23
  24 bool JSONToPoint(const std::string& str, gfx::PointF* point) {
  25   scoped_ptr<base::Value> value = base::JSONReader::Read(str);
  26   if (!value)
  27     return false;
  28   base::DictionaryValue* root;
  29   if (!value->GetAsDictionary(&root))
  30     return false;
  31   double x, y;
  32   if (!root->GetDouble("x", &x))
  33     return false;
  34   if (!root->GetDouble("y", &y))
  35     return false;
  36   point->set_x(x);
  37   point->set_y(y);
  38   return true;
  39 }
  40
  41 // A mock touch selection menu runner to use whenever a default one is not
  42 // installed.
  43 class TestTouchSelectionMenuRunner : public ui::TouchSelectionMenuRunner {
  44  public:
  45   TestTouchSelectionMenuRunner() : menu_opened_(false) {}
  46   ~TestTouchSelectionMenuRunner() override {}
  47
  48  private:
  49   void OpenMenu(ui::TouchSelectionMenuClient* client,
  50                 const gfx::Rect& anchor_rect,
  51                 const gfx::Size& handle_image_size,
  52                 aura::Window* context) override {
  53     menu_opened_ = true;
  54   }
  55
  56   void CloseMenu() override { menu_opened_ = false; }
  57
  58   bool IsRunning() const override { return menu_opened_; }
  59
  60   bool menu_opened_;
  61
  62   DISALLOW_COPY_AND_ASSIGN(TestTouchSelectionMenuRunner);
  63 };
  64
  65 }  // namespace
  66
  67 class TestTouchSelectionControllerClientAura
  68     : public TouchSelectionControllerClientAura {
  69  public:
  70   explicit TestTouchSelectionControllerClientAura(
  71       RenderWidgetHostViewAura* rwhva)
  72       : TouchSelectionControllerClientAura(rwhva),
  73         expected_event_(ui::SELECTION_HANDLES_SHOWN) {
  74     show_quick_menu_immediately_for_test_ = true;
  75   }
  76
  77   ~TestTouchSelectionControllerClientAura() override {}
  78
  79   void InitWaitForSelectionEvent(ui::SelectionEventType expected_event) {
  80     DCHECK(!run_loop_);
  81     expected_event_ = expected_event;
  82     run_loop_.reset(new base::RunLoop());
  83   }
  84
  85   void Wait() {
  86     DCHECK(run_loop_);
  87     run_loop_->Run();
  88     run_loop_.reset();
  89   }
  90
  91  private:
  92   // TouchSelectionControllerClientAura:
  93   void OnSelectionEvent(ui::SelectionEventType event) override {
  94     TouchSelectionControllerClientAura::OnSelectionEvent(event);
  95     if (run_loop_ && event == expected_event_)
  96       run_loop_->Quit();
  97   }
  98
  99   bool IsCommandIdEnabled(int command_id) const override {
 100     // Return true so that quick menu has something to show.
 101     return true;
 102   }
 103
 104   ui::SelectionEventType expected_event_;
 105   scoped_ptr<base::RunLoop> run_loop_;
 106
 107   DISALLOW_COPY_AND_ASSIGN(TestTouchSelectionControllerClientAura);
 108 };
 109
 110 class TouchSelectionControllerClientAuraTest : public ContentBrowserTest {
 111  public:
 112   TouchSelectionControllerClientAuraTest() {}
 113   ~TouchSelectionControllerClientAuraTest() override {}
 114
 115  protected:
 116   // Starts the test server and navigates to the given url. Sets a large enough
 117   // size to the root window.  Returns after the navigation to the url is
 118   // complete.
 119   void StartTestWithPage(const std::string& url) {
 120     ASSERT_TRUE(test_server()->Start());
 121     GURL test_url(test_server()->GetURL(url));
 122     NavigateToURL(shell(), test_url);
 123     aura::Window* content = shell()->web_contents()->GetContentNativeView();
 124     content->GetHost()->SetBounds(gfx::Rect(800, 600));
 125   }
 126
 127   bool GetPointInsideText(gfx::PointF* point) {
 128     std::string str;
 129     if (ExecuteScriptAndExtractString(shell()->web_contents()->GetMainFrame(),
 130                                       "get_point_inside_text()", &str)) {
 131       return JSONToPoint(str, point);
 132     }
 133     return false;
 134   }
 135
 136   bool GetPointInsideTextfield(gfx::PointF* point) {
 137     std::string str;
 138     if (ExecuteScriptAndExtractString(shell()->web_contents()->GetMainFrame(),
 139                                       "get_point_inside_textfield()", &str)) {
 140       return JSONToPoint(str, point);
 141     }
 142     return false;
 143   }
 144
 145  private:
 146   void SetUpOnMainThread() override {
 147     ContentBrowserTest::SetUpOnMainThread();
 148     if (!ui::TouchSelectionMenuRunner::GetInstance())
 149       menu_runner_.reset(new TestTouchSelectionMenuRunner);
 150   }
 151
 152   void TearDownOnMainThread() override {
 153     menu_runner_ = nullptr;
 154     ContentBrowserTest::TearDownOnMainThread();
 155   }
 156
 157   scoped_ptr<TestTouchSelectionMenuRunner> menu_runner_;
 158
 159   DISALLOW_COPY_AND_ASSIGN(TouchSelectionControllerClientAuraTest);
 160 };
 161
 162 // Tests if long-pressing on a text brings up selection handles and the quick
 163 // menu properly.
 164 IN_PROC_BROWSER_TEST_F(TouchSelectionControllerClientAuraTest, BasicSelection) {
 165   // Set the test page up.
 166   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 167   WebContents* web_contents =
 168       static_cast<WebContentsImpl*>(shell()->web_contents());
 169   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 170       web_contents->GetRenderWidgetHostView());
 171   TestTouchSelectionControllerClientAura* selection_controller_client =
 172       new TestTouchSelectionControllerClientAura(rwhva);
 173   rwhva->SetSelectionControllerClientForTest(
 174       make_scoped_ptr(selection_controller_client));
 175
 176   EXPECT_EQ(ui::TouchSelectionController::INACTIVE,
 177             rwhva->selection_controller()->active_status());
 178   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 179
 180   // Long-press on the text and wait for handles to appear.
 181   selection_controller_client->InitWaitForSelectionEvent(
 182       ui::SELECTION_HANDLES_SHOWN);
 183
 184   gfx::PointF point;
 185   ASSERT_TRUE(GetPointInsideText(&point));
 186   ui::GestureEvent long_press(
 187       point.x(), point.y(), 0, ui::EventTimeForNow(),
 188       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
 189   rwhva->OnGestureEvent(&long_press);
 190
 191   selection_controller_client->Wait();
 192
 193   // Check if selection is active and the quick menu is showing.
 194   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 195             rwhva->selection_controller()->active_status());
 196   EXPECT_TRUE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 197 }
 198
 199 // Tests if tapping in a textfield brings up the insertion handle and the quick
 200 // menu properly.
 201 IN_PROC_BROWSER_TEST_F(TouchSelectionControllerClientAuraTest, BasicInsertion) {
 202   // Set the test page up.
 203   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 204   WebContents* web_contents =
 205       static_cast<WebContentsImpl*>(shell()->web_contents());
 206   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 207       web_contents->GetRenderWidgetHostView());
 208   TestTouchSelectionControllerClientAura* selection_controller_client =
 209       new TestTouchSelectionControllerClientAura(rwhva);
 210   rwhva->SetSelectionControllerClientForTest(
 211       make_scoped_ptr(selection_controller_client));
 212
 213   EXPECT_EQ(ui::TouchSelectionController::INACTIVE,
 214             rwhva->selection_controller()->active_status());
 215   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 216
 217   // Tap inside the textfield and wait for the insertion handle to appear.
 218   selection_controller_client->InitWaitForSelectionEvent(
 219       ui::INSERTION_HANDLE_SHOWN);
 220
 221   gfx::PointF point;
 222   ASSERT_TRUE(GetPointInsideTextfield(&point));
 223   ui::GestureEventDetails tap_details(ui::ET_GESTURE_TAP);
 224   tap_details.set_tap_count(1);
 225   ui::GestureEvent tap(point.x(), point.y(), 0, ui::EventTimeForNow(),
 226                        tap_details);
 227   rwhva->OnGestureEvent(&tap);
 228
 229   selection_controller_client->Wait();
 230
 231   // Check if insertion is active and the quick menu is showing.
 232   EXPECT_EQ(ui::TouchSelectionController::INSERTION_ACTIVE,
 233             rwhva->selection_controller()->active_status());
 234   EXPECT_TRUE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 235 }
 236
 237 // Tests if the quick menu is hidden whenever a touch point is active.
 238 IN_PROC_BROWSER_TEST_F(TouchSelectionControllerClientAuraTest,
 239                        QuickMenuHiddenOnTouch) {
 240   // Set the test page up.
 241   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 242   WebContents* web_contents =
 243       static_cast<WebContentsImpl*>(shell()->web_contents());
 244   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 245       web_contents->GetRenderWidgetHostView());
 246   TestTouchSelectionControllerClientAura* selection_controller_client =
 247       new TestTouchSelectionControllerClientAura(rwhva);
 248   rwhva->SetSelectionControllerClientForTest(
 249       make_scoped_ptr(selection_controller_client));
 250
 251   EXPECT_EQ(ui::TouchSelectionController::INACTIVE,
 252             rwhva->selection_controller()->active_status());
 253   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 254
 255   // Long-press on the text and wait for selection handles to appear.
 256   selection_controller_client->InitWaitForSelectionEvent(
 257       ui::SELECTION_HANDLES_SHOWN);
 258
 259   gfx::PointF point;
 260   ASSERT_TRUE(GetPointInsideText(&point));
 261   ui::GestureEvent long_press(
 262       point.x(), point.y(), 0, ui::EventTimeForNow(),
 263       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
 264   rwhva->OnGestureEvent(&long_press);
 265
 266   selection_controller_client->Wait();
 267
 268   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 269             rwhva->selection_controller()->active_status());
 270   EXPECT_TRUE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 271
 272   ui::test::EventGenerator generator(
 273       web_contents->GetContentNativeView()->GetRootWindow(),
 274       web_contents->GetContentNativeView());
 275
 276   // Put the first finger down: the quick menu should get hidden.
 277   generator.PressTouchId(0);
 278   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 279             rwhva->selection_controller()->active_status());
 280   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 281
 282   // Put a second finger down: the quick menu should remain hidden.
 283   generator.PressTouchId(1);
 284   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 285             rwhva->selection_controller()->active_status());
 286   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 287
 288   // Lift the first finger up: the quick menu should still remain hidden.
 289   generator.ReleaseTouchId(0);
 290   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 291             rwhva->selection_controller()->active_status());
 292   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 293
 294   // Lift the second finger up: the quick menu should re-appear.
 295   generator.ReleaseTouchId(1);
 296   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 297             rwhva->selection_controller()->active_status());
 298   EXPECT_TRUE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 299 }
 300
 301 // Tests if the quick menu and touch handles are hidden during an scroll.
 302 IN_PROC_BROWSER_TEST_F(TouchSelectionControllerClientAuraTest, HiddenOnScroll) {
 303   // Set the test page up.
 304   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 305   WebContents* web_contents =
 306       static_cast<WebContentsImpl*>(shell()->web_contents());
 307   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 308       web_contents->GetRenderWidgetHostView());
 309   TestTouchSelectionControllerClientAura* selection_controller_client =
 310       new TestTouchSelectionControllerClientAura(rwhva);
 311   rwhva->SetSelectionControllerClientForTest(
 312       make_scoped_ptr(selection_controller_client));
 313   ui::TouchSelectionControllerTestApi selection_controller_test_api(
 314       rwhva->selection_controller());
 315
 316   EXPECT_EQ(ui::TouchSelectionController::INACTIVE,
 317             rwhva->selection_controller()->active_status());
 318   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 319
 320   // Long-press on the text and wait for selection handles to appear.
 321   selection_controller_client->InitWaitForSelectionEvent(
 322       ui::SELECTION_HANDLES_SHOWN);
 323
 324   gfx::PointF point;
 325   ASSERT_TRUE(GetPointInsideText(&point));
 326   ui::GestureEvent long_press(
 327       point.x(), point.y(), 0, ui::EventTimeForNow(),
 328       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
 329   rwhva->OnGestureEvent(&long_press);
 330
 331   selection_controller_client->Wait();
 332
 333   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 334             rwhva->selection_controller()->active_status());
 335   EXPECT_FALSE(selection_controller_test_api.temporarily_hidden());
 336   EXPECT_TRUE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 337
 338   // Put a finger down: the quick menu should go away, while touch handles stay
 339   // there.
 340   ui::TouchEvent touch_down(ui::ET_TOUCH_PRESSED, gfx::PointF(10, 10), 0,
 341                             ui::EventTimeForNow());
 342   rwhva->OnTouchEvent(&touch_down);
 343   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 344             rwhva->selection_controller()->active_status());
 345   EXPECT_FALSE(selection_controller_test_api.temporarily_hidden());
 346   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 347
 348   // Start scrolling: touch handles should get hidden, while touch selection is
 349   // still active.
 350   ui::GestureEvent scroll_begin(
 351       10, 10, 0, ui::EventTimeForNow(),
 352       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN));
 353   rwhva->OnGestureEvent(&scroll_begin);
 354   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 355             rwhva->selection_controller()->active_status());
 356   EXPECT_TRUE(selection_controller_test_api.temporarily_hidden());
 357   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 358
 359   // End scrolling: touch handles should re-appear.
 360   ui::GestureEvent scroll_end(
 361       10, 10, 0, ui::EventTimeForNow(),
 362       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_END));
 363   rwhva->OnGestureEvent(&scroll_end);
 364   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 365             rwhva->selection_controller()->active_status());
 366   EXPECT_FALSE(selection_controller_test_api.temporarily_hidden());
 367   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 368
 369   // Lift the finger up: the quick menu should re-appear.
 370   ui::TouchEvent touch_up(ui::ET_TOUCH_RELEASED, gfx::PointF(10, 10), 0,
 371                           ui::EventTimeForNow());
 372   rwhva->OnTouchEvent(&touch_up);
 373   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 374             rwhva->selection_controller()->active_status());
 375   EXPECT_FALSE(selection_controller_test_api.temporarily_hidden());
 376   EXPECT_TRUE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 377 }
 378
 379 // Tests if touch selection gets deactivated after an overscroll completes.
 380 IN_PROC_BROWSER_TEST_F(TouchSelectionControllerClientAuraTest,
 381                        HiddenAfterOverscroll) {
 382   // Set the page up.
 383   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 384   WebContents* web_contents =
 385       static_cast<WebContentsImpl*>(shell()->web_contents());
 386   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 387       web_contents->GetRenderWidgetHostView());
 388   TestTouchSelectionControllerClientAura* selection_controller_client =
 389       new TestTouchSelectionControllerClientAura(rwhva);
 390   rwhva->SetSelectionControllerClientForTest(
 391       make_scoped_ptr(selection_controller_client));
 392
 393   EXPECT_EQ(ui::TouchSelectionController::INACTIVE,
 394             rwhva->selection_controller()->active_status());
 395   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 396
 397   // Long-press on the text and wait for touch handles to appear.
 398   selection_controller_client->InitWaitForSelectionEvent(
 399       ui::SELECTION_HANDLES_SHOWN);
 400
 401   gfx::PointF point;
 402   ASSERT_TRUE(GetPointInsideText(&point));
 403   ui::GestureEvent long_press(
 404       point.x(), point.y(), 0, ui::EventTimeForNow(),
 405       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
 406   rwhva->OnGestureEvent(&long_press);
 407
 408   selection_controller_client->Wait();
 409
 410   EXPECT_EQ(ui::TouchSelectionController::SELECTION_ACTIVE,
 411             rwhva->selection_controller()->active_status());
 412   EXPECT_TRUE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 413
 414   // Scroll such that an overscroll is initiated and wait for it to complete:
 415   // touch selection should not be active at the end.
 416   selection_controller_client->InitWaitForSelectionEvent(
 417       ui::SELECTION_HANDLES_CLEARED);
 418
 419   ui::GestureEvent scroll_begin(
 420       10, 10, 0, ui::EventTimeForNow(),
 421       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN));
 422   rwhva->OnGestureEvent(&scroll_begin);
 423
 424   ui::GestureEvent scroll_update(
 425       210, 10, 0, ui::EventTimeForNow(),
 426       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_UPDATE, 200, 0));
 427   rwhva->OnGestureEvent(&scroll_update);
 428
 429   ui::GestureEvent scroll_end(
 430       210, 10, 0, ui::EventTimeForNow(),
 431       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_END));
 432   rwhva->OnGestureEvent(&scroll_end);
 433
 434   selection_controller_client->Wait();
 435
 436   EXPECT_EQ(ui::TouchSelectionController::INACTIVE,
 437             rwhva->selection_controller()->active_status());
 438   EXPECT_FALSE(ui::TouchSelectionMenuRunner::GetInstance()->IsRunning());
 439 }
 440
 441 }  // namespace content