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 79 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::INITIAL_NEW_TAB_UI_LOAD,
                  NotificationService::AllSources());
 }
 
 NewTabUILoadObserver::~NewTabUILoadObserver() {
 }
 
 void NewTabUILoadObserver::Observe(NotificationType type,
                                    const NotificationSource& source,
                                    const NotificationDetails& details) {
-  if (type == NotificationType::INITIAL_NEW_TAB_UI_LOAD) {
+  if (type == chrome::INITIAL_NEW_TAB_UI_LOAD) {
     Details<int> load_time(details);
     if (automation_) {
       automation_->Send(
           new AutomationMsg_InitialNewTabUILoadComplete(*load_time.ptr()));
     }
   } else {
     NOTREACHED();
   }
 }
 
@@ skipping 49 matching lines @@
       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, chrome::AUTH_NEEDED, source);
+  registrar_.Add(this, chrome::AUTH_SUPPLIED, source);
+  registrar_.Add(this, chrome::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,
     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.
+  // a chrome::NAV_ENTRY_COMMITTED until after we authenticate, so
+  // we need the chrome::LOAD_START.
   if (type == NotificationType::NAV_ENTRY_COMMITTED ||
       type == NotificationType::LOAD_START) {
     navigation_started_ = true;
   } else if (type == NotificationType::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::AUTH_SUPPLIED ||
+             type == chrome::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::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 158 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::EXTENSION_LOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_INSTALL_ERROR,
+  registrar_.Add(this, chrome::EXTENSION_INSTALL_ERROR,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
+  registrar_.Add(this, chrome::EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
 }
 
 ExtensionInstallNotificationObserver::~ExtensionInstallNotificationObserver() {
 }
 
 void ExtensionInstallNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type.value) {
-    case NotificationType::EXTENSION_LOADED:
+    case chrome::EXTENSION_LOADED:
       SendResponse(AUTOMATION_MSG_EXTENSION_INSTALL_SUCCEEDED);
       break;
-    case NotificationType::EXTENSION_INSTALL_ERROR:
-    case NotificationType::EXTENSION_UPDATE_DISABLED:
+    case chrome::EXTENSION_INSTALL_ERROR:
+    case chrome::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::EXTENSION_UNINSTALLED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UNINSTALL_NOT_ALLOWED,
+  registrar_.Add(this, chrome::EXTENSION_UNINSTALL_NOT_ALLOWED,
                  NotificationService::AllSources());
 }
 
 ExtensionUninstallObserver::~ExtensionUninstallObserver() {
 }
 
 void ExtensionUninstallObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
   switch (type.value) {
-    case NotificationType::EXTENSION_UNINSTALLED: {
+    case chrome::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::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::EXTENSION_HOST_DID_STOP_LOADING,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
+  registrar_.Add(this, chrome::EXTENSION_LOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_INSTALL_ERROR,
+  registrar_.Add(this, chrome::EXTENSION_INSTALL_ERROR,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
+  registrar_.Add(this, chrome::EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
 }
 
 ExtensionReadyNotificationObserver::~ExtensionReadyNotificationObserver() {
 }
 
 void ExtensionReadyNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
   switch (type.value) {
-    case NotificationType::EXTENSION_HOST_DID_STOP_LOADING:
+    case chrome::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::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::EXTENSION_INSTALL_ERROR:
+    case chrome::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::EXTENSION_UNLOADED,
                  NotificationService::AllSources());
 }
 
 ExtensionUnloadNotificationObserver::~ExtensionUnloadNotificationObserver() {
 }
 
 void ExtensionUnloadNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
-  if (type.value == NotificationType::EXTENSION_UNLOADED) {
+  if (type.value == chrome::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::EXTENSION_HOST_DID_STOP_LOADING,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_INSTALL_ERROR,
+  registrar_.Add(this, chrome::EXTENSION_INSTALL_ERROR,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_INSTALL_NOT_ALLOWED,
+  registrar_.Add(this, chrome::EXTENSION_INSTALL_NOT_ALLOWED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
+  registrar_.Add(this, chrome::EXTENSION_LOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
+  registrar_.Add(this, chrome::EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_FOUND,
+  registrar_.Add(this, chrome::EXTENSION_UPDATE_FOUND,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATING_FINISHED,
+  registrar_.Add(this, chrome::EXTENSION_UPDATING_FINISHED,
                  NotificationService::AllSources());
 }
 
 ExtensionsUpdatedObserver::~ExtensionsUpdatedObserver() {
 }
 
 void ExtensionsUpdatedObserver::Observe(
     NotificationType 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:
+    case chrome::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::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::EXTENSION_LOADED:
+    case chrome::EXTENSION_INSTALL_NOT_ALLOWED:
+    case chrome::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::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::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::EXTENSION_TEST_PASSED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_TEST_FAILED,
+  registrar_.Add(this, chrome::EXTENSION_TEST_FAILED,
                  NotificationService::AllSources());
 }
 
 ExtensionTestResultNotificationObserver::
     ~ExtensionTestResultNotificationObserver() {
 }
 
 void ExtensionTestResultNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type.value) {
-    case NotificationType::EXTENSION_TEST_PASSED:
+    case chrome::EXTENSION_TEST_PASSED:
       results_.push_back(true);
       messages_.push_back("");
       break;
 
-    case NotificationType::EXTENSION_TEST_FAILED:
+    case chrome::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::BROWSER_OPENED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::LOAD_STOP,
                  NotificationService::AllSources());
 }
 
 BrowserOpenedNotificationObserver::~BrowserOpenedNotificationObserver() {
 }
 
 void BrowserOpenedNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
-  if (type.value == NotificationType::BROWSER_OPENED) {
+  if (type.value == chrome::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) {
     // 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());
@@ skipping 17 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::BROWSER_CLOSED,
                  Source<Browser>(browser));
 }
 
 BrowserClosedNotificationObserver::~BrowserClosedNotificationObserver() {}
 
 void BrowserClosedNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::BROWSER_CLOSED);
+  DCHECK(type == chrome::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::BROWSER_OPENED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::BROWSER_CLOSED,
+  registrar_.Add(this, chrome::BROWSER_CLOSED,
                  NotificationService::AllSources());
 }
 
 BrowserCountChangeNotificationObserver::
     ~BrowserCountChangeNotificationObserver() {}
 
 void BrowserCountChangeNotificationObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::BROWSER_OPENED ||
-         type == NotificationType::BROWSER_CLOSED);
+  DCHECK(type == chrome::BROWSER_OPENED ||
+         type == chrome::BROWSER_CLOSED);
   int current_count = static_cast<int>(BrowserList::size());
-  if (type == NotificationType::BROWSER_CLOSED) {
+  if (type == chrome::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::APP_MODAL_DIALOG_SHOWN,
                  NotificationService::AllSources());
 }
 
 AppModalDialogShownObserver::~AppModalDialogShownObserver() {
 }
 
 void AppModalDialogShownObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::APP_MODAL_DIALOG_SHOWN);
+  DCHECK(type == chrome::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},
 
   // 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},
 
   // For the following commands, we need to wait for a new tab to be created,
@@ skipping 84 matching lines @@
 }
 
 bool ExecuteBrowserCommandObserver::Register(int command) {
   if (!GetNotificationType(command, &notification_type_))
     return false;
   registrar_.Add(this, notification_type_, NotificationService::AllSources());
   return true;
 }
 
 bool ExecuteBrowserCommandObserver::GetNotificationType(
-    int command, NotificationType::Type* type) {
+    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::FIND_RESULT_AVAILABLE,
                  Source<TabContents>(parent_tab));
 }
 
 FindInPageNotificationObserver::~FindInPageNotificationObserver() {
 }
 
 void FindInPageNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
   Details<FindNotificationDetails> find_details(details);
@@ skipping 35 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::DOM_OPERATION_RESPONSE,
                  NotificationService::AllSources());
 }
 
 DomOperationObserver::~DomOperationObserver() {}
 
 void DomOperationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
-  if (NotificationType::DOM_OPERATION_RESPONSE == type) {
+  if (chrome::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::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,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::PRINT_JOB_EVENT);
+  DCHECK(type == chrome::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::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,
     const NotificationSource& source, const NotificationDetails& details) {
-  if (type != NotificationType::METRIC_EVENT_DURATION) {
+  if (type != chrome::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::PAGE_TRANSLATED,
                  Source<TabContents>(tab_contents));
 }
 
 PageTranslatedObserver::~PageTranslatedObserver() {}
 
 void PageTranslatedObserver::Observe(NotificationType type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   if (!automation_) {
     delete this;
     return;
   }
 
-  DCHECK(type == NotificationType::PAGE_TRANSLATED);
+  DCHECK(type == chrome::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::TAB_LANGUAGE_DETERMINED,
                  Source<TabContents>(tab_contents));
 }
 
 TabLanguageDeterminedObserver::~TabLanguageDeterminedObserver() {}
 
 void TabLanguageDeterminedObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(type == NotificationType::TAB_LANGUAGE_DETERMINED);
+  DCHECK(type == chrome::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::TAB_CONTENTS_INFOBAR_ADDED, source);
+  registrar_.Add(this, chrome::TAB_CONTENTS_INFOBAR_REMOVED, source);
   CheckCount();
 }
 
 InfoBarCountObserver::~InfoBarCountObserver() {}
 
 void InfoBarCountObserver::Observe(NotificationType type,
                                    const NotificationSource& source,
                                    const NotificationDetails& details) {
-  DCHECK(type == NotificationType::TAB_CONTENTS_INFOBAR_ADDED ||
-         type == NotificationType::TAB_CONTENTS_INFOBAR_REMOVED);
+  DCHECK(type == chrome::TAB_CONTENTS_INFOBAR_ADDED ||
+         type == chrome::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::LOGINS_CHANGED,
                  NotificationService::AllSources());
   done_event_.Signal();
 }
 
 void PasswordStoreLoginsChangedObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  DCHECK(type.value == NotificationType::LOGINS_CHANGED);
+  DCHECK(type.value == chrome::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 54 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);
   // Pages requiring auth don't send LOAD_STOP.
-  registrar_.Add(this, NotificationType::AUTH_NEEDED, source);
+  registrar_.Add(this, chrome::AUTH_NEEDED, source);
 }
 
 OmniboxAcceptNotificationObserver::~OmniboxAcceptNotificationObserver() {
 }
 
 void OmniboxAcceptNotificationObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (type == NotificationType::LOAD_STOP ||
-      type == NotificationType::AUTH_NEEDED) {
+      type == chrome::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::SAVE_PACKAGE_SUCCESSFULLY_FINISHED,
                  source);
 }
 
 SavePackageNotificationObserver::~SavePackageNotificationObserver() {}
 
 void SavePackageNotificationObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  if (type == NotificationType::SAVE_PACKAGE_SUCCESSFULLY_FINISHED) {
+  if (type == chrome::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::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::TOP_SITES_LOADED,
                    Source<Profile>(automation_->profile()));
   }
 }
 
 NTPInfoObserver::~NTPInfoObserver() {}
 
 void NTPInfoObserver::Observe(NotificationType type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
-  if (type == NotificationType::TOP_SITES_LOADED) {
+  if (type == chrome::TOP_SITES_LOADED) {
     OnTopSitesLoaded();
-  } else if (type == NotificationType::TOP_SITES_UPDATED) {
+  } else if (type == chrome::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 35 matching lines @@
       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);
   } else {
     // Need to wait for a new tab in a new window to load.
     registrar_.Add(this, NotificationType::LOAD_STOP,
                    NotificationService::AllSources());
-    registrar_.Add(this, NotificationType::BROWSER_WINDOW_READY,
+    registrar_.Add(this, chrome::BROWSER_WINDOW_READY,
                    NotificationService::AllSources());
   }
 }
 
 AppLaunchObserver::~AppLaunchObserver() {}
 
 void AppLaunchObserver::Observe(NotificationType type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
   if (type.value == NotificationType::LOAD_STOP) {
@@ skipping 15 matching lines @@
       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.value == chrome::BROWSER_WINDOW_READY) {
     new_window_id_ = ExtensionTabUtil::GetWindowId(
         Source<Browser>(source).ptr());
   } else {
     NOTREACHED();
   }
 }
 
 AutofillDisplayedObserver::AutofillDisplayedObserver(
     NotificationType notification,
     RenderViewHost* render_view_host,
@@ skipping 44 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::AUTOFILL_CREDIT_CARD_CHANGED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::AUTOFILL_PROFILE_CHANGED,
+  registrar_.Add(this, chrome::AUTOFILL_PROFILE_CHANGED,
                  NotificationService::AllSources());
   done_event_.Signal();
 }
 
 void AutofillChangedObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
-  if (type.value == NotificationType::AUTOFILL_CREDIT_CARD_CHANGED) {
+  if (type.value == chrome::AUTOFILL_CREDIT_CARD_CHANGED) {
     num_credit_cards_--;
-  } else if (type.value == NotificationType::AUTOFILL_PROFILE_CHANGED) {
+  } else if (type.value == chrome::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::NOTIFY_BALLOON_CONNECTED,
                    NotificationService::AllSources());
   }
 }
 
 GetActiveNotificationsObserver::~GetActiveNotificationsObserver() {}
 
 void GetActiveNotificationsObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
@@ skipping 32 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::NOTIFY_BALLOON_CONNECTED,
                  NotificationService::AllSources());
   collection_->set_on_collection_changed_callback(NewCallback(
       this, &OnNotificationBalloonCountObserver::CheckBalloonCount));
   CheckBalloonCount();
 }
 
 OnNotificationBalloonCountObserver::~OnNotificationBalloonCountObserver() {
 }
 
 void OnNotificationBalloonCountObserver::Observe(
@@ skipping 231 matching lines @@
 void DragTargetDropAckNotificationObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (automation_) {
     AutomationJSONReply(automation_,
                         reply_message_.release()).SendSuccess(NULL);
   }
   delete this;
 }