Store blocked cookies in the tab contents.

net/url_request/url_request_unittest.h

 // Copyright (c) 2010 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 
 #include <stdlib.h>
 
 #include <sstream>
@@ skipping 186 matching lines @@
         cancel_in_getcookiesblocked_(false),
         cancel_in_setcookieblocked_(false),
         quit_on_complete_(true),
         quit_on_redirect_(false),
         allow_certificate_errors_(false),
         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)) {
   }
 
   virtual void OnReceivedRedirect(URLRequest* request, const GURL& new_url,
                                   bool* defer_redirect) {
     received_redirect_count_++;
     if (quit_on_redirect_) {
@@ skipping 82 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();
   }
 
-  virtual void OnGetCookiesBlocked(URLRequest* request) {
-    blocked_get_cookies_count_++;
-    if (cancel_in_getcookiesblocked_)
-      request->Cancel();
+  virtual void OnGetCookies(URLRequest* request, bool blocked_by_policy) {
+    if (blocked_by_policy) {
+      blocked_get_cookies_count_++;
+      if (cancel_in_getcookiesblocked_)
+        request->Cancel();
+    }
   }
 
-  virtual void OnSetCookieBlocked(URLRequest* request) {
-    blocked_set_cookie_count_++;
-    if (cancel_in_setcookieblocked_)
-      request->Cancel();
+  virtual void OnSetCookie(URLRequest* request,
+                           const std::string& cookie_line,
+                           bool blocked_by_policy) {
+    if (blocked_by_policy) {
+      blocked_set_cookie_count_++;
+      if (cancel_in_setcookieblocked_)
+        request->Cancel();
+    } else {
+      set_cookie_count_++;
+    }
   }
 
   void set_cancel_in_received_redirect(bool val) { cancel_in_rr_ = val; }
   void set_cancel_in_response_started(bool val) { cancel_in_rs_ = val; }
   void set_cancel_in_received_data(bool val) { cancel_in_rd_ = val; }
   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) {
     allow_certificate_errors_ = val;
   }
   void set_username(const std::wstring& u) { username_ = u; }
   void set_password(const std::wstring& p) { password_ = p; }
 
   // query state
   const std::string& data_received() const { return data_received_; }
   int bytes_received() const { return static_cast<int>(data_received_.size()); }
   int response_started_count() const { return response_started_count_; }
   int received_redirect_count() const { return received_redirect_count_; }
   int blocked_get_cookies_count() const { return blocked_get_cookies_count_; }
   int blocked_set_cookie_count() const { return blocked_set_cookie_count_; }
+  int set_cookie_count() const { return set_cookie_count_; }
   bool received_data_before_response() const {
     return received_data_before_response_;
   }
   bool request_failed() const { return request_failed_; }
   bool have_certificate_errors() const { return have_certificate_errors_; }
 
  private:
   static const int kBufferSize = 4096;
   // options for controlling behavior
   bool cancel_in_rr_;
   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_;
 
   std::wstring username_;
   std::wstring password_;
 
   // tracks status of callbacks
   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_;
   bool received_data_before_response_;
   bool request_failed_;
   bool have_certificate_errors_;
   std::string data_received_;
 
   // our read buffer
   scoped_refptr<net::IOBuffer> buf_;
 };
 
 //-----------------------------------------------------------------------------
@@ skipping 365 matching lines @@
       return false;
 
     return true;
   }
 
  private:
   ~FTPTestServer() {}
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_