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

chrome/browser/net/ssl_config_service_manager_pref.cc

Index: chrome/browser/net/ssl_config_service_manager_pref.cc
diff --git a/chrome/browser/net/ssl_config_service_manager_pref.cc b/chrome/browser/net/ssl_config_service_manager_pref.cc
index f7e0e7340fc3d26a304cbc69f623401a3a852774..4331308e80d3585e47aa378c52cd18819c2395e7 100644
--- a/chrome/browser/net/ssl_config_service_manager_pref.cc
+++ b/chrome/browser/net/ssl_config_service_manager_pref.cc
@@ -11,8 +11,10 @@
 #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"
@@ -145,11 +147,12 @@ 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();
 
@@ -168,9 +171,13 @@ class SSLConfigServiceManagerPref
   // cached list of parsed SSL/TLS cipher suites that are disabled.
   void OnDisabledCipherSuitesChange(PrefService* prefs);
 
-  PrefChangeRegistrar pref_change_registrar_;
+  // Processes changes to the default cookie settings.
+  void OnDefaultContentSettingsChange(PrefService* prefs);

[wtc, 2012/09/11 22:21:03]

I guess this argument is named "prefs" because it can be either
local state or user prefs?

[mattm, 2012/09/12 03:37:44]

Ah, I guess these could be named more specifically too.  The 
Observe function will get called with either kind of pref service, but it should
always be the one kind for each of the prefs.

done

 
-  // The prefs (should only be accessed from UI thread)
+  PrefChangeRegistrar local_state_change_registrar_;
+  PrefChangeRegistrar user_pref_change_registrar_;

[wtc, 2012/09/11 22:21:03]

Nit: user_pref => user_prefs ?

[mattm, 2012/09/12 03:37:44]

Done.

+
+  // The local_state prefs (should only be accessed from UI thread)
   BooleanPrefMember rev_checking_enabled_;
   StringPrefMember ssl_version_min_;
   StringPrefMember ssl_version_max_;
@@ -180,14 +187,24 @@ class SSLConfigServiceManagerPref
   // 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,
@@ -197,31 +214,41 @@ SSLConfigServiceManagerPref::SSLConfigServiceManagerPref(
   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);

[wtc, 2012/09/11 22:21:03]

Nit: align |this| with the first argument on the previous
line?  I know this is the old style, but it is followed by
this file.

[mattm, 2012/09/12 03:37:44]

Done.

+    user_pref_change_registrar_.Init(user_prefs);
+    user_pref_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);
   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() {
@@ -239,6 +266,8 @@ void SSLConfigServiceManagerPref::Observe(
     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);
@@ -280,6 +309,9 @@ void SSLConfigServiceManagerPref::GetSSLConfigFromPrefs(
   }
   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);
@@ -291,13 +323,26 @@ void SSLConfigServiceManagerPref::OnDisabledCipherSuitesChange(
   disabled_cipher_suites_ = ParseCipherSuites(ListValueToStringVector(value));
 }
 
+void SSLConfigServiceManagerPref::OnDefaultContentSettingsChange(
+    PrefService* prefs) {
+  const DictionaryValue* value = 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