content/browser/web_contents/touch_editable_impl_aura_browsertest.cc

   1 // Copyright (c) 2012 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/web_contents/touch_editable_impl_aura.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/run_loop.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/test/test_timeouts.h"
  11 #include "base/values.h"
  12 #include "content/browser/web_contents/web_contents_impl.h"
  13 #include "content/browser/web_contents/web_contents_view_aura.h"
  14 #include "content/public/browser/render_frame_host.h"
  15 #include "content/public/common/content_switches.h"
  16 #include "content/public/test/browser_test_utils.h"
  17 #include "content/public/test/content_browser_test.h"
  18 #include "content/public/test/content_browser_test_utils.h"
  19 #include "content/public/test/test_utils.h"
  20 #include "content/shell/browser/shell.h"
  21 #include "third_party/WebKit/public/web/WebInputEvent.h"
  22 #include "ui/aura/window.h"
  23 #include "ui/aura/window_tree_host.h"
  24 #include "ui/base/ui_base_switches.h"
  25 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  26 #include "ui/events/event_utils.h"
  27 #include "ui/events/test/event_generator.h"
  28
  29 using blink::WebInputEvent;
  30
  31 namespace content {
  32
  33 class TestTouchEditableImplAura : public TouchEditableImplAura {
  34  public:
  35   TestTouchEditableImplAura()
  36       : selection_changed_callback_arrived_(false),
  37         waiting_for_selection_changed_callback_(false),
  38         waiting_for_gesture_ack_type_(WebInputEvent::Undefined),
  39         last_gesture_ack_type_(WebInputEvent::Undefined),
  40         fling_stop_callback_arrived_(false),
  41         waiting_for_fling_stop_callback_(false) {}
  42
  43   virtual void Reset() {
  44     selection_changed_callback_arrived_ = false;
  45     waiting_for_selection_changed_callback_ = false;
  46     waiting_for_gesture_ack_type_ = WebInputEvent::Undefined;
  47     last_gesture_ack_type_ = WebInputEvent::Undefined;
  48     fling_stop_callback_arrived_ = false;
  49     waiting_for_fling_stop_callback_ = false;
  50   }
  51
  52   virtual void OnSelectionOrCursorChanged(const gfx::Rect& anchor,
  53                                           const gfx::Rect& focus) override {
  54     selection_changed_callback_arrived_ = true;
  55     TouchEditableImplAura::OnSelectionOrCursorChanged(anchor, focus);
  56     if (waiting_for_selection_changed_callback_)
  57       selection_changed_wait_run_loop_->Quit();
  58   }
  59
  60   virtual void GestureEventAck(int gesture_event_type) override {
  61     last_gesture_ack_type_ =
  62         static_cast<WebInputEvent::Type>(gesture_event_type);
  63     TouchEditableImplAura::GestureEventAck(gesture_event_type);
  64     if (waiting_for_gesture_ack_type_ == gesture_event_type)
  65       gesture_ack_wait_run_loop_->Quit();
  66   }
  67
  68   virtual void DidStopFlinging() override {
  69     fling_stop_callback_arrived_ = true;
  70     TouchEditableImplAura::DidStopFlinging();
  71     if (waiting_for_fling_stop_callback_)
  72       fling_stop_wait_run_loop_->Quit();
  73   }
  74
  75   virtual void WaitForSelectionChangeCallback() {
  76     if (selection_changed_callback_arrived_)
  77       return;
  78     waiting_for_selection_changed_callback_ = true;
  79     selection_changed_wait_run_loop_.reset(new base::RunLoop());
  80     selection_changed_wait_run_loop_->Run();
  81   }
  82
  83   virtual void WaitForGestureAck(WebInputEvent::Type gesture_event_type) {
  84     if (last_gesture_ack_type_ == gesture_event_type)
  85       return;
  86     waiting_for_gesture_ack_type_ = gesture_event_type;
  87     gesture_ack_wait_run_loop_.reset(new base::RunLoop());
  88     gesture_ack_wait_run_loop_->Run();
  89   }
  90
  91   virtual void WaitForFlingStopCallback() {
  92     if (fling_stop_callback_arrived_)
  93       return;
  94     waiting_for_fling_stop_callback_ = true;
  95     fling_stop_wait_run_loop_.reset(new base::RunLoop());
  96     fling_stop_wait_run_loop_->Run();
  97   }
  98
  99  protected:
 100   virtual ~TestTouchEditableImplAura() {}
 101
 102  private:
 103   bool selection_changed_callback_arrived_;
 104   bool waiting_for_selection_changed_callback_;
 105   WebInputEvent::Type waiting_for_gesture_ack_type_;
 106   WebInputEvent::Type last_gesture_ack_type_;
 107   bool fling_stop_callback_arrived_;
 108   bool waiting_for_fling_stop_callback_;
 109   scoped_ptr<base::RunLoop> selection_changed_wait_run_loop_;
 110   scoped_ptr<base::RunLoop> gesture_ack_wait_run_loop_;
 111   scoped_ptr<base::RunLoop> fling_stop_wait_run_loop_;
 112
 113   DISALLOW_COPY_AND_ASSIGN(TestTouchEditableImplAura);
 114 };
 115
 116 class TouchEditableImplAuraTest : public ContentBrowserTest {
 117  public:
 118   TouchEditableImplAuraTest() {}
 119
 120  protected:
 121   virtual void SetUpCommandLine(CommandLine* command_line) override {
 122     command_line->AppendSwitch(switches::kEnableTouchEditing);
 123   }
 124
 125   // Executes the javascript synchronously and makes sure the returned value is
 126   // freed properly.
 127   void ExecuteSyncJSFunction(RenderFrameHost* rfh, const std::string& jscript) {
 128     scoped_ptr<base::Value> value =
 129         content::ExecuteScriptAndGetValue(rfh, jscript);
 130   }
 131
 132   // Starts the test server and navigates to the given url. Sets a large enough
 133   // size to the root window.  Returns after the navigation to the url is
 134   // complete.
 135   void StartTestWithPage(const std::string& url) {
 136     ASSERT_TRUE(test_server()->Start());
 137     GURL test_url(test_server()->GetURL(url));
 138     NavigateToURL(shell(), test_url);
 139     aura::Window* content = shell()->web_contents()->GetContentNativeView();
 140     content->GetHost()->SetBounds(gfx::Rect(800, 600));
 141   }
 142
 143   RenderWidgetHostViewAura* GetRenderWidgetHostViewAura(
 144       TouchEditableImplAura* touch_editable) {
 145     return touch_editable->rwhva_;
 146   }
 147
 148   ui::TouchSelectionController* GetTouchSelectionController(
 149       TouchEditableImplAura* touch_editable) {
 150     return touch_editable->touch_selection_controller_.get();
 151   }
 152
 153   ui::TextInputType GetTextInputType(TouchEditableImplAura* touch_editable) {
 154     return touch_editable->text_input_type_;
 155   }
 156
 157  private:
 158   DISALLOW_COPY_AND_ASSIGN(TouchEditableImplAuraTest);
 159 };
 160
 161 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
 162                        TouchSelectionOriginatingFromWebpageTest) {
 163   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 164   WebContentsImpl* web_contents =
 165       static_cast<WebContentsImpl*>(shell()->web_contents());
 166   RenderFrameHost* main_frame = web_contents->GetMainFrame();
 167   WebContentsViewAura* view_aura = static_cast<WebContentsViewAura*>(
 168       web_contents->GetView());
 169   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
 170   view_aura->SetTouchEditableForTest(touch_editable);
 171   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 172       web_contents->GetRenderWidgetHostView());
 173   aura::Window* content = web_contents->GetContentNativeView();
 174   ui::test::EventGenerator generator(content->GetRootWindow(), content);
 175   gfx::Rect bounds = content->GetBoundsInRootWindow();
 176
 177   touch_editable->Reset();
 178   ExecuteSyncJSFunction(main_frame, "select_all_text()");
 179   touch_editable->WaitForSelectionChangeCallback();
 180
 181   // Tap inside selection to bring up selection handles.
 182   generator.GestureTapAt(gfx::Point(bounds.x() + 10, bounds.y() + 10));
 183   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);
 184
 185   scoped_ptr<base::Value> value =
 186       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
 187   std::string selection;
 188   value->GetAsString(&selection);
 189
 190   // Check if selection handles are showing.
 191   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 192   EXPECT_STREQ("Some text we can select", selection.c_str());
 193
 194   // Lets move the handles a bit to modify the selection
 195   touch_editable->Reset();
 196   generator.GestureScrollSequence(
 197       gfx::Point(10, 47),
 198       gfx::Point(30, 47),
 199       base::TimeDelta::FromMilliseconds(20),
 200       5);
 201   touch_editable->WaitForSelectionChangeCallback();
 202
 203   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 204   value = content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
 205   value->GetAsString(&selection);
 206
 207   // It is hard to tell what exactly the selection would be now. But it would
 208   // definitely be less than whatever was selected before.
 209   EXPECT_GT(std::strlen("Some text we can select"), selection.size());
 210 }
 211
 212 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
 213                        TestTouchSelectionHiddenWhenScrolling) {
 214   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 215   WebContentsImpl* web_contents =
 216       static_cast<WebContentsImpl*>(shell()->web_contents());
 217   RenderFrameHost* main_frame = web_contents->GetMainFrame();
 218   WebContentsViewAura* view_aura = static_cast<WebContentsViewAura*>(
 219       web_contents->GetView());
 220   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
 221   view_aura->SetTouchEditableForTest(touch_editable);
 222   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 223       web_contents->GetRenderWidgetHostView());
 224   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);
 225
 226   // Long press to select word.
 227   ui::GestureEvent long_press(
 228       10,
 229       10,
 230       0,
 231       ui::EventTimeForNow(),
 232       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
 233   touch_editable->Reset();
 234   rwhva->OnGestureEvent(&long_press);
 235   touch_editable->WaitForSelectionChangeCallback();
 236
 237   // Check if selection handles are showing.
 238   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 239
 240   scoped_ptr<base::Value> value =
 241       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
 242   std::string selection;
 243   value->GetAsString(&selection);
 244   EXPECT_STREQ("Some", selection.c_str());
 245
 246   // Start scrolling. Handles should get hidden.
 247   ui::GestureEvent scroll_begin(
 248       10,
 249       10,
 250       0,
 251       ui::EventTimeForNow(),
 252       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN));
 253   rwhva->OnGestureEvent(&scroll_begin);
 254   EXPECT_FALSE(GetTouchSelectionController(touch_editable));
 255
 256   // Handles should come back after scroll ends.
 257   ui::GestureEvent scroll_end(
 258       10,
 259       10,
 260       0,
 261       ui::EventTimeForNow(),
 262       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_END));
 263   rwhva->OnGestureEvent(&scroll_end);
 264   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 265 }
 266
 267 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
 268                        TestTouchSelectionReshownAfterFling) {
 269   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 270   WebContentsImpl* web_contents =
 271       static_cast<WebContentsImpl*>(shell()->web_contents());
 272   RenderFrameHost* main_frame = web_contents->GetMainFrame();
 273   WebContentsViewAura* view_aura = static_cast<WebContentsViewAura*>(
 274       web_contents->GetView());
 275   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
 276   view_aura->SetTouchEditableForTest(touch_editable);
 277   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 278       web_contents->GetRenderWidgetHostView());
 279   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);
 280
 281   // Long press to select word.
 282   ui::GestureEvent long_press(
 283       10,
 284       10,
 285       0,
 286       ui::EventTimeForNow(),
 287       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
 288   touch_editable->Reset();
 289   rwhva->OnGestureEvent(&long_press);
 290   touch_editable->WaitForSelectionChangeCallback();
 291
 292   // Check if selection handles are showing.
 293   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 294
 295   scoped_ptr<base::Value> value =
 296       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
 297   std::string selection;
 298   value->GetAsString(&selection);
 299   EXPECT_STREQ("Some", selection.c_str());
 300
 301   // Start scrolling. Handles should get hidden.
 302   ui::GestureEvent scroll_begin(
 303       10,
 304       10,
 305       0,
 306       ui::EventTimeForNow(),
 307       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN, 0, 0));
 308   rwhva->OnGestureEvent(&scroll_begin);
 309   EXPECT_FALSE(GetTouchSelectionController(touch_editable));
 310
 311   // Start a fling. Handles should come back after fling stops.
 312   ui::GestureEvent fling_start(
 313       10,
 314       10,
 315       0,
 316       ui::EventTimeForNow(),
 317       ui::GestureEventDetails(ui::ET_SCROLL_FLING_START, 1, 0));
 318   rwhva->OnGestureEvent(&fling_start);
 319   touch_editable->WaitForFlingStopCallback();
 320   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 321 }
 322
 323 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
 324                        TouchSelectionOnLongPressTest) {
 325   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 326   WebContentsImpl* web_contents =
 327       static_cast<WebContentsImpl*>(shell()->web_contents());
 328   RenderFrameHost* main_frame = web_contents->GetMainFrame();
 329   WebContentsViewAura* view_aura = static_cast<WebContentsViewAura*>(
 330       web_contents->GetView());
 331   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
 332   view_aura->SetTouchEditableForTest(touch_editable);
 333   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 334       web_contents->GetRenderWidgetHostView());
 335   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);
 336
 337   // Long press to select word.
 338   ui::GestureEvent long_press(
 339       10,
 340       10,
 341       0,
 342       ui::EventTimeForNow(),
 343       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
 344   touch_editable->Reset();
 345   rwhva->OnGestureEvent(&long_press);
 346   touch_editable->WaitForSelectionChangeCallback();
 347
 348   // Check if selection handles are showing.
 349   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 350
 351   scoped_ptr<base::Value> value =
 352       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
 353   std::string selection;
 354   value->GetAsString(&selection);
 355   EXPECT_STREQ("Some", selection.c_str());
 356 }
 357
 358 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
 359                        NoTouchSelectionOnDoubleTapTest) {
 360   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 361   WebContentsImpl* web_contents =
 362       static_cast<WebContentsImpl*>(shell()->web_contents());
 363   RenderFrameHost* main_frame = web_contents->GetMainFrame();
 364   WebContentsViewAura* view_aura =
 365       static_cast<WebContentsViewAura*>(web_contents->GetView());
 366   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
 367   view_aura->SetTouchEditableForTest(touch_editable);
 368   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 369       web_contents->GetRenderWidgetHostView());
 370   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);
 371
 372   // Double-tap to select word.
 373   ui::GestureEventDetails details(ui::ET_GESTURE_TAP);
 374   details.set_tap_count(2);
 375   ui::GestureEvent double_tap(10, 10, 0, ui::EventTimeForNow(), details);
 376   touch_editable->Reset();
 377   rwhva->OnGestureEvent(&double_tap);
 378   touch_editable->WaitForSelectionChangeCallback();
 379
 380   // Make sure touch selection handles are not showing.
 381   EXPECT_FALSE(GetTouchSelectionController(touch_editable));
 382
 383   scoped_ptr<base::Value> value =
 384       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
 385   std::string selection;
 386   value->GetAsString(&selection);
 387   EXPECT_STREQ("Some", selection.c_str());
 388 }
 389
 390 #if defined(OS_CHROMEOS)
 391 // http://crbug.com/396509
 392 #define MAYBE_TouchCursorInTextfieldTest DISABLED_TouchCursorInTextfieldTest
 393 #else
 394 #define MAYBE_TouchCursorInTextfieldTest TouchCursorInTextfieldTest
 395 #endif
 396 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
 397                        MAYBE_TouchCursorInTextfieldTest) {
 398   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
 399   WebContentsImpl* web_contents =
 400       static_cast<WebContentsImpl*>(shell()->web_contents());
 401   RenderFrameHost* main_frame = web_contents->GetMainFrame();
 402   WebContentsViewAura* view_aura = static_cast<WebContentsViewAura*>(
 403       web_contents->GetView());
 404   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
 405   view_aura->SetTouchEditableForTest(touch_editable);
 406   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
 407       web_contents->GetRenderWidgetHostView());
 408   aura::Window* content = web_contents->GetContentNativeView();
 409   ui::test::EventGenerator generator(content->GetRootWindow(), content);
 410   gfx::Rect bounds = content->GetBoundsInRootWindow();
 411   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);
 412
 413   ExecuteSyncJSFunction(main_frame, "focus_textfield()");
 414   touch_editable->WaitForSelectionChangeCallback();
 415
 416   // Tap textfield
 417   touch_editable->Reset();
 418   generator.GestureTapAt(gfx::Point(bounds.x() + 50, bounds.y() + 40));
 419   // Tap Down acks are sent synchronously, while Tap acks are asynchronous.
 420   touch_editable->WaitForGestureAck(WebInputEvent::GestureTap);
 421   touch_editable->WaitForSelectionChangeCallback();
 422   touch_editable->Reset();
 423
 424   // Check if cursor handle is showing.
 425   EXPECT_NE(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType(touch_editable));
 426   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 427
 428   scoped_ptr<base::Value> value =
 429       content::ExecuteScriptAndGetValue(main_frame, "get_cursor_position()");
 430   int cursor_pos = -1;
 431   value->GetAsInteger(&cursor_pos);
 432   EXPECT_NE(-1, cursor_pos);
 433
 434   // Move the cursor handle.
 435   generator.GestureScrollSequence(
 436       gfx::Point(50, 59),
 437       gfx::Point(10, 59),
 438       base::TimeDelta::FromMilliseconds(20),
 439       1);
 440   touch_editable->WaitForSelectionChangeCallback();
 441   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 442   value = content::ExecuteScriptAndGetValue(main_frame,
 443                                             "get_cursor_position()");
 444   int new_cursor_pos = -1;
 445   value->GetAsInteger(&new_cursor_pos);
 446   EXPECT_NE(-1, new_cursor_pos);
 447   // Cursor should have moved.
 448   EXPECT_NE(new_cursor_pos, cursor_pos);
 449 }
 450
 451 }  // namespace content