Disable TLS channel id if cookies are disabled or third-party cookies are blocked.

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 "chrome/browser/api/prefs/pref_change_registrar.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 {
@@ skipping 112 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //  SSLConfigServiceManagerPref
 
 // The manager for holding and updating an SSLConfigServicePref instance.
 class SSLConfigServiceManagerPref
     : public SSLConfigServiceManager,
       public content::NotificationObserver {
  public:
-  explicit SSLConfigServiceManagerPref(PrefService* local_state);
+  SSLConfigServiceManagerPref(PrefService* local_state,
+                              PrefService* user_prefs);
   virtual ~SSLConfigServiceManagerPref() {}
 
   // Register local_state SSL preferences.
-  static void RegisterPrefs(PrefService* prefs);
+  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);
 
   // 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* prefs);
+  void OnDisabledCipherSuitesChange(PrefService* local_state);
 
-  PrefChangeRegistrar pref_change_registrar_;
+  // Processes changes to the default cookie settings.
+  void OnDefaultContentSettingsChange(PrefService* user_prefs);
 
-  // The prefs (should only be accessed from UI thread)
+  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_;
 
   // The cached list of disabled SSL cipher suites.
   std::vector<uint16> disabled_cipher_suites_;
 
+  // The user_prefs prefs (should only be accessed from UI thread).
+  // |have_user_prefs_| will be false if no user_prefs are associated with this
+  // instance.
+  bool have_user_prefs_;
+  BooleanPrefMember block_third_party_cookies_;
+
+  // Cached value of if cookies are disabled by default.
+  bool cookies_disabled_;
+
   scoped_refptr<SSLConfigServicePref> ssl_config_service_;
 
   DISALLOW_COPY_AND_ASSIGN(SSLConfigServiceManagerPref);
 };
 
 SSLConfigServiceManagerPref::SSLConfigServiceManagerPref(
-    PrefService* local_state)
-    : ssl_config_service_(new SSLConfigServicePref()) {
+    PrefService* local_state, PrefService* user_prefs)
+    : have_user_prefs_(!!user_prefs),
+      ssl_config_service_(new SSLConfigServicePref()) {
   DCHECK(local_state);
 
   rev_checking_enabled_.Init(prefs::kCertRevocationCheckingEnabled,
                              local_state, this);
   ssl_version_min_.Init(prefs::kSSLVersionMin, local_state, this);
   ssl_version_max_.Init(prefs::kSSLVersionMax, local_state, this);
   channel_id_enabled_.Init(prefs::kEnableOriginBoundCerts, local_state, this);
   ssl_record_splitting_disabled_.Init(prefs::kDisableSSLRecordSplitting,
                                       local_state, this);
-  pref_change_registrar_.Init(local_state);
-  pref_change_registrar_.Add(prefs::kCipherSuiteBlacklist, this);
+  local_state_change_registrar_.Init(local_state);
+  local_state_change_registrar_.Add(prefs::kCipherSuiteBlacklist, this);
 
   OnDisabledCipherSuitesChange(local_state);
+
+  if (user_prefs) {
+    block_third_party_cookies_.Init(prefs::kBlockThirdPartyCookies, user_prefs,
+                                    this);
+    user_prefs_change_registrar_.Init(user_prefs);
+    user_prefs_change_registrar_.Add(prefs::kDefaultContentSettings, this);
+
+    OnDefaultContentSettingsChange(user_prefs);
+  }
+
   // Initialize from UI thread.  This is okay as there shouldn't be anything on
   // the IO thread trying to access it yet.
   GetSSLConfigFromPrefs(&ssl_config_service_->cached_config_);
 }
 
 // static
-void SSLConfigServiceManagerPref::RegisterPrefs(PrefService* prefs) {
+void SSLConfigServiceManagerPref::RegisterPrefs(PrefService* local_state) {
   net::SSLConfig default_config;
-  prefs->RegisterBooleanPref(prefs::kCertRevocationCheckingEnabled,
+  local_state->RegisterBooleanPref(prefs::kCertRevocationCheckingEnabled,
                              default_config.rev_checking_enabled);

[battre, 2012/09/12 12:11:31]

nit: can you fix the indentation? also below

[mattm, 2012/09/12 19:07:17]

done

   std::string version_min_str =
       SSLProtocolVersionToString(default_config.version_min);
   std::string version_max_str =
       SSLProtocolVersionToString(default_config.version_max);
-  prefs->RegisterStringPref(prefs::kSSLVersionMin, version_min_str);
-  prefs->RegisterStringPref(prefs::kSSLVersionMax, version_max_str);
-  prefs->RegisterBooleanPref(prefs::kEnableOriginBoundCerts,
+  local_state->RegisterStringPref(prefs::kSSLVersionMin, version_min_str);
+  local_state->RegisterStringPref(prefs::kSSLVersionMax, version_max_str);
+  local_state->RegisterBooleanPref(prefs::kEnableOriginBoundCerts,
                              default_config.channel_id_enabled);
-  prefs->RegisterBooleanPref(prefs::kDisableSSLRecordSplitting,
+  local_state->RegisterBooleanPref(prefs::kDisableSSLRecordSplitting,
                              !default_config.false_start_enabled);
-  prefs->RegisterListPref(prefs::kCipherSuiteBlacklist);
+  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);
 
     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(
@@ skipping 21 matching lines @@
     config->version_min = std::max(supported_version_min, version_min);
   }
   if (version_max) {
     // TODO(wtc): get the maximum SSL protocol version supported by the
     // SSLClientSocket class.
     uint16 supported_version_max = config->version_max;
     config->version_max = std::min(supported_version_max, version_max);
   }
   config->disabled_cipher_suites = disabled_cipher_suites_;
   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* prefs) {
-  const ListValue* value = prefs->GetList(prefs::kCipherSuiteBlacklist);
+    PrefService* local_state) {
+  const ListValue* value = local_state->GetList(prefs::kCipherSuiteBlacklist);
   disabled_cipher_suites_ = ParseCipherSuites(ListValueToStringVector(value));
 }
 
+void SSLConfigServiceManagerPref::OnDefaultContentSettingsChange(
+    PrefService* 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) {
-  return new SSLConfigServiceManagerPref(local_state);
+    PrefService* local_state, PrefService* user_prefs) {
+  return new SSLConfigServiceManagerPref(local_state, user_prefs);
 }
 
 // static
 void SSLConfigServiceManager::RegisterPrefs(PrefService* prefs) {
   SSLConfigServiceManagerPref::RegisterPrefs(prefs);
 }