Explicitly ShutdownOnUIThread the HostContentSettingsMap when destroying the Profile.

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/auto_reset.h"
 #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_switches.h"
 #include "chrome/common/content_settings.h"
@@ skipping 119 matching lines @@
       setting == CONTENT_SETTING_ASK) {
     return CONTENT_SETTING_BLOCK;
   }
   return setting;
 }
 
 }  // namespace
 
 namespace content_settings {
 
-PrefDefaultProvider::PrefDefaultProvider(Profile* profile)
-    : profile_(profile),
-      is_incognito_(profile_->IsOffTheRecord()),
+PrefDefaultProvider::PrefDefaultProvider(HostContentSettingsMap* map,
+                                         PrefService* prefs,
+                                         bool incognito)
+    : map_(map),
+      prefs_(prefs),
+      is_incognito_(incognito),
       updating_preferences_(false) {
-  initializing_ = true;
-  PrefService* prefs = profile->GetPrefs();
-
-  MigrateObsoleteNotificationPref(prefs);
+  MigrateObsoleteNotificationPref();
 
   // Read global defaults.
   DCHECK_EQ(arraysize(kTypeNames),
             static_cast<size_t>(CONTENT_SETTINGS_NUM_TYPES));
   ReadDefaultSettings(true);
   if (default_content_settings_.settings[CONTENT_SETTINGS_TYPE_COOKIES] ==
       CONTENT_SETTING_BLOCK) {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingEnabledPerDefault"));
   } else {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingDisabledPerDefault"));
   }
 
-  pref_change_registrar_.Init(prefs);
+  pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(prefs::kDefaultContentSettings, this);
-  notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
-                              Source<Profile>(profile_));
-  initializing_ = false;
 }
 
 PrefDefaultProvider::~PrefDefaultProvider() {
-  UnregisterObservers();
+  DCHECK(!prefs_);
 }
 
 ContentSetting PrefDefaultProvider::ProvideDefaultSetting(
     ContentSettingsType content_type) const {
   base::AutoLock lock(lock_);
   return default_content_settings_.settings[content_type];
 }
 
 void PrefDefaultProvider::UpdateDefaultSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
 
   // The default settings may not be directly modified for OTR sessions.
   // Instead, they are synced to the main profile's setting.
   if (is_incognito_)
     return;
 
-  PrefService* prefs = profile_->GetPrefs();
-
   std::string dictionary_path(kTypeNames[content_type]);
   updating_preferences_ = true;
   {
     base::AutoLock lock(lock_);
-    DictionaryPrefUpdate update(prefs, prefs::kDefaultContentSettings);
+    DictionaryPrefUpdate update(prefs_, prefs::kDefaultContentSettings);
     DictionaryValue* default_settings_dictionary = update.Get();
     if ((setting == CONTENT_SETTING_DEFAULT) ||
         (setting == kDefaultSettings[content_type])) {
       default_content_settings_.settings[content_type] =
           kDefaultSettings[content_type];
       default_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
                                                               NULL);
     } else {
       default_content_settings_.settings[content_type] = setting;
       default_settings_dictionary->SetWithoutPathExpansion(
@@ skipping 15 matching lines @@
   return false;
 }
 
 void PrefDefaultProvider::ResetToDefaults() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
   default_content_settings_ = ContentSettings();
   ForceDefaultsToBeExplicit();
 
   if (!is_incognito_) {
-    PrefService* prefs = profile_->GetPrefs();
     updating_preferences_ = true;
-    prefs->ClearPref(prefs::kDefaultContentSettings);
+    prefs_->ClearPref(prefs::kDefaultContentSettings);
     updating_preferences_ = false;
   }
 }
 
 void PrefDefaultProvider::Observe(NotificationType type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == NotificationType::PREF_CHANGED) {
-    DCHECK_EQ(profile_->GetPrefs(), Source<PrefService>(source).ptr());
+    DCHECK_EQ(prefs_, 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) {
-    DCHECK_EQ(profile_, Source<Profile>(source).ptr());
-    UnregisterObservers();
+    ContentSettingsDetails details(ContentSettingsPattern(),
+                                   ContentSettingsPattern(),
+                                   CONTENT_SETTINGS_TYPE_DEFAULT,
+                                   std::string());
+    NotifyObservers(details);
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
-void PrefDefaultProvider::UnregisterObservers() {
+void PrefDefaultProvider::ShutdownOnUIThread() {
+  if (!prefs_)
+    return;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!profile_)
-    return;
   pref_change_registrar_.RemoveAll();
-  notification_registrar_.Remove(this, NotificationType::PROFILE_DESTROYED,
-                                 Source<Profile>(profile_));
-  profile_ = NULL;
+  prefs_ = NULL;
+  map_ = NULL;
 }
 
 void PrefDefaultProvider::ReadDefaultSettings(bool overwrite) {
-  PrefService* prefs = profile_->GetPrefs();
   const DictionaryValue* default_settings_dictionary =
-      prefs->GetDictionary(prefs::kDefaultContentSettings);
+      prefs_->GetDictionary(prefs::kDefaultContentSettings);
 
   base::AutoLock lock(lock_);
 
   if (overwrite)
     default_content_settings_ = ContentSettings();
 
   // Careful: The returned value could be NULL if the pref has never been set.
   if (default_settings_dictionary != NULL) {
     GetSettingsFromDictionary(default_settings_dictionary,
                               &default_content_settings_);
@@ skipping 34 matching lines @@
     settings->settings[CONTENT_SETTINGS_TYPE_COOKIES] = CONTENT_SETTING_BLOCK;
 
   settings->settings[CONTENT_SETTINGS_TYPE_PLUGINS] =
       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)
+  if (map_ == NULL)
     return;
   NotificationService::current()->Notify(
       NotificationType::CONTENT_SETTINGS_CHANGED,
-      Source<HostContentSettingsMap>(profile_->GetHostContentSettingsMap()),
+      Source<HostContentSettingsMap>(map_),
       Details<const ContentSettingsDetails>(&details));
 }
 
-void PrefDefaultProvider::MigrateObsoleteNotificationPref(PrefService* prefs) {
-  if (prefs->HasPrefPath(prefs::kDesktopNotificationDefaultContentSetting)) {
+void PrefDefaultProvider::MigrateObsoleteNotificationPref() {
+  if (prefs_->HasPrefPath(prefs::kDesktopNotificationDefaultContentSetting)) {
     ContentSetting setting = IntToContentSetting(
-        prefs->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
+        prefs_->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
     UpdateDefaultSetting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, setting);
-    prefs->ClearPref(prefs::kDesktopNotificationDefaultContentSetting);
+    prefs_->ClearPref(prefs::kDesktopNotificationDefaultContentSetting);
   }
 }
 
 // static
 void PrefDefaultProvider::RegisterUserPrefs(PrefService* prefs) {
   // The registration of the preference prefs::kDefaultContentSettings should
   // also include the default values for default content settings. This allows
   // functional tests to get default content settings by reading the preference
   // prefs::kDefaultContentSettings via pyauto.
   // TODO(markusheintz): Write pyauto hooks for the content settings map as
@@ skipping 26 matching lines @@
 
   // Obsolete prefs, for migration:
   prefs->RegisterDictionaryPref(prefs::kContentSettingsPatterns,
                                 PrefService::SYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kPopupWhitelistedHosts,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(prefs::kPerHostContentSettings,
                                 PrefService::UNSYNCABLE_PREF);
 }
 
-PrefProvider::PrefProvider(Profile* profile)
-  : profile_(profile),
-    is_incognito_(profile_->IsOffTheRecord()),
+PrefProvider::PrefProvider(HostContentSettingsMap* map,
+                           PrefService* prefs,
+                           bool incognito)
+  : prefs_(prefs),
+    map_(map),
+    is_incognito_(incognito),
     updating_preferences_(false) {
-  Init();
-}
-
-void PrefProvider::Init() {
-  initializing_ = true;
-  PrefService* prefs = profile_->GetPrefs();
-
-  // Migrate obsolete preferences.
-  MigrateObsoletePerhostPref(prefs);
-  MigrateObsoletePopupsPref(prefs);
-  MigrateObsoleteContentSettingsPatternPref(prefs);
+  if (!is_incognito_) {
+    // Migrate obsolete preferences.
+    MigrateObsoletePerhostPref();
+    MigrateObsoletePopupsPref();
+    MigrateObsoleteContentSettingsPatternPref();
+  }
 
   // Verify preferences version.
-  if (!prefs->HasPrefPath(prefs::kContentSettingsVersion)) {
-    prefs->SetInteger(prefs::kContentSettingsVersion,
+  if (!prefs_->HasPrefPath(prefs::kContentSettingsVersion)) {
+    prefs_->SetInteger(prefs::kContentSettingsVersion,
                       ContentSettingsPattern::kContentSettingsPatternVersion);
   }
-  if (prefs->GetInteger(prefs::kContentSettingsVersion) >
+  if (prefs_->GetInteger(prefs::kContentSettingsVersion) >
       ContentSettingsPattern::kContentSettingsPatternVersion) {
     LOG(ERROR) << "Unknown content settings version in preferences.";
     return;
   }
 
   // Read content settings exceptions.
   ReadContentSettingsFromPref(false);
 
   if (!is_incognito_) {
     UMA_HISTOGRAM_COUNTS("ContentSettings.NumberOfExceptions",
                          value_map_.size());
   }
 
-  pref_change_registrar_.Init(prefs);
+  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,
-                              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
   // profile, this will always return NULL.
   // TODO(markusheintz): I don't like this. I'd like to have an
@@ skipping 70 matching lines @@
       map_to_modify->SetValue(
           primary_pattern,
           secondary_pattern,
           content_type,
           resource_identifier,
           Value::CreateIntegerValue(setting));
     }
   }
 
   // Update the content settings preference.
-  if (!is_incognito_ && profile_) {
+  if (!is_incognito_) {
     UpdatePref(primary_pattern,
                secondary_pattern,
                content_type,
                resource_identifier,
                setting);
   }
 
   ContentSettingsDetails details(
       primary_pattern, secondary_pattern, content_type, std::string());
   NotifyObservers(details);
 }
 
 void PrefProvider::ResetToDefaults() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(prefs_);
 
   {
     base::AutoLock auto_lock(lock_);
     value_map_.clear();
     incognito_value_map_.clear();
   }
 
   if (!is_incognito_) {
-    PrefService* prefs = profile_->GetPrefs();
     updating_preferences_ = true;
-    prefs->ClearPref(prefs::kContentSettingsPatternPairs);
-    prefs->ClearPref(prefs::kContentSettingsPatterns);
+    prefs_->ClearPref(prefs::kContentSettingsPatternPairs);
+    prefs_->ClearPref(prefs::kContentSettingsPatterns);
     updating_preferences_ = false;
   }
 }
 
 void PrefProvider::ClearAllContentSettingsRules(
     ContentSettingsType content_type) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
+  DCHECK(prefs_);
 
   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
   if (!is_incognito_)
     map_to_modify = &value_map_;
 
   {
     base::AutoLock auto_lock(lock_);
     OriginIdentifierValueMap::iterator entry(map_to_modify->begin());
     while (entry != map_to_modify->end()) {
       if (entry->content_type == content_type) {
@@ skipping 19 matching lines @@
   NotifyObservers(details);
 }
 
 void PrefProvider::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == NotificationType::PREF_CHANGED) {
-    DCHECK_EQ(profile_->GetPrefs(), Source<PrefService>(source).ptr());
+    DCHECK_EQ(prefs_, Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kContentSettingsPatternPairs) {
-      SyncObsoletePref(profile_->GetPrefs());
+      SyncObsoletePref();
       ReadContentSettingsFromPref(true);
     } else if (*name == prefs::kContentSettingsPatterns) {
-      updating_preferences_ = true;
-      MigrateObsoleteContentSettingsPatternPref(profile_->GetPrefs());
-      updating_preferences_ = false;
+      AutoReset<bool> tmp(&updating_preferences_, true);
+      MigrateObsoleteContentSettingsPatternPref();
       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) {
-    DCHECK_EQ(profile_, Source<Profile>(source).ptr());
-    UnregisterObservers();
+    ContentSettingsDetails details(ContentSettingsPattern(),
+                                   ContentSettingsPattern(),
+                                   CONTENT_SETTINGS_TYPE_DEFAULT,
+                                   std::string());
+    NotifyObservers(details);
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 PrefProvider::~PrefProvider() {
-  UnregisterObservers();
+  DCHECK(!prefs_);
 }
 
 // ////////////////////////////////////////////////////////////////////////////
 // Private
 
 void PrefProvider::UpdatePref(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
     ContentSetting setting) {
-  updating_preferences_ = true;
+  DCHECK(prefs_);
+  AutoReset<bool> tmp(&updating_preferences_, true);
   UpdatePatternPairsPref(primary_pattern,
                          secondary_pattern,
                          content_type,
                          resource_identifier,
                          setting);
   UpdatePatternsPref(primary_pattern,
                      secondary_pattern,
                      content_type,
                      resource_identifier,
                      setting);
-  updating_preferences_ = false;
 }
 
 void PrefProvider::ReadContentSettingsFromPref(bool overwrite) {
+  DCHECK(prefs_);
   base::AutoLock auto_lock(lock_);
 
-  PrefService* prefs = profile_->GetPrefs();
   const DictionaryValue* all_settings_dictionary =
-      prefs->GetDictionary(prefs::kContentSettingsPatternPairs);
+      prefs_->GetDictionary(prefs::kContentSettingsPatternPairs);
 
   if (overwrite)
     value_map_.clear();
 
-  updating_preferences_ = true;
+  AutoReset<bool> tmp(&updating_preferences_, true);
   // Careful: The returned value could be NULL if the pref has never been set.
   if (all_settings_dictionary != NULL) {
-    DictionaryPrefUpdate update(prefs, prefs::kContentSettingsPatternPairs);
+    DictionaryPrefUpdate update(prefs_, prefs::kContentSettingsPatternPairs);
     DictionaryValue* mutable_settings;
     scoped_ptr<DictionaryValue> mutable_settings_scope;
 
     if (!is_incognito_) {
       mutable_settings = update.Get();
     } else {
       // Create copy as we do not want to persist anything in OTR prefs.
       mutable_settings = all_settings_dictionary->DeepCopy();
       mutable_settings_scope.reset(mutable_settings);
     }
@@ skipping 66 matching lines @@
   }
   updating_preferences_ = false;
 }
 
 void PrefProvider::UpdatePatternsPref(
       const ContentSettingsPattern& primary_pattern,
       const ContentSettingsPattern& secondary_pattern,
       ContentSettingsType content_type,
       const ResourceIdentifier& resource_identifier,
       ContentSetting setting) {
-  DictionaryPrefUpdate update(profile_->GetPrefs(),
+  DCHECK(prefs_);
+  DictionaryPrefUpdate update(prefs_,
                               prefs::kContentSettingsPatterns);
   DictionaryValue* all_settings_dictionary = update.Get();
 
   // Get settings dictionary for |primary_pattern|.
   std::string pattern_str(primary_pattern.ToString());
   DictionaryValue* settings_dictionary = NULL;
   bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
       pattern_str, &settings_dictionary);
 
   if (!found && (setting != CONTENT_SETTING_DEFAULT)) {
@@ skipping 45 matching lines @@
     }
   }
 }
 
 void PrefProvider::UpdatePatternPairsPref(
       const ContentSettingsPattern& primary_pattern,
       const ContentSettingsPattern& secondary_pattern,
       ContentSettingsType content_type,
       const ResourceIdentifier& resource_identifier,
       ContentSetting setting) {
-  DictionaryPrefUpdate update(profile_->GetPrefs(),
+  DCHECK(prefs_);
+  DictionaryPrefUpdate update(prefs_,
                               prefs::kContentSettingsPatternPairs);
   DictionaryValue* all_settings_dictionary = update.Get();
 
   // Get settings dictionary for the given patterns.
   std::string pattern_str(CreatePatternString(primary_pattern,
                                             secondary_pattern));
   DictionaryValue* settings_dictionary = NULL;
   bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
       pattern_str, &settings_dictionary);
 
@@ skipping 92 matching lines @@
     all_settings_dictionary->RemoveWithoutPathExpansion(
         move_items[i].first, &pattern_settings_dictionary);
     all_settings_dictionary->SetWithoutPathExpansion(
         move_items[i].second, pattern_settings_dictionary);
   }
 }
 
 void PrefProvider::NotifyObservers(
     const ContentSettingsDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (initializing_ || profile_ == NULL)
+  if (map_ == NULL)
     return;
   NotificationService::current()->Notify(
       NotificationType::CONTENT_SETTINGS_CHANGED,
-      Source<HostContentSettingsMap>(
-          profile_->GetHostContentSettingsMap()),
+      Source<HostContentSettingsMap>(map_),
       Details<const ContentSettingsDetails>(&details));
 }
 
-void PrefProvider::UnregisterObservers() {
+void PrefProvider::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!profile_)
+  if (!prefs_)
     return;
   pref_change_registrar_.RemoveAll();
-  notification_registrar_.Remove(this, NotificationType::PROFILE_DESTROYED,
-                                 Source<Profile>(profile_));
-  profile_ = NULL;
+  prefs_ = NULL;
+  map_ = NULL;
 }
 
-void PrefProvider::MigrateObsoletePerhostPref(PrefService* prefs) {
-  if (prefs->HasPrefPath(prefs::kPerHostContentSettings)) {
+void PrefProvider::MigrateObsoletePerhostPref() {
+  if (prefs_->HasPrefPath(prefs::kPerHostContentSettings)) {
     const DictionaryValue* all_settings_dictionary =
-        prefs->GetDictionary(prefs::kPerHostContentSettings);
+        prefs_->GetDictionary(prefs::kPerHostContentSettings);
     DCHECK(all_settings_dictionary);
     for (DictionaryValue::key_iterator
          i(all_settings_dictionary->begin_keys());
          i != all_settings_dictionary->end_keys(); ++i) {
       const std::string& host(*i);
       ContentSettingsPattern pattern =
           ContentSettingsPattern::FromString(
               std::string(ContentSettingsPattern::kDomainWildcard) + host);
       DictionaryValue* host_settings_dictionary = NULL;
       bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
@@ skipping 31 matching lines @@
             SetContentSetting(
                 pattern,
                 pattern,
                 content_type,
                 "",
                 setting);
           }
         }
       }
     }
-    prefs->ClearPref(prefs::kPerHostContentSettings);
+    prefs_->ClearPref(prefs::kPerHostContentSettings);
   }
 }
 
-void PrefProvider::MigrateObsoletePopupsPref(PrefService* prefs) {
-  if (prefs->HasPrefPath(prefs::kPopupWhitelistedHosts)) {
+void PrefProvider::MigrateObsoletePopupsPref() {
+  if (prefs_->HasPrefPath(prefs::kPopupWhitelistedHosts)) {
     const ListValue* whitelist_pref =
-        prefs->GetList(prefs::kPopupWhitelistedHosts);
+        prefs_->GetList(prefs::kPopupWhitelistedHosts);
     for (ListValue::const_iterator i(whitelist_pref->begin());
          i != whitelist_pref->end(); ++i) {
       std::string host;
       (*i)->GetAsString(&host);
       SetContentSetting(ContentSettingsPattern::FromString(host),
                         ContentSettingsPattern::FromString(host),
                         CONTENT_SETTINGS_TYPE_POPUPS,
                         "",
                         CONTENT_SETTING_ALLOW);
     }
-    prefs->ClearPref(prefs::kPopupWhitelistedHosts);
+    prefs_->ClearPref(prefs::kPopupWhitelistedHosts);
   }
 }
 
-void PrefProvider::MigrateObsoleteContentSettingsPatternPref(
-    PrefService* prefs) {
-  if (prefs->HasPrefPath(prefs::kContentSettingsPatterns) &&
-      !is_incognito_) {
+void PrefProvider::MigrateObsoleteContentSettingsPatternPref() {
+  DCHECK(prefs_);
+  if (prefs_->HasPrefPath(prefs::kContentSettingsPatterns)) {
     const DictionaryValue* all_settings_dictionary =
-      prefs->GetDictionary(prefs::kContentSettingsPatterns);
+      prefs_->GetDictionary(prefs::kContentSettingsPatterns);
 
-    DictionaryPrefUpdate update(prefs, prefs::kContentSettingsPatternPairs);
+    DictionaryPrefUpdate update(prefs_, prefs::kContentSettingsPatternPairs);
     DictionaryValue* exceptions_dictionary;
     exceptions_dictionary = update.Get();
     for (DictionaryValue::key_iterator i(all_settings_dictionary->begin_keys());
          i != all_settings_dictionary->end_keys();
          ++i) {
       const std::string& key(*i);
 
       // Validate pattern string and skip it if it is invalid.
       std::pair<ContentSettingsPattern, ContentSettingsPattern> pattern_pair =
           ParsePatternString(key);
@@ skipping 12 matching lines @@
       std::string new_pattern_str = CreatePatternString(
           primary_pattern, ContentSettingsPattern::Wildcard());
 
       // Existing values are overwritten.
       exceptions_dictionary->SetWithoutPathExpansion(
           new_pattern_str, dictionary->DeepCopy());
     }
   }
 }
 
-void PrefProvider::SyncObsoletePref(PrefService* prefs) {
-  updating_preferences_ = true;
-  if (prefs->HasPrefPath(prefs::kContentSettingsPatternPairs) &&
+void PrefProvider::SyncObsoletePref() {
+  DCHECK(prefs_);
+  AutoReset<bool> tmp(&updating_preferences_, true);

[markusheintz_, 2011/07/06 15:56:24]

This is up to you:
Could we use a more descriptive name than tmp?
Maybe auto_reset or something like this?

+  if (prefs_->HasPrefPath(prefs::kContentSettingsPatternPairs) &&
       !is_incognito_) {
     const DictionaryValue* pattern_pairs_dictionary =
-      prefs->GetDictionary(prefs::kContentSettingsPatternPairs);
+      prefs_->GetDictionary(prefs::kContentSettingsPatternPairs);
 
-    DictionaryPrefUpdate update(prefs, prefs::kContentSettingsPatterns);
+    DictionaryPrefUpdate update(prefs_, prefs::kContentSettingsPatterns);
     DictionaryValue* obsolete_settings_dictionary = update.Get();
 
     for (DictionaryValue::key_iterator i =
              pattern_pairs_dictionary->begin_keys();
          i != pattern_pairs_dictionary->end_keys();
          ++i) {
       const std::string& key(*i);
       // Validate pattern string and skip it if it is invalid.
       std::pair<ContentSettingsPattern, ContentSettingsPattern> pattern_pair =
           ParsePatternString(key);
       if (!pattern_pair.first.IsValid() || !pattern_pair.second.IsValid())
         continue;
 
       // Copy dictionary
       DictionaryValue* dictionary = NULL;
       bool found = pattern_pairs_dictionary->GetDictionaryWithoutPathExpansion(
           key, &dictionary);
       DCHECK(found);
       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