ChannelID-less Connections in Chrome should be more granular.

Added enum PrivacyMode (Enabled/Disabled) to mark connections which should not use ChannelID even if it is globally enabled. 
PrivacyMode is enabled if user blocks sending or saving cookies to/from particular server, taking in account third party cookie settings as well. See crbug.com/223191 for design doc.

Segmented client socket pools according to privacy mode setting used for particular connection (added 'pm/' prefix to pool key. Introduced SpdySessionKey structure and added PrivacyMode to the key of SpdySessionPool.

Added propagation of Privacy Mode setting from Web Sockets. Added check of Privacy Mode to predictor and pre-connect logic.

BUG=223191
TEST=unit_tests gtest_filter=ChromeNetworkDelegatePrivacyModeTest*

Review URL: https://chromiumcodereview.appspot.com/13008028

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@200852 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 176 insertions, 144 deletions

diff --git a/chrome/browser/net/chrome_network_delegate.cc b/chrome/browser/net/chrome_network_delegate.cc
index cce6f4f..64cbc00 100644
--- a/chrome/browser/net/chrome_network_delegate.cc
+++ b/chrome/browser/net/chrome_network_delegate.cc
@@ -734,6 +734,21 @@ bool ChromeNetworkDelegate::OnCanThrottleRequest(
       extensions::kExtensionScheme;
 }
 
+bool ChromeNetworkDelegate::OnCanEnablePrivacyMode(
+    const GURL& url,
+    const GURL& first_party_for_cookies) const {
+  // NULL during tests, or when we're running in the system context.
+  if (!cookie_settings_)
+    return false;
+
+  bool reading_cookie_allowed = cookie_settings_->IsReadingCookieAllowed(
+      url, first_party_for_cookies);
+  bool setting_cookie_allowed = cookie_settings_->IsSettingCookieAllowed(
+      url, first_party_for_cookies);
+  bool privacy_mode = !(reading_cookie_allowed && setting_cookie_allowed);
+  return privacy_mode;
+}
+
 int ChromeNetworkDelegate::OnBeforeSocketStreamConnect(
     net::SocketStream* socket,
     const net::CompletionCallback& callback) {
diff --git a/chrome/browser/net/chrome_network_delegate.h b/chrome/browser/net/chrome_network_delegate.h
index 85bfd0f..25a79ec 100644
--- a/chrome/browser/net/chrome_network_delegate.h
+++ b/chrome/browser/net/chrome_network_delegate.h
@@ -157,6 +157,9 @@ class ChromeNetworkDelegate : public net::NetworkDelegate {
                                const base::FilePath& path) const OVERRIDE;
   virtual bool OnCanThrottleRequest(
       const net::URLRequest& request) const OVERRIDE;
+  virtual bool OnCanEnablePrivacyMode(
+      const GURL& url,
+      const GURL& first_party_for_cookies) const OVERRIDE;
   virtual int OnBeforeSocketStreamConnect(
       net::SocketStream* stream,
       const net::CompletionCallback& callback) OVERRIDE;
diff --git a/chrome/browser/net/chrome_network_delegate_unittest.cc b/chrome/browser/net/chrome_network_delegate_unittest.cc
index b5c8151..6afbfa2 100644
--- a/chrome/browser/net/chrome_network_delegate_unittest.cc
+++ b/chrome/browser/net/chrome_network_delegate_unittest.cc
@@ -8,6 +8,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/prefs/pref_member.h"
+#include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
@@ -280,3 +281,112 @@ TEST_F(ChromeNetworkDelegateSafeSearchTest, SafeSearchOff) {
   CheckAddedParameters("http://google.com/search?q=google&safe=active",
                        "q=google&safe=active");
 }
+
+// Privacy Mode disables Channel Id if cookies are blocked (cr223191)
+class ChromeNetworkDelegatePrivacyModeTest : public testing::Test {
+ public:
+  ChromeNetworkDelegatePrivacyModeTest()
+      : ui_thread_(content::BrowserThread::UI, &message_loop_),
+        io_thread_(content::BrowserThread::IO, &message_loop_),
+        forwarder_(new extensions::EventRouterForwarder()),
+        cookie_settings_(CookieSettings::Factory::GetForProfile(&profile_)),
+        kBlockedSite("http://ads.thirdparty.com"),
+        kAllowedSite("http://good.allays.com"),
+        kFirstPartySite("http://cool.things.com"),
+        kBlockedFirstPartySite("http://no.thirdparties.com") {
+  }
+
+  virtual void SetUp() OVERRIDE {
+    ChromeNetworkDelegate::InitializePrefsOnUIThread(
+        &enable_referrers_, NULL, NULL,
+        profile_.GetTestingPrefService());
+  }
+
+ protected:
+  scoped_ptr<ChromeNetworkDelegate> CreateNetworkDelegate() {
+    scoped_ptr<ChromeNetworkDelegate> network_delegate(
+        new ChromeNetworkDelegate(forwarder_.get(), &enable_referrers_));
+    network_delegate->set_cookie_settings(cookie_settings_);
+    return network_delegate.Pass();
+  }
+
+  void SetDelegate(net::NetworkDelegate* delegate) {
+    network_delegate_ = delegate;
+    context_.set_network_delegate(network_delegate_);
+  }
+
+ protected:
+  MessageLoopForIO message_loop_;
+  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread io_thread_;
+  scoped_refptr<extensions::EventRouterForwarder> forwarder_;
+  TestingProfile profile_;
+  CookieSettings* cookie_settings_;
+  BooleanPrefMember enable_referrers_;
+  scoped_ptr<net::URLRequest> request_;
+  net::TestURLRequestContext context_;
+  net::NetworkDelegate* network_delegate_;
+
+  const GURL kBlockedSite;
+  const GURL kAllowedSite;
+  const GURL kEmptyFirstPartySite;
+  const GURL kFirstPartySite;
+  const GURL kBlockedFirstPartySite;
+};
+
+TEST_F(ChromeNetworkDelegatePrivacyModeTest, DisablePrivacyIfCookiesAllowed) {
+  scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
+  SetDelegate(delegate.get());
+
+  EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
+                                                       kEmptyFirstPartySite));
+}
+
+
+TEST_F(ChromeNetworkDelegatePrivacyModeTest, EnablePrivacyIfCookiesBlocked) {
+  scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
+  SetDelegate(delegate.get());
+
+  EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kBlockedSite,
+                                                       kEmptyFirstPartySite));
+
+  cookie_settings_->SetCookieSetting(
+      ContentSettingsPattern::FromURL(kBlockedSite),
+      ContentSettingsPattern::Wildcard(),
+      CONTENT_SETTING_BLOCK);
+  EXPECT_TRUE(network_delegate_->CanEnablePrivacyMode(kBlockedSite,
+                                                      kEmptyFirstPartySite));
+}
+
+TEST_F(ChromeNetworkDelegatePrivacyModeTest, EnablePrivacyIfThirdPartyBlocked) {
+  scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
+  SetDelegate(delegate.get());
+
+  EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
+                                                       kFirstPartySite));
+
+  profile_.GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, true);
+  EXPECT_TRUE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
+                                                      kFirstPartySite));
+  profile_.GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, false);
+  EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
+                                                       kFirstPartySite));
+}
+
+TEST_F(ChromeNetworkDelegatePrivacyModeTest,
+       DisablePrivacyIfOnlyFirstPartyBlocked) {
+  scoped_ptr<ChromeNetworkDelegate> delegate(CreateNetworkDelegate());
+  SetDelegate(delegate.get());
+
+  EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
+                                                       kBlockedFirstPartySite));
+
+  cookie_settings_->SetCookieSetting(
+      ContentSettingsPattern::FromURL(kBlockedFirstPartySite),
+      ContentSettingsPattern::Wildcard(),
+      CONTENT_SETTING_BLOCK);
+  // Privacy mode is disabled as kAllowedSite is still getting cookies
+  EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
+                                                       kBlockedFirstPartySite));
+}
+
diff --git a/chrome/browser/net/connect_interceptor.cc b/chrome/browser/net/connect_interceptor.cc
index d40bc06..e2bf67b 100644
--- a/chrome/browser/net/connect_interceptor.cc
+++ b/chrome/browser/net/connect_interceptor.cc
@@ -82,7 +82,8 @@ void ConnectInterceptor::WitnessURLRequest(net::URLRequest* request) const {
   // main frame request - way back in RenderViewHost::Navigate.  So only handle
   // predictions now for subresources or for redirected hosts.
   if ((request->load_flags() & net::LOAD_SUB_FRAME) || redirected_host)
-    predictor_->PredictFrameSubresources(request_scheme_host);
+    predictor_->PredictFrameSubresources(request_scheme_host,
+                                         request->first_party_for_cookies());
   return;
 }
 
diff --git a/chrome/browser/net/preconnect.cc b/chrome/browser/net/preconnect.cc
index d57b82a..d15dad5 100644
--- a/chrome/browser/net/preconnect.cc
+++ b/chrome/browser/net/preconnect.cc
@@ -23,6 +23,7 @@ namespace chrome_browser_net {
 
 void PreconnectOnUIThread(
     const GURL& url,
+    const GURL& first_party_for_cookies,
     UrlInfo::ResolutionMotivation motivation,
     int count,
     net::URLRequestContextGetter* getter) {
@@ -30,14 +31,15 @@ void PreconnectOnUIThread(
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&PreconnectOnIOThread, url, motivation, count,
-                 make_scoped_refptr(getter)));
+      base::Bind(&PreconnectOnIOThread, url, first_party_for_cookies,
+                 motivation, count, make_scoped_refptr(getter)));
   return;
 }
 
 
 void PreconnectOnIOThread(
     const GURL& url,
+    const GURL& first_party_for_cookies,
     UrlInfo::ResolutionMotivation motivation,
     int count,
     net::URLRequestContextGetter* getter) {
@@ -60,6 +62,11 @@ void PreconnectOnIOThread(
   request_info.method = "GET";
   request_info.extra_headers.SetHeader(net::HttpRequestHeaders::kUserAgent,
                                        context->GetUserAgent(url));
+
+  net::NetworkDelegate* delegate = context->network_delegate();
+  if (delegate->CanEnablePrivacyMode(url, first_party_for_cookies))
+    request_info.privacy_mode = net::kPrivacyModeEnabled;
+
   // It almost doesn't matter whether we use net::LOWEST or net::HIGHEST
   // priority here, as we won't make a request, and will surrender the created
   // socket to the pool as soon as we can.  However, we would like to mark the
diff --git a/chrome/browser/net/preconnect.h b/chrome/browser/net/preconnect.h
index 6b74f83..6e8442c 100644
--- a/chrome/browser/net/preconnect.h
+++ b/chrome/browser/net/preconnect.h
@@ -22,6 +22,7 @@ namespace chrome_browser_net {
 // |count| may be used to request more than one connection be established in
 // parallel.
 void PreconnectOnUIThread(const GURL& url,
+                          const GURL& first_party_for_cookies,
                           UrlInfo::ResolutionMotivation motivation,
                           int count,
                           net::URLRequestContextGetter* getter);
@@ -30,6 +31,7 @@ void PreconnectOnUIThread(const GURL& url,
 // needs a connection. |count| may be used to request more than one connection
 // be established in parallel.
 void PreconnectOnIOThread(const GURL& url,
+                          const GURL& first_party_for_cookies,
                           UrlInfo::ResolutionMotivation motivation,
                           int count,
                           net::URLRequestContextGetter* getter);
diff --git a/chrome/browser/net/predictor.cc b/chrome/browser/net/predictor.cc
index 3981c5e..3af1cf3 100644
--- a/chrome/browser/net/predictor.cc
+++ b/chrome/browser/net/predictor.cc
@@ -243,7 +243,7 @@ void Predictor::AnticipateOmniboxUrl(const GURL& url, bool preconnectable) {
           return;  // We've done a preconnect recently.
         last_omnibox_preconnect_ = now;
         const int kConnectionsNeeded = 1;
-        PreconnectOnUIThread(CanonicalizeUrl(url), motivation,
+        PreconnectOnUIThread(CanonicalizeUrl(url), GURL(), motivation,
                              kConnectionsNeeded,
                              url_request_context_getter_);
         return;  // Skip pre-resolution, since we'll open a connection.
@@ -273,7 +273,8 @@ void Predictor::AnticipateOmniboxUrl(const GURL& url, bool preconnectable) {
                  CanonicalizeUrl(url), motivation));
 }
 
-void Predictor::PreconnectUrlAndSubresources(const GURL& url) {
+void Predictor::PreconnectUrlAndSubresources(const GURL& url,
+    const GURL& first_party_for_cookies) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!predictor_enabled_)
     return;
@@ -283,10 +284,10 @@ void Predictor::PreconnectUrlAndSubresources(const GURL& url) {
     std::string host = url.HostNoBrackets();
     UrlInfo::ResolutionMotivation motivation(UrlInfo::EARLY_LOAD_MOTIVATED);
     const int kConnectionsNeeded = 1;
-    PreconnectOnUIThread(CanonicalizeUrl(url), motivation,
-                         kConnectionsNeeded,
+    PreconnectOnUIThread(CanonicalizeUrl(url), first_party_for_cookies,
+                         motivation, kConnectionsNeeded,
                          url_request_context_getter_);
-    PredictFrameSubresources(url.GetWithEmptyPath());
+    PredictFrameSubresources(url.GetWithEmptyPath(), first_party_for_cookies);
   }
 }
 
@@ -823,7 +824,8 @@ void Predictor::EnablePredictorOnIOThread(bool enable) {
   predictor_enabled_ = enable;
 }
 
-void Predictor::PredictFrameSubresources(const GURL& url) {
+void Predictor::PredictFrameSubresources(const GURL& url,
+                                         const GURL& first_party_for_cookies) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_)
@@ -832,13 +834,13 @@ void Predictor::PredictFrameSubresources(const GURL& url) {
   // Add one pass through the message loop to allow current navigation to
   // proceed.
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    PrepareFrameSubresources(url);
+    PrepareFrameSubresources(url, first_party_for_cookies);
   } else {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&Predictor::PrepareFrameSubresources,
-                   base::Unretained(this), url));
+                   base::Unretained(this), url, first_party_for_cookies));
   }
 }
 
@@ -849,7 +851,8 @@ enum SubresourceValue {
   SUBRESOURCE_VALUE_MAX
 };
 
-void Predictor::PrepareFrameSubresources(const GURL& url) {
+void Predictor::PrepareFrameSubresources(const GURL& url,
+                                         const GURL& first_party_for_cookies) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(url.GetWithEmptyPath(), url);
   Referrers::iterator it = referrers_.find(url);
@@ -861,7 +864,8 @@ void Predictor::PrepareFrameSubresources(const GURL& url) {
     // load any subresources).  If we learn about this resource, we will instead
     // provide a more carefully estimated preconnection count.
     if (preconnect_enabled_) {
-      PreconnectOnIOThread(url, UrlInfo::SELF_REFERAL_MOTIVATED, 2,
+      PreconnectOnIOThread(url, first_party_for_cookies,
+                           UrlInfo::SELF_REFERAL_MOTIVATED, 2,
                            url_request_context_getter_);
     }
     return;
@@ -886,8 +890,8 @@ void Predictor::PrepareFrameSubresources(const GURL& url) {
       int count = static_cast<int>(std::ceil(connection_expectation));
       if (url.host() == future_url->first.host())
         ++count;
-      PreconnectOnIOThread(future_url->first, motivation, count,
-                           url_request_context_getter_);
+      PreconnectOnIOThread(future_url->first, first_party_for_cookies,
+                           motivation, count, url_request_context_getter_);
     } else if (connection_expectation > kDNSPreresolutionWorthyExpectedValue) {
       evalution = PRERESOLUTION;
       future_url->second.preresolution_increment();
diff --git a/chrome/browser/net/predictor.h b/chrome/browser/net/predictor.h
index 996bc8c..8161a36 100644
--- a/chrome/browser/net/predictor.h
+++ b/chrome/browser/net/predictor.h
@@ -117,7 +117,8 @@ class Predictor {
   void AnticipateOmniboxUrl(const GURL& url, bool preconnectable);
 
   // Preconnect a URL and all of its subresource domains.
-  void PreconnectUrlAndSubresources(const GURL& url);
+  void PreconnectUrlAndSubresources(const GURL& url,
+                                    const GURL& first_party_for_cookies);
 
   static UrlList GetPredictedUrlListAtStartup(PrefService* user_prefs,
                                               PrefService* local_state);
@@ -228,7 +229,8 @@ class Predictor {
   // more-embedded resources on a page).  This method will actually post a task
   // to do the actual work, so as not to jump ahead of the frame navigation that
   // instigated this activity.
-  void PredictFrameSubresources(const GURL& url);
+  void PredictFrameSubresources(const GURL& url,
+                                const GURL& first_party_for_cookies);
 
   // Put URL in canonical form, including a scheme, host, and port.
   // Returns GURL::EmptyGURL() if the scheme is not http/https or if the url
@@ -383,7 +385,8 @@ class Predictor {
   // Perform actual resolution or preconnection to subresources now.  This is
   // an internal worker method that is reached via a post task from
   // PredictFrameSubresources().
-  void PrepareFrameSubresources(const GURL& url);
+  void PrepareFrameSubresources(const GURL& url,
+                                const GURL& first_party_for_cookies);
 
   // Access method for use by async lookup request to pass resolution result.
   void OnLookupFinished(LookupRequest* request, const GURL& url, bool found);
diff --git a/chrome/browser/net/predictor_browsertest.cc b/chrome/browser/net/predictor_browsertest.cc
index b2a00c7..946d656 100644
--- a/chrome/browser/net/predictor_browsertest.cc
+++ b/chrome/browser/net/predictor_browsertest.cc
@@ -131,7 +131,7 @@ class PredictorBrowserTest : public InProcessBrowserTest {
 
   void PrepareFrameSubresources(const GURL& url) {
     Predictor* predictor = browser()->profile()->GetNetworkPredictor();
-    predictor->PredictFrameSubresources(url);
+    predictor->PredictFrameSubresources(url, GURL());
   }
 
   void GetListFromPrefsAsString(const char* list_path,
diff --git a/chrome/browser/net/ssl_config_service_manager.h b/chrome/browser/net/ssl_config_service_manager.h
index dd98293a..85185c6 100644
--- a/chrome/browser/net/ssl_config_service_manager.h
+++ b/chrome/browser/net/ssl_config_service_manager.h
@@ -17,11 +17,9 @@ class SSLConfigServiceManager {
  public:
   // Create an instance of the SSLConfigServiceManager. The lifetime of the
   // PrefService objects must be longer than that of the manager. Get SSL
-  // preferences from local_state object.  The user_prefs may be NULL if this
-  // SSLConfigServiceManager is not associated with a profile.
+  // preferences from local_state object.
   static SSLConfigServiceManager* CreateDefaultManager(
-      PrefService* local_state,
-      PrefService* user_prefs);
+      PrefService* local_state);
 
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
diff --git a/chrome/browser/net/ssl_config_service_manager_pref.cc b/chrome/browser/net/ssl_config_service_manager_pref.cc
index 4d4d659..baf541b 100644
--- a/chrome/browser/net/ssl_config_service_manager_pref.cc
+++ b/chrome/browser/net/ssl_config_service_manager_pref.cc
@@ -145,8 +145,7 @@ void SSLConfigServicePref::SetNewSSLConfig(
 class SSLConfigServiceManagerPref
     : public SSLConfigServiceManager {
  public:
-  SSLConfigServiceManagerPref(PrefService* local_state,
-                              PrefService* user_prefs);
+  explicit SSLConfigServiceManagerPref(PrefService* local_state);
   virtual ~SSLConfigServiceManagerPref() {}
 
   // Register local_state SSL preferences.
@@ -168,11 +167,7 @@ class SSLConfigServiceManagerPref
   // cached list of parsed SSL/TLS cipher suites that are disabled.
   void OnDisabledCipherSuitesChange(PrefService* local_state);
 
-  // Processes changes to the default cookie settings.
-  void OnDefaultContentSettingsChange(PrefService* 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_;
@@ -185,24 +180,14 @@ 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, PrefService* user_prefs)
-    : have_user_prefs_(!!user_prefs),
-      ssl_config_service_(new SSLConfigServicePref()) {
+    PrefService* local_state)
+    : ssl_config_service_(new SSLConfigServicePref()) {
   DCHECK(local_state);
 
   PrefChangeRegistrar::NamedChangeCallback local_state_callback = base::Bind(
@@ -230,20 +215,6 @@ SSLConfigServiceManagerPref::SSLConfigServiceManagerPref(
 
   OnDisabledCipherSuitesChange(local_state);
 
-  if (user_prefs) {
-    PrefChangeRegistrar::NamedChangeCallback user_prefs_callback = base::Bind(
-        &SSLConfigServiceManagerPref::OnPreferenceChanged,
-        base::Unretained(this),
-        user_prefs);
-    block_third_party_cookies_.Init(
-        prefs::kBlockThirdPartyCookies, user_prefs, user_prefs_callback);
-    user_prefs_change_registrar_.Init(user_prefs);
-    user_prefs_change_registrar_.Add(
-        prefs::kDefaultContentSettings, user_prefs_callback);
-
-    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_);
@@ -282,8 +253,6 @@ void SSLConfigServiceManagerPref::OnPreferenceChanged(
   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);
@@ -324,9 +293,6 @@ 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();
   config->unrestricted_ssl3_fallback_enabled =
@@ -340,26 +306,13 @@ void SSLConfigServiceManagerPref::OnDisabledCipherSuitesChange(
   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, PrefService* user_prefs) {
-  return new SSLConfigServiceManagerPref(local_state, user_prefs);
+    PrefService* local_state) {
+  return new SSLConfigServiceManagerPref(local_state);
 }
 
 // static
diff --git a/chrome/browser/net/ssl_config_service_manager_pref_unittest.cc b/chrome/browser/net/ssl_config_service_manager_pref_unittest.cc
index 59db10c..0e8fc37 100644
--- a/chrome/browser/net/ssl_config_service_manager_pref_unittest.cc
+++ b/chrome/browser/net/ssl_config_service_manager_pref_unittest.cc
@@ -67,7 +67,7 @@ TEST_F(SSLConfigServiceManagerPrefTest, ChannelIDWithoutUserPrefs) {
                           Value::CreateBooleanValue(false));
 
   scoped_ptr<SSLConfigServiceManager> config_manager(
-      SSLConfigServiceManager::CreateDefaultManager(&local_state, NULL));
+      SSLConfigServiceManager::CreateDefaultManager(&local_state));
   ASSERT_TRUE(config_manager.get());
   scoped_refptr<SSLConfigService> config_service(config_manager->Get());
   ASSERT_TRUE(config_service.get());
@@ -85,70 +85,6 @@ TEST_F(SSLConfigServiceManagerPrefTest, ChannelIDWithoutUserPrefs) {
   EXPECT_TRUE(config.channel_id_enabled);
 }
 
-// Test channel id with user prefs.
-TEST_F(SSLConfigServiceManagerPrefTest, ChannelIDWithUserPrefs) {
-  TestingPrefServiceSimple local_state;
-  SSLConfigServiceManager::RegisterPrefs(local_state.registry());
-  local_state.SetUserPref(prefs::kEnableOriginBoundCerts,
-                          Value::CreateBooleanValue(false));
-
-  TestingProfile testing_profile;
-  TestingPrefServiceSyncable* user_prefs =
-      testing_profile.GetTestingPrefService();
-  SetCookiePref(&testing_profile, CONTENT_SETTING_BLOCK);
-  user_prefs->SetUserPref(prefs::kBlockThirdPartyCookies,
-                          Value::CreateBooleanValue(true));
-
-  scoped_ptr<SSLConfigServiceManager> config_manager(
-      SSLConfigServiceManager::CreateDefaultManager(&local_state, user_prefs));
-  ASSERT_TRUE(config_manager.get());
-  scoped_refptr<SSLConfigService> config_service(config_manager->Get());
-  ASSERT_TRUE(config_service.get());
-
-  // channelid=false, cookies=block, 3rdpartycookies=block
-  EXPECT_FALSE(IsChannelIdEnabled(config_service));
-
-  // channelid=false, cookies=block, 3rdpartycookies=allow
-  user_prefs->SetUserPref(prefs::kBlockThirdPartyCookies,
-                          Value::CreateBooleanValue(false));
-  EXPECT_FALSE(IsChannelIdEnabled(config_service));
-
-  // channelid=false, cookies=allow, 3rdpartycookies=block
-  SetCookiePref(&testing_profile, CONTENT_SETTING_ALLOW);
-  user_prefs->SetUserPref(prefs::kBlockThirdPartyCookies,
-                          Value::CreateBooleanValue(true));
-  EXPECT_FALSE(IsChannelIdEnabled(config_service));
-
-  // channelid=false, cookies=allow, 3rdpartycookies=allow
-  user_prefs->SetUserPref(prefs::kBlockThirdPartyCookies,
-                          Value::CreateBooleanValue(false));
-  EXPECT_FALSE(IsChannelIdEnabled(config_service));
-
-  // channelid=true, cookies=block, 3rdpartycookies=block
-  local_state.SetUserPref(prefs::kEnableOriginBoundCerts,
-                          Value::CreateBooleanValue(true));
-  SetCookiePref(&testing_profile, CONTENT_SETTING_BLOCK);
-  user_prefs->SetUserPref(prefs::kBlockThirdPartyCookies,
-                          Value::CreateBooleanValue(true));
-  EXPECT_FALSE(IsChannelIdEnabled(config_service));
-
-  // channelid=true, cookies=block, 3rdpartycookies=allow
-  user_prefs->SetUserPref(prefs::kBlockThirdPartyCookies,
-                          Value::CreateBooleanValue(false));
-  EXPECT_FALSE(IsChannelIdEnabled(config_service));
-
-  // channelid=true, cookies=allow, 3rdpartycookies=block
-  SetCookiePref(&testing_profile, CONTENT_SETTING_ALLOW);
-  user_prefs->SetUserPref(prefs::kBlockThirdPartyCookies,
-                          Value::CreateBooleanValue(true));
-  EXPECT_FALSE(IsChannelIdEnabled(config_service));
-
-  // channelid=true, cookies=allow, 3rdpartycookies=allow
-  user_prefs->SetUserPref(prefs::kBlockThirdPartyCookies,
-                          Value::CreateBooleanValue(false));
-  EXPECT_TRUE(IsChannelIdEnabled(config_service));
-}
-
 // Test that cipher suites can be disabled. "Good" refers to the fact that
 // every value is expected to be successfully parsed into a cipher suite.
 TEST_F(SSLConfigServiceManagerPrefTest, GoodDisabledCipherSuites) {
@@ -156,7 +92,7 @@ TEST_F(SSLConfigServiceManagerPrefTest, GoodDisabledCipherSuites) {
   SSLConfigServiceManager::RegisterPrefs(local_state.registry());
 
   scoped_ptr<SSLConfigServiceManager> config_manager(
-      SSLConfigServiceManager::CreateDefaultManager(&local_state, NULL));
+      SSLConfigServiceManager::CreateDefaultManager(&local_state));
   ASSERT_TRUE(config_manager.get());
   scoped_refptr<SSLConfigService> config_service(config_manager->Get());
   ASSERT_TRUE(config_service.get());
@@ -191,7 +127,7 @@ TEST_F(SSLConfigServiceManagerPrefTest, BadDisabledCipherSuites) {
   SSLConfigServiceManager::RegisterPrefs(local_state.registry());
 
   scoped_ptr<SSLConfigServiceManager> config_manager(
-      SSLConfigServiceManager::CreateDefaultManager(&local_state, NULL));
+      SSLConfigServiceManager::CreateDefaultManager(&local_state));
   ASSERT_TRUE(config_manager.get());
   scoped_refptr<SSLConfigService> config_service(config_manager->Get());
   ASSERT_TRUE(config_service.get());
@@ -238,7 +174,7 @@ TEST_F(SSLConfigServiceManagerPrefTest, NoCommandLinePrefs) {
   SSLConfigServiceManager::RegisterPrefs(registry);
 
   scoped_ptr<SSLConfigServiceManager> config_manager(
-      SSLConfigServiceManager::CreateDefaultManager(local_state.get(), NULL));
+      SSLConfigServiceManager::CreateDefaultManager(local_state.get()));
   ASSERT_TRUE(config_manager.get());
   scoped_refptr<SSLConfigService> config_service(config_manager->Get());
   ASSERT_TRUE(config_service.get());
@@ -290,7 +226,7 @@ TEST_F(SSLConfigServiceManagerPrefTest, CommandLinePrefs) {
   SSLConfigServiceManager::RegisterPrefs(registry);
 
   scoped_ptr<SSLConfigServiceManager> config_manager(
-      SSLConfigServiceManager::CreateDefaultManager(local_state.get(), NULL));
+      SSLConfigServiceManager::CreateDefaultManager(local_state.get()));
   ASSERT_TRUE(config_manager.get());
   scoped_refptr<SSLConfigService> config_service(config_manager->Get());
   ASSERT_TRUE(config_service.get());