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

chrome/browser/extensions/extension_service.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_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 73 matching lines @@
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/debugger/devtools_manager.h"
 #include "content/browser/plugin_process_host.h"
 #include "content/browser/plugin_service.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/user_metrics.h"
-#include "content/common/notification_service.h"
+#include "content/public/browser/notification_service.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/public/browser/notification_types.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/registry_controlled_domain.h"
 #include "webkit/database/database_tracker.h"
 #include "webkit/database/database_util.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/cros/cros_library.h"
@@ skipping 504 matching lines @@
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions)) {
     extensions_enabled_ = false;
   } else if (profile->GetPrefs()->GetBoolean(prefs::kDisableExtensions)) {
     extensions_enabled_ = false;
   }
 
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
-                 NotificationService::AllBrowserContextsAndSources());
+                 content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
-                 NotificationService::AllBrowserContextsAndSources());
+                 content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-                 NotificationService::AllBrowserContextsAndSources());
+                 content::NotificationService::AllBrowserContextsAndSources());
   pref_change_registrar_.Init(profile->GetPrefs());
   pref_change_registrar_.Add(prefs::kExtensionInstallAllowList, this);
   pref_change_registrar_.Add(prefs::kExtensionInstallDenyList, this);
 
   // Set up the ExtensionUpdater
   if (autoupdate_enabled) {
     int update_frequency = kDefaultUpdateFrequencySeconds;
     if (command_line->HasSwitch(switches::kExtensionsUpdateFrequency)) {
       base::StringToInt(command_line->GetSwitchValueASCII(
           switches::kExtensionsUpdateFrequency),
@@ skipping 250 matching lines @@
   scoped_refptr<const Extension> extension(GetInstalledExtension(extension_id));
 
   // Callers should not send us nonexistent extensions.
   CHECK(extension);
 
   // Policy change which triggers an uninstall will always set
   // |external_uninstall| to true so this is the only way to uninstall
   // managed extensions.
   if (!Extension::UserMayDisable(extension->location()) &&
       !external_uninstall) {
-    NotificationService::current()->Notify(
+    content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
     if (error != NULL) {
       *error = errors::kCannotUninstallManagedExtension;
     }
     return false;
   }
 
   // Extract the data we need for sync now, but don't actually sync until we've
@@ skipping 47 matching lines @@
           IsStorageProtected(launch_web_url_origin)) {
     ExtensionDataDeleter::StartDeleting(
         profile_, extension_id, launch_web_url_origin, is_storage_isolated);
   }
   ExtensionDataDeleter::StartDeleting(
       profile_, extension_id, extension->url(), is_storage_isolated);
 
   UntrackTerminatedExtension(extension_id);
 
   // Notify interested parties that we've uninstalled this extension.
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const std::string>(&extension_id));
 
   if (sync_bundle && sync_bundle->HasExtensionId(extension_id)) {
     sync_bundle->sync_processor->ProcessSyncChanges(
         FROM_HERE, SyncChangeList(1, sync_change));
     sync_bundle->synced_extensions.erase(extension_id);
   }
 
@@ skipping 493 matching lines @@
   // The ChromeURLRequestContexts need to be first to know that the extension
   // was loaded, otherwise a race can arise where a renderer that is created
   // for the extension may try to load an extension URL with an extension id
   // that the request context doesn't yet know about. The profile is responsible
   // for ensuring its URLRequestContexts appropriately discover the loaded
   // extension.
   profile_->RegisterExtensionWithRequestContexts(extension);
 
   // Tell subsystems that use the EXTENSION_LOADED notification about the new
   // extension.
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_LOADED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension));
 
   // Tell renderers about the new extension.
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     RenderProcessHost* host = i.GetCurrentValue();
     Profile* host_profile =
         Profile::FromBrowserContext(host->browser_context());
@@ skipping 93 matching lines @@
     }
 #endif
   }
 #endif
 }
 
 void ExtensionService::NotifyExtensionUnloaded(
     const Extension* extension,
     extension_misc::UnloadedExtensionReason reason) {
   UnloadedExtensionInfo details(extension, reason);
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNLOADED,
       content::Source<Profile>(profile_),
       content::Details<UnloadedExtensionInfo>(&details));
 
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     RenderProcessHost* host = i.GetCurrentValue();
     Profile* host_profile =
         Profile::FromBrowserContext(host->browser_context());
     if (host_profile->GetOriginalProfile() == profile_->GetOriginalProfile())
@@ skipping 669 matching lines @@
   // Clean up runtime data.
   extension_runtime_data_.erase(extension_id);
 
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension.get());
   if (iter != disabled_extensions_.end()) {
     UnloadedExtensionInfo details(extension, reason);
     details.already_disabled = true;
     disabled_extensions_.erase(iter);
-    NotificationService::current()->Notify(
+    content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNLOADED,
         content::Source<Profile>(profile_),
         content::Details<UnloadedExtensionInfo>(&details));
     // Make sure the profile cleans up its RequestContexts when an already
     // disabled extension is unloaded (since they are also tracking the disabled
     // extensions).
     profile_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     return;
   }
 
@@ skipping 51 matching lines @@
     ThemeServiceFactory::GetForProfile(profile_)->RemoveUnusedThemes();
   }
 }
 
 void ExtensionService::OnLoadedInstalledExtensions() {
   if (updater_.get()) {
     updater_->Start();
   }
 
   ready_ = true;
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSIONS_READY,
       content::Source<Profile>(profile_),
-      NotificationService::NoDetails());
+      content::NotificationService::NoDetails());
 }
 
 void ExtensionService::AddExtension(const Extension* extension) {
   // Ensure extension is deleted unless we transfer ownership.
   scoped_refptr<const Extension> scoped_extension(extension);
 
   // TODO(jstritar): We may be able to get rid of this branch by overriding the
   // default extension state to DISABLED when the --disable-extensions flag
   // is set (http://crbug.com/29067).
   if (!extensions_enabled() &&
@@ skipping 17 matching lines @@
   // Check if the extension's privileges have changed and disable the
   // extension if necessary.
   InitializePermissions(extension);
 
   bool disabled = extension_prefs_->IsExtensionDisabled(extension->id());
   if (disabled) {
     disabled_extensions_.push_back(scoped_extension);
     // TODO(aa): This seems dodgy. It seems that AddExtension() could get called
     // with a disabled extension for other reasons other than that an update was
     // disabled.
-    NotificationService::current()->Notify(
+    content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
     SyncExtensionChangeIfNeeded(*extension);
     return;
   }
 
   extensions_.push_back(scoped_extension);
   SyncExtensionChangeIfNeeded(*extension);
   NotifyExtensionLoaded(extension);
@@ skipping 147 matching lines @@
   if (pending_extension_manager()->GetById(id, &pending_extension_info)) {
     pending_extension_manager()->Remove(id);
 
     if (!pending_extension_info.ShouldAllowInstall(*extension)) {
       LOG(WARNING)
           << "ShouldAllowInstall() returned false for "
           << id << " of type " << extension->GetType()
           << " and update URL " << extension->update_url().spec()
           << "; not installing";
 
-      NotificationService::current()->Notify(
+      content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_EXTENSION_INSTALL_NOT_ALLOWED,
           content::Source<Profile>(profile_),
           content::Details<const Extension>(extension));
 
       // Delete the extension directory since we're not going to
       // load it.
       if (!BrowserThread::PostTask(
               BrowserThread::FILE, FROM_HERE,
               base::Bind(&extension_file_util::DeleteFile,
                          extension->path(), true)))
@@ skipping 30 matching lines @@
       !extension_prefs_->HasAllowFileAccessSetting(id)) {
     extension_prefs_->SetAllowFileAccess(id, true);
   }
 
   // If the extension should automatically block network startup (e.g., it uses
   // the webRequest API), set the preference. Otherwise clear it, in case the
   // extension stopped using a relevant API.
   extension_prefs_->SetDelaysNetworkRequests(
       extension->id(), extension->ImplicitlyDelaysNetworkStartup());
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_INSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension));
 
   // Transfer ownership of |extension| to AddExtension.
   AddExtension(scoped_extension);
 }
 
 const Extension* ExtensionService::GetExtensionByIdInternal(
     const std::string& id, bool include_enabled, bool include_disabled,
@@ skipping 153 matching lines @@
   installer->set_expected_id(id);
   installer->set_expected_version(*version);
   installer->set_install_cause(extension_misc::INSTALL_CAUSE_EXTERNAL_FILE);
   installer->InstallCrx(path);
 }
 
 void ExtensionService::ReportExtensionLoadError(
     const FilePath& extension_path,
     const std::string &error,
     bool be_noisy) {
-  NotificationService* service = NotificationService::current();
+  content::NotificationService* service =
+      content::NotificationService::current();
   service->Notify(chrome::NOTIFICATION_EXTENSION_LOAD_ERROR,
                   content::Source<Profile>(profile_),
                   content::Details<const std::string>(&error));
 
   std::string path_str = UTF16ToUTF8(extension_path.LossyDisplayName());
   std::string message = base::StringPrintf(
       "Could not load extension from '%s'. %s",
       path_str.c_str(), error.c_str());
   ExtensionErrorReporter::GetInstance()->ReportError(message, be_noisy);
 }
@@ skipping 114 matching lines @@
 }
 
 bool ExtensionService::IsBackgroundPageReady(const Extension* extension) {
   return (extension->background_url().is_empty() ||
           extension_runtime_data_[extension->id()].background_page_ready);
 }
 
 void ExtensionService::SetBackgroundPageReady(const Extension* extension) {
   DCHECK(!extension->background_url().is_empty());
   extension_runtime_data_[extension->id()].background_page_ready = true;
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_BACKGROUND_PAGE_READY,
       content::Source<const Extension>(extension),
-      NotificationService::NoDetails());
+      content::NotificationService::NoDetails());
 }
 
 bool ExtensionService::IsBeingUpgraded(const Extension* extension) {
   return extension_runtime_data_[extension->id()].being_upgraded;
 }
 
 void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
@@ skipping 71 matching lines @@
 
 ExtensionService::NaClModuleInfoList::iterator
     ExtensionService::FindNaClModule(const GURL& url) {
   for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }