Explicitly ShutdownOnUIThread the HostContentSettingsMap when destroying the Profile.

chrome/browser/content_settings/content_settings_policy_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_policy_provider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 81 matching lines @@
     prefs::kManagedPopupsBlockedForUrls,
     CONTENT_SETTINGS_TYPE_POPUPS,
     CONTENT_SETTING_BLOCK
   }
 };
 
 }  // namespace
 
 namespace content_settings {
 
-PolicyDefaultProvider::PolicyDefaultProvider(Profile* profile)
-    : profile_(profile),
-      is_off_the_record_(profile_->IsOffTheRecord()) {
-  PrefService* prefs = profile->GetPrefs();
-
+PolicyDefaultProvider::PolicyDefaultProvider(HostContentSettingsMap* map,
+                                             PrefService* prefs)
+    : map_(map),
+      prefs_(prefs) {
   // Read global defaults.
   DCHECK_EQ(arraysize(kPrefToManageType),
             static_cast<size_t>(CONTENT_SETTINGS_NUM_TYPES));
   ReadManagedDefaultSettings();
 
-  pref_change_registrar_.Init(prefs);
+  pref_change_registrar_.Init(prefs_);
   // The following preferences are only used to indicate if a
   // default-content-setting is managed and to hold the managed default-setting
   // value. If the value for any of the following perferences is set then the
   // corresponding default-content-setting is managed. These preferences exist
   // in parallel to the preference default-content-settings.  If a
   // default-content-settings-type is managed any user defined excpetions
   // (patterns) for this type are ignored.
   pref_change_registrar_.Add(prefs::kManagedDefaultCookiesSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultImagesSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultJavaScriptSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultPluginsSetting, this);
   pref_change_registrar_.Add(prefs::kManagedDefaultPopupsSetting, this);
-  notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
-                              Source<Profile>(profile_));
 }
 
 PolicyDefaultProvider::~PolicyDefaultProvider() {
-  UnregisterObservers();
+  DCHECK(!prefs_);
 }
 
 ContentSetting PolicyDefaultProvider::ProvideDefaultSetting(
     ContentSettingsType content_type) const {
   base::AutoLock auto_lock(lock_);
   return managed_default_content_settings_.settings[content_type];
 }
 
 void PolicyDefaultProvider::UpdateDefaultSetting(
     ContentSettingsType content_type,
@@ skipping 13 matching lines @@
 
 void PolicyDefaultProvider::ResetToDefaults() {
 }
 
 void PolicyDefaultProvider::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());
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kManagedDefaultCookiesSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_COOKIES);
     } else if (*name == prefs::kManagedDefaultImagesSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_IMAGES);
     } else if (*name == prefs::kManagedDefaultJavaScriptSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_JAVASCRIPT);
     } else if (*name == prefs::kManagedDefaultPluginsSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_PLUGINS);
     } else if (*name == prefs::kManagedDefaultPopupsSetting) {
       UpdateManagedDefaultSetting(CONTENT_SETTINGS_TYPE_POPUPS);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
-    if (!is_off_the_record_) {
-      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 PolicyDefaultProvider::UnregisterObservers() {
+void PolicyDefaultProvider::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 PolicyDefaultProvider::NotifyObservers(
     const ContentSettingsDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (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 PolicyDefaultProvider::ReadManagedDefaultSettings() {
   for (size_t type = 0; type < arraysize(kPrefToManageType); ++type) {
     if (kPrefToManageType[type] == NULL) {
       continue;
     }
     UpdateManagedDefaultSetting(ContentSettingsType(type));
   }
 }
 
 void PolicyDefaultProvider::UpdateManagedDefaultSetting(
     ContentSettingsType type) {
   // If a pref to manage a default-content-setting was not set (NOTICE:
   // "HasPrefPath" returns false if no value was set for a registered pref) then
   // the default value of the preference is used. The default value of a
   // preference to manage a default-content-settings is CONTENT_SETTING_DEFAULT.
   // This indicates that no managed value is set. If a pref was set, than it
   // MUST be managed.
-  PrefService* prefs = profile_->GetPrefs();
-  DCHECK(!prefs->HasPrefPath(kPrefToManageType[type]) ||
-          prefs->IsManagedPreference(kPrefToManageType[type]));
+  DCHECK(!prefs_->HasPrefPath(kPrefToManageType[type]) ||
+          prefs_->IsManagedPreference(kPrefToManageType[type]));
   base::AutoLock auto_lock(lock_);
   managed_default_content_settings_.settings[type] = IntToContentSetting(
-      prefs->GetInteger(kPrefToManageType[type]));
+      prefs_->GetInteger(kPrefToManageType[type]));
 }
 
 // static
 void PolicyDefaultProvider::RegisterUserPrefs(PrefService* prefs) {
   // Preferences for default content setting policies. A policy is not set of
   // the corresponding preferences below is set to CONTENT_SETTING_DEFAULT.
   prefs->RegisterIntegerPref(prefs::kManagedDefaultCookiesSetting,
                              CONTENT_SETTING_DEFAULT,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kManagedDefaultImagesSetting,
@@ skipping 32 matching lines @@
   prefs->RegisterListPref(prefs::kManagedPluginsAllowedForUrls,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedPluginsBlockedForUrls,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedPopupsAllowedForUrls,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedPopupsBlockedForUrls,
                           PrefService::UNSYNCABLE_PREF);
 }
 
-PolicyProvider::PolicyProvider(Profile* profile,
+PolicyProvider::PolicyProvider(HostContentSettingsMap* map,
+                               PrefService* prefs,
                                DefaultProviderInterface* default_provider)
-    : profile_(profile),
+    : map_(map),
+      prefs_(prefs),
       default_provider_(default_provider) {
-  Init();
-}
-
-PolicyProvider::~PolicyProvider() {
-  UnregisterObservers();
-}
-
-void PolicyProvider::Init() {
-  PrefService* prefs = profile_->GetPrefs();
-
   ReadManagedContentSettings(false);
 
-  pref_change_registrar_.Init(prefs);
+  pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(prefs::kManagedCookiesBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedCookiesAllowedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedCookiesSessionOnlyForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedImagesBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedImagesAllowedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedJavaScriptBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedJavaScriptAllowedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedPluginsBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedPluginsAllowedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedPopupsBlockedForUrls, this);
   pref_change_registrar_.Add(prefs::kManagedPopupsAllowedForUrls, this);
+}
 
-  notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
-                              Source<Profile>(profile_));
+PolicyProvider::~PolicyProvider() {
+  DCHECK(!prefs_);
 }
 
 void PolicyProvider::GetContentSettingsFromPreferences(
-    PrefService* prefs,
     ContentSettingsRules* rules) {
   for (size_t i = 0; i < arraysize(kPrefsForManagedContentSettingsMap); ++i) {
     const char* pref_name = kPrefsForManagedContentSettingsMap[i].pref_name;
     // Skip unset policies.
-    if (!prefs->HasPrefPath(pref_name)) {
+    if (!prefs_->HasPrefPath(pref_name)) {
       VLOG(2) << "Skipping unset preference: " << pref_name;
       continue;
     }
 
-    const PrefService::Preference* pref = prefs->FindPreference(pref_name);
+    const PrefService::Preference* pref = prefs_->FindPreference(pref_name);
     DCHECK(pref);
     DCHECK(pref->IsManaged());
-    DCHECK_EQ(Value::TYPE_LIST, pref->GetType());
 
-    const ListValue* pattern_str_list =
-        static_cast<const ListValue*>(pref->GetValue());
+    const ListValue* pattern_str_list = NULL;
+    if (!pref->GetValue()->GetAsList(&pattern_str_list)) {
+      NOTREACHED();
+      return;
+    }
+
     for (size_t j = 0; j < pattern_str_list->GetSize(); ++j) {
       std::string original_pattern_str;
       pattern_str_list->GetString(j, &original_pattern_str);
       PatternPair pattern_pair = ParsePatternString(original_pattern_str);
       // Ignore invalid patterns.
       if (!pattern_pair.first.IsValid()) {
         VLOG(1) << "Ignoring invalid content settings pattern: " <<
                    original_pattern_str;
         continue;
       }
 
       ContentSettingsType content_type =
           kPrefsForManagedContentSettingsMap[i].content_type;
       // If only one pattern was defined auto expand it to a pattern pair.
       rules->push_back(MakeTuple(
           pattern_pair.first,
           !pattern_pair.second.IsValid() ? ContentSettingsPattern::Wildcard()
                                          : pattern_pair.second,
           content_type,
           ResourceIdentifier(NO_RESOURCE_IDENTIFIER),
           kPrefsForManagedContentSettingsMap[i].setting));
     }
   }
 }
 
 void PolicyProvider::ReadManagedContentSettings(bool overwrite) {
   ContentSettingsRules rules;
-  PrefService* prefs = profile_->GetPrefs();
-  GetContentSettingsFromPreferences(prefs, &rules);
+  GetContentSettingsFromPreferences(&rules);
   {
     base::AutoLock auto_lock(lock_);
     if (overwrite)
       value_map_.clear();
     for (ContentSettingsRules::iterator rule = rules.begin();
          rule != rules.end();
          ++rule) {
       value_map_.SetValue(rule->a,
                           rule->b,
                           rule->c,
@@ skipping 58 matching lines @@
   }
 }
 
 void PolicyProvider::ClearAllContentSettingsRules(
     ContentSettingsType content_type) {
 }
 
 void PolicyProvider::ResetToDefaults() {
 }
 
-void PolicyProvider::UnregisterObservers() {
+void PolicyProvider::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 PolicyProvider::NotifyObservers(
     const ContentSettingsDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (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 PolicyProvider::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());
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kManagedCookiesAllowedForUrls ||
         *name == prefs::kManagedCookiesBlockedForUrls ||
         *name == prefs::kManagedCookiesSessionOnlyForUrls ||
         *name == prefs::kManagedImagesAllowedForUrls ||
         *name == prefs::kManagedImagesBlockedForUrls ||
         *name == prefs::kManagedJavaScriptAllowedForUrls ||
         *name == prefs::kManagedJavaScriptBlockedForUrls ||
         *name == prefs::kManagedPluginsAllowedForUrls ||
         *name == prefs::kManagedPluginsBlockedForUrls ||
         *name == prefs::kManagedPopupsAllowedForUrls ||
         *name == prefs::kManagedPopupsBlockedForUrls) {
       ReadManagedContentSettings(true);
       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();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 }  // namespace content_settings