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

chrome/browser/automation/automation_provider_observers.cc

 // 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.
 
 #include "chrome/browser/automation/automation_provider_observers.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 42 matching lines @@
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/find_bar/find_notification_details.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
 #include "chrome/browser/ui/webui/ntp/most_visited_handler.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 #include "chrome/common/automation_messages.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_service.h"
 #include "googleurl/src/gurl.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/rect.h"
 
@@ skipping 16 matching lines @@
   base::TimeTicks load_start_time_;
   base::TimeTicks load_stop_time_;
 };
 
 InitialLoadObserver::InitialLoadObserver(size_t tab_count,
                                          AutomationProvider* automation)
     : automation_(automation->AsWeakPtr()),
       outstanding_tab_count_(tab_count),
       init_time_(base::TimeTicks::Now()) {
   if (outstanding_tab_count_ > 0) {
-    registrar_.Add(this, NotificationType::LOAD_START,
+    registrar_.Add(this, content::NOTIFICATION_LOAD_START,
                    NotificationService::AllSources());
-    registrar_.Add(this, NotificationType::LOAD_STOP,
+    registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                    NotificationService::AllSources());
   }
 }
 
 InitialLoadObserver::~InitialLoadObserver() {
 }
 
-void InitialLoadObserver::Observe(NotificationType type,
+void InitialLoadObserver::Observe(int type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
-  if (type == NotificationType::LOAD_START) {
+  if (type == content::NOTIFICATION_LOAD_START) {
     if (outstanding_tab_count_ > loading_tabs_.size())
       loading_tabs_.insert(TabTimeMap::value_type(
           source.map_key(),
           TabTime(base::TimeTicks::Now())));
-  } else if (type == NotificationType::LOAD_STOP) {
+  } else if (type == content::NOTIFICATION_LOAD_STOP) {
     if (outstanding_tab_count_ > finished_tabs_.size()) {
       TabTimeMap::iterator iter = loading_tabs_.find(source.map_key());
       if (iter != loading_tabs_.end()) {
         finished_tabs_.insert(source.map_key());
         iter->second.set_stop_time(base::TimeTicks::Now());
       }
       if (outstanding_tab_count_ == finished_tabs_.size())
         ConditionMet();
     }
   } else {
@@ skipping 24 matching lines @@
 }
 
 void InitialLoadObserver::ConditionMet() {
   registrar_.RemoveAll();
   if (automation_)
     automation_->OnInitialTabLoadsComplete();
 }
 
 NewTabUILoadObserver::NewTabUILoadObserver(AutomationProvider* automation)
     : automation_(automation->AsWeakPtr()) {
-  registrar_.Add(this, NotificationType::INITIAL_NEW_TAB_UI_LOAD,
+  registrar_.Add(this, chrome::NOTIFICATION_INITIAL_NEW_TAB_UI_LOAD,
                  NotificationService::AllSources());
 }
 
 NewTabUILoadObserver::~NewTabUILoadObserver() {
 }
 
-void NewTabUILoadObserver::Observe(NotificationType type,
+void NewTabUILoadObserver::Observe(int type,
                                    const NotificationSource& source,
                                    const NotificationDetails& details) {
-  if (type == NotificationType::INITIAL_NEW_TAB_UI_LOAD) {
+  if (type == chrome::NOTIFICATION_INITIAL_NEW_TAB_UI_LOAD) {
     Details<int> load_time(details);
     if (automation_) {
       automation_->Send(
           new AutomationMsg_InitialNewTabUILoadComplete(*load_time.ptr()));
     }
   } else {
     NOTREACHED();
   }
 }
 
 NavigationControllerRestoredObserver::NavigationControllerRestoredObserver(
     AutomationProvider* automation,
     NavigationController* controller,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       controller_(controller),
       reply_message_(reply_message) {
   if (FinishedRestoring()) {
     SendDone();
   } else {
-    registrar_.Add(this, NotificationType::LOAD_STOP,
+    registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                    NotificationService::AllSources());
   }
 }
 
 NavigationControllerRestoredObserver::~NavigationControllerRestoredObserver() {
 }
 
 void NavigationControllerRestoredObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
   if (FinishedRestoring()) {
     SendDone();
     registrar_.RemoveAll();
   }
 }
 
 bool NavigationControllerRestoredObserver::FinishedRestoring() {
   return (!controller_->needs_reload() && !controller_->pending_entry() &&
           !controller_->tab_contents()->is_loading());
@@ skipping 16 matching lines @@
     bool include_current_navigation,
     bool use_json_interface)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       controller_(controller),
       navigations_remaining_(number_of_navigations),
       navigation_started_(false),
       use_json_interface_(use_json_interface) {
   DCHECK_LT(0, navigations_remaining_);
   Source<NavigationController> source(controller_);
-  registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED, source);
-  registrar_.Add(this, NotificationType::LOAD_START, source);
-  registrar_.Add(this, NotificationType::LOAD_STOP, source);
-  registrar_.Add(this, NotificationType::AUTH_NEEDED, source);
-  registrar_.Add(this, NotificationType::AUTH_SUPPLIED, source);
-  registrar_.Add(this, NotificationType::AUTH_CANCELLED, source);
+  registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED, source);
+  registrar_.Add(this, content::NOTIFICATION_LOAD_START, source);
+  registrar_.Add(this, content::NOTIFICATION_LOAD_STOP, source);
+  registrar_.Add(this, chrome::NOTIFICATION_AUTH_NEEDED, source);
+  registrar_.Add(this, chrome::NOTIFICATION_AUTH_SUPPLIED, source);
+  registrar_.Add(this, chrome::NOTIFICATION_AUTH_CANCELLED, source);
 
   if (include_current_navigation && controller->tab_contents()->is_loading())
     navigation_started_ = true;
 }
 
 NavigationNotificationObserver::~NavigationNotificationObserver() {
 }
 
 void NavigationNotificationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
   // We listen for 2 events to determine when the navigation started because:
   // - when this is used by the WaitForNavigation method, we might be invoked
   // afer the load has started (but not after the entry was committed, as
   // WaitForNavigation compares times of the last navigation).
   // - when this is used with a page requiring authentication, we will not get
-  // a NotificationType::NAV_ENTRY_COMMITTED until after we authenticate, so
-  // we need the NotificationType::LOAD_START.
-  if (type == NotificationType::NAV_ENTRY_COMMITTED ||
-      type == NotificationType::LOAD_START) {
+  // a chrome::NAV_ENTRY_COMMITTED until after we authenticate, so
+  // we need the chrome::LOAD_START.
+  if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED ||
+      type == content::NOTIFICATION_LOAD_START) {
     navigation_started_ = true;
-  } else if (type == NotificationType::LOAD_STOP) {
+  } else if (type == content::NOTIFICATION_LOAD_STOP) {
     if (navigation_started_) {
       navigation_started_ = false;
       if (--navigations_remaining_ == 0)
         ConditionMet(AUTOMATION_MSG_NAVIGATION_SUCCESS);
     }
-  } else if (type == NotificationType::AUTH_SUPPLIED ||
-             type == NotificationType::AUTH_CANCELLED) {
+  } else if (type == chrome::NOTIFICATION_AUTH_SUPPLIED ||
+             type == chrome::NOTIFICATION_AUTH_CANCELLED) {
     // The LoginHandler for this tab is no longer valid.
     automation_->RemoveLoginHandler(controller_);
 
     // Treat this as if navigation started again, since load start/stop don't
     // occur while authentication is ongoing.
     navigation_started_ = true;
-  } else if (type == NotificationType::AUTH_NEEDED) {
+  } else if (type == chrome::NOTIFICATION_AUTH_NEEDED) {
     // Remember the login handler that wants authentication.
     // We do this in all cases (not just when navigation_started_ == true) so
     // tests can still wait for auth dialogs outside of navigation.
     LoginHandler* handler =
         Details<LoginNotificationDetails>(details)->handler();
     automation_->AddLoginHandler(controller_, handler);
 
     // Respond that authentication is needed.
     navigation_started_ = false;
     ConditionMet(AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED);
@@ skipping 14 matching lines @@
       IPC::ParamTraits<AutomationMsg_NavigationResponseValues>::Write(
           reply_message_.get(), navigation_result);
       automation_->Send(reply_message_.release());
     }
   }
 
   delete this;
 }
 
 TabStripNotificationObserver::TabStripNotificationObserver(
-    NotificationType notification, AutomationProvider* automation)
+    int notification, AutomationProvider* automation)
     : automation_(automation->AsWeakPtr()),
       notification_(notification) {
   registrar_.Add(this, notification_, NotificationService::AllSources());
 }
 
 TabStripNotificationObserver::~TabStripNotificationObserver() {
 }
 
-void TabStripNotificationObserver::Observe(NotificationType type,
+void TabStripNotificationObserver::Observe(int type,
                                            const NotificationSource& source,
                                            const NotificationDetails& details) {
   if (type == notification_) {
-    if (type == NotificationType::TAB_PARENTED)
+    if (type == content::NOTIFICATION_TAB_PARENTED)
       ObserveTab(&(Source<TabContentsWrapper>(source).ptr()->controller()));
     else
       ObserveTab(Source<NavigationController>(source).ptr());
     delete this;
   } else {
     NOTREACHED();
   }
 }
 
 TabAppendedNotificationObserver::TabAppendedNotificationObserver(
     Browser* parent, AutomationProvider* automation,
     IPC::Message* reply_message)
-    : TabStripNotificationObserver(NotificationType::TAB_PARENTED, automation),
+    : TabStripNotificationObserver(content::NOTIFICATION_TAB_PARENTED,
+                                   automation),
       parent_(parent),
       reply_message_(reply_message) {
 }
 
 TabAppendedNotificationObserver::~TabAppendedNotificationObserver() {}
 
 void TabAppendedNotificationObserver::ObserveTab(
     NavigationController* controller) {
   if (!automation_)
     return;
 
   if (automation_->GetIndexForNavigationController(controller, parent_) ==
       TabStripModel::kNoTab) {
     // This tab notification doesn't belong to the parent_.
     return;
   }
 
   new NavigationNotificationObserver(controller, automation_,
                                      reply_message_.release(),
                                      1, false, false);
 }
 
 TabClosedNotificationObserver::TabClosedNotificationObserver(
     AutomationProvider* automation, bool wait_until_closed,
     IPC::Message* reply_message)
     : TabStripNotificationObserver(wait_until_closed ?
-          NotificationType::TAB_CLOSED : NotificationType::TAB_CLOSING,
+          content::NOTIFICATION_TAB_CLOSED : content::NOTIFICATION_TAB_CLOSING,
           automation),
       reply_message_(reply_message),
       for_browser_command_(false) {
 }
 
 TabClosedNotificationObserver::~TabClosedNotificationObserver() {}
 
 void TabClosedNotificationObserver::ObserveTab(
     NavigationController* controller) {
   if (!automation_)
@@ skipping 70 matching lines @@
       return false;
   }
   return true;
 }
 
 ExtensionInstallNotificationObserver::ExtensionInstallNotificationObserver(
     AutomationProvider* automation, int id, IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       id_(id),
       reply_message_(reply_message) {
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_INSTALL_ERROR,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
 }
 
 ExtensionInstallNotificationObserver::~ExtensionInstallNotificationObserver() {
 }
 
 void ExtensionInstallNotificationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::EXTENSION_LOADED:
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_LOADED:
       SendResponse(AUTOMATION_MSG_EXTENSION_INSTALL_SUCCEEDED);
       break;
-    case NotificationType::EXTENSION_INSTALL_ERROR:
-    case NotificationType::EXTENSION_UPDATE_DISABLED:
+    case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR:
+    case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
       SendResponse(AUTOMATION_MSG_EXTENSION_INSTALL_FAILED);
       break;
     default:
       NOTREACHED();
       break;
   }
 
   delete this;
 }
 
@@ skipping 17 matching lines @@
   automation_->Send(reply_message_.release());
 }
 
 ExtensionUninstallObserver::ExtensionUninstallObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message,
     const std::string& id)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       id_(id) {
-  registrar_.Add(this, NotificationType::EXTENSION_UNINSTALLED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UNINSTALL_NOT_ALLOWED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
                  NotificationService::AllSources());
 }
 
 ExtensionUninstallObserver::~ExtensionUninstallObserver() {
 }
 
 void ExtensionUninstallObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
-  switch (type.value) {
-    case NotificationType::EXTENSION_UNINSTALLED: {
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_UNINSTALLED: {
       UninstalledExtensionInfo* info =
           Details<UninstalledExtensionInfo>(details).ptr();
       if (id_ == info->extension_id) {
         scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
         return_value->SetBoolean("success", true);
         AutomationJSONReply(automation_, reply_message_.release())
             .SendSuccess(return_value.get());
         delete this;
         return;
       }
       break;
     }
 
-    case NotificationType::EXTENSION_UNINSTALL_NOT_ALLOWED: {
+    case chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED: {
       const Extension* extension = Details<Extension>(details).ptr();
       if (id_ == extension->id()) {
         scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
         return_value->SetBoolean("success", false);
         AutomationJSONReply(automation_, reply_message_.release())
             .SendSuccess(return_value.get());
         delete this;
         return;
       }
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 ExtensionReadyNotificationObserver::ExtensionReadyNotificationObserver(
     ExtensionProcessManager* manager, AutomationProvider* automation, int id,
     IPC::Message* reply_message)
     : manager_(manager),
       automation_(automation->AsWeakPtr()),
       id_(id),
       reply_message_(reply_message),
       extension_(NULL) {
-  registrar_.Add(this, NotificationType::EXTENSION_HOST_DID_STOP_LOADING,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_INSTALL_ERROR,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
 }
 
 ExtensionReadyNotificationObserver::~ExtensionReadyNotificationObserver() {
 }
 
 void ExtensionReadyNotificationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
-  switch (type.value) {
-    case NotificationType::EXTENSION_HOST_DID_STOP_LOADING:
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING:
       // Only continue on with this method if our extension has been loaded
       // and all the extension hosts have stopped loading.
       if (!extension_ || !DidExtensionHostsStopLoading(manager_))
         return;
       break;
-    case NotificationType::EXTENSION_LOADED:
+    case chrome::NOTIFICATION_EXTENSION_LOADED:
       extension_ = Details<const Extension>(details).ptr();
       if (!DidExtensionHostsStopLoading(manager_))
         return;
       break;
-    case NotificationType::EXTENSION_INSTALL_ERROR:
-    case NotificationType::EXTENSION_UPDATE_DISABLED:
+    case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR:
+    case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
       break;
     default:
       NOTREACHED();
       break;
   }
 
   if (id_ == AutomationMsg_InstallExtensionAndGetHandle::ID) {
     // A handle of zero indicates an error.
     int extension_handle = 0;
     if (extension_)
       extension_handle = automation_->AddExtension(extension_);
     AutomationMsg_InstallExtensionAndGetHandle::WriteReplyParams(
         reply_message_.get(), extension_handle);
   } else if (id_ == AutomationMsg_EnableExtension::ID) {
     AutomationMsg_EnableExtension::WriteReplyParams(reply_message_.get(), true);
   } else {
     NOTREACHED();
     LOG(ERROR) << "Cannot write reply params for unknown message id.";
   }
 
   automation_->Send(reply_message_.release());
   delete this;
 }
 
 ExtensionUnloadNotificationObserver::ExtensionUnloadNotificationObserver()
     : did_receive_unload_notification_(false) {
-  registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  NotificationService::AllSources());
 }
 
 ExtensionUnloadNotificationObserver::~ExtensionUnloadNotificationObserver() {
 }
 
 void ExtensionUnloadNotificationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
-  if (type.value == NotificationType::EXTENSION_UNLOADED) {
+  if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
     did_receive_unload_notification_ = true;
   } else {
     NOTREACHED();
   }
 }
 
 ExtensionsUpdatedObserver::ExtensionsUpdatedObserver(
     ExtensionProcessManager* manager, AutomationProvider* automation,
     IPC::Message* reply_message)
     : manager_(manager), automation_(automation->AsWeakPtr()),
       reply_message_(reply_message), updater_finished_(false) {
-  registrar_.Add(this, NotificationType::EXTENSION_HOST_DID_STOP_LOADING,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_INSTALL_ERROR,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_INSTALL_NOT_ALLOWED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_NOT_ALLOWED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_FOUND,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATING_FINISHED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATING_FINISHED,
                  NotificationService::AllSources());
 }
 
 ExtensionsUpdatedObserver::~ExtensionsUpdatedObserver() {
 }
 
 void ExtensionsUpdatedObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
   // We expect the following sequence of events.  First, the ExtensionUpdater
   // service notifies of each extension that needs to be updated.  Once the
   // ExtensionUpdater has finished searching for extensions to update, it
   // notifies that it is finished.  Meanwhile, the extensions are updated
   // asynchronously: either they will be updated and loaded, or else they will
   // not load due to (1) not being allowed; (2) having updating disabled; or
   // (3) encountering an error.  Finally, notifications are also sent whenever
   // an extension host stops loading.  Updating is not considered complete if
   // any extension hosts are still loading.
-  switch (type.value) {
-    case NotificationType::EXTENSION_UPDATE_FOUND:
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND:
       // Extension updater has identified an extension that needs to be updated.
       in_progress_updates_.insert(*(Details<const std::string>(details).ptr()));
       break;
 
-    case NotificationType::EXTENSION_UPDATING_FINISHED:
+    case chrome::NOTIFICATION_EXTENSION_UPDATING_FINISHED:
       // Extension updater has completed notifying all extensions to update
       // themselves.
       updater_finished_ = true;
       break;
 
-    case NotificationType::EXTENSION_LOADED:
-    case NotificationType::EXTENSION_INSTALL_NOT_ALLOWED:
-    case NotificationType::EXTENSION_UPDATE_DISABLED: {
+    case chrome::NOTIFICATION_EXTENSION_LOADED:
+    case chrome::NOTIFICATION_EXTENSION_INSTALL_NOT_ALLOWED:
+    case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED: {
       // An extension has either completed update installation and is now
       // loaded, or else the install has been skipped because it is
       // either not allowed or else has been disabled.
       const Extension* extension = Details<Extension>(details).ptr();
       in_progress_updates_.erase(extension->id());
       break;
     }
 
-    case NotificationType::EXTENSION_INSTALL_ERROR: {
+    case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR: {
       // An extension had an error on update installation.
       CrxInstaller* installer = Source<CrxInstaller>(source).ptr();
       in_progress_updates_.erase(installer->expected_id());
       break;
     }
 
-    case NotificationType::EXTENSION_HOST_DID_STOP_LOADING:
+    case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING:
       // Break out to the conditional check below to see if all extension hosts
       // have stopped loading.
       break;
 
     default:
       NOTREACHED();
       break;
   }
 
   // Send the reply if (1) the extension updater has finished notifying all
   // extensions to update themselves; (2) all extensions that need to be updated
   // have completed installation and are now loaded; and (3) all extension hosts
   // have stopped loading.
   if (updater_finished_ && in_progress_updates_.empty() &&
       DidExtensionHostsStopLoading(manager_)) {
     AutomationJSONReply reply(automation_, reply_message_.release());
     reply.SendSuccess(NULL);
     delete this;
   }
 }
 
 ExtensionTestResultNotificationObserver::
     ExtensionTestResultNotificationObserver(AutomationProvider* automation)
         : automation_(automation->AsWeakPtr()) {
-  registrar_.Add(this, NotificationType::EXTENSION_TEST_PASSED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_TEST_PASSED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_TEST_FAILED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_TEST_FAILED,
                  NotificationService::AllSources());
 }
 
 ExtensionTestResultNotificationObserver::
     ~ExtensionTestResultNotificationObserver() {
 }
 
 void ExtensionTestResultNotificationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::EXTENSION_TEST_PASSED:
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_TEST_PASSED:
       results_.push_back(true);
       messages_.push_back("");
       break;
 
-    case NotificationType::EXTENSION_TEST_FAILED:
+    case chrome::NOTIFICATION_EXTENSION_TEST_FAILED:
       results_.push_back(false);
       messages_.push_back(*(Details<std::string>(details).ptr()));
       break;
 
     default:
       NOTREACHED();
   }
   // There may be a reply message waiting for this event, so check.
   MaybeSendResult();
 }
@@ skipping 18 matching lines @@
   }
 }
 
 BrowserOpenedNotificationObserver::BrowserOpenedNotificationObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       new_window_id_(extension_misc::kUnknownWindowId),
       for_browser_command_(false) {
-  registrar_.Add(this, NotificationType::BROWSER_OPENED,
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::LOAD_STOP,
+  registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  NotificationService::AllSources());
 }
 
 BrowserOpenedNotificationObserver::~BrowserOpenedNotificationObserver() {
 }
 
 void BrowserOpenedNotificationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
-  if (type.value == NotificationType::BROWSER_OPENED) {
+  if (type == chrome::NOTIFICATION_BROWSER_OPENED) {
     // Store the new browser ID and continue waiting for a new tab within it
     // to stop loading.
     new_window_id_ = ExtensionTabUtil::GetWindowId(
         Source<Browser>(source).ptr());
-  } else if (type.value == NotificationType::LOAD_STOP) {
+  } else if (type == content::NOTIFICATION_LOAD_STOP) {
     // Only send the result if the loaded tab is in the new window.
     NavigationController* controller =
         Source<NavigationController>(source).ptr();
     TabContentsWrapper* tab = TabContentsWrapper::GetCurrentWrapperForContents(
         controller->tab_contents());
     int window_id = tab ? tab->restore_tab_helper()->window_id().id() : -1;
     if (window_id == new_window_id_) {
       if (for_browser_command_) {
         AutomationMsg_WindowExecuteCommand::WriteReplyParams(
             reply_message_.get(), true);
@@ skipping 12 matching lines @@
   for_browser_command_ = for_browser_command;
 }
 
 BrowserClosedNotificationObserver::BrowserClosedNotificationObserver(
     Browser* browser,
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       for_browser_command_(false) {
-  registrar_.Add(this, NotificationType::BROWSER_CLOSED,
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
                  Source<Browser>(browser));
 }
 
 BrowserClosedNotificationObserver::~BrowserClosedNotificationObserver() {}
 
 void BrowserClosedNotificationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::BROWSER_CLOSED);
+  DCHECK(type == chrome::NOTIFICATION_BROWSER_CLOSED);
 
   if (!automation_) {
     delete this;
     return;
   }
 
   Details<bool> close_app(details);
 
   if (for_browser_command_) {
     AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message_.get(),
@@ skipping 11 matching lines @@
   for_browser_command_ = for_browser_command;
 }
 
 BrowserCountChangeNotificationObserver::BrowserCountChangeNotificationObserver(
     int target_count,
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : target_count_(target_count),
       automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
-  registrar_.Add(this, NotificationType::BROWSER_OPENED,
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::BROWSER_CLOSED,
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
                  NotificationService::AllSources());
 }
 
 BrowserCountChangeNotificationObserver::
     ~BrowserCountChangeNotificationObserver() {}
 
 void BrowserCountChangeNotificationObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::BROWSER_OPENED ||
-         type == NotificationType::BROWSER_CLOSED);
+  DCHECK(type == chrome::NOTIFICATION_BROWSER_OPENED ||
+         type == chrome::NOTIFICATION_BROWSER_CLOSED);
   int current_count = static_cast<int>(BrowserList::size());
-  if (type == NotificationType::BROWSER_CLOSED) {
+  if (type == chrome::NOTIFICATION_BROWSER_CLOSED) {
     // At the time of the notification the browser being closed is not removed
     // from the list. The real count is one less than the reported count.
     DCHECK_LT(0, current_count);
     current_count--;
   }
 
   if (!automation_) {
     delete this;
     return;
   }
 
   if (current_count == target_count_) {
     AutomationMsg_WaitForBrowserWindowCountToBecome::WriteReplyParams(
         reply_message_.get(), true);
     automation_->Send(reply_message_.release());
     delete this;
   }
 }
 
 AppModalDialogShownObserver::AppModalDialogShownObserver(
     AutomationProvider* automation, IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
-  registrar_.Add(this, NotificationType::APP_MODAL_DIALOG_SHOWN,
+  registrar_.Add(this, chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
                  NotificationService::AllSources());
 }
 
 AppModalDialogShownObserver::~AppModalDialogShownObserver() {
 }
 
 void AppModalDialogShownObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::APP_MODAL_DIALOG_SHOWN);
+  DCHECK(type == chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN);
 
   if (automation_) {
     AutomationMsg_WaitForAppModalDialogToBeShown::WriteReplyParams(
         reply_message_.get(), true);
     automation_->Send(reply_message_.release());
   }
   delete this;
 }
 
 namespace {
 
 // Define mapping from command to notification
 struct CommandNotification {
   int command;
-  NotificationType::Type notification_type;
+  int notification_type;
 };
 
 const struct CommandNotification command_notifications[] = {
-  {IDC_DUPLICATE_TAB, NotificationType::TAB_PARENTED},
+  {IDC_DUPLICATE_TAB, content::NOTIFICATION_TAB_PARENTED},
 
   // Returns as soon as the restored tab is created. To further wait until
   // the content page is loaded, use WaitForTabToBeRestored.
-  {IDC_RESTORE_TAB, NotificationType::TAB_PARENTED},
+  {IDC_RESTORE_TAB, content::NOTIFICATION_TAB_PARENTED},
 
   // For the following commands, we need to wait for a new tab to be created,
   // load to finish, and title to change.
-  {IDC_MANAGE_EXTENSIONS, NotificationType::TAB_CONTENTS_TITLE_UPDATED},
-  {IDC_OPTIONS, NotificationType::TAB_CONTENTS_TITLE_UPDATED},
-  {IDC_PRINT, NotificationType::TAB_CONTENTS_TITLE_UPDATED},
-  {IDC_SHOW_DOWNLOADS, NotificationType::TAB_CONTENTS_TITLE_UPDATED},
-  {IDC_SHOW_HISTORY, NotificationType::TAB_CONTENTS_TITLE_UPDATED},
+  {IDC_MANAGE_EXTENSIONS, content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED},
+  {IDC_OPTIONS, content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED},
+  {IDC_PRINT, content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED},
+  {IDC_SHOW_DOWNLOADS, content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED},
+  {IDC_SHOW_HISTORY, content::NOTIFICATION_TAB_CONTENTS_TITLE_UPDATED},
 };
 
 }  // namespace
 
 ExecuteBrowserCommandObserver::~ExecuteBrowserCommandObserver() {
 }
 
 // static
 bool ExecuteBrowserCommandObserver::CreateAndRegisterObserver(
     AutomationProvider* automation, Browser* browser, int command,
@@ skipping 39 matching lines @@
         delete observer;
         result = false;
       }
       break;
     }
   }
   return result;
 }
 
 void ExecuteBrowserCommandObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
   if (type == notification_type_) {
     if (automation_) {
       AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message_.get(),
                                                            true);
       automation_->Send(reply_message_.release());
     }
     delete this;
   } else {
     NOTREACHED();
   }
 }
 
 ExecuteBrowserCommandObserver::ExecuteBrowserCommandObserver(
     AutomationProvider* automation, IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
-      notification_type_(NotificationType::ALL),
+      notification_type_(content::NOTIFICATION_ALL),
       reply_message_(reply_message) {
 }
 
 bool ExecuteBrowserCommandObserver::Register(int command) {
-  if (!GetNotificationType(command, &notification_type_))
+  if (!Getint(command, &notification_type_))
     return false;
   registrar_.Add(this, notification_type_, NotificationService::AllSources());
   return true;
 }
 
-bool ExecuteBrowserCommandObserver::GetNotificationType(
-    int command, NotificationType::Type* type) {
+bool ExecuteBrowserCommandObserver::Getint(
+    int command, int* type) {
   if (!type)
     return false;
   bool found = false;
   for (unsigned int i = 0; i < arraysize(command_notifications); i++) {
     if (command_notifications[i].command == command) {
       *type = command_notifications[i].notification_type;
       found = true;
       break;
     }
   }
   return found;
 }
 
 FindInPageNotificationObserver::FindInPageNotificationObserver(
     AutomationProvider* automation, TabContents* parent_tab,
     bool reply_with_json, IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       active_match_ordinal_(-1),
       reply_with_json_(reply_with_json),
       reply_message_(reply_message) {
-  registrar_.Add(this, NotificationType::FIND_RESULT_AVAILABLE,
+  registrar_.Add(this, chrome::NOTIFICATION_FIND_RESULT_AVAILABLE,
                  Source<TabContents>(parent_tab));
 }
 
 FindInPageNotificationObserver::~FindInPageNotificationObserver() {
 }
 
 void FindInPageNotificationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
   Details<FindNotificationDetails> find_details(details);
   if (!(find_details->final_update() && reply_message_ != NULL)) {
     DVLOG(1) << "Ignoring, since we only care about the final message";
     return;
   }
 
   if (!automation_) {
     delete this;
     return;
@@ skipping 27 matching lines @@
         automation_->Send(reply_message_.release());
       }
     }
   }
 }
 
 // static
 const int FindInPageNotificationObserver::kFindInPageRequestId = -1;
 
 DomOperationObserver::DomOperationObserver() {
-  registrar_.Add(this, NotificationType::DOM_OPERATION_RESPONSE,
+  registrar_.Add(this, chrome::NOTIFICATION_DOM_OPERATION_RESPONSE,
                  NotificationService::AllSources());
 }
 
 DomOperationObserver::~DomOperationObserver() {}
 
 void DomOperationObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
-  if (NotificationType::DOM_OPERATION_RESPONSE == type) {
+  if (chrome::NOTIFICATION_DOM_OPERATION_RESPONSE == type) {
     Details<DomOperationNotificationDetails> dom_op_details(details);
     OnDomOperationCompleted(dom_op_details->json());
   }
 }
 
 DomOperationMessageSender::DomOperationMessageSender(
     AutomationProvider* automation,
     IPC::Message* reply_message,
     bool use_json_interface)
     : automation_(automation->AsWeakPtr()),
@@ skipping 17 matching lines @@
     }
   }
   delete this;
 }
 
 DocumentPrintedNotificationObserver::DocumentPrintedNotificationObserver(
     AutomationProvider* automation, IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       success_(false),
       reply_message_(reply_message) {
-  registrar_.Add(this, NotificationType::PRINT_JOB_EVENT,
+  registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
                  NotificationService::AllSources());
 }
 
 DocumentPrintedNotificationObserver::~DocumentPrintedNotificationObserver() {
   if (automation_) {
     AutomationMsg_PrintNow::WriteReplyParams(reply_message_.get(), success_);
     automation_->Send(reply_message_.release());
   }
 }
 
 void DocumentPrintedNotificationObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::PRINT_JOB_EVENT);
+  DCHECK(type == chrome::NOTIFICATION_PRINT_JOB_EVENT);
   switch (Details<printing::JobEventDetails>(details)->type()) {
     case printing::JobEventDetails::JOB_DONE: {
       // Succeeded.
       success_ = true;
       delete this;
       break;
     }
     case printing::JobEventDetails::USER_INIT_CANCELED:
     case printing::JobEventDetails::FAILED: {
       // Failed.
@@ skipping 11 matching lines @@
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 MetricEventDurationObserver::MetricEventDurationObserver() {
-  registrar_.Add(this, NotificationType::METRIC_EVENT_DURATION,
+  registrar_.Add(this, chrome::NOTIFICATION_METRIC_EVENT_DURATION,
                  NotificationService::AllSources());
 }
 
 MetricEventDurationObserver::~MetricEventDurationObserver() {}
 
 int MetricEventDurationObserver::GetEventDurationMs(
     const std::string& event_name) {
   EventDurationMap::const_iterator it = durations_.find(event_name);
   if (it == durations_.end())
     return -1;
   return it->second;
 }
 
-void MetricEventDurationObserver::Observe(NotificationType type,
+void MetricEventDurationObserver::Observe(int type,
     const NotificationSource& source, const NotificationDetails& details) {
-  if (type != NotificationType::METRIC_EVENT_DURATION) {
+  if (type != chrome::NOTIFICATION_METRIC_EVENT_DURATION) {
     NOTREACHED();
     return;
   }
   MetricEventDurationDetails* metric_event_duration =
       Details<MetricEventDurationDetails>(details).ptr();
   durations_[metric_event_duration->event_name] =
       metric_event_duration->duration_ms;
 }
 
 PageTranslatedObserver::PageTranslatedObserver(AutomationProvider* automation,
                                                IPC::Message* reply_message,
                                                TabContents* tab_contents)
   : automation_(automation->AsWeakPtr()),
     reply_message_(reply_message) {
-  registrar_.Add(this, NotificationType::PAGE_TRANSLATED,
+  registrar_.Add(this, chrome::NOTIFICATION_PAGE_TRANSLATED,
                  Source<TabContents>(tab_contents));
 }
 
 PageTranslatedObserver::~PageTranslatedObserver() {}
 
-void PageTranslatedObserver::Observe(NotificationType type,
+void PageTranslatedObserver::Observe(int type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
-  DCHECK(type == NotificationType::PAGE_TRANSLATED);
+  DCHECK(type == chrome::NOTIFICATION_PAGE_TRANSLATED);
   AutomationJSONReply reply(automation_, reply_message_.release());
 
   PageTranslatedDetails* translated_details =
       Details<PageTranslatedDetails>(details).ptr();
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   return_value->SetBoolean(
       "translation_success",
       translated_details->error_type == TranslateErrors::NONE);
   reply.SendSuccess(return_value.get());
   delete this;
 }
 
 TabLanguageDeterminedObserver::TabLanguageDeterminedObserver(
     AutomationProvider* automation, IPC::Message* reply_message,
     TabContents* tab_contents, TranslateInfoBarDelegate* translate_bar)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       tab_contents_(tab_contents),
       translate_bar_(translate_bar) {
-  registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
+  registrar_.Add(this, chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
                  Source<TabContents>(tab_contents));
 }
 
 TabLanguageDeterminedObserver::~TabLanguageDeterminedObserver() {}
 
 void TabLanguageDeterminedObserver::Observe(
-    NotificationType type, const NotificationSource& source,
+    int type, const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::TAB_LANGUAGE_DETERMINED);
+  DCHECK(type == chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED);
 
   if (!automation_) {
     delete this;
     return;
   }
 
   TranslateTabHelper* helper = TabContentsWrapper::GetCurrentWrapperForContents(
       tab_contents_)->translate_tab_helper();
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   return_value->SetBoolean("page_translated",
@@ skipping 35 matching lines @@
 
 InfoBarCountObserver::InfoBarCountObserver(AutomationProvider* automation,
                                            IPC::Message* reply_message,
                                            TabContentsWrapper* tab_contents,
                                            size_t target_count)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       tab_contents_(tab_contents),
       target_count_(target_count) {
   Source<TabContentsWrapper> source(tab_contents);
-  registrar_.Add(this, NotificationType::TAB_CONTENTS_INFOBAR_ADDED, source);
-  registrar_.Add(this, NotificationType::TAB_CONTENTS_INFOBAR_REMOVED, source);
+  registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
+                 source);
+  registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
+                 source);
   CheckCount();
 }
 
 InfoBarCountObserver::~InfoBarCountObserver() {}
 
-void InfoBarCountObserver::Observe(NotificationType type,
+void InfoBarCountObserver::Observe(int type,
                                    const NotificationSource& source,
                                    const NotificationDetails& details) {
-  DCHECK(type == NotificationType::TAB_CONTENTS_INFOBAR_ADDED ||
-         type == NotificationType::TAB_CONTENTS_INFOBAR_REMOVED);
+  DCHECK(type == chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED ||
+         type == chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED);
   CheckCount();
 }
 
 void InfoBarCountObserver::CheckCount() {
   if (tab_contents_->infobar_count() != target_count_)
     return;
 
   if (automation_) {
     AutomationMsg_WaitForInfoBarCount::WriteReplyParams(reply_message_.get(),
                                                         true);
@@ skipping 312 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::DB,
       FROM_HERE,
       NewRunnableMethod(
           this, &PasswordStoreLoginsChangedObserver::RegisterObserversTask));
   done_event_.Wait();
 }
 
 void PasswordStoreLoginsChangedObserver::RegisterObserversTask() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  registrar_.Add(this, NotificationType::LOGINS_CHANGED,
+  registrar_.Add(this, chrome::NOTIFICATION_LOGINS_CHANGED,
                  NotificationService::AllSources());
   done_event_.Signal();
 }
 
 void PasswordStoreLoginsChangedObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  DCHECK(type.value == NotificationType::LOGINS_CHANGED);
+  DCHECK(type == chrome::NOTIFICATION_LOGINS_CHANGED);
   PasswordStoreChangeList* change_details =
       Details<PasswordStoreChangeList>(details).ptr();
   if (change_details->size() != 1 ||
       change_details->front().type() != expected_type_) {
     // Notify the UI thread that there's an error.
     std::string error = "Unexpected password store login change details.";
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableMethod(
@@ skipping 52 matching lines @@
 }
 
 OmniboxAcceptNotificationObserver::OmniboxAcceptNotificationObserver(
     NavigationController* controller,
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       controller_(controller) {
   Source<NavigationController> source(controller_);
-  registrar_.Add(this, NotificationType::LOAD_STOP, source);
+  registrar_.Add(this, content::NOTIFICATION_LOAD_STOP, source);
   // Pages requiring auth don't send LOAD_STOP.
-  registrar_.Add(this, NotificationType::AUTH_NEEDED, source);
+  registrar_.Add(this, chrome::NOTIFICATION_AUTH_NEEDED, source);
 }
 
 OmniboxAcceptNotificationObserver::~OmniboxAcceptNotificationObserver() {
 }
 
 void OmniboxAcceptNotificationObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  if (type == NotificationType::LOAD_STOP ||
-      type == NotificationType::AUTH_NEEDED) {
+  if (type == content::NOTIFICATION_LOAD_STOP ||
+      type == chrome::NOTIFICATION_AUTH_NEEDED) {
     if (automation_) {
       AutomationJSONReply(automation_,
                           reply_message_.release()).SendSuccess(NULL);
     }
     delete this;
   } else {
     NOTREACHED();
   }
 }
 
 SavePackageNotificationObserver::SavePackageNotificationObserver(
     SavePackage* save_package,
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   Source<SavePackage> source(save_package);
-  registrar_.Add(this, NotificationType::SAVE_PACKAGE_SUCCESSFULLY_FINISHED,
+  registrar_.Add(this, chrome::NOTIFICATION_SAVE_PACKAGE_SUCCESSFULLY_FINISHED,
                  source);
 }
 
 SavePackageNotificationObserver::~SavePackageNotificationObserver() {}
 
 void SavePackageNotificationObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  if (type == NotificationType::SAVE_PACKAGE_SUCCESSFULLY_FINISHED) {
+  if (type == chrome::NOTIFICATION_SAVE_PACKAGE_SUCCESSFULLY_FINISHED) {
     if (automation_) {
       AutomationJSONReply(automation_,
                           reply_message_.release()).SendSuccess(NULL);
     }
     delete this;
   } else {
     NOTREACHED();
   }
 }
 
@@ skipping 183 matching lines @@
 
   // Add default site URLs.
   ListValue* default_sites_list = new ListValue;
   std::vector<GURL> urls = MostVisitedHandler::GetPrePopulatedUrls();
   for (size_t i = 0; i < urls.size(); ++i) {
     default_sites_list->Append(Value::CreateStringValue(
         urls[i].possibly_invalid_spec()));
   }
   ntp_info_->Set("default_sites", default_sites_list);
 
-  registrar_.Add(this, NotificationType::TOP_SITES_UPDATED,
+  registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_UPDATED,
                  Source<history::TopSites>(top_sites_));
   if (top_sites_->loaded()) {
     OnTopSitesLoaded();
   } else {
-    registrar_.Add(this, NotificationType::TOP_SITES_LOADED,
+    registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_LOADED,
                    Source<Profile>(automation_->profile()));
   }
 }
 
 NTPInfoObserver::~NTPInfoObserver() {}
 
-void NTPInfoObserver::Observe(NotificationType type,
+void NTPInfoObserver::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
-  if (type == NotificationType::TOP_SITES_LOADED) {
+  if (type == chrome::NOTIFICATION_TOP_SITES_LOADED) {
     OnTopSitesLoaded();
-  } else if (type == NotificationType::TOP_SITES_UPDATED) {
+  } else if (type == chrome::NOTIFICATION_TOP_SITES_UPDATED) {
     Details<CancelableRequestProvider::Handle> request_details(details);
     if (request_ == *request_details.ptr()) {
       top_sites_->GetMostVisitedURLs(
           consumer_,
           NewCallback(this, &NTPInfoObserver::OnTopSitesReceived));
     }
   }
 }
 
 void NTPInfoObserver::OnTopSitesLoaded() {
@@ skipping 30 matching lines @@
     IPC::Message* reply_message,
     extension_misc::LaunchContainer launch_container)
     : controller_(controller),
       automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       launch_container_(launch_container),
       new_window_id_(extension_misc::kUnknownWindowId) {
   if (launch_container_ == extension_misc::LAUNCH_TAB) {
     // Need to wait for the currently-active tab to reload.
     Source<NavigationController> source(controller_);
-    registrar_.Add(this, NotificationType::LOAD_STOP, source);
+    registrar_.Add(this, content::NOTIFICATION_LOAD_STOP, source);
   } else {
     // Need to wait for a new tab in a new window to load.
-    registrar_.Add(this, NotificationType::LOAD_STOP,
+    registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                    NotificationService::AllSources());
-    registrar_.Add(this, NotificationType::BROWSER_WINDOW_READY,
+    registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    NotificationService::AllSources());
   }
 }
 
 AppLaunchObserver::~AppLaunchObserver() {}
 
-void AppLaunchObserver::Observe(NotificationType type,
+void AppLaunchObserver::Observe(int type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
-  if (type.value == NotificationType::LOAD_STOP) {
+  if (type == content::NOTIFICATION_LOAD_STOP) {
     if (launch_container_ == extension_misc::LAUNCH_TAB) {
       // The app has been launched in the new tab.
       if (automation_) {
         AutomationJSONReply(automation_,
                             reply_message_.release()).SendSuccess(NULL);
       }
       delete this;
       return;
     } else {
       // The app has launched only if the loaded tab is in the new window.
       NavigationController* controller =
           Source<NavigationController>(source).ptr();
       TabContentsWrapper* tab =
           TabContentsWrapper::GetCurrentWrapperForContents(
               controller->tab_contents());
       int window_id = tab ? tab->restore_tab_helper()->window_id().id() : -1;
       if (window_id == new_window_id_) {
         if (automation_) {
           AutomationJSONReply(automation_,
                               reply_message_.release()).SendSuccess(NULL);
         }
         delete this;
         return;
       }
     }
-  } else if (type.value == NotificationType::BROWSER_WINDOW_READY) {
+  } else if (type == chrome::NOTIFICATION_BROWSER_WINDOW_READY) {
     new_window_id_ = ExtensionTabUtil::GetWindowId(
         Source<Browser>(source).ptr());
   } else {
     NOTREACHED();
   }
 }
 
 AutofillDisplayedObserver::AutofillDisplayedObserver(
-    NotificationType notification,
+    int notification,
     RenderViewHost* render_view_host,
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : notification_(notification),
       render_view_host_(render_view_host),
       automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   Source<RenderViewHost> source(render_view_host_);
   registrar_.Add(this, notification_, source);
 }
 
 AutofillDisplayedObserver::~AutofillDisplayedObserver() {}
 
 void AutofillDisplayedObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK_EQ(type.value, notification_.value);
+  DCHECK_EQ(type, notification_);
   DCHECK_EQ(Source<RenderViewHost>(source).ptr(), render_view_host_);
   if (automation_) {
     AutomationJSONReply(automation_,
                         reply_message_.release()).SendSuccess(NULL);
   }
   delete this;
 }
 
 AutofillChangedObserver::AutofillChangedObserver(
     AutomationProvider* automation,
@@ skipping 17 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::DB,
       FROM_HERE,
       NewRunnableMethod(this, &AutofillChangedObserver::RegisterObserversTask));
   done_event_.Wait();
 }
 
 void AutofillChangedObserver::RegisterObserversTask() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  registrar_.Add(this, NotificationType::AUTOFILL_CREDIT_CARD_CHANGED,
+  registrar_.Add(this, chrome::NOTIFICATION_AUTOFILL_CREDIT_CARD_CHANGED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::AUTOFILL_PROFILE_CHANGED,
+  registrar_.Add(this, chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
                  NotificationService::AllSources());
   done_event_.Signal();
 }
 
 void AutofillChangedObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
-  if (type.value == NotificationType::AUTOFILL_CREDIT_CARD_CHANGED) {
+  if (type == chrome::NOTIFICATION_AUTOFILL_CREDIT_CARD_CHANGED) {
     num_credit_cards_--;
-  } else if (type.value == NotificationType::AUTOFILL_PROFILE_CHANGED) {
+  } else if (type == chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED) {
     num_profiles_--;
   } else {
     NOTREACHED();
   }
 
   if (num_profiles_ == 0 && num_credit_cards_ == 0) {
     registrar_.RemoveAll();  // Must be done from the DB thread.
 
     // Notify the UI thread that we're done listening for all relevant
     // autofill notifications.
@@ skipping 31 matching lines @@
 }  // namespace
 
 GetActiveNotificationsObserver::GetActiveNotificationsObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   if (AreActiveNotificationProcessesReady()) {
     SendMessage();
   } else {
-    registrar_.Add(this, NotificationType::NOTIFY_BALLOON_CONNECTED,
+    registrar_.Add(this, chrome::NOTIFICATION_NOTIFY_BALLOON_CONNECTED,
                    NotificationService::AllSources());
   }
 }
 
 GetActiveNotificationsObserver::~GetActiveNotificationsObserver() {}
 
 void GetActiveNotificationsObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
   if (AreActiveNotificationProcessesReady())
     SendMessage();
 }
 
@@ skipping 24 matching lines @@
 
 OnNotificationBalloonCountObserver::OnNotificationBalloonCountObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message,
     int count)
     : automation_(provider->AsWeakPtr()),
       reply_message_(reply_message),
       collection_(
           g_browser_process->notification_ui_manager()->balloon_collection()),
       count_(count) {
-  registrar_.Add(this, NotificationType::NOTIFY_BALLOON_CONNECTED,
+  registrar_.Add(this, chrome::NOTIFICATION_NOTIFY_BALLOON_CONNECTED,
                  NotificationService::AllSources());
   collection_->set_on_collection_changed_callback(NewCallback(
       this, &OnNotificationBalloonCountObserver::CheckBalloonCount));
   CheckBalloonCount();
 }
 
 OnNotificationBalloonCountObserver::~OnNotificationBalloonCountObserver() {
 }
 
 void OnNotificationBalloonCountObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   CheckBalloonCount();
 }
 
 void OnNotificationBalloonCountObserver::CheckBalloonCount() {
   bool balloon_count_met = AreActiveNotificationProcessesReady() &&
       static_cast<int>(collection_->GetActiveBalloons().size()) == count_;
 
   if (balloon_count_met && automation_) {
     AutomationJSONReply(automation_,
                         reply_message_.release()).SendSuccess(NULL);
   }
 
   if (balloon_count_met || !automation_) {
     collection_->set_on_collection_changed_callback(NULL);
     delete this;
   }
 }
 
 RendererProcessClosedObserver::RendererProcessClosedObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
-  registrar_.Add(this, NotificationType::RENDERER_PROCESS_CLOSED,
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  NotificationService::AllSources());
 }
 
 RendererProcessClosedObserver::~RendererProcessClosedObserver() {}
 
 void RendererProcessClosedObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (automation_) {
     AutomationJSONReply(automation_,
                         reply_message_.release()).SendSuccess(NULL);
   }
   delete this;
 }
 
 InputEventAckNotificationObserver::InputEventAckNotificationObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message,
     int event_type,
     int count)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       event_type_(event_type),
       count_(count) {
   DCHECK(1 <= count);
   registrar_.Add(
-      this, NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
+      this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
       NotificationService::AllSources());
 }
 
 InputEventAckNotificationObserver::~InputEventAckNotificationObserver() {}
 
 void InputEventAckNotificationObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   Details<int> request_details(details);
   // If the event type matches for |count_| times, replies with a JSON message.
   if (event_type_ == *request_details.ptr()) {
     if (--count_ == 0 && automation_) {
       AutomationJSONReply(automation_,
                           reply_message_.release()).SendSuccess(NULL);
       delete this;
     }
@@ skipping 61 matching lines @@
     delete this;
   }
 }
 
 NewTabObserver::NewTabObserver(AutomationProvider* automation,
                                IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   // Use TAB_PARENTED to detect the new tab.
   registrar_.Add(this,
-                 NotificationType::TAB_PARENTED,
+                 content::NOTIFICATION_TAB_PARENTED,
                  NotificationService::AllSources());
 }
 
-void NewTabObserver::Observe(NotificationType type,
+void NewTabObserver::Observe(int type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
-  DCHECK_EQ(NotificationType::TAB_PARENTED, type.value);
+  DCHECK_EQ(content::NOTIFICATION_TAB_PARENTED, type);
   NavigationController* controller =
       &(Source<TabContentsWrapper>(source).ptr()->controller());
   if (automation_) {
     // TODO(phajdan.jr): Clean up this hack. We write the correct return type
     // here, but don't send the message. NavigationNotificationObserver
     // will wait properly for the load to finish, and send the message,
     // but it will also append its own return value at the end of the reply.
     AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message_.get(),
                                                          true);
     new NavigationNotificationObserver(controller, automation_,
@@ skipping 53 matching lines @@
   Release();
 }
 
 DragTargetDropAckNotificationObserver::DragTargetDropAckNotificationObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   registrar_.Add(
       this,
-      NotificationType::RENDER_VIEW_HOST_DID_RECEIVE_DRAG_TARGET_DROP_ACK,
+      content::NOTIFICATION_RENDER_VIEW_HOST_DID_RECEIVE_DRAG_TARGET_DROP_ACK,
       NotificationService::AllSources());
 }
 
 DragTargetDropAckNotificationObserver::
     ~DragTargetDropAckNotificationObserver() {}
 
 void DragTargetDropAckNotificationObserver::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (automation_) {
     AutomationJSONReply(automation_,
                         reply_message_.release()).SendSuccess(NULL);
   }
   delete this;
 }