Remove content::NotificationObserver dependency from most Prefs code.

chrome/browser/net/ssl_config_service_manager_pref.cc

 // Copyright (c) 2012 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/net/ssl_config_service_manager.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/prefs/public/pref_change_registrar.h"
+#include "base/prefs/public/pref_observer.h"
 #include "chrome/browser/api/prefs/pref_member.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_source.h"
 #include "net/base/ssl_cipher_suite_names.h"
 #include "net/base/ssl_config_service.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Converts a ListValue of StringValues into a vector of strings. Any Values
 // which cannot be converted will be skipped.
 std::vector<std::string> ListValueToStringVector(const ListValue* value) {
@@ skipping 106 matching lines @@
   cached_config_ = new_config;
   ProcessConfigUpdate(orig_config, new_config);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //  SSLConfigServiceManagerPref
 
 // The manager for holding and updating an SSLConfigServicePref instance.
 class SSLConfigServiceManagerPref
     : public SSLConfigServiceManager,
-      public content::NotificationObserver {
+      public PrefObserver {
  public:
   SSLConfigServiceManagerPref(PrefService* local_state,
                               PrefService* user_prefs);
   virtual ~SSLConfigServiceManagerPref() {}
 
   // Register local_state SSL preferences.
   static void RegisterPrefs(PrefService* local_state);
 
   virtual net::SSLConfigService* Get();
 
  private:
   // Callback for preference changes.  This will post the changes to the IO
   // thread with SetNewSSLConfig.
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+  virtual void OnPreferenceChanged(PrefServiceBase* service,
+                                   const std::string& pref_name) OVERRIDE;
 
   // Store SSL config settings in |config|, directly from the preferences. Must
   // only be called from UI thread.
   void GetSSLConfigFromPrefs(net::SSLConfig* config);
 
   // Processes changes to the disabled cipher suites preference, updating the
   // cached list of parsed SSL/TLS cipher suites that are disabled.
-  void OnDisabledCipherSuitesChange(PrefService* local_state);
+  void OnDisabledCipherSuitesChange(PrefServiceBase* local_state);
 
   // Processes changes to the default cookie settings.
-  void OnDefaultContentSettingsChange(PrefService* user_prefs);
+  void OnDefaultContentSettingsChange(PrefServiceBase* user_prefs);
 
   PrefChangeRegistrar local_state_change_registrar_;
   PrefChangeRegistrar user_prefs_change_registrar_;
 
   // The local_state prefs (should only be accessed from UI thread)
   BooleanPrefMember rev_checking_enabled_;
   StringPrefMember ssl_version_min_;
   StringPrefMember ssl_version_max_;
   BooleanPrefMember channel_id_enabled_;
   BooleanPrefMember ssl_record_splitting_disabled_;
@@ skipping 62 matching lines @@
                                    default_config.channel_id_enabled);
   local_state->RegisterBooleanPref(prefs::kDisableSSLRecordSplitting,
                                    !default_config.false_start_enabled);
   local_state->RegisterListPref(prefs::kCipherSuiteBlacklist);
 }
 
 net::SSLConfigService* SSLConfigServiceManagerPref::Get() {
   return ssl_config_service_;
 }
 
-void SSLConfigServiceManagerPref::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  if (type == chrome::NOTIFICATION_PREF_CHANGED) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    std::string* pref_name_in = content::Details<std::string>(details).ptr();
-    PrefService* prefs = content::Source<PrefService>(source).ptr();
-    DCHECK(pref_name_in && prefs);
-    if (*pref_name_in == prefs::kCipherSuiteBlacklist)
-      OnDisabledCipherSuitesChange(prefs);
-    else if (*pref_name_in == prefs::kDefaultContentSettings)
-      OnDefaultContentSettingsChange(prefs);
+void SSLConfigServiceManagerPref::OnPreferenceChanged(
+    PrefServiceBase* prefs,
+    const std::string& pref_name_in) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(prefs);
+  if (pref_name_in == prefs::kCipherSuiteBlacklist)
+    OnDisabledCipherSuitesChange(prefs);
+  else if (pref_name_in == prefs::kDefaultContentSettings)
+    OnDefaultContentSettingsChange(prefs);
 
-    net::SSLConfig new_config;
-    GetSSLConfigFromPrefs(&new_config);
+  net::SSLConfig new_config;
+  GetSSLConfigFromPrefs(&new_config);
 
-    // Post a task to |io_loop| with the new configuration, so it can
-    // update |cached_config_|.
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(
-            &SSLConfigServicePref::SetNewSSLConfig,
-            ssl_config_service_.get(),
-            new_config));
-  }
+  // Post a task to |io_loop| with the new configuration, so it can
+  // update |cached_config_|.
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &SSLConfigServicePref::SetNewSSLConfig,
+          ssl_config_service_.get(),
+          new_config));
 }
 
 void SSLConfigServiceManagerPref::GetSSLConfigFromPrefs(
     net::SSLConfig* config) {
   config->rev_checking_enabled = rev_checking_enabled_.GetValue();
   std::string version_min_str = ssl_version_min_.GetValue();
   std::string version_max_str = ssl_version_max_.GetValue();
   config->version_min = net::SSLConfigService::default_version_min();
   config->version_max = net::SSLConfigService::default_version_max();
   uint16 version_min = SSLProtocolVersionFromString(version_min_str);
@@ skipping 16 matching lines @@
   config->channel_id_enabled = channel_id_enabled_.GetValue();
   if (have_user_prefs_ &&
       (cookies_disabled_ || block_third_party_cookies_.GetValue()))
     config->channel_id_enabled = false;
   // disabling False Start also happens to disable record splitting.
   config->false_start_enabled = !ssl_record_splitting_disabled_.GetValue();
   SSLConfigServicePref::SetSSLConfigFlags(config);
 }
 
 void SSLConfigServiceManagerPref::OnDisabledCipherSuitesChange(
-    PrefService* local_state) {
+    PrefServiceBase* local_state) {
   const ListValue* value = local_state->GetList(prefs::kCipherSuiteBlacklist);
   disabled_cipher_suites_ = ParseCipherSuites(ListValueToStringVector(value));
 }
 
 void SSLConfigServiceManagerPref::OnDefaultContentSettingsChange(
-    PrefService* user_prefs) {
+    PrefServiceBase* user_prefs) {
   const DictionaryValue* value = user_prefs->GetDictionary(
       prefs::kDefaultContentSettings);
   int default_cookie_settings = -1;
   cookies_disabled_ = (
       value &&
       value->GetInteger(
           content_settings::GetTypeName(CONTENT_SETTINGS_TYPE_COOKIES),
           &default_cookie_settings) &&
       default_cookie_settings == CONTENT_SETTING_BLOCK);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //  SSLConfigServiceManager
 
 // static
 SSLConfigServiceManager* SSLConfigServiceManager::CreateDefaultManager(
     PrefService* local_state, PrefService* user_prefs) {
   return new SSLConfigServiceManagerPref(local_state, user_prefs);
 }
 
 // static
 void SSLConfigServiceManager::RegisterPrefs(PrefService* prefs) {
   SSLConfigServiceManagerPref::RegisterPrefs(prefs);
 }