Moving notification types which are chrome specific to a new header file chrome_notification_type...

chrome/test/ui_test_utils.h

 // Copyright (c) 2011 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_UI_TEST_UTILS_H_
 #define CHROME_TEST_UI_TEST_UTILS_H_
 #pragma once
 
 #include <map>
 #include <queue>
@@ skipping 19 matching lines @@
 class BookmarkModel;
 class BookmarkNode;
 class Browser;
 class CommandLine;
 class DownloadManager;
 class ExtensionAction;
 class FilePath;
 class GURL;
 class MessageLoop;
 class NavigationController;
-class NotificationType;
 class Profile;
 class RenderViewHost;
 class RenderWidgetHost;
 class ScopedTempDir;
 class SkBitmap;
 class TabContents;
 class TabContentsWrapper;
 class Value;
 
 namespace gfx {
@@ skipping 159 matching lines @@
                bool case_sensitive,
                int* ordinal);
 
 // Returns true if the View is focused.
 bool IsViewFocused(const Browser* browser, ViewID vid);
 
 // Simulates a mouse click on a View in the browser.
 void ClickOnView(const Browser* browser, ViewID vid);
 
 // Blocks until a notification for given |type| is received.
-void WaitForNotification(NotificationType type);
+void WaitForNotification(int type);
 
 // Blocks until a notification for given |type| from the specified |source|
 // is received.
-void WaitForNotificationFrom(NotificationType type,
+void WaitForNotificationFrom(int type,
                              const NotificationSource& source);
 
 // Register |observer| for the given |type| and |source| and run
 // the message loop until the observer posts a quit task.
 void RegisterAndWait(NotificationObserver* observer,
-                     NotificationType type,
+                     int type,
                      const NotificationSource& source);
 
 // Blocks until |model| finishes loading.
 void WaitForBookmarkModelToLoad(BookmarkModel* model);
 
 // Blocks until the |browser|'s history finishes loading.
 void WaitForHistoryToLoad(Browser* browser);
 
 // Puts the native window for |browser| in |native_window|. Returns true on
 // success.
@@ skipping 20 matching lines @@
 // Sends a key press, blocking until both the key press and a notification from
 // |source| of type |type| are received, or until the test times out. This uses
 // ui_controls::SendKeyPress, see it for details. Returns true if the event was
 // successfully sent and both the event and notification were received.
 bool SendKeyPressAndWait(const Browser* browser,
                          ui::KeyboardCode key,
                          bool control,
                          bool shift,
                          bool alt,
                          bool command,
-                         NotificationType type,
+                         int type,
                          const NotificationSource& source) WARN_UNUSED_RESULT;
 
 // Run a message loop only for the specified amount of time.
 class TimedMessageLoopRunner {
  public:
   // Create new MessageLoopForUI and attach to it.
   TimedMessageLoopRunner();
 
   // Attach to an existing message loop.
   explicit TimedMessageLoopRunner(MessageLoop* loop)
@@ skipping 75 matching lines @@
 
   const NotificationSource& source() const {
     return source_;
   }
 
   const NotificationDetails& details() const {
     return details_;
   }
 
   // NotificationObserver:
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationSource source_;
   NotificationDetails details_;
 };
 
 // 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 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(NotificationType notification_type,
+  WindowedNotificationObserver(int notification_type,
                                const 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();
 
   // WaitFor waits until the given notification type is received from the
   // given object. If the notification was emitted between the construction of
   // this object and this call then it returns immediately.
   //
   // Use this variant when you supply AllSources to the constructor but want
   // to wait for notification from a specific observer.
   //
   // Beware that this is inheriently plagued by ABA issues. Consider:
   //   WindowedNotificationObserver is created, listening for notifications from
   //     all sources
   //   Object A is created with address x and fires a notification
   //   Object A is freed
   //   Object B is created with the same address
   //   WaitFor is called with the address of B
   //
   // In this case, WaitFor will return immediately because of the
   // notification from A (because they shared an address), despite being
   // different objects.
   void WaitFor(const NotificationSource& source);
 
   // NotificationObserver:
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
  private:
   bool seen_;
   bool running_;
   std::set<uintptr_t> sources_seen_;
   NotificationSource waiting_for_;
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowedNotificationObserver);
 };
 
 // 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:
-  WindowedNotificationObserverWithDetails(NotificationType notification_type,
+  WindowedNotificationObserverWithDetails(int notification_type,
                                           const NotificationSource& source)
       : 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(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     const U* details_ptr = Details<U>(details).ptr();
     if (details_ptr)
       details_[source.map_key()] = *details_ptr;
     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 NotificationObserver {
  public:
   // |tab_contents| must be non-NULL and needs to stay alive for the
   // entire lifetime of |this|. |expected_title| is the title that |this|
   // will wait for.
   TitleWatcher(TabContents* tab_contents, const string16& expected_title);
   virtual ~TitleWatcher();
 
   // Waits until the title for the tab is set to the |expected_title|
   // passed into the constructor.
   bool Wait() WARN_UNUSED_RESULT;
 
  private:
   // NotificationObserver
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
   TabContents* expected_tab_;
   string16 expected_title_;
   NotificationRegistrar notification_registrar_;
   bool title_observed_;
   bool quit_loop_on_observation_;
 
   DISALLOW_COPY_AND_ASSIGN(TitleWatcher);
 };
 
 // See SendKeyPressAndWait.  This function additionally performs a check on the
 // NotificationDetails using the provided Details<U>.
 template <class U>
 bool SendKeyPressAndWaitWithDetails(
     const Browser* browser,
     ui::KeyboardCode key,
     bool control,
     bool shift,
     bool alt,
     bool command,
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const Details<U>& details) WARN_UNUSED_RESULT;
 
 template <class U>
 bool SendKeyPressAndWaitWithDetails(
     const Browser* browser,
     ui::KeyboardCode key,
     bool control,
     bool shift,
     bool alt,
     bool command,
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const Details<U>& details) {
   WindowedNotificationObserverWithDetails<U> observer(type, source);
 
   if (!SendKeyPressSync(browser, key, control, shift, alt, command))
     return false;
 
   observer.Wait();
 
   U my_details;
@@ skipping 17 matching lines @@
   // DOMAutomationController. Do not construct this until the browser has
   // started.
   DOMMessageQueue();
   virtual ~DOMMessageQueue();
 
   // Wait for the next message to arrive. |message| will be set to the next
   // message, if not null. Returns true on success.
   bool WaitForMessage(std::string* message) WARN_UNUSED_RESULT;
 
   // Overridden NotificationObserver methods.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   std::queue<std::string> message_queue_;
   bool waiting_for_message_;
 
   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(RenderWidgetHost* rwh,
                               const gfx::Size& page_size,
                               SkBitmap* bitmap) WARN_UNUSED_RESULT;
 
 // Takes a snapshot of the entire page, according to the width and height
 // properties of the DOM's document. Returns true on success. DOMAutomation
 // must be enabled.
 bool TakeEntirePageSnapshot(RenderViewHost* rvh,
                             SkBitmap* bitmap) WARN_UNUSED_RESULT;
 
 }  // namespace ui_test_utils
 
 #endif  // CHROME_TEST_UI_TEST_UTILS_H_