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

net/url_request/url_request_test_util.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_test_util.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
@@ skipping 173 matching lines @@
 }
 
 TestDelegate::TestDelegate()
     : cancel_in_rr_(false),
       cancel_in_rs_(false),
       cancel_in_rd_(false),
       cancel_in_rd_pending_(false),
       quit_on_complete_(true),
       quit_on_redirect_(false),
       allow_certificate_errors_(false),
-      cookie_options_bit_mask_(0),
       response_started_count_(0),
       received_bytes_count_(0),
       received_redirect_count_(0),
-      blocked_get_cookies_count_(0),
-      blocked_set_cookie_count_(0),
-      set_cookie_count_(0),
       received_data_before_response_(false),
       request_failed_(false),
       have_certificate_errors_(false),
       certificate_errors_are_fatal_(false),
       auth_required_(false),
       buf_(new net::IOBuffer(kBufferSize)) {
 }
 
 TestDelegate::~TestDelegate() {}
 
@@ skipping 26 matching lines @@
   // independent of any possible errors, or whether it wants SSL errors to
   // cancel the request.
   have_certificate_errors_ = true;
   certificate_errors_are_fatal_ = fatal;
   if (allow_certificate_errors_)
     request->ContinueDespiteLastError();
   else
     request->Cancel();
 }
 
-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_++;
-  }
-
-  return allow;
-}
-
-bool TestDelegate::CanSetCookie(const net::URLRequest* request,
-                                const std::string& cookie_line,
-                                net::CookieOptions* options) const {
-  bool allow = true;
-  if (cookie_options_bit_mask_ & NO_SET_COOKIE)
-    allow = false;
-
-  if (cookie_options_bit_mask_ & FORCE_SESSION)
-    options->set_force_session();
-
-
-  if (!allow) {
-    blocked_set_cookie_count_++;
-  } else {
-    set_cookie_count_++;
-  }
-
-  return allow;
-}
-
 void TestDelegate::OnResponseStarted(net::URLRequest* request) {
   // It doesn't make sense for the request to have IO pending at this point.
   DCHECK(!request->status().is_io_pending());
 
   response_started_count_++;
   if (cancel_in_rs_) {
     request->Cancel();
     OnResponseCompleted(request);
   } else if (!request->status().is_success()) {
     DCHECK(request->status().status() == net::URLRequestStatus::FAILED ||
@@ skipping 45 matching lines @@
   else if (cancel_in_rd_pending_)
     request->Cancel();
 }
 
 void TestDelegate::OnResponseCompleted(net::URLRequest* request) {
   if (quit_on_complete_)
     MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 TestNetworkDelegate::TestNetworkDelegate()
-  : last_error_(0),
-    error_count_(0),
-    created_requests_(0),
-    destroyed_requests_(0),
-    completed_requests_(0) {
+    : last_error_(0),
+      error_count_(0),
+      created_requests_(0),
+      destroyed_requests_(0),
+      completed_requests_(0),
+      cookie_options_bit_mask_(0),
+      blocked_get_cookies_count_(0),
+      blocked_set_cookie_count_(0),
+      set_cookie_count_(0) {
 }
 
 TestNetworkDelegate::~TestNetworkDelegate() {
   for (std::map<int, int>::iterator i = next_states_.begin();
        i != next_states_.end(); ++i) {
     event_order_[i->first] += "~TestNetworkDelegate\n";
     EXPECT_TRUE(i->second & kStageDestruction) << event_order_[i->first];
   }
 }
 
@@ skipping 157 matching lines @@
   EXPECT_TRUE(next_states_[req_id] & kStageAuthRequired) <<
       event_order_[req_id];
   next_states_[req_id] = kStageBeforeSendHeaders |
       kStageHeadersReceived |  // Request canceled by delegate simulates empty
                                // response.
       kStageResponseStarted |  // data: URLs do not trigger sending headers
       kStageBeforeRedirect;  // a delegate can trigger a redirection
   return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 }
 
+bool TestNetworkDelegate::CanGetCookies(const net::URLRequest* request,
+                                        const net::CookieList& cookie_list) {
+  bool allow = true;
+  if (cookie_options_bit_mask_ & NO_GET_COOKIES)
+    allow = false;
+
+  if (!allow) {
+    blocked_get_cookies_count_++;
+  }
+
+  return allow;
+}
+
+bool TestNetworkDelegate::CanSetCookie(const net::URLRequest* request,
+                                       const std::string& cookie_line,
+                                       net::CookieOptions* options) {
+  bool allow = true;
+  if (cookie_options_bit_mask_ & NO_SET_COOKIE)
+    allow = false;
+
+  if (cookie_options_bit_mask_ & FORCE_SESSION)
+    options->set_force_session();
+
+  if (!allow) {
+    blocked_set_cookie_count_++;
+  } else {
+    set_cookie_count_++;
+  }
+
+  return allow;
+}
+
 // static
 std::string ScopedCustomUrlRequestTestHttpHost::value_("127.0.0.1");
 
 ScopedCustomUrlRequestTestHttpHost::ScopedCustomUrlRequestTestHttpHost(
   const std::string& new_value)
     : old_value_(value_),
       new_value_(new_value) {
   value_ = new_value_;
 }
 
 ScopedCustomUrlRequestTestHttpHost::~ScopedCustomUrlRequestTestHttpHost() {
   DCHECK_EQ(value_, new_value_);
   value_ = old_value_;
 }
 
 // static
 const std::string& ScopedCustomUrlRequestTestHttpHost::value() {
   return value_;
 }