Wait for SHOW_PRESS gesture to avoid flake in root_window_unittest.cc

ui/aura/root_window_unittest.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 "ui/aura/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 412 matching lines @@
 }
 
 namespace {
 
 // FilterFilter that tracks the types of events it's seen.
 class EventFilterRecorder : public ui::EventHandler {
  public:
   typedef std::vector<ui::EventType> Events;
   typedef std::vector<gfx::Point> EventLocations;
 
-  EventFilterRecorder() {}
+  EventFilterRecorder()
+      : wait_until_event_(ui::ET_UNKNOWN) {
+  }
 
   const Events& events() const { return events_; }
 
   const EventLocations& mouse_locations() const { return mouse_locations_; }
   gfx::Point mouse_location(int i) const { return mouse_locations_[i]; }
   const EventLocations& touch_locations() const { return touch_locations_; }
 
+  void WaitUntilReceivedGesture(ui::EventType type) {

[sadrul, 2014/01/15 19:08:59]

Call this WaitUntilReceivedEvent

[tdresser, 2014/01/15 19:30:41]

Done.

+    wait_until_event_ = type;
+    run_loop_.reset(new base::RunLoop(
+        Env::GetInstance()->GetDispatcher()));
+    run_loop_->Run();
+  }
+
   Events GetAndResetEvents() {
     Events events = events_;
     Reset();
     return events;
   }
 
   void Reset() {
     events_.clear();
     mouse_locations_.clear();
     touch_locations_.clear();
   }
 
   // ui::EventHandler overrides:
   virtual void OnEvent(ui::Event* event) OVERRIDE {
     ui::EventHandler::OnEvent(event);
     events_.push_back(event->type());
   }
 
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     mouse_locations_.push_back(event->location());
   }
 
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
     touch_locations_.push_back(event->location());
   }
 
+  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+    if (wait_until_event_ == event->type() && run_loop_) {
+      run_loop_->Quit();
+      wait_until_event_ = ui::ET_UNKNOWN;

[sadrul, 2014/01/15 19:08:59]

Do this in OnEvent

[tdresser, 2014/01/15 19:30:41]

Done.

+    }
+  }
+
  private:
+  scoped_ptr<base::RunLoop> run_loop_;
+  ui::EventType wait_until_event_;
+
   Events events_;
   EventLocations mouse_locations_;
   EventLocations touch_locations_;
 
   DISALLOW_COPY_AND_ASSIGN(EventFilterRecorder);
 };
 
 // Converts an EventType to a string.
 std::string EventTypeToString(ui::EventType type) {
   switch (type) {
@@ skipping 184 matching lines @@
       &mouse_dragged_event);
   dispatcher()->ReleasePointerMoves();
   dispatcher()->AsWindowTreeHostDelegate()->OnHostMouseEvent(
       &mouse_dragged_event2);
   EXPECT_EQ("MOUSE_DRAGGED", EventTypesToString(filter->events()));
   filter->Reset();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(filter->events().empty());
 }
 
-#if defined(OS_CHROMEOS)
-// This test may be flaky on Chromium OS valgrind bots: http://crbug.com/333644
-#define MAYBE_TouchMovesHeld DISABLED_TouchMovesHeld
-#else
-#define MAYBE_TouchMovesHeld TouchMovesHeld
-#endif
-TEST_F(RootWindowTest, MAYBE_TouchMovesHeld) {
+TEST_F(RootWindowTest, TouchMovesHeld) {
   EventFilterRecorder* filter = new EventFilterRecorder;
   root_window()->SetEventFilter(filter);  // passes ownership
 
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(50, 50, 100, 100), root_window()));
 
   const gfx::Point touch_location(60, 60);
   // Starting the touch and throwing out the first few events, since the system
   // is going to generate synthetic mouse events that are not relevant to the
   // test.
   ui::TouchEvent touch_pressed_event(ui::ET_TOUCH_PRESSED, touch_location,
                                      0, base::TimeDelta());
   dispatcher()->AsWindowTreeHostDelegate()->OnHostTouchEvent(
       &touch_pressed_event);
-  RunAllPendingInMessageLoop();
+  filter->WaitUntilReceivedGesture(ui::ET_GESTURE_SHOW_PRESS);
   filter->Reset();
 
   dispatcher()->HoldPointerMoves();
 
   // Check that we don't immediately dispatch the TOUCH_MOVED event.
   ui::TouchEvent touch_moved_event(ui::ET_TOUCH_MOVED, touch_location,
                                    0, base::TimeDelta());
   dispatcher()->AsWindowTreeHostDelegate()->OnHostTouchEvent(
       &touch_moved_event);
   EXPECT_TRUE(filter->events().empty());
@@ skipping 897 matching lines @@
   CHECK(!message_loop()->is_running());
   // Perform the test in a callback, so that it runs after the message-loop
   // starts.
   message_loop()->PostTask(FROM_HERE,
                            base::Bind(&RootWindowTestWithMessageLoop::RunTest,
                                       base::Unretained(this)));
   message_loop()->Run();
 }
 
 }  // namespace aura