Re-enable TouchSelectionOriginatingFromWebpageTest with some fixes and logs

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"
@@ skipping 10 matching lines @@
 #include "content/test/content_browser_test_utils.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/window.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 
 namespace content {
 
+// TODO(mohsen): Remove logs if the test showed no flakiness anymore.
 class TestTouchEditableImplAura : public TouchEditableImplAura {
  public:
   TestTouchEditableImplAura()
       : selection_changed_callback_arrived_(false),
         waiting_for_selection_changed_callback_(false),
         gesture_ack_callback_arrived_(false),
         waiting_for_gesture_ack_callback_(false) {}
 
   void Reset() {
+    LOG(INFO) << "TestTouchEditableImplAura::Reset()";
     selection_changed_callback_arrived_ = false;
     waiting_for_selection_changed_callback_ = false;
     gesture_ack_callback_arrived_ = false;
     waiting_for_gesture_ack_callback_ = false;
   }
 
   virtual void OnSelectionOrCursorChanged(const gfx::Rect& anchor,
                                           const gfx::Rect& focus) OVERRIDE {
+    LOG(INFO) << "TestTouchEditableImplAura::OnSelectionOrCursorChanged("
+              << anchor.ToString() << ", " << focus.ToString() << ")";
     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 {
+    LOG(INFO) << "TestTouchEditableImplAura::GestureEventAck("
+              << gesture_event_type << ")";
     gesture_ack_callback_arrived_ = true;
     TouchEditableImplAura::GestureEventAck(gesture_event_type);
     if (waiting_for_gesture_ack_callback_)
       gesture_ack_wait_run_loop_->Quit();
   }
 
   void WaitForSelectionChangeCallback() {
+    LOG(INFO) << "TestTouchEditableImplAura::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();
   }
 
   void WaitForGestureAck() {
+    LOG(INFO) << "TestTouchEditableImplAura::WaitForGestureAck()";
     if (gesture_ack_callback_arrived_)
       return;
     waiting_for_gesture_ack_callback_ = true;
     gesture_ack_wait_run_loop_.reset(new base::RunLoop());
     gesture_ack_wait_run_loop_->Run();
   }
 
  protected:
   virtual ~TestTouchEditableImplAura() {}
 
@@ skipping 28 matching lines @@
   // 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()->GetView()->GetContentNativeView();
     content->GetRootWindow()->SetHostSize(gfx::Size(800, 600));
   }
 
+  // TODO(mohsen): Remove logs if the test showed no flakiness anymore.
   void TestTouchSelectionOriginatingFromWebpage() {
     ASSERT_NO_FATAL_FAILURE(
         StartTestWithPage("files/touch_selection.html"));
     WebContentsImpl* web_contents =
         static_cast<WebContentsImpl*>(shell()->web_contents());
     RenderViewHostImpl* view_host = static_cast<RenderViewHostImpl*>(
         web_contents->GetRenderViewHost());
     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->GetView()->GetContentNativeView();
     aura::test::EventGenerator generator(content->GetRootWindow(), content);
     gfx::Rect bounds = content->GetBoundsInRootWindow();
 
+    LOG(INFO) << "Select text and wait for selection change.";
     touch_editable->Reset();
     ExecuteSyncJSFunction(view_host, "select_all_text()");
     touch_editable->WaitForSelectionChangeCallback();
 
+    LOG(INFO) << "Tap on selection to bring up handles.";
     // Tap inside selection to bring up selection handles.
     generator.GestureTapAt(gfx::Point(bounds.x() + 10, bounds.y() + 10));
     EXPECT_EQ(touch_editable->rwhva_, rwhva);
 
+    LOG(INFO) << "Get selection.";
     scoped_ptr<base::Value> value =
         content::ExecuteScriptAndGetValue(view_host, "get_selection()");
     std::string selection;
     value->GetAsString(&selection);
 
+    LOG(INFO) << "Test handles and selection.";
     // Check if selection handles are showing.
     EXPECT_TRUE(touch_editable->touch_selection_controller_.get());
     EXPECT_STREQ("Some text we can select", selection.c_str());
 
+    LOG(INFO) << "Drag handles to modify the selection.";
     // Lets move the handles a bit to modify the selection
     touch_editable->Reset();
     generator.GestureScrollSequence(
         gfx::Point(10, 47),
         gfx::Point(30, 47),
         base::TimeDelta::FromMilliseconds(20),
         1);
+    LOG(INFO) << "Handle moved. Now, waiting for selection to change.";
+    touch_editable->WaitForSelectionChangeCallback();
+    LOG(INFO) << "Selection changed.";
+
+    LOG(INFO) << "Test selection.";
     EXPECT_TRUE(touch_editable->touch_selection_controller_.get());
     value = content::ExecuteScriptAndGetValue(view_host, "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());
   }
 
   void TestTouchSelectionOnLongPress() {
@@ skipping 157 matching lines @@
     value->GetAsInteger(&new_cursor_pos);
     EXPECT_NE(-1, new_cursor_pos);
     // Cursor should have moved.
     EXPECT_NE(new_cursor_pos, cursor_pos);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TouchEditableImplAuraTest);
 };
 
-#if defined(OS_CHROMEOS)
-#define MAYBE_TouchSelectionOriginatingFromWebpageTest \
-    DISABLED_TouchSelectionOriginatingFromWebpageTest
-#else
-#define MAYBE_TouchSelectionOriginatingFromWebpageTest \
-    TouchSelectionOriginatingFromWebpageTest
-#endif
 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
-                       MAYBE_TouchSelectionOriginatingFromWebpageTest) {
+                       TouchSelectionOriginatingFromWebpageTest) {
   TestTouchSelectionOriginatingFromWebpage();
 }
 
 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        TestTouchSelectionHiddenWhenScrolling) {
   TestTouchSelectionHiddenWhenScrolling();
 }
 
 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        TouchSelectionOnLongPressTest) {
   TestTouchSelectionOnLongPress();
 }
 
 // TODO(miu): Disabled test due to flakiness.  http://crbug.com/235991
 IN_PROC_BROWSER_TEST_F(TouchEditableImplAuraTest,
                        DISABLED_TouchCursorInTextfieldTest) {
   TestTouchCursorInTextfield();
 }
 
 }  // namespace content