Changes to support new cookie policy....

chrome/browser/net/chrome_url_request_context.cc

 // Copyright (c) 2010 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/chrome_url_request_context.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/sqlite_persistent_cookie_store.h"
 #include "chrome/browser/net/dns_global.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
 #include "chrome/browser/privacy_blacklist/blacklist_request_info.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "net/base/static_cookie_policy.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_util.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/webkit_glue.h"
 
@@ skipping 502 matching lines @@
     DCHECK(pref_name_in && prefs);
     if (*pref_name_in == prefs::kAcceptLanguages) {
       std::string accept_language =
           WideToASCII(prefs->GetString(prefs::kAcceptLanguages));
       ChromeThread::PostTask(
           ChromeThread::IO, FROM_HERE,
           NewRunnableMethod(
               this,
               &ChromeURLRequestContextGetter::OnAcceptLanguageChange,
               accept_language));
-    } else if (*pref_name_in == prefs::kCookieBehavior) {
-      net::CookiePolicy::Type policy_type = net::CookiePolicy::FromInt(
-          prefs_->GetInteger(prefs::kCookieBehavior));
-      ChromeThread::PostTask(
-          ChromeThread::IO, FROM_HERE,
-          NewRunnableMethod(
-              this,
-              &ChromeURLRequestContextGetter::OnCookiePolicyChange,
-              policy_type));
     } else if (*pref_name_in == prefs::kDefaultCharset) {
       std::string default_charset =
           WideToASCII(prefs->GetString(prefs::kDefaultCharset));
       ChromeThread::PostTask(
           ChromeThread::IO, FROM_HERE,
           NewRunnableMethod(
               this,
               &ChromeURLRequestContextGetter::OnDefaultCharsetChange,
               default_charset));
     }
@@ skipping 23 matching lines @@
                           disk_cache_path,
                           cache_size,
                           off_the_record));
 }
 
 void ChromeURLRequestContextGetter::OnAcceptLanguageChange(
     const std::string& accept_language) {
   GetIOContext()->OnAcceptLanguageChange(accept_language);
 }
 
-void ChromeURLRequestContextGetter::OnCookiePolicyChange(
-    net::CookiePolicy::Type type) {
-  GetIOContext()->OnCookiePolicyChange(type);
-}
-
 void ChromeURLRequestContextGetter::OnDefaultCharsetChange(
     const std::string& default_charset) {
   GetIOContext()->OnDefaultCharsetChange(default_charset);
 }
 
 void ChromeURLRequestContextGetter::GetCookieStoreAsyncHelper(
     base::WaitableEvent* completion,
     net::CookieStore** result) {
   // Note that CookieStore is refcounted, yet we do not add a reference.
   *result = GetURLRequestContext()->cookie_store();
   completion->Signal();
 }
 
 // ----------------------------------------------------------------------------
 // ChromeURLRequestContext
 // ----------------------------------------------------------------------------
 
 ChromeURLRequestContext::ChromeURLRequestContext() {
   CheckCurrentlyOnIOThread();
+
+  cookie_policy_ = this;  // We implement CookiePolicy
+
   url_request_tracker()->SetGraveyardFilter(
       &ChromeURLRequestContext::ShouldTrackRequest);
 }
 
 ChromeURLRequestContext::~ChromeURLRequestContext() {
   CheckCurrentlyOnIOThread();
+
   if (appcache_service_.get() && appcache_service_->request_context() == this)
     appcache_service_->set_request_context(NULL);
 
   if (proxy_service_ &&
       proxy_service_->GetProxyScriptFetcher() &&
       proxy_service_->GetProxyScriptFetcher()->GetRequestContext() == this) {
     // Remove the ProxyScriptFetcher's weak reference to this context.
     proxy_service_->SetProxyScriptFetcher(NULL);
   }
 
 #if defined(OS_LINUX)
   if (this == net::GetURLRequestContextForOCSP()) {
     // We are releasing the URLRequestContext used by OCSP handlers.
     net::SetURLRequestContextForOCSP(NULL);
   }
 #endif
 
   NotificationService::current()->Notify(
       NotificationType::URL_REQUEST_CONTEXT_RELEASED,
       Source<URLRequestContext>(this),
       NotificationService::NoDetails());
 
   delete ftp_transaction_factory_;
   delete http_transaction_factory_;
+
+  cookie_policy_ = NULL;
 }
 
 FilePath ChromeURLRequestContext::GetPathForExtension(const std::string& id) {
   ExtensionInfoMap::iterator iter = extension_info_.find(id);
   if (iter != extension_info_.end())
     return iter->second->path;
   else
     return FilePath();
 }
 
@@ skipping 88 matching lines @@
 
 void ChromeURLRequestContext::OnUnloadedExtension(const std::string& id) {
   CheckCurrentlyOnIOThread();
   if (is_off_the_record_)
     return;
   ExtensionInfoMap::iterator iter = extension_info_.find(id);
   DCHECK(iter != extension_info_.end());
   extension_info_.erase(iter);
 }
 
+bool ChromeURLRequestContext::AreCookiesEnabled() const {
+  ContentSetting setting =
+      host_content_settings_map_->GetDefaultContentSetting(
+          CONTENT_SETTINGS_TYPE_COOKIES);
+  return setting != CONTENT_SETTING_BLOCK;
+}
+
+bool ChromeURLRequestContext::CanGetCookies(const GURL& url,
+                                            const GURL& first_party) {
+  if (host_content_settings_map_->BlockThirdPartyCookies()) {
+    net::StaticCookiePolicy policy(
+        net::StaticCookiePolicy::BLOCK_THIRD_PARTY_COOKIES);
+    if (!policy.CanGetCookies(url, first_party))
+      return false;
+  }
+
+  ContentSetting setting = host_content_settings_map_->GetContentSetting(
+      url.host(), CONTENT_SETTINGS_TYPE_COOKIES);
+  if (setting == CONTENT_SETTING_BLOCK)
+    return false;
+
+  // TODO(darin): Implement CONTENT_SETTING_ASK
+  return true;
+}
+
+bool ChromeURLRequestContext::CanSetCookie(const GURL& url,
+                                           const GURL& first_party) {
+  if (host_content_settings_map_->BlockThirdPartyCookies()) {
+    net::StaticCookiePolicy policy(
+        net::StaticCookiePolicy::BLOCK_THIRD_PARTY_COOKIES);
+    if (!policy.CanSetCookie(url, first_party))
+      return false;
+  }
+
+  ContentSetting setting = host_content_settings_map_->GetContentSetting(
+      url.host(), CONTENT_SETTINGS_TYPE_COOKIES);
+  if (setting == CONTENT_SETTING_BLOCK)
+    return false;
+
+  // TODO(darin): Implement CONTENT_SETTING_ASK
+  return true;
+}
+
 ChromeURLRequestContext::ChromeURLRequestContext(
     ChromeURLRequestContext* other) {
   CheckCurrentlyOnIOThread();
 
+  cookie_policy_ = this;  // We implement CookiePolicy
+
   // Set URLRequestContext members
   host_resolver_ = other->host_resolver_;
   proxy_service_ = other->proxy_service_;
   ssl_config_service_ = other->ssl_config_service_;
   http_transaction_factory_ = other->http_transaction_factory_;
   ftp_transaction_factory_ = other->ftp_transaction_factory_;
   cookie_store_ = other->cookie_store_;
-  cookie_policy_.set_type(other->cookie_policy_.type());
   transport_security_state_ = other->transport_security_state_;
   accept_language_ = other->accept_language_;
   accept_charset_ = other->accept_charset_;
   referrer_charset_ = other->referrer_charset_;
 
   // Set ChromeURLRequestContext members
   extension_info_ = other->extension_info_;
   user_script_dir_path_ = other->user_script_dir_path_;
   appcache_service_ = other->appcache_service_;
   host_content_settings_map_ = other->host_content_settings_map_;
   host_zoom_map_ = other->host_zoom_map_;
   privacy_blacklist_ = other->privacy_blacklist_;
   is_media_ = other->is_media_;
   is_off_the_record_ = other->is_off_the_record_;
 }
 
 void ChromeURLRequestContext::OnAcceptLanguageChange(
     const std::string& accept_language) {
   CheckCurrentlyOnIOThread();
   accept_language_ =
       net::HttpUtil::GenerateAcceptLanguageHeader(accept_language);
 }
 
-void ChromeURLRequestContext::OnCookiePolicyChange(
-    net::CookiePolicy::Type type) {
-  CheckCurrentlyOnIOThread();
-  cookie_policy_.set_type(type);
-}
-
 void ChromeURLRequestContext::OnDefaultCharsetChange(
     const std::string& default_charset) {
   CheckCurrentlyOnIOThread();
   referrer_charset_ = default_charset;
   accept_charset_ =
       net::HttpUtil::GenerateAcceptCharsetHeader(default_charset);
 }
 
 // static
 bool ChromeURLRequestContext::ShouldTrackRequest(const GURL& url) {
@@ skipping 31 matching lines @@
   // when download request is made through the context menu in a web page).
   // At the moment, it'll remain 'undeterministic' when a user
   // types a URL in the omnibar or click on a download link in a page.
   // For the latter, we need a change on the webkit-side.
   // We initialize it to the default charset here and a user will
   // have an *arguably* better default charset for interpreting a raw 8bit
   // C-D header field.  It means the native OS codepage fallback in
   // net_util::GetSuggestedFilename is unlikely to be taken.
   referrer_charset_ = default_charset;
 
-  cookie_policy_type_ = net::CookiePolicy::FromInt(
-      prefs->GetInteger(prefs::kCookieBehavior));
-
   host_content_settings_map_ = profile->GetHostContentSettingsMap();
 
   host_zoom_map_ = profile->GetHostZoomMap();
 
   privacy_blacklist_ = profile->GetPrivacyBlacklist();
 
   // TODO(eroman): this doesn't look safe; sharing between IO and UI threads!
   transport_security_state_ = profile->GetTransportSecurityState();
 
   if (profile->GetExtensionsService()) {
@@ skipping 25 matching lines @@
 
 void ChromeURLRequestContextFactory::ApplyProfileParametersToContext(
     ChromeURLRequestContext* context) {
   // Apply all the parameters. NOTE: keep this in sync with
   // ChromeURLRequestContextFactory(Profile*).
   context->set_is_media(is_media_);
   context->set_is_off_the_record(is_off_the_record_);
   context->set_accept_language(accept_language_);
   context->set_accept_charset(accept_charset_);
   context->set_referrer_charset(referrer_charset_);
-  context->set_cookie_policy_type(cookie_policy_type_);
   context->set_extension_info(extension_info_);
   context->set_user_script_dir_path(user_script_dir_path_);
   context->set_host_content_settings_map(host_content_settings_map_);
   context->set_host_zoom_map(host_zoom_map_);
   context->set_privacy_blacklist(privacy_blacklist_);
   context->set_transport_security_state(
       transport_security_state_);
   context->set_ssl_config_service(ssl_config_service_);
 }
 
@@ skipping 49 matching lines @@
   }
 
   if (command_line.HasSwitch(switches::kProxyBypassList)) {
     proxy_config->ParseNoProxyList(
         WideToASCII(command_line.GetSwitchValue(
             switches::kProxyBypassList)));
   }
 
   return proxy_config;
 }