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 105 matching lines @@
     SSLCertRequestInfo* cert_request_info) {
   request->Cancel();
 }
 
 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;
-}
-
-bool URLRequest::Delegate::CanSetCookie(const URLRequest* request,
-                                        const std::string& cookie_line,
-                                        CookieOptions* options) const {
-  return true;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest
 
 URLRequest::URLRequest(const GURL& url, Delegate* delegate)
     : url_chain_(1, url),
       method_("GET"),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
       is_pending_(false),
       redirect_limit_(kMaxRedirects),
@@ skipping 683 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 (delegate_)
-    return delegate_->CanGetCookies(this, cookie_list);
+  DCHECK(!(load_flags_ & LOAD_DO_NOT_SEND_COOKIES));
+  if (context_ && context_->network_delegate()) {
+    return context_->network_delegate()->NotifyReadingCookies(this,
+                                                              cookie_list);
+  }
   return false;
 }
 
 bool URLRequest::CanSetCookie(const std::string& cookie_line,
                               CookieOptions* options) const {
-  if (delegate_)
-    return delegate_->CanSetCookie(this, cookie_line, options);
+  DCHECK(!(load_flags_ & LOAD_DO_NOT_SAVE_COOKIES));
+  if (context_ && context_->network_delegate()) {
+    return context_->network_delegate()->NotifySettingCookie(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();
 
   if (delegate_)
@@ skipping 21 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