content/browser/web_contents/touch_editable_impl_aura_browsertest.cc - chromium/src - Git at Google

 // 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;
   }

   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();
   }

   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();
   }

   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;
     selection_changed_wait_run_loop_.reset(new base::RunLoop());
     selection_changed_wait_run_loop_->Run();
   }

   virtual void WaitForGestureAck(WebInputEvent::Type gesture_event_type) {
     if (last_gesture_ack_type_ == gesture_event_type)
       return;
     waiting_for_gesture_ack_type_ = gesture_event_type;
     gesture_ack_wait_run_loop_.reset(new base::RunLoop());
     gesture_ack_wait_run_loop_->Run();
   }

   virtual void WaitForFlingStopCallback() {
     if (fling_stop_callback_arrived_)
       return;
     waiting_for_fling_stop_callback_ = true;
     fling_stop_wait_run_loop_.reset(new base::RunLoop());
     fling_stop_wait_run_loop_->Run();
   }

  protected:
   ~TestTouchEditableImplAura() override {}

  private:
   bool selection_changed_callback_arrived_;
   bool waiting_for_selection_changed_callback_;
   WebInputEvent::Type waiting_for_gesture_ack_type_;
   WebInputEvent::Type last_gesture_ack_type_;
   bool fling_stop_callback_arrived_;
   bool waiting_for_fling_stop_callback_;
   scoped_ptr<base::RunLoop> selection_changed_wait_run_loop_;
   scoped_ptr<base::RunLoop> gesture_ack_wait_run_loop_;
   scoped_ptr<base::RunLoop> fling_stop_wait_run_loop_;

   DISALLOW_COPY_AND_ASSIGN(TestTouchEditableImplAura);
 };

 class TouchEditableImplAuraTest : public ContentBrowserTest {
  public:
   TouchEditableImplAuraTest() {}

  protected:
   void SetUpOnMainThread() override {
     ContentBrowserTest::SetUpOnMainThread();
     aura::client::SetScreenPositionClient(shell()->window()->GetRootWindow(),
                                           &screen_position_client_);
   }

   void SetUpCommandLine(base::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);
   }

   // Starts the test server and navigates to the given url. Sets a large enough
   // size to the root window.  Returns after the navigation to the url is
   // complete.
   void StartTestWithPage(const std::string& url) {
     ASSERT_TRUE(test_server()->Start());
     GURL test_url(test_server()->GetURL(url));
     NavigateToURL(shell(), test_url);
     aura::Window* content = shell()->web_contents()->GetContentNativeView();
     content->GetHost()->SetBounds(gfx::Rect(800, 600));
   }

   RenderWidgetHostViewAura* GetRenderWidgetHostViewAura(
       TouchEditableImplAura* touch_editable) {
     return touch_editable->rwhva_;
   }

   ui::TouchEditingControllerDeprecated* 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*>(
       web_contents->GetView());
   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
   view_aura->SetTouchEditableForTest(touch_editable);
   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView());
   aura::Window* content = web_contents->GetContentNativeView();
   ui::test::EventGenerator generator(content->GetRootWindow(), content);
   gfx::Rect bounds = content->GetBoundsInRootWindow();

   touch_editable->Reset();
   ExecuteSyncJSFunction(main_frame, "select_all_text()");
   touch_editable->WaitForSelectionChangeCallback();

   // Tap inside selection to bring up selection handles.
   generator.GestureTapAt(gfx::Point(bounds.x() + 10, bounds.y() + 10));
   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

   scoped_ptr<base::Value> value =
       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);
   // The distance by which a handle image is offset from the bottom of the
   // selection/text baseline.
   const int kSelectionHandleVerticalVisualOffset = 2;
   int handle_grab_x = bounds.x() + anchor.edge_bottom_rounded().x();
   int handle_grab_y = bounds.y() + anchor.edge_bottom_rounded().y() +
                       kSelectionHandleVerticalVisualOffset + 1;
   generator.GestureScrollSequence(
       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.
   EXPECT_GT(std::strlen("Some text we can select"), selection.size());
 }

 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        TestTouchSelectionHiddenWhenScrolling) {
   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*>(
       web_contents->GetView());
   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
   view_aura->SetTouchEditableForTest(touch_editable);
   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView());
   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

   // Long press to select word.
   ui::GestureEvent long_press(
       10,
       10,
       0,
       ui::EventTimeForNow(),
       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
   touch_editable->Reset();
   rwhva->OnGestureEvent(&long_press);
   touch_editable->WaitForSelectionChangeCallback();

   // Check if selection handles are showing.
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));

   scoped_ptr<base::Value> value =
       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
   std::string selection;
   value->GetAsString(&selection);
   EXPECT_STREQ("Some", selection.c_str());

   // Start scrolling. Handles should get hidden.
   ui::GestureEvent scroll_begin(
       10,
       10,
       0,
       ui::EventTimeForNow(),
       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN));
   rwhva->OnGestureEvent(&scroll_begin);
   EXPECT_FALSE(GetTouchSelectionController(touch_editable));

   // Handles should come back after scroll ends.
   ui::GestureEvent scroll_end(
       10,
       10,
       0,
       ui::EventTimeForNow(),
       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_END));
   rwhva->OnGestureEvent(&scroll_end);
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 }

 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        TestTouchSelectionReshownAfterFling) {
   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*>(
       web_contents->GetView());
   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
   view_aura->SetTouchEditableForTest(touch_editable);
   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView());
   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

   // Long press to select word.
   ui::GestureEvent long_press(
       10,
       10,
       0,
       ui::EventTimeForNow(),
       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
   touch_editable->Reset();
   rwhva->OnGestureEvent(&long_press);
   touch_editable->WaitForSelectionChangeCallback();

   // Check if selection handles are showing.
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));

   scoped_ptr<base::Value> value =
       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
   std::string selection;
   value->GetAsString(&selection);
   EXPECT_STREQ("Some", selection.c_str());

   // Start scrolling. Handles should get hidden.
   ui::GestureEvent scroll_begin(
       10,
       10,
       0,
       ui::EventTimeForNow(),
       ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN, 0, 0));
   rwhva->OnGestureEvent(&scroll_begin);
   EXPECT_FALSE(GetTouchSelectionController(touch_editable));

   // Start a fling. Handles should come back after fling stops.
   ui::GestureEvent fling_start(
       10,
       10,
       0,
       ui::EventTimeForNow(),
       ui::GestureEventDetails(ui::ET_SCROLL_FLING_START, 1, 0));
   rwhva->OnGestureEvent(&fling_start);
   touch_editable->WaitForFlingStopCallback();
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
 }

 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        TouchSelectionOnLongPressTest) {
   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*>(
       web_contents->GetView());
   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
   view_aura->SetTouchEditableForTest(touch_editable);
   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView());
   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

   // Long press to select word.
   ui::GestureEvent long_press(
       10,
       10,
       0,
       ui::EventTimeForNow(),
       ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
   touch_editable->Reset();
   rwhva->OnGestureEvent(&long_press);
   touch_editable->WaitForSelectionChangeCallback();

   // Check if selection handles are showing.
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));

   scoped_ptr<base::Value> value =
       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
   std::string selection;
   value->GetAsString(&selection);
   EXPECT_STREQ("Some", selection.c_str());
 }

 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        NoTouchSelectionOnDoubleTapTest) {
   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*>(web_contents->GetView());
   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
   view_aura->SetTouchEditableForTest(touch_editable);
   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView());
   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

   // Double-tap to select word.
   ui::GestureEventDetails details(ui::ET_GESTURE_TAP);
   details.set_tap_count(2);
   ui::GestureEvent double_tap(10, 10, 0, ui::EventTimeForNow(), details);
   touch_editable->Reset();
   rwhva->OnGestureEvent(&double_tap);
   touch_editable->WaitForSelectionChangeCallback();

   // Make sure touch selection handles are not showing.
   EXPECT_FALSE(GetTouchSelectionController(touch_editable));

   scoped_ptr<base::Value> value =
       content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
   std::string selection;
   value->GetAsString(&selection);
   EXPECT_STREQ("Some", selection.c_str());
 }

 #if defined(OS_CHROMEOS)
 // http://crbug.com/396509
 #define MAYBE_TouchCursorInTextfieldTest DISABLED_TouchCursorInTextfieldTest
 #else
 #define MAYBE_TouchCursorInTextfieldTest TouchCursorInTextfieldTest
 #endif
 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        MAYBE_TouchCursorInTextfieldTest) {
   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*>(
       web_contents->GetView());
   TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
   view_aura->SetTouchEditableForTest(touch_editable);
   RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView());
   aura::Window* content = web_contents->GetContentNativeView();
   ui::test::EventGenerator generator(content->GetRootWindow(), content);
   gfx::Rect bounds = content->GetBoundsInRootWindow();
   EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

   ExecuteSyncJSFunction(main_frame, "focus_textfield()");
   touch_editable->WaitForSelectionChangeCallback();

   // Tap textfield
   touch_editable->Reset();
   generator.GestureTapAt(gfx::Point(bounds.x() + 50, bounds.y() + 40));
   // Tap Down acks are sent synchronously, while Tap acks are asynchronous.
   touch_editable->WaitForGestureAck(WebInputEvent::GestureTap);
   touch_editable->WaitForSelectionChangeCallback();
   touch_editable->Reset();

   // Check if cursor handle is showing.
   EXPECT_NE(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType(touch_editable));
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));

   scoped_ptr<base::Value> value =
       content::ExecuteScriptAndGetValue(main_frame, "get_cursor_position()");
   int cursor_pos = -1;
   value->GetAsInteger(&cursor_pos);
   EXPECT_NE(-1, cursor_pos);

   // Move the cursor handle.
   generator.GestureScrollSequence(
       gfx::Point(50, 59),
       gfx::Point(10, 59),
       base::TimeDelta::FromMilliseconds(20),
       1);
   touch_editable->WaitForSelectionChangeCallback();
   EXPECT_TRUE(GetTouchSelectionController(touch_editable));
   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
	// 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;
	}

	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();
	}

	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();
	}

	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;
	selection_changed_wait_run_loop_.reset(new base::RunLoop());
	selection_changed_wait_run_loop_->Run();
	}

	virtual void WaitForGestureAck(WebInputEvent::Type gesture_event_type) {
	if (last_gesture_ack_type_ == gesture_event_type)
	return;
	waiting_for_gesture_ack_type_ = gesture_event_type;
	gesture_ack_wait_run_loop_.reset(new base::RunLoop());
	gesture_ack_wait_run_loop_->Run();
	}

	virtual void WaitForFlingStopCallback() {
	if (fling_stop_callback_arrived_)
	return;
	waiting_for_fling_stop_callback_ = true;
	fling_stop_wait_run_loop_.reset(new base::RunLoop());
	fling_stop_wait_run_loop_->Run();
	}

	protected:
	~TestTouchEditableImplAura() override {}

	private:
	bool selection_changed_callback_arrived_;
	bool waiting_for_selection_changed_callback_;
	WebInputEvent::Type waiting_for_gesture_ack_type_;
	WebInputEvent::Type last_gesture_ack_type_;
	bool fling_stop_callback_arrived_;
	bool waiting_for_fling_stop_callback_;
	scoped_ptr<base::RunLoop> selection_changed_wait_run_loop_;
	scoped_ptr<base::RunLoop> gesture_ack_wait_run_loop_;
	scoped_ptr<base::RunLoop> fling_stop_wait_run_loop_;

	DISALLOW_COPY_AND_ASSIGN(TestTouchEditableImplAura);
	};

	class TouchEditableImplAuraTest : public ContentBrowserTest {
	public:
	TouchEditableImplAuraTest() {}

	protected:
	void SetUpOnMainThread() override {
	ContentBrowserTest::SetUpOnMainThread();
	aura::client::SetScreenPositionClient(shell()->window()->GetRootWindow(),
	&screen_position_client_);
	}

	void SetUpCommandLine(base::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);
	}

	// Starts the test server and navigates to the given url. Sets a large enough
	// size to the root window. Returns after the navigation to the url is
	// complete.
	void StartTestWithPage(const std::string& url) {
	ASSERT_TRUE(test_server()->Start());
	GURL test_url(test_server()->GetURL(url));
	NavigateToURL(shell(), test_url);
	aura::Window* content = shell()->web_contents()->GetContentNativeView();
	content->GetHost()->SetBounds(gfx::Rect(800, 600));
	}

	RenderWidgetHostViewAura* GetRenderWidgetHostViewAura(
	TouchEditableImplAura* touch_editable) {
	return touch_editable->rwhva_;
	}

	ui::TouchEditingControllerDeprecated* 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*>(
	web_contents->GetView());
	TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
	view_aura->SetTouchEditableForTest(touch_editable);
	RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
	web_contents->GetRenderWidgetHostView());
	aura::Window* content = web_contents->GetContentNativeView();
	ui::test::EventGenerator generator(content->GetRootWindow(), content);
	gfx::Rect bounds = content->GetBoundsInRootWindow();

	touch_editable->Reset();
	ExecuteSyncJSFunction(main_frame, "select_all_text()");
	touch_editable->WaitForSelectionChangeCallback();

	// Tap inside selection to bring up selection handles.
	generator.GestureTapAt(gfx::Point(bounds.x() + 10, bounds.y() + 10));
	EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

	scoped_ptr<base::Value> value =
	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);
	// The distance by which a handle image is offset from the bottom of the
	// selection/text baseline.
	const int kSelectionHandleVerticalVisualOffset = 2;
	int handle_grab_x = bounds.x() + anchor.edge_bottom_rounded().x();
	int handle_grab_y = bounds.y() + anchor.edge_bottom_rounded().y() +
	kSelectionHandleVerticalVisualOffset + 1;
	generator.GestureScrollSequence(
	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.
	EXPECT_GT(std::strlen("Some text we can select"), selection.size());
	}

	IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
	TestTouchSelectionHiddenWhenScrolling) {
	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*>(
	web_contents->GetView());
	TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
	view_aura->SetTouchEditableForTest(touch_editable);
	RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
	web_contents->GetRenderWidgetHostView());
	EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

	// Long press to select word.
	ui::GestureEvent long_press(
	10,
	10,
	0,
	ui::EventTimeForNow(),
	ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
	touch_editable->Reset();
	rwhva->OnGestureEvent(&long_press);
	touch_editable->WaitForSelectionChangeCallback();

	// Check if selection handles are showing.
	EXPECT_TRUE(GetTouchSelectionController(touch_editable));

	scoped_ptr<base::Value> value =
	content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
	std::string selection;
	value->GetAsString(&selection);
	EXPECT_STREQ("Some", selection.c_str());

	// Start scrolling. Handles should get hidden.
	ui::GestureEvent scroll_begin(
	10,
	10,
	0,
	ui::EventTimeForNow(),
	ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN));
	rwhva->OnGestureEvent(&scroll_begin);
	EXPECT_FALSE(GetTouchSelectionController(touch_editable));

	// Handles should come back after scroll ends.
	ui::GestureEvent scroll_end(
	10,
	10,
	0,
	ui::EventTimeForNow(),
	ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_END));
	rwhva->OnGestureEvent(&scroll_end);
	EXPECT_TRUE(GetTouchSelectionController(touch_editable));
	}

	IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
	TestTouchSelectionReshownAfterFling) {
	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*>(
	web_contents->GetView());
	TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
	view_aura->SetTouchEditableForTest(touch_editable);
	RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
	web_contents->GetRenderWidgetHostView());
	EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

	// Long press to select word.
	ui::GestureEvent long_press(
	10,
	10,
	0,
	ui::EventTimeForNow(),
	ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
	touch_editable->Reset();
	rwhva->OnGestureEvent(&long_press);
	touch_editable->WaitForSelectionChangeCallback();

	// Check if selection handles are showing.
	EXPECT_TRUE(GetTouchSelectionController(touch_editable));

	scoped_ptr<base::Value> value =
	content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
	std::string selection;
	value->GetAsString(&selection);
	EXPECT_STREQ("Some", selection.c_str());

	// Start scrolling. Handles should get hidden.
	ui::GestureEvent scroll_begin(
	10,
	10,
	0,
	ui::EventTimeForNow(),
	ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN, 0, 0));
	rwhva->OnGestureEvent(&scroll_begin);
	EXPECT_FALSE(GetTouchSelectionController(touch_editable));

	// Start a fling. Handles should come back after fling stops.
	ui::GestureEvent fling_start(
	10,
	10,
	0,
	ui::EventTimeForNow(),
	ui::GestureEventDetails(ui::ET_SCROLL_FLING_START, 1, 0));
	rwhva->OnGestureEvent(&fling_start);
	touch_editable->WaitForFlingStopCallback();
	EXPECT_TRUE(GetTouchSelectionController(touch_editable));
	}

	IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
	TouchSelectionOnLongPressTest) {
	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*>(
	web_contents->GetView());
	TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
	view_aura->SetTouchEditableForTest(touch_editable);
	RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
	web_contents->GetRenderWidgetHostView());
	EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

	// Long press to select word.
	ui::GestureEvent long_press(
	10,
	10,
	0,
	ui::EventTimeForNow(),
	ui::GestureEventDetails(ui::ET_GESTURE_LONG_PRESS));
	touch_editable->Reset();
	rwhva->OnGestureEvent(&long_press);
	touch_editable->WaitForSelectionChangeCallback();

	// Check if selection handles are showing.
	EXPECT_TRUE(GetTouchSelectionController(touch_editable));

	scoped_ptr<base::Value> value =
	content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
	std::string selection;
	value->GetAsString(&selection);
	EXPECT_STREQ("Some", selection.c_str());
	}

	IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
	NoTouchSelectionOnDoubleTapTest) {
	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*>(web_contents->GetView());
	TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
	view_aura->SetTouchEditableForTest(touch_editable);
	RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
	web_contents->GetRenderWidgetHostView());
	EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

	// Double-tap to select word.
	ui::GestureEventDetails details(ui::ET_GESTURE_TAP);
	details.set_tap_count(2);
	ui::GestureEvent double_tap(10, 10, 0, ui::EventTimeForNow(), details);
	touch_editable->Reset();
	rwhva->OnGestureEvent(&double_tap);
	touch_editable->WaitForSelectionChangeCallback();

	// Make sure touch selection handles are not showing.
	EXPECT_FALSE(GetTouchSelectionController(touch_editable));

	scoped_ptr<base::Value> value =
	content::ExecuteScriptAndGetValue(main_frame, "get_selection()");
	std::string selection;
	value->GetAsString(&selection);
	EXPECT_STREQ("Some", selection.c_str());
	}

	#if defined(OS_CHROMEOS)
	// http://crbug.com/396509
	#define MAYBE_TouchCursorInTextfieldTest DISABLED_TouchCursorInTextfieldTest
	#else
	#define MAYBE_TouchCursorInTextfieldTest TouchCursorInTextfieldTest
	#endif
	IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
	MAYBE_TouchCursorInTextfieldTest) {
	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*>(
	web_contents->GetView());
	TestTouchEditableImplAura* touch_editable = new TestTouchEditableImplAura;
	view_aura->SetTouchEditableForTest(touch_editable);
	RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
	web_contents->GetRenderWidgetHostView());
	aura::Window* content = web_contents->GetContentNativeView();
	ui::test::EventGenerator generator(content->GetRootWindow(), content);
	gfx::Rect bounds = content->GetBoundsInRootWindow();
	EXPECT_EQ(GetRenderWidgetHostViewAura(touch_editable), rwhva);

	ExecuteSyncJSFunction(main_frame, "focus_textfield()");
	touch_editable->WaitForSelectionChangeCallback();

	// Tap textfield
	touch_editable->Reset();
	generator.GestureTapAt(gfx::Point(bounds.x() + 50, bounds.y() + 40));
	// Tap Down acks are sent synchronously, while Tap acks are asynchronous.
	touch_editable->WaitForGestureAck(WebInputEvent::GestureTap);
	touch_editable->WaitForSelectionChangeCallback();
	touch_editable->Reset();

	// Check if cursor handle is showing.
	EXPECT_NE(ui::TEXT_INPUT_TYPE_NONE, GetTextInputType(touch_editable));
	EXPECT_TRUE(GetTouchSelectionController(touch_editable));

	scoped_ptr<base::Value> value =
	content::ExecuteScriptAndGetValue(main_frame, "get_cursor_position()");
	int cursor_pos = -1;
	value->GetAsInteger(&cursor_pos);
	EXPECT_NE(-1, cursor_pos);

	// Move the cursor handle.
	generator.GestureScrollSequence(
	gfx::Point(50, 59),
	gfx::Point(10, 59),
	base::TimeDelta::FromMilliseconds(20),
	1);
	touch_editable->WaitForSelectionChangeCallback();
	EXPECT_TRUE(GetTouchSelectionController(touch_editable));
	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