1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5// This file contains test infrastructure for multiple files 6// (current cookie_monster_unittest.cc and cookie_monster_perftest.cc) 7// that need to test out CookieMonster interactions with the backing store. 8// It should only be included by test code. 9 10#ifndef NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_ 11#define NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_ 12 13#include <map> 14#include <string> 15#include <utility> 16#include <vector> 17#include "net/cookies/canonical_cookie.h" 18#include "net/cookies/cookie_monster.h" 19 20namespace base { 21class Time; 22} 23 24namespace net { 25 26// Wrapper class for posting a loaded callback. Since the Callback class is not 27// reference counted, we cannot post a callback to the message loop directly, 28// instead we post a LoadedCallbackTask. 29class LoadedCallbackTask 30 : public base::RefCountedThreadSafe<LoadedCallbackTask> { 31 public: 32 typedef CookieMonster::PersistentCookieStore::LoadedCallback LoadedCallback; 33 34 LoadedCallbackTask(LoadedCallback loaded_callback, 35 std::vector<CanonicalCookie*> cookies); 36 37 void Run() { 38 loaded_callback_.Run(cookies_); 39 } 40 41 private: 42 friend class base::RefCountedThreadSafe<LoadedCallbackTask>; 43 ~LoadedCallbackTask(); 44 45 LoadedCallback loaded_callback_; 46 std::vector<CanonicalCookie*> cookies_; 47 48 DISALLOW_COPY_AND_ASSIGN(LoadedCallbackTask); 49}; // Wrapper class LoadedCallbackTask 50 51// Describes a call to one of the 3 functions of PersistentCookieStore. 52struct CookieStoreCommand { 53 enum Type { 54 ADD, 55 UPDATE_ACCESS_TIME, 56 REMOVE, 57 }; 58 59 CookieStoreCommand(Type type, const CanonicalCookie& cookie) 60 : type(type), 61 cookie(cookie) {} 62 63 Type type; 64 CanonicalCookie cookie; 65}; 66 67// Implementation of PersistentCookieStore that captures the 68// received commands and saves them to a list. 69// The result of calls to Load() can be configured using SetLoadExpectation(). 70class MockPersistentCookieStore 71 : public CookieMonster::PersistentCookieStore { 72 public: 73 typedef std::vector<CookieStoreCommand> CommandList; 74 75 MockPersistentCookieStore(); 76 77 void SetLoadExpectation( 78 bool return_value, 79 const std::vector<CanonicalCookie*>& result); 80 81 const CommandList& commands() const { 82 return commands_; 83 } 84 85 virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE; 86 87 virtual void LoadCookiesForKey(const std::string& key, 88 const LoadedCallback& loaded_callback) OVERRIDE; 89 90 virtual void AddCookie(const CanonicalCookie& cookie) OVERRIDE; 91 92 virtual void UpdateCookieAccessTime( 93 const CanonicalCookie& cookie) OVERRIDE; 94 95 virtual void DeleteCookie( 96 const CanonicalCookie& cookie) OVERRIDE; 97 98 virtual void Flush(const base::Closure& callback) OVERRIDE; 99 100 virtual void SetForceKeepSessionState() OVERRIDE; 101 102 protected: 103 virtual ~MockPersistentCookieStore(); 104 105 private: 106 CommandList commands_; 107 108 // Deferred result to use when Load() is called. 109 bool load_return_value_; 110 std::vector<CanonicalCookie*> load_result_; 111 // Indicates if the store has been fully loaded to avoid returning duplicate 112 // cookies. 113 bool loaded_; 114 115 DISALLOW_COPY_AND_ASSIGN(MockPersistentCookieStore); 116}; 117 118// Mock for CookieMonsterDelegate 119class MockCookieMonsterDelegate : public CookieMonsterDelegate { 120 public: 121 typedef std::pair<CanonicalCookie, bool> 122 CookieNotification; 123 124 MockCookieMonsterDelegate(); 125 126 const std::vector<CookieNotification>& changes() const { return changes_; } 127 128 void reset() { changes_.clear(); } 129 130 virtual void OnCookieChanged( 131 const CanonicalCookie& cookie, 132 bool removed, 133 CookieMonsterDelegate::ChangeCause cause) OVERRIDE; 134 135 virtual void OnLoaded() OVERRIDE; 136 137 private: 138 virtual ~MockCookieMonsterDelegate(); 139 140 std::vector<CookieNotification> changes_; 141 142 DISALLOW_COPY_AND_ASSIGN(MockCookieMonsterDelegate); 143}; 144 145// Helper to build a single CanonicalCookie. 146CanonicalCookie BuildCanonicalCookie(const std::string& key, 147 const std::string& cookie_line, 148 const base::Time& creation_time); 149 150// Helper to build a list of CanonicalCookie*s. 151void AddCookieToList( 152 const std::string& key, 153 const std::string& cookie_line, 154 const base::Time& creation_time, 155 std::vector<CanonicalCookie*>* out_list); 156 157// Just act like a backing database. Keep cookie information from 158// Add/Update/Delete and regurgitate it when Load is called. 159class MockSimplePersistentCookieStore 160 : public CookieMonster::PersistentCookieStore { 161 public: 162 MockSimplePersistentCookieStore(); 163 164 virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE; 165 166 virtual void LoadCookiesForKey(const std::string& key, 167 const LoadedCallback& loaded_callback) OVERRIDE; 168 169 virtual void AddCookie(const CanonicalCookie& cookie) OVERRIDE; 170 171 virtual void UpdateCookieAccessTime(const CanonicalCookie& cookie) OVERRIDE; 172 173 virtual void DeleteCookie(const CanonicalCookie& cookie) OVERRIDE; 174 175 virtual void Flush(const base::Closure& callback) OVERRIDE; 176 177 virtual void SetForceKeepSessionState() OVERRIDE; 178 179 protected: 180 virtual ~MockSimplePersistentCookieStore(); 181 182 private: 183 typedef std::map<int64, CanonicalCookie> CanonicalCookieMap; 184 185 CanonicalCookieMap cookies_; 186 187 // Indicates if the store has been fully loaded to avoid return duplicate 188 // cookies in subsequent load requests 189 bool loaded_; 190}; 191 192// Helper function for creating a CookieMonster backed by a 193// MockSimplePersistentCookieStore for garbage collection testing. 194// 195// Fill the store through import with |num_cookies| cookies, |num_old_cookies| 196// with access time Now()-days_old, the rest with access time Now(). 197// Do two SetCookies(). Return whether each of the two SetCookies() took 198// longer than |gc_perf_micros| to complete, and how many cookie were 199// left in the store afterwards. 200CookieMonster* CreateMonsterFromStoreForGC( 201 int num_cookies, 202 int num_old_cookies, 203 int days_old); 204 205} // namespace net 206 207#endif // NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_ 208