Create content\public\test\test_utils.h to hold common test classes that are used by unit and brows…

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_
 
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.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_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/ui_controls/ui_controls.h"
 #include "webkit/glue/window_open_disposition.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
@@ skipping 15 matching lines @@
 class ScopedTempDir;
 class SkBitmap;
 class TabContents;
 class TemplateURLService;
 
 namespace chrome {
 struct NavigateParams;
 }
 
 namespace content {
+class MessageLoopRunner;
 class RenderViewHost;
 class RenderWidgetHost;
 class WebContents;
 }
 
 namespace gfx {
 class Point;
 class Rect;
 class Size;
 }
@@ skipping 220 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;
 
-// 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:
-  MessageLoopRunner();
-
-  // Run the current MessageLoop.
-  void Run();
-
-  // Quit the matching call to Run (nested MessageLoops are unaffected).
-  void Quit();
-
-  // Hand this closure off to code that uses callbacks to notify completion.
-  // Example:
-  //   scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner;
-  //   kick_off_some_api(runner.QuitNowClosure());
-  //   runner.Run();
-  base::Closure QuitClosure();
-
- private:
-  friend class base::RefCounted<MessageLoopRunner>;
-  ~MessageLoopRunner();
-
-  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
 // |root_directory| will be found and active while running the test
 // server.
@@ skipping 44 matching lines @@
 
   // Holds port number which the python websocket server uses.
   int port_;
 
   // If the python websocket server serves with TLS.
   bool secure_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebSocketServer);
 };
 
-// A WindowedNotificationObserver allows code to watch for a notification
-// over a window of time. Typically testing code will need to do something
-// like this:
-//   PerformAction()
-//   WaitForCompletionNotification()
-// This leads to flakiness as there's a window between PerformAction returning
-// and the observers getting registered, where a notification will be missed.
-//
-// Rather, one can do this:
-//   WindowedNotificationObserver signal(...)
-//   PerformAction()
-//   signal.Wait()
-class WindowedNotificationObserver : public content::NotificationObserver {
- public:
-  // Register to listen for notifications of the given type from either a
-  // specific source, or from all sources if |source| is
-  // NotificationService::AllSources().
-  WindowedNotificationObserver(int notification_type,
-                               const content::NotificationSource& source);
-  virtual ~WindowedNotificationObserver();
-
-  // Wait until the specified notification occurs.  If the notification was
-  // emitted between the construction of this object and this call then it
-  // returns immediately.
-  void Wait();
-
-  // Returns NotificationService::AllSources() if we haven't observed a
-  // notification yet.
-  const content::NotificationSource& source() const {
-    return source_;
-  }
-
-  const content::NotificationDetails& details() const {
-    return details_;
-  }
-
-  // content::NotificationObserver:
-  virtual void Observe(int type,
-                       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 content::WindowedNotificationObserver {
  public:
   // Register to listen for notifications of NOTIFICATION_TAB_ADDED from either
   // a specific source, or from all sources if |source| is
   // NotificationService::AllSources().
   explicit WindowedTabAddedNotificationObserver(
       const content::NotificationSource& source);
 
   // Returns the added tab, or NULL if no notification was observed yet.
   content::WebContents* GetTab() { return added_tab_; }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::WebContents* added_tab_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowedTabAddedNotificationObserver);
 };
 
 // Similar to WindowedNotificationObserver but also provides a way of retrieving
 // the details associated with the notification.
 // Note that in order to use that class the details class should be copiable,
 // which is the case with most notifications.
 template <class U>
 class WindowedNotificationObserverWithDetails
-    : public WindowedNotificationObserver {
+    : public content::WindowedNotificationObserver {
  public:
   WindowedNotificationObserverWithDetails(
       int notification_type,
       const content::NotificationSource& source)
-      : WindowedNotificationObserver(notification_type, source) {}
+      : content::WindowedNotificationObserver(notification_type, source) {}
 
   // Fills |details| with the details of the notification received for |source|.
   bool GetDetailsFor(uintptr_t source, U* details) {
     typename std::map<uintptr_t, U>::const_iterator iter =
         details_.find(source);
     if (iter == details_.end())
       return false;
     *details = iter->second;
     return true;
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) {
     const U* details_ptr = content::Details<U>(details).ptr();
     if (details_ptr)
       details_[source.map_key()] = *details_ptr;
-    WindowedNotificationObserver::Observe(type, source, details);
+    content::WindowedNotificationObserver::Observe(type, source, details);
   }
 
  private:
   std::map<uintptr_t, U> details_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowedNotificationObserverWithDetails);
 };
 
 // Watches title changes on a tab, blocking until an expected title is set.
 class TitleWatcher : public content::NotificationObserver {
@@ skipping 15 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_;
+  scoped_refptr<content::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);
 };
 
 // Convenience class for waiting for a new browser to be created.
 // Like WindowedNotificationObserver, this class provides a safe, non-racey
 // way to wait for a new browser to be created.
 class BrowserAddedObserver {
  public:
   BrowserAddedObserver();
   ~BrowserAddedObserver();
 
   // Wait for a new browser to be created, and return a pointer to it.
   Browser* WaitForSingleNewBrowser();
 
  private:
-  WindowedNotificationObserver notification_observer_;
+  content::WindowedNotificationObserver notification_observer_;
   std::set<Browser*> original_browsers_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserAddedObserver);
 };
 
 // See SendKeyPressAndWait.  This function additionally performs a check on the
 // NotificationDetails using the provided Details<U>.
 template <class U>
 bool SendKeyPressAndWaitWithDetails(
     const Browser* browser,
@@ skipping 56 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_;
+  scoped_refptr<content::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_