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

chrome/browser/automation/automation_provider_observers.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_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_
 #define CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_
 #pragma once
 
 #include <deque>
 #include <map>
@@ skipping 19 matching lines @@
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/importer/importer_data_types.h"
 #include "chrome/browser/importer/importer_progress_observer.h"
 #include "chrome/browser/password_manager/password_store_change.h"
 #include "chrome/browser/password_manager/password_store_consumer.h"
 #include "chrome/browser/search_engines/template_url_service_observer.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/browser/cancelable_request.h"
+#include "content/common/content_notification_types.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
-#include "content/common/notification_type.h"
 #include "ui/gfx/size.h"
 
 class AutocompleteEditModel;
 class AutomationProvider;
 class BalloonCollection;
 class Browser;
 class Extension;
 class ExtensionProcessManager;
 class NavigationController;
 class RenderViewHost;
@@ skipping 13 matching lines @@
 
 namespace IPC {
 class Message;
 }
 
 class InitialLoadObserver : public NotificationObserver {
  public:
   InitialLoadObserver(size_t tab_count, AutomationProvider* automation);
   virtual ~InitialLoadObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Caller owns the return value and is responsible for deleting it.
   // Example return value:
   // {'tabs': [{'start_time_ms': 1, 'stop_time_ms': 2.5},
   //           {'start_time_ms': 0.5, 'stop_time_ms': 3}]}
   // stop_time_ms values may be null if WaitForInitialLoads has not finished.
   // Only includes entries for the |tab_count| tabs we are monitoring.
   // There is no defined ordering of the return value.
@@ skipping 34 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NetworkManagerInitObserver);
 };
 #endif  // defined(OS_CHROMEOS)
 
 // Watches for NewTabUI page loads for performance timing purposes.
 class NewTabUILoadObserver : public NotificationObserver {
  public:
   explicit NewTabUILoadObserver(AutomationProvider* automation);
   virtual ~NewTabUILoadObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
 
   DISALLOW_COPY_AND_ASSIGN(NewTabUILoadObserver);
 };
 
 class NavigationControllerRestoredObserver : public NotificationObserver {
  public:
   NavigationControllerRestoredObserver(AutomationProvider* automation,
                                        NavigationController* controller,
                                        IPC::Message* reply_message);
   virtual ~NavigationControllerRestoredObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   bool FinishedRestoring();
   void SendDone();
 
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   NavigationController* controller_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationControllerRestoredObserver);
 };
 
 class NavigationNotificationObserver : public NotificationObserver {
  public:
   NavigationNotificationObserver(NavigationController* controller,
                                  AutomationProvider* automation,
                                  IPC::Message* reply_message,
                                  int number_of_navigations,
                                  bool include_current_navigation,
                                  bool use_json_interface);
   virtual ~NavigationNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   void ConditionMet(AutomationMsg_NavigationResponseValues navigation_result);
 
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   NavigationController* controller_;
   int navigations_remaining_;
   bool navigation_started_;
   bool use_json_interface_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationNotificationObserver);
 };
 
 class TabStripNotificationObserver : public NotificationObserver {
  public:
-  TabStripNotificationObserver(NotificationType notification,
+  TabStripNotificationObserver(int notification,
                                AutomationProvider* automation);
   virtual ~TabStripNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   virtual void ObserveTab(NavigationController* controller) = 0;
 
  protected:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
-  NotificationType notification_;
+  int notification_;
 };
 
 class TabAppendedNotificationObserver : public TabStripNotificationObserver {
  public:
   TabAppendedNotificationObserver(Browser* parent,
                                   AutomationProvider* automation,
                                   IPC::Message* reply_message);
   virtual ~TabAppendedNotificationObserver();
 
   virtual void ObserveTab(NavigationController* controller);
@@ skipping 59 matching lines @@
 // Observes when an extension has finished installing or possible install
 // errors. This does not guarantee that the extension is ready for use.
 class ExtensionInstallNotificationObserver : public NotificationObserver {
  public:
   ExtensionInstallNotificationObserver(AutomationProvider* automation,
                                        int id,
                                        IPC::Message* reply_message);
   virtual ~ExtensionInstallNotificationObserver();
 
   // Implementation of NotificationObserver.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   // Send |response| back to the provider's client.
   void SendResponse(AutomationMsg_ExtensionResponseValues response);
 
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   int id_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionInstallNotificationObserver);
 };
 
 // Observes when an extension has been uninstalled.
 class ExtensionUninstallObserver : public NotificationObserver {
  public:
   ExtensionUninstallObserver(AutomationProvider* automation,
                              IPC::Message* reply_message,
                              const std::string& id);
   virtual ~ExtensionUninstallObserver();
 
   // Implementation of NotificationObserver.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   std::string id_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionUninstallObserver);
 };
 
 // Observes when an extension has finished loading and is ready for use. Also
 // checks for possible install errors.
 class ExtensionReadyNotificationObserver : public NotificationObserver {
  public:
   ExtensionReadyNotificationObserver(ExtensionProcessManager* manager,
                                      AutomationProvider* automation,
                                      int id,
                                      IPC::Message* reply_message);
   virtual ~ExtensionReadyNotificationObserver();
 
   // Implementation of NotificationObserver.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   ExtensionProcessManager* manager_;
   base::WeakPtr<AutomationProvider> automation_;
   int id_;
   scoped_ptr<IPC::Message> reply_message_;
   const Extension* extension_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionReadyNotificationObserver);
 };
 
 class ExtensionUnloadNotificationObserver : public NotificationObserver {
  public:
   ExtensionUnloadNotificationObserver();
   virtual ~ExtensionUnloadNotificationObserver();
 
   // Implementation of NotificationObserver.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   bool did_receive_unload_notification() {
     return did_receive_unload_notification_;
   }
 
  private:
   NotificationRegistrar registrar_;
   bool did_receive_unload_notification_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionUnloadNotificationObserver);
 };
 
 // Observes when the extensions have been fully updated.  The ExtensionUpdater
 // service provides notifications for each extension that gets updated, but
 // it does not wait for the updated extensions to be installed or loaded.  This
 // observer waits until all updated extensions have actually been loaded.
 class ExtensionsUpdatedObserver : public NotificationObserver {
  public:
   ExtensionsUpdatedObserver(ExtensionProcessManager* manager,
                             AutomationProvider* automation,
                             IPC::Message* reply_message);
   virtual ~ExtensionsUpdatedObserver();
 
   // Implementation of NotificationObserver.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   ExtensionProcessManager* manager_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   std::set<std::string> in_progress_updates_;
   bool updater_finished_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionsUpdatedObserver);
 };
 
 class ExtensionTestResultNotificationObserver : public NotificationObserver {
  public:
   explicit ExtensionTestResultNotificationObserver(
       AutomationProvider* automation);
   virtual ~ExtensionTestResultNotificationObserver();
 
   // Implementation of NotificationObserver.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Sends a test result back to the provider's client, if there is a pending
   // provider message and there is a result in the queue.
   void MaybeSendResult();
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
@@ skipping 11 matching lines @@
 };
 
 // Observes when a new browser has been opened and a tab within it has stopped
 // loading.
 class BrowserOpenedNotificationObserver : public NotificationObserver {
  public:
   BrowserOpenedNotificationObserver(AutomationProvider* automation,
                                     IPC::Message* reply_message);
   virtual ~BrowserOpenedNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   void set_for_browser_command(bool for_browser_command);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   int new_window_id_;
   bool for_browser_command_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserOpenedNotificationObserver);
 };
 
 class BrowserClosedNotificationObserver : public NotificationObserver {
  public:
   BrowserClosedNotificationObserver(Browser* browser,
                                     AutomationProvider* automation,
                                     IPC::Message* reply_message);
   virtual ~BrowserClosedNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   void set_for_browser_command(bool for_browser_command);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   bool for_browser_command_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserClosedNotificationObserver);
 };
 
 class BrowserCountChangeNotificationObserver : public NotificationObserver {
  public:
   BrowserCountChangeNotificationObserver(int target_count,
                                          AutomationProvider* automation,
                                          IPC::Message* reply_message);
   virtual ~BrowserCountChangeNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   int target_count_;
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserCountChangeNotificationObserver);
 };
 
 class AppModalDialogShownObserver : public NotificationObserver {
  public:
   AppModalDialogShownObserver(AutomationProvider* automation,
                               IPC::Message* reply_message);
   virtual ~AppModalDialogShownObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(AppModalDialogShownObserver);
 };
 
 class ExecuteBrowserCommandObserver : public NotificationObserver {
  public:
   virtual ~ExecuteBrowserCommandObserver();
 
   static bool CreateAndRegisterObserver(AutomationProvider* automation,
                                         Browser* browser,
                                         int command,
                                         IPC::Message* reply_message);
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   ExecuteBrowserCommandObserver(AutomationProvider* automation,
                                 IPC::Message* reply_message);
 
   bool Register(int command);
 
-  bool GetNotificationType(int command, NotificationType::Type* type);
+  bool Getint(int command, int* type);
 
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
-  NotificationType::Type notification_type_;
+  int notification_type_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(ExecuteBrowserCommandObserver);
 };
 
 class FindInPageNotificationObserver : public NotificationObserver {
  public:
   FindInPageNotificationObserver(AutomationProvider* automation,
                                  TabContents* parent_tab,
                                  bool reply_with_json,
                                  IPC::Message* reply_message);
   virtual ~FindInPageNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // The Find mechanism is over asynchronous IPC, so a search is kicked off and
   // we wait for notification to find out what the results are. As the user is
   // typing, new search requests can be issued and the Request ID helps us make
   // sense of whether this is the current request or an old one. The unit tests,
   // however, which uses this constant issues only one search at a time, so we
   // don't need a rolling id to identify each search. But, we still need to
   // specify one, so we just use a fixed one - its value does not matter.
@@ skipping 10 matching lines @@
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(FindInPageNotificationObserver);
 };
 
 class DomOperationObserver : public NotificationObserver {
  public:
   DomOperationObserver();
   virtual ~DomOperationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   virtual void OnDomOperationCompleted(const std::string& json) = 0;
 
  private:
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(DomOperationObserver);
 };
@@ skipping 16 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DomOperationMessageSender);
 };
 
 class DocumentPrintedNotificationObserver : public NotificationObserver {
  public:
   DocumentPrintedNotificationObserver(AutomationProvider* automation,
                                       IPC::Message* reply_message);
   virtual ~DocumentPrintedNotificationObserver();
 
-  virtual void Observe(NotificationType type, const NotificationSource& source,
+  virtual void Observe(int type, const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   bool success_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(DocumentPrintedNotificationObserver);
 };
 
 // Collects METRIC_EVENT_DURATION notifications and keep track of the times.
 class MetricEventDurationObserver : public NotificationObserver {
  public:
   MetricEventDurationObserver();
   virtual ~MetricEventDurationObserver();
 
   // Get the duration of an event.  Returns -1 if we haven't seen the event.
   int GetEventDurationMs(const std::string& event_name);
 
   // NotificationObserver interface.
-  virtual void Observe(NotificationType type, const NotificationSource& source,
+  virtual void Observe(int type, const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
 
   typedef std::map<std::string, int> EventDurationMap;
   EventDurationMap durations_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricEventDurationObserver);
 };
 
 class PageTranslatedObserver : public NotificationObserver {
  public:
   PageTranslatedObserver(AutomationProvider* automation,
                          IPC::Message* reply_message,
                          TabContents* tab_contents);
   virtual ~PageTranslatedObserver();
 
   // NotificationObserver interface.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(PageTranslatedObserver);
 };
 
 class TabLanguageDeterminedObserver : public NotificationObserver {
  public:
   TabLanguageDeterminedObserver(AutomationProvider* automation,
                                 IPC::Message* reply_message,
                                 TabContents* tab_contents,
                                 TranslateInfoBarDelegate* translate_bar);
   virtual ~TabLanguageDeterminedObserver();
 
   // NotificationObserver interface.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   TabContents* tab_contents_;
   TranslateInfoBarDelegate* translate_bar_;
 
   DISALLOW_COPY_AND_ASSIGN(TabLanguageDeterminedObserver);
 };
 
 class InfoBarCountObserver : public NotificationObserver {
  public:
   InfoBarCountObserver(AutomationProvider* automation,
                        IPC::Message* reply_message,
                        TabContentsWrapper* tab_contents,
                        size_t target_count);
   virtual ~InfoBarCountObserver();
 
   // NotificationObserver interface.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   // Checks whether the infobar count matches our target, and if so
   // sends the reply message and deletes itself.
   void CheckCount();
 
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
@@ skipping 16 matching lines @@
   virtual ~LoginObserver();
 
   virtual void OnLoginFailure(const chromeos::LoginFailure& error);
 
   virtual void OnLoginSuccess(
       const std::string& username,
       const std::string& password,
       const GaiaAuthConsumer::ClientLoginResult& credentials,
       bool pending_requests);
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                const NotificationSource& source,
                const NotificationDetails& details);
 
  private:
   chromeos::ExistingUserController* controller_;
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginObserver);
 };
 
 // Collects SCREEN_LOCK_STATE_CHANGED notifications and returns
 // whether authentication succeeded to the automation provider.
 class ScreenLockUnlockObserver : public NotificationObserver {
  public:
   // Set lock_screen to true to observe lock screen events,
   // false for unlock screen events.
   ScreenLockUnlockObserver(AutomationProvider* automation,
                            IPC::Message* reply_message,
                            bool lock_screen);
   virtual ~ScreenLockUnlockObserver();
 
   // NotificationObserver interface.
-  virtual void Observe(NotificationType type, const NotificationSource& source,
+  virtual void Observe(int type, const NotificationSource& source,
                        const NotificationDetails& details);
 
  protected:
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
  private:
   NotificationRegistrar registrar_;
   bool lock_screen_;
 
@@ skipping 319 matching lines @@
   PasswordStoreLoginsChangedObserver(AutomationProvider* automation,
                                      IPC::Message* reply_message,
                                      PasswordStoreChange::Type expected_type,
                                      const std::string& result_key);
   virtual ~PasswordStoreLoginsChangedObserver();
 
   // Schedules a task on the DB thread to register the appropriate observers.
   virtual void Init();
 
   // NotificationObserver interface.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class DeleteTask<PasswordStoreLoginsChangedObserver>;
 
   // Registers the appropriate observers.  Called on the DB thread.
   void RegisterObserversTask();
 
@@ skipping 35 matching lines @@
 
 // Allows automation provider to wait until page load after selecting an item
 // in the omnibox popup.
 class OmniboxAcceptNotificationObserver : public NotificationObserver {
  public:
   OmniboxAcceptNotificationObserver(NavigationController* controller,
                                  AutomationProvider* automation,
                                  IPC::Message* reply_message);
   virtual ~OmniboxAcceptNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   NavigationController* controller_;
 
   DISALLOW_COPY_AND_ASSIGN(OmniboxAcceptNotificationObserver);
 };
 
 // Allows the automation provider to wait for a save package notification.
 class SavePackageNotificationObserver : public NotificationObserver {
  public:
   SavePackageNotificationObserver(SavePackage* save_package,
                                   AutomationProvider* automation,
                                   IPC::Message* reply_message);
   virtual ~SavePackageNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(SavePackageNotificationObserver);
 };
@@ skipping 35 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PageSnapshotTaker);
 };
 
 class NTPInfoObserver : public NotificationObserver {
  public:
   NTPInfoObserver(AutomationProvider* automation,
                   IPC::Message* reply_message,
                   CancelableRequestConsumer* consumer);
   virtual ~NTPInfoObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   void OnTopSitesLoaded();
   void OnTopSitesReceived(const history::MostVisitedURLList& visited_list);
 
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   CancelableRequestConsumer* consumer_;
   CancelableRequestProvider::Handle request_;
   scoped_ptr<DictionaryValue> ntp_info_;
   history::TopSites* top_sites_;
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPInfoObserver);
 };
 
 // Observes when an app has been launched, as indicated by a notification that
 // a content load in some tab has stopped.
 class AppLaunchObserver : public NotificationObserver {
  public:
   AppLaunchObserver(NavigationController* controller,
                     AutomationProvider* automation,
                     IPC::Message* reply_message,
                     extension_misc::LaunchContainer launch_container);
   virtual ~AppLaunchObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NavigationController* controller_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   NotificationRegistrar registrar_;
   extension_misc::LaunchContainer launch_container_;
   int new_window_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AppLaunchObserver);
 };
 
 // Observes when Autofill information is displayed in the renderer.  This can
 // happen in two different ways: (1) a popup containing Autofill suggestions
 // has been shown in the renderer; (2) a webpage form is filled or previewed
 // with Autofill suggestions.  A constructor argument specifies the appropriate
 // notification to wait for.
 class AutofillDisplayedObserver : public NotificationObserver {
  public:
-  AutofillDisplayedObserver(NotificationType notification,
+  AutofillDisplayedObserver(int notification,
                             RenderViewHost* render_view_host,
                             AutomationProvider* automation,
                             IPC::Message* reply_message);
   virtual ~AutofillDisplayedObserver();
 
   // NotificationObserver interface.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
-  NotificationType notification_;
+  int notification_;
   RenderViewHost* render_view_host_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(AutofillDisplayedObserver);
 };
 
 // Observes when a specified number of autofill profiles and credit cards have
 // been changed in the WebDataService.  The notifications are sent on the DB
 // thread, the thread that interacts with the database.
 class AutofillChangedObserver
     : public base::RefCountedThreadSafe<
           AutofillChangedObserver,
           BrowserThread::DeleteOnUIThread>,
       public NotificationObserver {
  public:
   AutofillChangedObserver(AutomationProvider* automation,
                           IPC::Message* reply_message,
                           int num_profiles,
                           int num_credit_cards);
   virtual ~AutofillChangedObserver();
 
   // Schedules a task on the DB thread to register the appropriate observers.
   virtual void Init();
 
   // NotificationObserver interface.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class DeleteTask<AutofillChangedObserver>;
 
   // Registers the appropriate observers.  Called on the DB thread.
   void RegisterObserversTask();
 
@@ skipping 15 matching lines @@
 };
 
 // Allows the automation provider to wait until all the notification
 // processes are ready.
 class GetActiveNotificationsObserver : public NotificationObserver {
  public:
   GetActiveNotificationsObserver(AutomationProvider* automation,
                                  IPC::Message* reply_message);
   virtual ~GetActiveNotificationsObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   // Sends a message via the |AutomationProvider|. |automation_| must be valid.
   // Deletes itself after the message is sent.
   void SendMessage();
 
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(GetActiveNotificationsObserver);
 };
 
 // Allows the automation provider to wait for a given number of
 // notification balloons.
 class OnNotificationBalloonCountObserver : public NotificationObserver {
  public:
   OnNotificationBalloonCountObserver(AutomationProvider* provider,
                                      IPC::Message* reply_message,
                                      int count);
   virtual ~OnNotificationBalloonCountObserver();
 
   // Sends an automation reply message if |automation_| is still valid and the
   // number of ready balloons matches the desired count. Deletes itself if the
   // message is sent or if |automation_| is invalid.
   void CheckBalloonCount();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   BalloonCollection* collection_;
   int count_;
 
   DISALLOW_COPY_AND_ASSIGN(OnNotificationBalloonCountObserver);
 };
 
 // Allows the automation provider to wait for a RENDERER_PROCESS_CLOSED
 // notification.
 class RendererProcessClosedObserver : public NotificationObserver {
  public:
   RendererProcessClosedObserver(AutomationProvider* automation,
                                 IPC::Message* reply_message);
   virtual ~RendererProcessClosedObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererProcessClosedObserver);
 };
 
 // Allows the automation provider to wait for acknowledgement that a certain
 // type and number of input events has been processed by the renderer.
 class InputEventAckNotificationObserver : public NotificationObserver {
  public:
   InputEventAckNotificationObserver(AutomationProvider* automation,
                                     IPC::Message* reply_message,
                                     int event_type, int count);
   virtual ~InputEventAckNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   int event_type_;
   int count_;
 
@@ skipping 27 matching lines @@
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(AllTabsStoppedLoadingObserver);
 };
 
 // Observer used to listen for new tab creation to complete.
 class NewTabObserver : public NotificationObserver {
  public:
   NewTabObserver(AutomationProvider* automation, IPC::Message* reply_message);
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
  private:
   virtual ~NewTabObserver();
 
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
@@ skipping 36 matching lines @@
 };
 
 // Allows the automation provider to wait for acknowledgement that a drop
 // operation has been processed by the renderer.
 class DragTargetDropAckNotificationObserver : public NotificationObserver {
  public:
   DragTargetDropAckNotificationObserver(AutomationProvider* automation,
                                         IPC::Message* reply_message);
   virtual ~DragTargetDropAckNotificationObserver();
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(DragTargetDropAckNotificationObserver);
 };
 
 #endif  // CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_