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