Make the hcsm and its providers communicate via an observer interface.

chrome/browser/content_settings/host_content_settings_map.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/host_content_settings_map.h"
 
 #include <list>
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/content_settings_extension_provider.h"
 #include "chrome/browser/content_settings/content_settings_policy_provider.h"
 #include "chrome/browser/content_settings/content_settings_pref_provider.h"
 #include "chrome/browser/content_settings/content_settings_provider.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/extensions/extension_service.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"
@@ skipping 26 matching lines @@
 typedef std::vector<DefaultContentSettingsProviderPtr>::iterator
     DefaultProviderIterator;
 typedef std::vector<DefaultContentSettingsProviderPtr>::const_iterator
     ConstDefaultProviderIterator;
 
 typedef linked_ptr<content_settings::ProviderInterface> ProviderPtr;
 typedef std::vector<ProviderPtr>::iterator ProviderIterator;
 typedef std::vector<ProviderPtr>::const_iterator ConstProviderIterator;
 
 typedef content_settings::ProviderInterface::Rules Rules;
-typedef content_settings::ProviderInterface::Rules::iterator
-    rules_iterator;
-typedef content_settings::ProviderInterface::Rules::const_iterator
-    const_rules_iterator;
 
 const char* kProviderNames[] = {
   "policy",
   "extension",
   "preference"
 };
 
 }  // namespace
 
 HostContentSettingsMap::HostContentSettingsMap(
@@ skipping 30 matching lines @@
     UserMetrics::RecordAction(
         UserMetricsAction("ThirdPartyCookieBlockingDisabled"));
   }
   is_block_third_party_cookies_managed_ =
       prefs_->IsManagedPreference(prefs::kBlockThirdPartyCookies);
 
   // User defined non default content settings are provided by the PrefProvider.
   // The order in which the content settings providers are created is critical,
   // as providers that are further up in the list (i.e. added earlier) override
   // providers further down.
-  content_settings_providers_.push_back(make_linked_ptr(
-      new content_settings::PolicyProvider(this,
-                                           prefs_,
-                                           policy_default_provider)));
+  content_settings::AbstractProvider* provider =
+      new content_settings::PolicyProvider(
+          this, prefs_, policy_default_provider);
+  content_settings_providers_.push_back(make_linked_ptr(provider));
+
   if (extension_service) {
     // |extension_service| can be NULL in unit tests.
-    content_settings_providers_.push_back(make_linked_ptr(
-        new content_settings::ExtensionProvider(
-            this,
-            extension_service->GetExtensionContentSettingsStore(),
-            is_off_the_record_)));
+    provider = new content_settings::ExtensionProvider(
+        this,
+        extension_service->GetExtensionContentSettingsStore(),
+        is_off_the_record_);
+    content_settings_providers_.push_back(make_linked_ptr(provider));
   }
-  content_settings_providers_.push_back(make_linked_ptr(
-      new content_settings::PrefProvider(this, prefs_, is_off_the_record_)));
+  provider = new content_settings::PrefProvider(
+      this, prefs_, is_off_the_record_);
+  content_settings_providers_.push_back(make_linked_ptr(provider));
 
   pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(prefs::kBlockThirdPartyCookies, this);
 }
 
 // static
 void HostContentSettingsMap::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kBlockThirdPartyCookies,
                              false,
                              PrefService::SYNCABLE_PREF);
@@ skipping 304 matching lines @@
   }
 
   {
     base::AutoLock auto_lock(lock_);
     block_third_party_cookies_ = block;
   }
 
   prefs_->SetBoolean(prefs::kBlockThirdPartyCookies, block);
 }
 
+void HostContentSettingsMap::OnContentSettingChanged(
+    ContentSettingsPattern primary_pattern,
+    ContentSettingsPattern secondary_pattern,
+    ContentSettingsType content_type,
+    std::string resource_identifier) {
+  const ContentSettingsDetails details(primary_pattern,
+                                       secondary_pattern,
+                                       content_type,
+                                       resource_identifier);
+  NotificationService::current()->Notify(
+      chrome::NOTIFICATION_CONTENT_SETTINGS_CHANGED,
+      Source<HostContentSettingsMap>(this),
+      Details<const ContentSettingsDetails>(&details));
+}
+
 void HostContentSettingsMap::Observe(int type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     DCHECK_EQ(prefs_, Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
@@ skipping 54 matching lines @@
         SetDefaultContentSetting(CONTENT_SETTINGS_TYPE_COOKIES,
             (cookie_behavior == net::StaticCookiePolicy::BLOCK_ALL_COOKIES) ?
                 CONTENT_SETTING_BLOCK : CONTENT_SETTING_ALLOW);
     }
     if (!prefs_->HasPrefPath(prefs::kBlockThirdPartyCookies)) {
       SetBlockThirdPartyCookies(cookie_behavior ==
           net::StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES);
     }
   }
 }