Move extension notifications to extensions/browser/notification_types.h

chrome/browser/extensions/extension_test_notification_observer.cc

 // Copyright 2013 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/extensions/extension_test_notification_observer.h"
 
 #include "base/callback_list.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 138 matching lines @@
       notification_type, content::NotificationService::AllSources()).Wait();
 }
 
 bool ExtensionTestNotificationObserver::WaitForPageActionCountChangeTo(
     int count) {
   LocationBarTesting* location_bar =
       browser_->window()->GetLocationBar()->GetLocationBarForTesting();
   WaitForCondition(
       base::Bind(
           &HasExtensionPageActionCountReachedTarget, location_bar, count),
-      chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED);
+      extensions::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED);
   return true;
 }
 
 bool ExtensionTestNotificationObserver::WaitForPageActionVisibilityChangeTo(
     int count) {
   LocationBarTesting* location_bar =
       browser_->window()->GetLocationBar()->GetLocationBarForTesting();
   WaitForCondition(
       base::Bind(
           &HasExtensionPageActionVisibilityReachedTarget, location_bar, count),
-      chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED);
+      extensions::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED);
   return true;
 }
 
 bool ExtensionTestNotificationObserver::WaitForExtensionViewsToLoad() {
   extensions::ProcessManager* manager =
       extensions::ExtensionSystem::Get(GetProfile())->process_manager();
   NotificationSet notification_set;
   notification_set.Add(content::NOTIFICATION_WEB_CONTENTS_DESTROYED);
   notification_set.Add(content::NOTIFICATION_LOAD_STOP);
   WaitForCondition(
       base::Bind(&HaveAllExtensionRenderViewHostsFinishedLoading, manager),
       &notification_set);
   return true;
 }
 
 bool ExtensionTestNotificationObserver::WaitForExtensionInstall() {
   int before = extension_installs_observed_;
   WaitForNotification(
-      chrome::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED);
+      extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED);
   return extension_installs_observed_ == (before + 1);
 }
 
 bool ExtensionTestNotificationObserver::WaitForExtensionInstallError() {
   int before = extension_installs_observed_;
   content::WindowedNotificationObserver(
-      chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
+      extensions::NOTIFICATION_EXTENSION_INSTALL_ERROR,
       content::NotificationService::AllSources()).Wait();
   return extension_installs_observed_ == before;
 }
 
 void ExtensionTestNotificationObserver::WaitForExtensionLoad() {
-  WaitForNotification(chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED);
+  WaitForNotification(extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED);
 }
 
 void ExtensionTestNotificationObserver::WaitForExtensionAndViewLoad() {
   this->WaitForExtensionLoad();
   WaitForExtensionViewsToLoad();
 }
 
 bool ExtensionTestNotificationObserver::WaitForExtensionLoadError() {
   int before = extension_load_errors_observed_;
-  WaitForNotification(chrome::NOTIFICATION_EXTENSION_LOAD_ERROR);
+  WaitForNotification(extensions::NOTIFICATION_EXTENSION_LOAD_ERROR);
   return extension_load_errors_observed_ != before;
 }
 
 bool ExtensionTestNotificationObserver::WaitForExtensionCrash(
     const std::string& extension_id) {
   ExtensionService* service = extensions::ExtensionSystem::Get(
       GetProfile())->extension_service();
 
   if (!service->GetExtensionById(extension_id, true)) {
     // The extension is already unloaded, presumably due to a crash.
     return true;
   }
   content::WindowedNotificationObserver(
-      chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
+      extensions::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
       content::NotificationService::AllSources()).Wait();
   return (service->GetExtensionById(extension_id, true) == NULL);
 }
 
 bool ExtensionTestNotificationObserver::WaitForCrxInstallerDone() {
   int before = crx_installers_done_observed_;
-  WaitForNotification(chrome::NOTIFICATION_CRX_INSTALLER_DONE);
+  WaitForNotification(extensions::NOTIFICATION_CRX_INSTALLER_DONE);
   return crx_installers_done_observed_ == (before + 1);
 }
 
 void ExtensionTestNotificationObserver::Watch(
     int type,
     const content::NotificationSource& source) {
   CHECK(!observer_);
   observer_.reset(new content::WindowedNotificationObserver(type, source));
   registrar_.Add(this, type, source);
 }
 
 void ExtensionTestNotificationObserver::Wait() {
   observer_->Wait();
 
   registrar_.RemoveAll();
   observer_.reset();
 }
 
 void ExtensionTestNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
+    case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
       last_loaded_extension_id_ =
         content::Details<const Extension>(details).ptr()->id();
       VLOG(1) << "Got EXTENSION_LOADED notification.";
       break;
 
-    case chrome::NOTIFICATION_CRX_INSTALLER_DONE:
+    case extensions::NOTIFICATION_CRX_INSTALLER_DONE:
       VLOG(1) << "Got CRX_INSTALLER_DONE notification.";
       {
           const Extension* extension =
             content::Details<const Extension>(details).ptr();
           if (extension)
             last_loaded_extension_id_ = extension->id();
           else
             last_loaded_extension_id_.clear();
       }
       ++crx_installers_done_observed_;
       break;
 
-    case chrome::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED:
+    case extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED:
       VLOG(1) << "Got EXTENSION_INSTALLED notification.";
       ++extension_installs_observed_;
       break;
 
-    case chrome::NOTIFICATION_EXTENSION_LOAD_ERROR:
+    case extensions::NOTIFICATION_EXTENSION_LOAD_ERROR:
       VLOG(1) << "Got EXTENSION_LOAD_ERROR notification.";
       ++extension_load_errors_observed_;
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }