Enable cookies per default in net. Add an API to disable them by default, and do that in Chrome

net/url_request/url_request.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 "net/url_request/url_request.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 46 matching lines @@
 // This lock protects g_next_url_request_identifier.
 base::LazyInstance<base::Lock>::Leaky
     g_next_url_request_identifier_lock = LAZY_INSTANCE_INITIALIZER;
 
 // Returns an prior unused identifier for URL requests.
 uint64 GenerateURLRequestIdentifier() {
   base::AutoLock lock(g_next_url_request_identifier_lock.Get());
   return g_next_url_request_identifier++;
 }
 
+// True once the first URLRequest was started.
+bool g_url_requests_started = false;
+
+// True if cookies are accepted by default.
+bool g_default_can_use_cookies = true;
+
 }  // namespace
 
 URLRequest::ProtocolFactory*
 URLRequest::Deprecated::RegisterProtocolFactory(const std::string& scheme,
                                                 ProtocolFactory* factory) {
   return URLRequest::RegisterProtocolFactory(scheme, factory);
 }
 
 void URLRequest::Deprecated::RegisterRequestInterceptor(
     Interceptor* interceptor) {
@@ skipping 237 matching lines @@
   DCHECK(job_);
   job_->GetCharset(charset);
 }
 
 int URLRequest::GetResponseCode() {
   DCHECK(job_);
   return job_->GetResponseCode();
 }
 
 // static
+void URLRequest::SetDefaultCookiePolicyToBlock() {
+  CHECK(!g_url_requests_started);
+  g_default_can_use_cookies = false;
+}
+
+// static
 bool URLRequest::IsHandledProtocol(const std::string& scheme) {
   return URLRequestJobManager::GetInstance()->SupportsScheme(scheme);
 }
 
 // static
 bool URLRequest::IsHandledURL(const GURL& url) {
   if (!url.is_valid()) {
     // We handle error cases.
     return true;
   }
@@ skipping 38 matching lines @@
   }
 
   return ret;
 }
 
 void URLRequest::set_delegate(Delegate* delegate) {
   delegate_ = delegate;
 }
 
 void URLRequest::Start() {
+  g_url_requests_started = true;
   response_info_.request_time = Time::Now();
 
   // Only notify the delegate for the initial request.
   if (context_ && context_->network_delegate()) {
     int error = context_->network_delegate()->NotifyBeforeURLRequest(
         this, before_request_callback_, &delegate_redirect_url_);
     if (error != net::OK) {
       if (error == net::ERR_IO_PENDING) {
         // Paused on the delegate, will invoke |before_request_callback_| later.
         SetBlockedOnDelegate();
@@ skipping 420 matching lines @@
   if (delegate_)
     delegate_->OnSSLCertificateError(this, ssl_info, fatal);
 }
 
 bool URLRequest::CanGetCookies(const CookieList& cookie_list) const {
   DCHECK(!(load_flags_ & LOAD_DO_NOT_SEND_COOKIES));
   if (context_ && context_->network_delegate()) {
     return context_->network_delegate()->NotifyReadingCookies(this,
                                                               cookie_list);
   }
-  return false;
+  return g_default_can_use_cookies;
 }
 
 bool URLRequest::CanSetCookie(const std::string& cookie_line,
                               CookieOptions* options) const {
   DCHECK(!(load_flags_ & LOAD_DO_NOT_SAVE_COOKIES));
   if (context_ && context_->network_delegate()) {
     return context_->network_delegate()->NotifySettingCookie(this,
                                                              cookie_line,
                                                              options);
   }
-  return false;
+  return g_default_can_use_cookies;
 }
 
 
 void URLRequest::NotifyReadCompleted(int bytes_read) {
   // Notify in case the entire URL Request has been finished.
   if (bytes_read <= 0)
     NotifyRequestCompleted();
 
   if (delegate_)
     delegate_->OnReadCompleted(this, bytes_read);
@@ skipping 20 matching lines @@
 
 void URLRequest::SetUnblockedOnDelegate() {
   if (!blocked_on_delegate_)
     return;
   blocked_on_delegate_ = false;
   load_state_param_.clear();
   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
 }
 
 }  // namespace net