Make NotificationService an interface in the content namespace, and switch callers to use it. Mov...

chrome/browser/extensions/extension_browsertest.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/extensions/extension_browsertest.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_registrar.h"
-#include "content/common/notification_service.h"
+#include "content/public/browser/notification_service.h"
 
 ExtensionBrowserTest::ExtensionBrowserTest()
     : loaded_(false),
       installed_(false),
       extension_installs_observed_(0),
       target_page_action_count_(-1),
       target_visible_page_action_count_(-1) {
   EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
 }
 
@@ skipping 17 matching lines @@
   command_line->AppendSwitch(switches::kNoFirstRun);
 #endif
 }
 
 const Extension* ExtensionBrowserTest::LoadExtensionWithOptions(
     const FilePath& path, bool incognito_enabled, bool fileaccess_enabled) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   {
     content::NotificationRegistrar registrar;
     registrar.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
-                  NotificationService::AllSources());
+                  content::NotificationService::AllSources());
     service->LoadExtension(path, false);
     ui_test_utils::RunMessageLoop();
   }
 
   // Find the extension by iterating backwards since it is likely last.
   FilePath extension_path = path;
   file_util::AbsolutePath(&extension_path);
   const Extension* extension = NULL;
   for (ExtensionList::const_reverse_iterator iter =
            service->extensions()->rbegin();
@@ skipping 156 matching lines @@
                                                     int expected_change,
                                                     Profile* profile,
                                                     bool from_webstore) {
   ExtensionService* service = profile->GetExtensionService();
   service->set_show_extensions_prompts(false);
   size_t num_before = service->extensions()->size();
 
   {
     content::NotificationRegistrar registrar;
     registrar.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
-                  NotificationService::AllSources());
+                  content::NotificationService::AllSources());
     registrar.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
-                  NotificationService::AllSources());
+                  content::NotificationService::AllSources());
     registrar.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
-                  NotificationService::AllSources());
+                  content::NotificationService::AllSources());
     registrar.Add(this, chrome::NOTIFICATION_EXTENSION_LOAD_ERROR,
-                  NotificationService::AllSources());
+                  content::NotificationService::AllSources());
 
     ExtensionInstallUI* install_ui = NULL;
     if (ui_type == INSTALL_UI_TYPE_CANCEL)
       install_ui = new MockAbortExtensionInstallUI();
     else if (ui_type == INSTALL_UI_TYPE_NORMAL)
       install_ui = new ExtensionInstallUI(profile);
     else if (ui_type == INSTALL_UI_TYPE_AUTO_CONFIRM)
       install_ui = new MockAutoConfirmExtensionInstallUI(profile);
 
     // TODO(tessamac): Update callers to always pass an unpacked extension
@@ skipping 34 matching lines @@
   }
 
   return WaitForExtensionHostsToLoad();
 }
 
 void ExtensionBrowserTest::ReloadExtension(const std::string& extension_id) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->ReloadExtension(extension_id);
   ui_test_utils::RegisterAndWait(this,
                                  chrome::NOTIFICATION_EXTENSION_LOADED,
-                                 NotificationService::AllSources());
+                                 content::NotificationService::AllSources());
 }
 
 void ExtensionBrowserTest::UnloadExtension(const std::string& extension_id) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->UnloadExtension(extension_id, extension_misc::UNLOAD_REASON_DISABLE);
 }
 
 void ExtensionBrowserTest::UninstallExtension(const std::string& extension_id) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->UninstallExtension(extension_id, false, NULL);
 }
 
 void ExtensionBrowserTest::DisableExtension(const std::string& extension_id) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->DisableExtension(extension_id);
 }
 
 void ExtensionBrowserTest::EnableExtension(const std::string& extension_id) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   service->EnableExtension(extension_id);
 }
 
 bool ExtensionBrowserTest::WaitForPageActionCountChangeTo(int count) {
   LocationBarTesting* location_bar =
       browser()->window()->GetLocationBar()->GetLocationBarForTesting();
   if (location_bar->PageActionCount() != count) {
     target_page_action_count_ = count;
     ui_test_utils::RegisterAndWait(this,
         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED,
-        NotificationService::AllSources());
+        content::NotificationService::AllSources());
   }
   return location_bar->PageActionCount() == count;
 }
 
 bool ExtensionBrowserTest::WaitForPageActionVisibilityChangeTo(int count) {
   LocationBarTesting* location_bar =
       browser()->window()->GetLocationBar()->GetLocationBarForTesting();
   if (location_bar->PageActionVisibleCount() != count) {
     target_visible_page_action_count_ = count;
     ui_test_utils::RegisterAndWait(this,
         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED,
-        NotificationService::AllSources());
+        content::NotificationService::AllSources());
   }
   return location_bar->PageActionVisibleCount() == count;
 }
 
 bool ExtensionBrowserTest::WaitForExtensionHostsToLoad() {
   // Wait for all the extension hosts that exist to finish loading.
   content::NotificationRegistrar registrar;
   registrar.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
-                NotificationService::AllSources());
+                content::NotificationService::AllSources());
 
   ExtensionProcessManager* manager =
         browser()->profile()->GetExtensionProcessManager();
   for (ExtensionProcessManager::const_iterator iter = manager->begin();
        iter != manager->end();) {
     if ((*iter)->did_stop_loading()) {
       ++iter;
     } else {
       ui_test_utils::RunMessageLoop();
 
       // Test activity may have modified the set of extension processes during
       // message processing, so re-start the iteration to catch added/removed
       // processes.
       iter = manager->begin();
     }
   }
   return true;
 }
 
 bool ExtensionBrowserTest::WaitForExtensionInstall() {
   int before = extension_installs_observed_;
   ui_test_utils::RegisterAndWait(this,
                                  chrome::NOTIFICATION_EXTENSION_INSTALLED,
-                                 NotificationService::AllSources());
+                                 content::NotificationService::AllSources());
   return extension_installs_observed_ == (before + 1);
 }
 
 bool ExtensionBrowserTest::WaitForExtensionInstallError() {
   int before = extension_installs_observed_;
   ui_test_utils::RegisterAndWait(this,
                                  chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
-                                 NotificationService::AllSources());
+                                 content::NotificationService::AllSources());
   return extension_installs_observed_ == before;
 }
 
 void ExtensionBrowserTest::WaitForExtensionLoad() {
   ui_test_utils::RegisterAndWait(this, chrome::NOTIFICATION_EXTENSION_LOADED,
-                                 NotificationService::AllSources());
+                                 content::NotificationService::AllSources());
   WaitForExtensionHostsToLoad();
 }
 
 bool ExtensionBrowserTest::WaitForExtensionCrash(
     const std::string& extension_id) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
 
   if (!service->GetExtensionById(extension_id, true)) {
     // The extension is already unloaded, presumably due to a crash.
     return true;
   }
   ui_test_utils::RegisterAndWait(
       this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
-      NotificationService::AllSources());
+      content::NotificationService::AllSources());
   return (service->GetExtensionById(extension_id, true) == NULL);
 }
 
 void ExtensionBrowserTest::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOADED:
       last_loaded_extension_id_ =
@@ skipping 63 matching lines @@
         MessageLoopForUI::current()->Quit();
       }
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }