Add base::RunLoop and update ui_test_utils to use it to reduce flakiness

chrome/test/base/ui_test_utils.h

 // 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.
 
 #ifndef CHROME_TEST_BASE_UI_TEST_UTILS_H_
 #define CHROME_TEST_BASE_UI_TEST_UTILS_H_
 #pragma once
 
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
-#include "base/message_loop.h"
 #include "base/process.h"
+#include "base/run_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string16.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/test/automation/dom_element_proxy.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 61 matching lines @@
   BROWSER_TEST_MASK = BROWSER_TEST_WAIT_FOR_BROWSER |
                       BROWSER_TEST_WAIT_FOR_TAB |
                       BROWSER_TEST_WAIT_FOR_NAVIGATION
 };
 
 // Turns on nestable tasks, runs the message loop, then resets nestable tasks
 // to what they were originally. Prefer this over MessageLoop::Run for in
 // process browser tests that need to block until a condition is met.
 void RunMessageLoop();
 
+// Variant of RunMessageLoop that takes RunLoop.
+void RunRunLoop(const base::WeakPtr<base::RunLoop>& run_loop);
+
+// Quit the given RunLoop. Allows a few generations of pending tasks to run.
+void QuitRunLoop(const base::WeakPtr<base::RunLoop>& run_loop);
+
 // Turns on nestable tasks, runs all pending tasks in the message loop,
 // then resets nestable tasks to what they were originally. Prefer this
 // over MessageLoop::RunAllPending for in process browser tests to run
 // all pending tasks.
 void RunAllPendingInMessageLoop();
 
 // Blocks the current thread until all the pending messages in the loop of the
 // thread |thread_id| have been processed.
 void RunAllPendingInMessageLoop(content::BrowserThread::ID thread_id);
 
@@ skipping 185 matching lines @@
                          const content::NotificationSource& source)
                              WARN_UNUSED_RESULT;
 
 // Sends a move event blocking until received. Returns true if the event was
 // successfully received. This uses ui_controls::SendMouse***NotifyWhenDone,
 // see it for details.
 bool SendMouseMoveSync(const gfx::Point& location) WARN_UNUSED_RESULT;
 bool SendMouseEventsSync(ui_controls::MouseButton type,
                          int state) WARN_UNUSED_RESULT;
 
-// Run a message loop only for the specified amount of time.
-class TimedMessageLoopRunner {
+// Helper class to Run and Quit the message loop. Run and Quit can only happen
+// once per instance. Make a new instance for each use. Calling Quit after Run
+// has returned is safe and has no effect.
+class MessageLoopRunner
+    : public base::RefCounted<MessageLoopRunner> {
  public:
-  // Create new MessageLoopForUI and attach to it.
-  TimedMessageLoopRunner();
+  MessageLoopRunner();
 
-  // Attach to an existing message loop.
-  explicit TimedMessageLoopRunner(MessageLoop* loop)
-      : loop_(loop), owned_(false), quit_loop_invoked_(false) {}
+  // Run the current MessageLoop. This can't be called recursively.
+  void Run();
 
-  ~TimedMessageLoopRunner();
+  // Quit the matching call to Run (nested MessageLoops are unaffected).
+  void QuitNow();
 
-  // Run the message loop for ms milliseconds.
-  void RunFor(int ms);
-
-  // Post Quit task to the message loop.
-  void Quit();
-
-  // Post delayed Quit task to the message loop.
-  void QuitAfter(int ms);
-
-  bool WasTimedOut() const {
-    return !quit_loop_invoked_;
-  }
+  // Hand this closure off to code that uses callbacks to notify completion.
+  // Example:
+  //   scoped_refptr<MessageLoopRunner> runner =
+  //       new MessageLoopRunner;
+  //   // Must be no nested MessageLoop::Run calls during kick_off_some_api:
+  //   kick_off_some_api(runner.QuitNowClosure());
+  //   runner.Run();
+  base::Closure QuitNowClosure();
 
  private:
-  MessageLoop* loop_;
-  bool owned_;
-  bool quit_loop_invoked_;
+  friend class base::RefCounted<MessageLoopRunner>;
+  ~MessageLoopRunner();
 
-  DISALLOW_COPY_AND_ASSIGN(TimedMessageLoopRunner);
+  base::RunLoop run_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(MessageLoopRunner);
 };
 
 // This is a utility class for running a python websocket server
 // during tests. The server is started during the construction of the
 // object, and is stopped when the destructor is called. Note that
 // because of the underlying script that is used:
 //
 //    third_paty/WebKit/Tools/Scripts/new-run-webkit-websocketserver
 //
 // Only *_wsh.py handlers found under "http/tests/websocket/tests" from the
@@ skipping 94 matching lines @@
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   bool seen_;
   bool running_;
   content::NotificationRegistrar registrar_;
 
   content::NotificationSource source_;
   content::NotificationDetails details_;
+  scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowedNotificationObserver);
 };
 
 // A WindowedNotificationObserver hard-wired to observe
 // chrome::NOTIFICATION_TAB_ADDED.
 class WindowedTabAddedNotificationObserver
     : public WindowedNotificationObserver {
  public:
   // Register to listen for notifications of NOTIFICATION_TAB_ADDED from either
@@ skipping 73 matching lines @@
 
  private:
   // content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   content::WebContents* web_contents_;
   std::vector<string16> expected_titles_;
   content::NotificationRegistrar notification_registrar_;
+  scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   // The most recently observed expected title, if any.
   string16 observed_title_;
 
   bool expected_title_observed_;
   bool quit_loop_on_observation_;
 
   DISALLOW_COPY_AND_ASSIGN(TitleWatcher);
 };
 
@@ skipping 79 matching lines @@
 
   // Overridden content::NotificationObserver methods.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   std::queue<std::string> message_queue_;
   bool waiting_for_message_;
+  scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(DOMMessageQueue);
 };
 
 // Takes a snapshot of the given render widget, rendered at |page_size|. The
 // snapshot is set to |bitmap|. Returns true on success.
 bool TakeRenderWidgetSnapshot(content::RenderWidgetHost* rwh,
                               const gfx::Size& page_size,
                               SkBitmap* bitmap) WARN_UNUSED_RESULT;
 
@@ skipping 38 matching lines @@
 // ui_controls_linux.cc and ui_controls_mac.cc
 void ClickTask(ui_controls::MouseButton button,
                int state,
                const base::Closure& followup);
 
 }  // namespace internal
 
 }  // namespace ui_test_utils
 
 #endif  // CHROME_TEST_BASE_UI_TEST_UTILS_H_