Do cookie checks in NetworkDelegate instead of the URLRequest::Delegate.

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 107 matching lines @@
 }
 
 void URLRequest::Delegate::OnSSLCertificateError(URLRequest* request,
                                                  const SSLInfo& ssl_info,
                                                  bool is_hsts_ok) {
   request->Cancel();
 }
 
 bool URLRequest::Delegate::CanGetCookies(const URLRequest* request,
                                          const CookieList& cookie_list) const {
-  return true;
+  return false;

[jam, 2012/03/01 19:30:42]

why?

[jochen (gone - plz use gerrit), 2012/03/01 19:39:11]

The default of URLRequest::CanSetCookies is false, the Delegate should have the
same default.

Anyway, now that NetworkDelegate does the cookie stuff, I think I can just
remove this method from URLRequest::Delegate

[willchan no longer on Chromium, 2012/03/01 20:30:10]

Please just remove this method. Having it in both places is confusing. The
Delegate shouldn't be in control. If it wanted explicit control to override the
NetworkDelegate, it should be using a net::LoadFlag.

 }
 
 bool URLRequest::Delegate::CanSetCookie(const URLRequest* request,
                                         const std::string& cookie_line,
                                         CookieOptions* options) const {
-  return true;
+  return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest
 
 URLRequest::URLRequest(const GURL& url, Delegate* delegate)
     : url_chain_(1, url),
       method_("GET"),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
@@ skipping 685 matching lines @@
     delegate_->OnCertificateRequested(this, cert_request_info);
 }
 
 void URLRequest::NotifySSLCertificateError(const SSLInfo& ssl_info,
                                            bool fatal) {
   if (delegate_)
     delegate_->OnSSLCertificateError(this, ssl_info, fatal);
 }
 
 bool URLRequest::CanGetCookies(const CookieList& cookie_list) const {
+  if (context_ && context_->network_delegate()) {
+    return context_->network_delegate()->NotifyReadingCookies(this,
+                                                              cookie_list);
+  }
   if (delegate_)
     return delegate_->CanGetCookies(this, cookie_list);
   return false;
 }
 
 bool URLRequest::CanSetCookie(const std::string& cookie_line,
                               CookieOptions* options) const {
+  if (context_ && context_->network_delegate()) {
+    return context_->network_delegate()->NotifySettingCookie(this,
+                                                             cookie_line,
+                                                             options);
+  }
   if (delegate_)
     return delegate_->CanSetCookie(this, cookie_line, options);
   return false;
 }
 
 
 void URLRequest::NotifyReadCompleted(int bytes_read) {
   // Notify in case the entire URL Request has been finished.
   if (bytes_read <= 0)
     NotifyRequestCompleted();
@@ skipping 23 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