Implementing directional text selection handles

content/browser/web_contents/touch_editable_impl_aura_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/web_contents/touch_editable_impl_aura.h"
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
 #include "base/values.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view_aura.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/event_generator.h"
+#include "ui/wm/core/default_screen_position_client.h"
 
 using blink::WebInputEvent;
 
 namespace content {
 
 class TestTouchEditableImplAura : public TouchEditableImplAura {
  public:
   TestTouchEditableImplAura()
       : selection_changed_callback_arrived_(false),
         waiting_for_selection_changed_callback_(false),
         waiting_for_gesture_ack_type_(WebInputEvent::Undefined),
         last_gesture_ack_type_(WebInputEvent::Undefined),
         fling_stop_callback_arrived_(false),
         waiting_for_fling_stop_callback_(false) {}
 
   virtual void Reset() {
     selection_changed_callback_arrived_ = false;
     waiting_for_selection_changed_callback_ = false;
     waiting_for_gesture_ack_type_ = WebInputEvent::Undefined;
     last_gesture_ack_type_ = WebInputEvent::Undefined;
     fling_stop_callback_arrived_ = false;
     waiting_for_fling_stop_callback_ = false;
   }
 
-  virtual void OnSelectionOrCursorChanged(const gfx::Rect& anchor,
-                                          const gfx::Rect& focus) override {
+  void OnSelectionOrCursorChanged(const ui::SelectionBound& anchor,
+                                  const ui::SelectionBound& focus) override {
     selection_changed_callback_arrived_ = true;
     TouchEditableImplAura::OnSelectionOrCursorChanged(anchor, focus);
     if (waiting_for_selection_changed_callback_)
       selection_changed_wait_run_loop_->Quit();
   }
 
-  virtual void GestureEventAck(int gesture_event_type) override {
+  void GestureEventAck(int gesture_event_type) override {
     last_gesture_ack_type_ =
         static_cast<WebInputEvent::Type>(gesture_event_type);
     TouchEditableImplAura::GestureEventAck(gesture_event_type);
     if (waiting_for_gesture_ack_type_ == gesture_event_type)
       gesture_ack_wait_run_loop_->Quit();
   }
 
-  virtual void DidStopFlinging() override {
+  void DidStopFlinging() override {
     fling_stop_callback_arrived_ = true;
     TouchEditableImplAura::DidStopFlinging();
     if (waiting_for_fling_stop_callback_)
       fling_stop_wait_run_loop_->Quit();
   }
 
   virtual void WaitForSelectionChangeCallback() {
     if (selection_changed_callback_arrived_)
       return;
     waiting_for_selection_changed_callback_ = true;
@@ skipping 32 matching lines @@
   scoped_ptr<base::RunLoop> fling_stop_wait_run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTouchEditableImplAura);
 };
 
 class TouchEditableImplAuraTest : public ContentBrowserTest {
  public:
   TouchEditableImplAuraTest() {}
 
  protected:
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpOnMainThread() override {
+    ContentBrowserTest::SetUpOnMainThread();
+    aura::client::SetScreenPositionClient(shell()->window()->GetRootWindow(),
+                                          &screen_position_client_);
+  }
+
+  void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kEnableTouchEditing);
   }
 
   // Executes the javascript synchronously and makes sure the returned value is
   // freed properly.
   void ExecuteSyncJSFunction(RenderFrameHost* rfh, const std::string& jscript) {
     scoped_ptr<base::Value> value =
         content::ExecuteScriptAndGetValue(rfh, jscript);
   }
 
@@ skipping 16 matching lines @@
   ui::TouchSelectionController* GetTouchSelectionController(
       TouchEditableImplAura* touch_editable) {
     return touch_editable->touch_selection_controller_.get();
   }
 
   ui::TextInputType GetTextInputType(TouchEditableImplAura* touch_editable) {
     return touch_editable->text_input_type_;
   }
 
  private:
+  wm::DefaultScreenPositionClient screen_position_client_;
+
   DISALLOW_COPY_AND_ASSIGN(TouchEditableImplAuraTest);
 };
 
 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        TouchSelectionOriginatingFromWebpageTest) {
   ASSERT_NO_FATAL_FAILURE(StartTestWithPage("files/touch_selection.html"));
   WebContentsImpl* web_contents =
       static_cast<WebContentsImpl*>(shell()->web_contents());
   RenderFrameHost* main_frame = web_contents->GetMainFrame();
   WebContentsViewAura* view_aura = static_cast<WebContentsViewAura*>(
@@ skipping 18 matching lines @@
       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
   std::string selection;
   value->GetAsString(&selection);
 
   // Check if selection handles are showing.
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
   EXPECT_STREQ("Some text we can select", selection.c_str());
 
   // Lets move the handles a bit to modify the selection
   touch_editable->Reset();
+  ui::SelectionBound anchor, focus;
+  touch_editable->GetSelectionEndPoints(&anchor, &focus);
+  int handle_grab_x = bounds.x() + anchor.edge_bottom.x();
+  int handle_grab_y = bounds.y() + anchor.edge_bottom.y() + 1;
   generator.GestureScrollSequence(
-      gfx::Point(10, 47),
-      gfx::Point(30, 47),
+      gfx::Point(handle_grab_x, handle_grab_y),
+      gfx::Point(handle_grab_x + 20, handle_grab_y),
       base::TimeDelta::FromMilliseconds(20),
       5);
   touch_editable->WaitForSelectionChangeCallback();
 
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
   value = content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
   value->GetAsString(&selection);
 
   // It is hard to tell what exactly the selection would be now. But it would
   // definitely be less than whatever was selected before.
@@ skipping 233 matching lines @@
   value = content::ExecuteScriptAndGetValue(main_frame,
                                             "get_cursor_position()");
   int new_cursor_pos = -1;
   value->GetAsInteger(&new_cursor_pos);
   EXPECT_NE(-1, new_cursor_pos);
   // Cursor should have moved.
   EXPECT_NE(new_cursor_pos, cursor_pos);
 }
 
 }  // namespace content