More progress towards removing content settings code from the content layer. We can't use Cookie...

net/url_request/url_request_test_util.cc

 // Copyright (c) 2011 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"
 #include "net/base/host_port_pair.h"
 #include "net/http/http_network_session.h"
 
-TestCookiePolicy::TestCookiePolicy(int options_bit_mask)
-    : options_(options_bit_mask) {
-}
-
-TestCookiePolicy::~TestCookiePolicy() {}
-
-int TestCookiePolicy::CanGetCookies(const GURL& url,
-                                    const GURL& first_party) const {
-  if (options_ & NO_GET_COOKIES)
-    return net::ERR_ACCESS_DENIED;
-
-  return net::OK;
-}
-
-int TestCookiePolicy::CanSetCookie(const GURL& url,
-                                   const GURL& first_party,
-                                   const std::string& cookie_line) const {
-  if (options_ & NO_SET_COOKIE)
-    return net::ERR_ACCESS_DENIED;
-
-  if (options_ & FORCE_SESSION)
-    return net::OK_FOR_SESSION_ONLY;
-
-  return net::OK;
-}
-
 TestURLRequestContext::TestURLRequestContext()
     : ALLOW_THIS_IN_INITIALIZER_LIST(context_storage_(this)) {
   context_storage_.set_host_resolver(
       net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism,
                                     NULL));
   context_storage_.set_proxy_service(net::ProxyService::CreateDirect());
   Init();
 }
 
 TestURLRequestContext::TestURLRequestContext(const std::string& proxy)
@@ skipping 56 matching lines @@
 TestDelegate::TestDelegate()
     : cancel_in_rr_(false),
       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),
+      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),
       buf_(new net::IOBuffer(kBufferSize)) {
@@ skipping 28 matching lines @@
   // The caller can control whether it needs all SSL requests to go through,
   // independent of any possible errors, or whether it wants SSL errors to
   // cancel the request.
   have_certificate_errors_ = true;
   if (allow_certificate_errors_)
     request->ContinueDespiteLastError();
   else
     request->Cancel();
 }
 
-void TestDelegate::OnGetCookies(net::URLRequest* request,
-                                bool blocked_by_policy) {
-  if (blocked_by_policy) {
+bool TestDelegate::CanGetCookies(net::URLRequest* request) {
+  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;
 }
 
-void TestDelegate::OnSetCookie(net::URLRequest* request,
-                               const std::string& cookie_line,
-                               const net::CookieOptions& options,
-                               bool blocked_by_policy) {
-  if (blocked_by_policy) {
+bool TestDelegate::CanSetCookie(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_++;
     if (cancel_in_setcookieblocked_)
       request->Cancel();
   } 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);
@@ skipping 108 matching lines @@
 }
 
 net::URLRequestJob* TestNetworkDelegate::OnMaybeCreateURLRequestJob(
     net::URLRequest* request) {
   return NULL;
 }
 
 void TestNetworkDelegate::OnPACScriptError(int line_number,
                                            const string16& error) {
 }