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

chrome/browser/content_settings/content_settings_pref_provider.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/content_settings/content_settings_pref_provider.h"
 
 #include <list>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/content_settings_pattern.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
@@ skipping 135 matching lines @@
       CONTENT_SETTING_BLOCK) {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingEnabledPerDefault"));
   } else {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingDisabledPerDefault"));
   }
 
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(prefs::kDefaultContentSettings, this);
-  notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
+  notification_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                               Source<Profile>(profile_));
   initializing_ = false;
 }
 
 PrefDefaultProvider::~PrefDefaultProvider() {
   UnregisterObservers();
 }
 
 ContentSetting PrefDefaultProvider::ProvideDefaultSetting(
     ContentSettingsType content_type) const {
@@ skipping 40 matching lines @@
       content_type,
       std::string());
   NotifyObservers(details);
 }
 
 bool PrefDefaultProvider::DefaultSettingIsManaged(
     ContentSettingsType content_type) const {
   return false;
 }
 
-void PrefDefaultProvider::Observe(NotificationType type,
+void PrefDefaultProvider::Observe(int type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (type == NotificationType::PREF_CHANGED) {
+  if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     DCHECK_EQ(profile_->GetPrefs(), Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kDefaultContentSettings) {
       ReadDefaultSettings(true);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     if (!is_incognito_) {
       ContentSettingsDetails details(ContentSettingsPattern(),
                                      ContentSettingsPattern(),
                                      CONTENT_SETTINGS_TYPE_DEFAULT,
                                      std::string());
       NotifyObservers(details);
     }
-  } else if (type == NotificationType::PROFILE_DESTROYED) {
+  } else if (type == chrome::NOTIFICATION_PROFILE_DESTROYED) {
     DCHECK_EQ(profile_, Source<Profile>(source).ptr());
     UnregisterObservers();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 void PrefDefaultProvider::UnregisterObservers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!profile_)
     return;
   pref_change_registrar_.RemoveAll();
-  notification_registrar_.Remove(this, NotificationType::PROFILE_DESTROYED,
+  notification_registrar_.Remove(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                                  Source<Profile>(profile_));
   profile_ = NULL;
 }
 
 void PrefDefaultProvider::ReadDefaultSettings(bool overwrite) {
   PrefService* prefs = profile_->GetPrefs();
   const DictionaryValue* default_settings_dictionary =
       prefs->GetDictionary(prefs::kDefaultContentSettings);
 
   base::AutoLock lock(lock_);
@@ skipping 45 matching lines @@
       ClickToPlayFixup(CONTENT_SETTINGS_TYPE_PLUGINS,
                        settings->settings[CONTENT_SETTINGS_TYPE_PLUGINS]);
 }
 
 void PrefDefaultProvider::NotifyObservers(
     const ContentSettingsDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (initializing_ || profile_ == NULL)
     return;
   NotificationService::current()->Notify(
-      NotificationType::CONTENT_SETTINGS_CHANGED,
+      chrome::NOTIFICATION_CONTENT_SETTINGS_CHANGED,
       Source<HostContentSettingsMap>(profile_->GetHostContentSettingsMap()),
       Details<const ContentSettingsDetails>(&details));
 }
 
 void PrefDefaultProvider::MigrateObsoleteNotificationPref(PrefService* prefs) {
   if (prefs->HasPrefPath(prefs::kDesktopNotificationDefaultContentSetting)) {
     ContentSetting setting = IntToContentSetting(
         prefs->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
     UpdateDefaultSetting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, setting);
     prefs->ClearPref(prefs::kDesktopNotificationDefaultContentSetting);
@@ skipping 75 matching lines @@
 
   if (!is_incognito_) {
     UMA_HISTOGRAM_COUNTS("ContentSettings.NumberOfExceptions",
                          value_map_.size());
   }
 
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(prefs::kContentSettingsPatterns, this);
   pref_change_registrar_.Add(prefs::kContentSettingsPatternPairs, this);
 
-  notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
+  notification_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                               Source<Profile>(profile_));
   initializing_ = false;
 }
 
 ContentSetting PrefProvider::GetContentSetting(
       const GURL& primary_url,
       const GURL& secondary_url,
       ContentSettingsType content_type,
       const ResourceIdentifier& resource_identifier) const {
   // For a |PrefProvider| used in a |HostContentSettingsMap| of a non incognito
@@ skipping 121 matching lines @@
 
   ContentSettingsDetails details(
       ContentSettingsPattern(),
       ContentSettingsPattern(),
       content_type,
       std::string());
   NotifyObservers(details);
 }
 
 void PrefProvider::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (type == NotificationType::PREF_CHANGED) {
+  if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     DCHECK_EQ(profile_->GetPrefs(), Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kContentSettingsPatternPairs) {
       SyncObsoletePref(profile_->GetPrefs());
       ReadContentSettingsFromPref(true);
     } else if (*name == prefs::kContentSettingsPatterns) {
       updating_preferences_ = true;
       MigrateObsoleteContentSettingsPatternPref(profile_->GetPrefs());
       updating_preferences_ = false;
       ReadContentSettingsFromPref(true);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     if (!is_incognito_) {
       ContentSettingsDetails details(ContentSettingsPattern(),
                                      ContentSettingsPattern(),
                                      CONTENT_SETTINGS_TYPE_DEFAULT,
                                      std::string());
       NotifyObservers(details);
     }
-  } else if (type == NotificationType::PROFILE_DESTROYED) {
+  } else if (type == chrome::NOTIFICATION_PROFILE_DESTROYED) {
     DCHECK_EQ(profile_, Source<Profile>(source).ptr());
     UnregisterObservers();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 PrefProvider::~PrefProvider() {
   UnregisterObservers();
 }
@@ skipping 296 matching lines @@
         move_items[i].second, pattern_settings_dictionary);
   }
 }
 
 void PrefProvider::NotifyObservers(
     const ContentSettingsDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (initializing_ || profile_ == NULL)
     return;
   NotificationService::current()->Notify(
-      NotificationType::CONTENT_SETTINGS_CHANGED,
+      chrome::NOTIFICATION_CONTENT_SETTINGS_CHANGED,
       Source<HostContentSettingsMap>(
           profile_->GetHostContentSettingsMap()),
       Details<const ContentSettingsDetails>(&details));
 }
 
 void PrefProvider::UnregisterObservers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!profile_)
     return;
   pref_change_registrar_.RemoveAll();
-  notification_registrar_.Remove(this, NotificationType::PROFILE_DESTROYED,
+  notification_registrar_.Remove(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                                  Source<Profile>(profile_));
   profile_ = NULL;
 }
 
 void PrefProvider::MigrateObsoletePerhostPref(PrefService* prefs) {
   if (prefs->HasPrefPath(prefs::kPerHostContentSettings)) {
     const DictionaryValue* all_settings_dictionary =
         prefs->GetDictionary(prefs::kPerHostContentSettings);
     DCHECK(all_settings_dictionary);
     for (DictionaryValue::key_iterator
@@ skipping 137 matching lines @@
       std::string new_key = pattern_pair.first.ToString();
       // Existing values are overwritten.
       obsolete_settings_dictionary->SetWithoutPathExpansion(
           new_key, dictionary->DeepCopy());
     }
   }
   updating_preferences_ = false;
 }
 
 }  // namespace content_settings