Change CanGetCookies signature, add CookieList as parameters in order to remove the getting cookies call inside ResourceDispatcherHost::CanGetCookies.

BUG=68657
TEST=XXXX

Review URL: http://codereview.chromium.org/7461121

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

12 files changed, 84 insertions, 70 deletions

diff --git a/content/browser/renderer_host/resource_dispatcher_host.cc b/content/browser/renderer_host/resource_dispatcher_host.cc
index 7030b10..0b78183 100644
--- a/content/browser/renderer_host/resource_dispatcher_host.cc
+++ b/content/browser/renderer_host/resource_dispatcher_host.cc
@@ -11,6 +11,7 @@
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ -1182,34 +1183,31 @@ void ResourceDispatcherHost::OnSSLCertificateError(
   SSLManager::OnSSLCertificateError(this, request, cert_error, cert);
 }
 
-bool ResourceDispatcherHost::CanGetCookies(net::URLRequest* request) {
+bool ResourceDispatcherHost::CanGetCookies(
+    const net::URLRequest* request,
+    const net::CookieList& cookie_list) const {
   VLOG(1) << "OnGetCookies: " << request->url().spec();
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return false;
 
-  const net::URLRequestContext* context = request->context();
-  net::CookieMonster* cookie_monster =
-      context->cookie_store()->GetCookieMonster();
-  net::CookieList cookie_list =
-      cookie_monster->GetAllCookiesForURL(request->url());
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   return content::GetContentClient()->browser()->AllowGetCookie(
       request->url(), request->first_party_for_cookies(), cookie_list,
       *info->context(), render_process_id, render_view_id);
 }
 
-bool ResourceDispatcherHost::CanSetCookie(net::URLRequest* request,
+bool ResourceDispatcherHost::CanSetCookie(const net::URLRequest* request,
                                           const std::string& cookie_line,
-                                          net::CookieOptions* options) {
+                                          net::CookieOptions* options) const {
   VLOG(1) << "OnSetCookie: " << request->url().spec();
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return false;
 
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   return content::GetContentClient()->browser()->AllowSetCookie(
       request->url(), request->first_party_for_cookies(), cookie_line,
       *info->context(), render_process_id, render_view_id, options);
diff --git a/content/browser/renderer_host/resource_dispatcher_host.h b/content/browser/renderer_host/resource_dispatcher_host.h
index 49500a2..415d0c2 100644
--- a/content/browser/renderer_host/resource_dispatcher_host.h
+++ b/content/browser/renderer_host/resource_dispatcher_host.h
@@ -50,6 +50,7 @@ namespace content {
 class ResourceContext;
 }
 namespace net {
+class CookieList;
 class URLRequestJobFactory;
 }  // namespace net
 
@@ -174,21 +175,24 @@ class ResourceDispatcherHost : public net::URLRequest::Delegate {
   // net::URLRequest::Delegate
   virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const GURL& new_url,
-                                  bool* defer_redirect);
+                                  bool* defer_redirect) OVERRIDE;
   virtual void OnAuthRequired(net::URLRequest* request,
-                              net::AuthChallengeInfo* auth_info);
+                              net::AuthChallengeInfo* auth_info) OVERRIDE;
   virtual void OnCertificateRequested(
       net::URLRequest* request,
-      net::SSLCertRequestInfo* cert_request_info);
+      net::SSLCertRequestInfo* cert_request_info) OVERRIDE;
   virtual void OnSSLCertificateError(net::URLRequest* request,
                                      int cert_error,
-                                     net::X509Certificate* cert);
-  virtual bool CanGetCookies(net::URLRequest* request);
-  virtual bool CanSetCookie(net::URLRequest* request,
+                                     net::X509Certificate* cert) OVERRIDE;
+  virtual bool CanGetCookies(const net::URLRequest* request,
+                             const net::CookieList& cookie_list) const OVERRIDE;
+  virtual bool CanSetCookie(const net::URLRequest* request,
                             const std::string& cookie_line,
-                            net::CookieOptions* options);
-  virtual void OnResponseStarted(net::URLRequest* request);
-  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
+                            net::CookieOptions* options) const OVERRIDE;
+  virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
+  virtual void OnReadCompleted(net::URLRequest* request,
+                               int bytes_read) OVERRIDE;
+
   void OnResponseCompleted(net::URLRequest* request);
 
   // Helper functions to get the dispatcher's request info for the request.
diff --git a/net/base/cookie_store_test_helpers.cc b/net/base/cookie_store_test_helpers.cc
index 8ab3e1a..c74133e 100644
--- a/net/base/cookie_store_test_helpers.cc
+++ b/net/base/cookie_store_test_helpers.cc
@@ -141,8 +141,7 @@ void DelayedCookieMonster::DeleteCookieAsync(const GURL& url,
 }
 
 CookieMonster* DelayedCookieMonster::GetCookieMonster() {
-  ADD_FAILURE();
-  return NULL;
+  return cookie_monster_;
 }
 
 }  // namespace net
diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc
index 07af22f..97c4d06 100644
--- a/net/url_request/url_request.cc
+++ b/net/url_request/url_request.cc
@@ -117,13 +117,14 @@ void URLRequest::Delegate::OnSSLCertificateError(URLRequest* request,
   request->Cancel();
 }
 
-bool URLRequest::Delegate::CanGetCookies(URLRequest* request) {
+bool URLRequest::Delegate::CanGetCookies(const URLRequest* request,
+                                         const CookieList& cookie_list) const {
   return true;
 }
 
-bool URLRequest::Delegate::CanSetCookie(URLRequest* request,
+bool URLRequest::Delegate::CanSetCookie(const URLRequest* request,
                                         const std::string& cookie_line,
-                                        CookieOptions* options) {
+                                        CookieOptions* options) const {
   return true;
 }
 
@@ -764,14 +765,14 @@ void URLRequest::NotifySSLCertificateError(int cert_error,
     delegate_->OnSSLCertificateError(this, cert_error, cert);
 }
 
-bool URLRequest::CanGetCookies() {
+bool URLRequest::CanGetCookies(const CookieList& cookie_list) const {
   if (delegate_)
-    return delegate_->CanGetCookies(this);
+    return delegate_->CanGetCookies(this, cookie_list);
   return false;
 }
 
 bool URLRequest::CanSetCookie(const std::string& cookie_line,
-                              CookieOptions* options) {
+                              CookieOptions* options) const {
   if (delegate_)
     return delegate_->CanSetCookie(this, cookie_line, options);
   return false;
diff --git a/net/url_request/url_request.h b/net/url_request/url_request.h
index a42fd3a..f6d5371 100644
--- a/net/url_request/url_request.h
+++ b/net/url_request/url_request.h
@@ -78,6 +78,7 @@ class BlobURLRequestJobTest;
 
 namespace net {
 
+class CookieList;
 class CookieOptions;
 class HostPortPair;
 class IOBuffer;
@@ -273,14 +274,15 @@ class NET_API URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe) {
     // Called when reading cookies to allow the delegate to block access to the
     // cookie. This method will never be invoked when LOAD_DO_NOT_SEND_COOKIES
     // is specified.
-    virtual bool CanGetCookies(URLRequest* request);
+    virtual bool CanGetCookies(const URLRequest* request,
+                               const CookieList& cookie_list) const;
 
     // Called when a cookie is set to allow the delegate to block access to the
     // cookie. This method will never be invoked when LOAD_DO_NOT_SAVE_COOKIES
     // is specified.
-    virtual bool CanSetCookie(URLRequest* request,
+    virtual bool CanSetCookie(const URLRequest* request,
                               const std::string& cookie_line,
-                              CookieOptions* options);
+                              CookieOptions* options) const;
 
     // After calling Start(), the delegate will receive an OnResponseStarted
     // callback when the request has completed.  If an error occurred, the
@@ -708,8 +710,9 @@ class NET_API URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe) {
   void NotifyAuthRequired(AuthChallengeInfo* auth_info);
   void NotifyCertificateRequested(SSLCertRequestInfo* cert_request_info);
   void NotifySSLCertificateError(int cert_error, X509Certificate* cert);
-  bool CanGetCookies();
-  bool CanSetCookie(const std::string& cookie_line, CookieOptions* options);
+  bool CanGetCookies(const CookieList& cookie_list) const;
+  bool CanSetCookie(const std::string& cookie_line,
+                    CookieOptions* options) const;
   void NotifyReadCompleted(int bytes_read);
 
   // Contextual information used for this request (can be NULL). This contains
diff --git a/net/url_request/url_request_http_job.cc b/net/url_request/url_request_http_job.cc
index af6c9c0..7e989a8 100644
--- a/net/url_request/url_request_http_job.cc
+++ b/net/url_request/url_request_http_job.cc
@@ -512,13 +512,27 @@ void URLRequestHttpJob::AddCookieHeaderAndStart() {
   if (!request_)
     return;
 
+  CookieStore* cookie_store =
+      request_->context()->cookie_store();
+  if (cookie_store) {
+    cookie_store->GetCookieMonster()->GetAllCookiesForURLAsync(
+        request_->url(),
+        base::Bind(&URLRequestHttpJob::CheckCookiePolicyAndLoad,
+                   weak_ptr_factory_.GetWeakPtr()));
+  } else {
+    DoStartTransaction();
+  }
+}
+
+void URLRequestHttpJob::CheckCookiePolicyAndLoad(
+    const CookieList& cookie_list) {
   bool allow = true;
   if ((request_info_.load_flags & LOAD_DO_NOT_SEND_COOKIES) ||
-      !CanGetCookies()) {
+      !CanGetCookies(cookie_list)) {
     allow = false;
   }
 
-  if (request_->context()->cookie_store() && allow) {
+  if (allow) {
     CookieOptions options;
     options.set_include_httponly();
     request_->context()->cookie_store()->GetCookiesWithInfoAsync(
@@ -543,7 +557,7 @@ void URLRequestHttpJob::OnCookiesLoaded(
 }
 
 void URLRequestHttpJob::DoStartTransaction() {
-  // We may have been canceled within CanGetCookies.
+  // We may have been canceled while retrieving cookies.
   if (GetStatus().is_success()) {
     StartTransaction();
   } else {
diff --git a/net/url_request/url_request_http_job.h b/net/url_request/url_request_http_job.h
index b5e22da..95ce950 100644
--- a/net/url_request/url_request_http_job.h
+++ b/net/url_request/url_request_http_job.h
@@ -164,6 +164,7 @@ class URLRequestHttpJob : public URLRequestJob {
   void DoneWithRequest(CompletionCause reason);
 
   // Callback functions for Cookie Monster
+  void CheckCookiePolicyAndLoad(const CookieList& cookie_list);
   void OnCookiesLoaded(
       std::string* cookie_line,
       std::vector<CookieStore::CookieInfo>* cookie_infos);
diff --git a/net/url_request/url_request_job.cc b/net/url_request/url_request_job.cc
index cd02911..db31e8d 100644
--- a/net/url_request/url_request_job.cc
+++ b/net/url_request/url_request_job.cc
@@ -230,15 +230,15 @@ void URLRequestJob::NotifySSLCertificateError(int cert_error,
   request_->NotifySSLCertificateError(cert_error, cert);
 }
 
-bool URLRequestJob::CanGetCookies() {
+bool URLRequestJob::CanGetCookies(const CookieList& cookie_list) const {
   if (!request_)
     return false;  // The request was destroyed, so there is no more work to do.
 
-  return request_->CanGetCookies();
+  return request_->CanGetCookies(cookie_list);
 }
 
 bool URLRequestJob::CanSetCookie(const std::string& cookie_line,
-                                 CookieOptions* options) {
+                                 CookieOptions* options) const {
   if (!request_)
     return false;  // The request was destroyed, so there is no more work to do.
 
diff --git a/net/url_request/url_request_job.h b/net/url_request/url_request_job.h
index e9887ad..523d0f4 100644
--- a/net/url_request/url_request_job.h
+++ b/net/url_request/url_request_job.h
@@ -24,6 +24,7 @@
 namespace net {
 
 class AuthChallengeInfo;
+class CookieList;
 class CookieOptions;
 class HttpRequestHeaders;
 class HttpResponseInfo;
@@ -199,10 +200,11 @@ class NET_API URLRequestJob : public base::RefCounted<URLRequestJob>,
   void NotifySSLCertificateError(int cert_error, X509Certificate* cert);
 
   // Delegates to URLRequest::Delegate.
-  bool CanGetCookies();
+  bool CanGetCookies(const CookieList& cookie_list) const;
 
   // Delegates to URLRequest::Delegate.
-  bool CanSetCookie(const std::string& cookie_line, CookieOptions* options);
+  bool CanSetCookie(const std::string& cookie_line,
+                    CookieOptions* options) const;
 
   // Notifies the job that headers have been received.
   void NotifyHeadersComplete();
diff --git a/net/url_request/url_request_test_util.cc b/net/url_request/url_request_test_util.cc
index 59d00f0..8c1a4fe 100644
--- a/net/url_request/url_request_test_util.cc
+++ b/net/url_request/url_request_test_util.cc
@@ -153,8 +153,6 @@ TestDelegate::TestDelegate()
       cancel_in_rs_(false),
       cancel_in_rd_(false),
       cancel_in_rd_pending_(false),
-      cancel_in_getcookiesblocked_(false),
-      cancel_in_setcookieblocked_(false),
       quit_on_complete_(true),
       quit_on_redirect_(false),
       allow_certificate_errors_(false),
@@ -207,23 +205,22 @@ void TestDelegate::OnSSLCertificateError(net::URLRequest* request,
     request->Cancel();
 }
 
-bool TestDelegate::CanGetCookies(net::URLRequest* request) {
+bool TestDelegate::CanGetCookies(const net::URLRequest* request,
+                                 const net::CookieList& cookie_list) const {
   bool allow = true;
   if (cookie_options_bit_mask_ & NO_GET_COOKIES)
     allow = false;
 
   if (!allow) {
     blocked_get_cookies_count_++;
-    if (cancel_in_getcookiesblocked_)
-      request->Cancel();
   }
 
   return allow;
 }
 
-bool TestDelegate::CanSetCookie(net::URLRequest* request,
+bool TestDelegate::CanSetCookie(const net::URLRequest* request,
                                 const std::string& cookie_line,
-                                net::CookieOptions* options) {
+                                net::CookieOptions* options) const {
   bool allow = true;
   if (cookie_options_bit_mask_ & NO_SET_COOKIE)
     allow = false;
@@ -234,8 +231,6 @@ bool TestDelegate::CanSetCookie(net::URLRequest* request,
 
   if (!allow) {
     blocked_set_cookie_count_++;
-    if (cancel_in_setcookieblocked_)
-      request->Cancel();
   } else {
     set_cookie_count_++;
   }
diff --git a/net/url_request/url_request_test_util.h b/net/url_request/url_request_test_util.h
index 3bd1292..8b3206ea 100644
--- a/net/url_request/url_request_test_util.h
+++ b/net/url_request/url_request_test_util.h
@@ -100,12 +100,6 @@ class TestDelegate : public net::URLRequest::Delegate {
   void set_cancel_in_received_data_pending(bool val) {
     cancel_in_rd_pending_ = val;
   }
-  void set_cancel_in_get_cookies_blocked(bool val) {
-    cancel_in_getcookiesblocked_ = val;
-  }
-  void set_cancel_in_set_cookie_blocked(bool val) {
-    cancel_in_setcookieblocked_ = val;
-  }
   void set_quit_on_complete(bool val) { quit_on_complete_ = val; }
   void set_quit_on_redirect(bool val) { quit_on_redirect_ = val; }
   void set_allow_certificate_errors(bool val) {
@@ -137,10 +131,11 @@ class TestDelegate : public net::URLRequest::Delegate {
   virtual void OnSSLCertificateError(net::URLRequest* request,
                                      int cert_error,
                                      net::X509Certificate* cert) OVERRIDE;
-  virtual bool CanGetCookies(net::URLRequest* request) OVERRIDE;
-  virtual bool CanSetCookie(net::URLRequest* request,
+  virtual bool CanGetCookies(const net::URLRequest* request,
+                             const net::CookieList& cookie_list) const OVERRIDE;
+  virtual bool CanSetCookie(const net::URLRequest* request,
                             const std::string& cookie_line,
-                            net::CookieOptions* options) OVERRIDE;
+                            net::CookieOptions* options) const OVERRIDE;
   virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
   virtual void OnReadCompleted(net::URLRequest* request,
                                int bytes_read) OVERRIDE;
@@ -155,8 +150,6 @@ class TestDelegate : public net::URLRequest::Delegate {
   bool cancel_in_rs_;
   bool cancel_in_rd_;
   bool cancel_in_rd_pending_;
-  bool cancel_in_getcookiesblocked_;
-  bool cancel_in_setcookieblocked_;
   bool quit_on_complete_;
   bool quit_on_redirect_;
   bool allow_certificate_errors_;
@@ -169,9 +162,9 @@ class TestDelegate : public net::URLRequest::Delegate {
   int response_started_count_;
   int received_bytes_count_;
   int received_redirect_count_;
-  int blocked_get_cookies_count_;
-  int blocked_set_cookie_count_;
-  int set_cookie_count_;
+  mutable int blocked_get_cookies_count_;
+  mutable int blocked_set_cookie_count_;
+  mutable int set_cookie_count_;
   bool received_data_before_response_;
   bool request_failed_;
   bool have_certificate_errors_;
diff --git a/webkit/tools/test_shell/simple_resource_loader_bridge.cc b/webkit/tools/test_shell/simple_resource_loader_bridge.cc
index 9dddcdf..ff5691c 100644
--- a/webkit/tools/test_shell/simple_resource_loader_bridge.cc
+++ b/webkit/tools/test_shell/simple_resource_loader_bridge.cc
@@ -32,6 +32,7 @@
 
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
+#include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ -416,14 +417,14 @@ class RequestProxy : public net::URLRequest::Delegate,
 
   virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const GURL& new_url,
-                                  bool* defer_redirect) {
+                                  bool* defer_redirect) OVERRIDE {
     DCHECK(request->status().is_success());
     ResourceResponseInfo info;
     PopulateResponseInfo(request, &info);
     OnReceivedRedirect(new_url, info, defer_redirect);
   }
 
-  virtual void OnResponseStarted(net::URLRequest* request) {
+  virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE {
     if (request->status().is_success()) {
       ResourceResponseInfo info;
       PopulateResponseInfo(request, &info);
@@ -436,12 +437,14 @@ class RequestProxy : public net::URLRequest::Delegate,
 
   virtual void OnSSLCertificateError(net::URLRequest* request,
                                      int cert_error,
-                                     net::X509Certificate* cert) {
+                                     net::X509Certificate* cert) OVERRIDE {
     // Allow all certificate errors.
     request->ContinueDespiteLastError();
   }
 
-  virtual bool CanGetCookies(net::URLRequest* request) {
+  virtual bool CanGetCookies(
+      const net::URLRequest* request,
+      const net::CookieList& cookie_list) const OVERRIDE {
     StaticCookiePolicy::Type policy_type = g_accept_all_cookies ?
         StaticCookiePolicy::ALLOW_ALL_COOKIES :
         StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES;
@@ -452,9 +455,9 @@ class RequestProxy : public net::URLRequest::Delegate,
     return rv == net::OK;
   }
 
-  virtual bool CanSetCookie(net::URLRequest* request,
+  virtual bool CanSetCookie(const net::URLRequest* request,
                             const std::string& cookie_line,
-                            net::CookieOptions* options) {
+                            net::CookieOptions* options) const OVERRIDE {
     StaticCookiePolicy::Type policy_type = g_accept_all_cookies ?
         StaticCookiePolicy::ALLOW_ALL_COOKIES :
         StaticCookiePolicy::BLOCK_SETTING_THIRD_PARTY_COOKIES;
@@ -465,7 +468,8 @@ class RequestProxy : public net::URLRequest::Delegate,
     return rv == net::OK;
   }
 
-  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {
+  virtual void OnReadCompleted(net::URLRequest* request,
+                               int bytes_read) OVERRIDE {
     if (request->status().is_success() && bytes_read > 0) {
       OnReceivedData(bytes_read);
     } else {