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

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/basictypes.h"
@@ skipping 40 matching lines @@
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/browser/ui/webui/favicon_source.h"
 #include "chrome/browser/ui/webui/ntp/shown_sections_handler.h"
 #include "chrome/common/child_process_logging.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #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/common/content_notification_types.h"
 #include "content/common/json_value_serializer.h"
 #include "content/common/notification_service.h"
-#include "content/common/notification_type.h"
 #include "content/common/pepper_plugin_registry.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/extensions/file_browser_event_router.h"
 #include "chrome/browser/chromeos/extensions/media_player_event_router.h"
@@ skipping 255 matching lines @@
               &ExtensionServiceBackend::OnLoadSingleExtension,
               extension)))
     NOTREACHED();
 }
 
 void ExtensionServiceBackend::ReportExtensionLoadError(
     const FilePath& extension_path, const std::string &error) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (frontend_.get())
     frontend_->ReportExtensionLoadError(
-        extension_path, error, NotificationType::EXTENSION_INSTALL_ERROR,
+        extension_path, error, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
         true /* alert_on_error */);
 }
 
 void ExtensionServiceBackend::OnLoadSingleExtension(
     const scoped_refptr<const Extension>& extension) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (frontend_.get())
     frontend_->OnLoadSingleExtension(extension);
 }
 
@@ skipping 188 matching lines @@
       event_routers_initialized_(false) {
   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, NotificationType::EXTENSION_PROCESS_TERMINATED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::RENDERER_PROCESS_CREATED,
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::RENDERER_PROCESS_TERMINATED,
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  NotificationService::AllSources());
   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(
@@ skipping 248 matching lines @@
   // Get hold of information we need after unloading, since the extension
   // pointer will be invalid then.
   GURL extension_url(extension->url());
   Extension::Location location(extension->location());
 
   // 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(location) && !external_uninstall) {
     NotificationService::current()->Notify(
-        NotificationType::EXTENSION_UNINSTALL_NOT_ALLOWED,
+        chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
         Source<Profile>(profile_),
         Details<const Extension>(extension));
     if (error != NULL) {
       *error = errors::kCannotUninstallManagedExtension;
     }
     return false;
   }
 
   UninstalledExtensionInfo uninstalled_extension_info(*extension);
 
@@ skipping 23 matching lines @@
                 install_directory_,
                 extension_id)))
       NOTREACHED();
   }
 
   ClearExtensionData(extension_url);
   UntrackTerminatedExtension(extension_id);
 
   // Notify interested parties that we've uninstalled this extension.
   NotificationService::current()->Notify(
-      NotificationType::EXTENSION_UNINSTALLED,
+      chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
       Source<Profile>(profile_),
       Details<UninstalledExtensionInfo>(&uninstalled_extension_info));
 
   return true;
 }
 
 void ExtensionService::ClearExtensionData(const GURL& extension_url) {
   scoped_refptr<ExtensionDataDeleter> deleter(
       new ExtensionDataDeleter(profile_, extension_url));
   deleter->StartDeleting();
@@ skipping 354 matching lines @@
         *info.extension_manifest,
         flags,
         &error);
   } else {
     error = errors::kManifestUnreadable;
   }
 
   if (!extension) {
     ReportExtensionLoadError(info.extension_path,
                              error,
-                             NotificationType::EXTENSION_INSTALL_ERROR,
+                             chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                              false);
     return;
   }
 
   if (write_to_prefs)
     extension_prefs_->UpdateManifest(extension);
 
   AddExtension(extension);
 }
 
 void ExtensionService::NotifyExtensionLoaded(const Extension* extension) {
   // 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(
-      NotificationType::EXTENSION_LOADED,
+      chrome::NOTIFICATION_EXTENSION_LOADED,
       Source<Profile>(profile_),
       Details<const Extension>(extension));
 
   // Tell renderers about the new extension.
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     RenderProcessHost* host = i.GetCurrentValue();
     if (host->profile()->GetOriginalProfile() ==
         profile_->GetOriginalProfile()) {
       host->Send(
@@ skipping 76 matching lines @@
                                                     is_system);
     }
   }
 #endif
 }
 
 void ExtensionService::NotifyExtensionUnloaded(
     const Extension* extension, UnloadedExtensionInfo::Reason reason) {
   UnloadedExtensionInfo details(extension, reason);
   NotificationService::current()->Notify(
-      NotificationType::EXTENSION_UNLOADED,
+      chrome::NOTIFICATION_EXTENSION_UNLOADED,
       Source<Profile>(profile_),
       Details<UnloadedExtensionInfo>(&details));
 
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     RenderProcessHost* host = i.GetCurrentValue();
     if (host->profile()->GetOriginalProfile() ==
         profile_->GetOriginalProfile()) {
       host->Send(new ExtensionMsg_Unloaded(extension->id()));
     }
@@ skipping 397 matching lines @@
   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(
-        NotificationType::EXTENSION_UNLOADED,
+        chrome::NOTIFICATION_EXTENSION_UNLOADED,
         Source<Profile>(profile_),
         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;
   }
 
   iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
@@ skipping 51 matching lines @@
   }
 }
 
 void ExtensionService::OnLoadedInstalledExtensions() {
   if (updater_.get()) {
     updater_->Start();
   }
 
   ready_ = true;
   NotificationService::current()->Notify(
-      NotificationType::EXTENSIONS_READY,
+      chrome::NOTIFICATION_EXTENSIONS_READY,
       Source<Profile>(profile_),
       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
@@ skipping 20 matching lines @@
   // extension if necessary.
   DisableIfPrivilegeIncrease(extension);
 
   Extension::State state = extension_prefs_->GetExtensionState(extension->id());
   if (state == Extension::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(
-        NotificationType::EXTENSION_UPDATE_DISABLED,
+        chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
         Source<Profile>(profile_),
         Details<const Extension>(extension));
     return;
   }
 
   // It should not be possible to get here with EXTERNAL_EXTENSION_UNINSTALLED
   // because we would not have loaded the extension in that case.
   CHECK(state == Extension::ENABLED);
   extensions_.push_back(scoped_extension);
   NotifyExtensionLoaded(extension);
@@ skipping 113 matching lines @@
     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(
-          NotificationType::EXTENSION_INSTALL_NOT_ALLOWED,
+          chrome::NOTIFICATION_EXTENSION_INSTALL_NOT_ALLOWED,
           Source<Profile>(profile_),
           Details<const Extension>(extension));
 
       // Delete the extension directory since we're not going to
       // load it.
       if (!BrowserThread::PostTask(
               BrowserThread::FILE, FROM_HERE,
               NewRunnableFunction(&extension_file_util::DeleteFile,
                                   extension->path(), true)))
         NOTREACHED();
@@ skipping 21 matching lines @@
       extension, initial_enable ? Extension::ENABLED : Extension::DISABLED);
 
   // Unpacked extensions default to allowing file access, but if that has been
   // overridden, don't reset the value.
   if (Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD) &&
       !extension_prefs_->HasAllowFileAccessSetting(id)) {
     extension_prefs_->SetAllowFileAccess(id, true);
   }
 
   NotificationService::current()->Notify(
-      NotificationType::EXTENSION_INSTALLED,
+      chrome::NOTIFICATION_EXTENSION_INSTALLED,
       Source<Profile>(profile_),
       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,
     bool include_terminated) const {
@@ skipping 138 matching lines @@
   installer->set_install_source(location);
   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,
-    NotificationType type,
+    int type,
     bool be_noisy) {
   NotificationService* service = NotificationService::current();
   service->Notify(type,
                   Source<Profile>(profile_),
                   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);
 }
 
 void ExtensionService::DidCreateRenderViewForBackgroundPage(
     ExtensionHost* host) {
   OrphanedDevTools::iterator iter =
       orphaned_dev_tools_.find(host->extension_id());
   if (iter == orphaned_dev_tools_.end())
     return;
 
   DevToolsManager::GetInstance()->AttachClientHost(
       iter->second, host->render_view_host());
   orphaned_dev_tools_.erase(iter);
 }
 
-void ExtensionService::Observe(NotificationType type,
+void ExtensionService::Observe(int type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::EXTENSION_PROCESS_TERMINATED: {
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED: {
       if (profile_ != Source<Profile>(source).ptr()->GetOriginalProfile())
         break;
 
       ExtensionHost* host = Details<ExtensionHost>(details).ptr();
 
       // Mark the extension as terminated and Unload it. We want it to
       // be in a consistent state: either fully working or not loaded
       // at all, but never half-crashed.  We do it in a PostTask so
       // that other handlers of this notification will still have
       // access to the Extension and ExtensionHost.
       MessageLoop::current()->PostTask(
           FROM_HERE,
           method_factory_.NewRunnableMethod(
               &ExtensionService::TrackTerminatedExtension,
               host->extension()));
       break;
     }
-    case NotificationType::RENDERER_PROCESS_CREATED: {
+    case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
       RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
       // Valid extension function names, used to setup bindings in renderer.
       std::vector<std::string> function_names;
       ExtensionFunctionDispatcher::GetAllFunctionNames(&function_names);
       process->Send(new ExtensionMsg_SetFunctionNames(function_names));
 
       // Scripting whitelist. This is modified by tests and must be communicated
       // to renderers.
       process->Send(new ExtensionMsg_SetScriptingWhitelist(
           *Extension::GetScriptingWhitelist()));
 
       // Loaded extensions.
       for (size_t i = 0; i < extensions_.size(); ++i) {
         process->Send(new ExtensionMsg_Loaded(
             ExtensionMsg_Loaded_Params(extensions_[i])));
       }
       break;
     }
-    case NotificationType::RENDERER_PROCESS_TERMINATED: {
+    case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
       RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
       installed_app_hosts_.erase(process->id());
       break;
     }
-    case NotificationType::PREF_CHANGED: {
+    case chrome::NOTIFICATION_PREF_CHANGED: {
       std::string* pref_name = Details<std::string>(details).ptr();
       if (*pref_name == prefs::kExtensionInstallAllowList ||
           *pref_name == prefs::kExtensionInstallDenyList) {
         CheckAdminBlacklist();
       } else {
         NOTREACHED() << "Unexpected preference name.";
       }
       break;
     }
 
@@ skipping 24 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(
-      NotificationType::EXTENSION_BACKGROUND_PAGE_READY,
+      chrome::NOTIFICATION_EXTENSION_BACKGROUND_PAGE_READY,
       Source<const Extension>(extension),
       NotificationService::NoDetails());
 }
 
 bool ExtensionService::IsBeingUpgraded(const Extension* extension) {
   return extension_runtime_data_[extension->id()].being_upgraded;
 }
 
 void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
@@ skipping 55 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();
 }