?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Perf: Update size expectations on linux-rel
[chromium-blink-merge.git] / net / cookies / cookie_monster_unittest.cc
blob0610612027a1e36785df2c5f639f690a36e2c24c
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 #include "net/cookies/cookie_store_unittest.h"
6
7 #include <algorithm>
8 #include <string>
9 #include <vector>
10
11 #include "base/basictypes.h"
12 #include "base/bind.h"
13 #include "base/memory/ref_counted.h"
14 #include "base/memory/scoped_ptr.h"
15 #include "base/message_loop/message_loop.h"
16 #include "base/metrics/histogram.h"
17 #include "base/metrics/histogram_samples.h"
18 #include "base/strings/string_number_conversions.h"
19 #include "base/strings/string_piece.h"
20 #include "base/strings/string_split.h"
21 #include "base/strings/string_tokenizer.h"
22 #include "base/strings/stringprintf.h"
23 #include "base/threading/thread.h"
24 #include "base/time/time.h"
25 #include "net/cookies/canonical_cookie.h"
26 #include "net/cookies/cookie_constants.h"
27 #include "net/cookies/cookie_monster.h"
28 #include "net/cookies/cookie_monster_store_test.h" // For CookieStore mock
29 #include "net/cookies/cookie_util.h"
30 #include "net/cookies/parsed_cookie.h"
31 #include "testing/gmock/include/gmock/gmock.h"
32 #include "testing/gtest/include/gtest/gtest.h"
33 #include "url/gurl.h"
34
35 namespace net {
36
37 using base::Time;
38 using base::TimeDelta;
39
40 namespace {
41
42 // TODO(erikwright): Replace the pre-existing MockPersistentCookieStore (and
43 // brethren) with this one, and remove the 'New' prefix.
44 class NewMockPersistentCookieStore
45 : public CookieMonster::PersistentCookieStore {
46 public:
47 MOCK_METHOD1(Load, void(const LoadedCallback& loaded_callback));
48 MOCK_METHOD2(LoadCookiesForKey, void(const std::string& key,
49 const LoadedCallback& loaded_callback));
50 MOCK_METHOD1(AddCookie, void(const CanonicalCookie& cc));
51 MOCK_METHOD1(UpdateCookieAccessTime, void(const CanonicalCookie& cc));
52 MOCK_METHOD1(DeleteCookie, void(const CanonicalCookie& cc));
53 virtual void Flush(const base::Closure& callback) {
54 if (!callback.is_null())
55 base::MessageLoop::current()->PostTask(FROM_HERE, callback);
56 }
57 MOCK_METHOD0(SetForceKeepSessionState, void());
58
59 private:
60 virtual ~NewMockPersistentCookieStore() {}
61 };
62
63 const char* kTopLevelDomainPlus1 = "http://www.harvard.edu";
64 const char* kTopLevelDomainPlus2 = "http://www.math.harvard.edu";
65 const char* kTopLevelDomainPlus2Secure = "https://www.math.harvard.edu";
66 const char* kTopLevelDomainPlus3 =
67 "http://www.bourbaki.math.harvard.edu";
68 const char* kOtherDomain = "http://www.mit.edu";
69 const char kUrlGoogleSpecific[] = "http://www.gmail.google.izzle";
70
71 class GetCookieListCallback : public CookieCallback {
72 public:
73 GetCookieListCallback() {}
74 explicit GetCookieListCallback(Thread* run_in_thread)
75 : CookieCallback(run_in_thread) {}
76
77 void Run(const CookieList& cookies) {
78 cookies_ = cookies;
79 CallbackEpilogue();
80 }
81
82 const CookieList& cookies() { return cookies_; }
83
84 private:
85 CookieList cookies_;
86 };
87
88 struct CookieMonsterTestTraits {
89 static scoped_refptr<CookieStore> Create() {
90 return new CookieMonster(NULL, NULL);
91 }
92
93 static const bool is_cookie_monster = true;
94 static const bool supports_http_only = true;
95 static const bool supports_non_dotted_domains = true;
96 static const bool supports_trailing_dots = true;
97 static const bool filters_schemes = true;
98 static const bool has_path_prefix_bug = false;
99 static const int creation_time_granularity_in_ms = 0;
100 };
101
102 INSTANTIATE_TYPED_TEST_CASE_P(CookieMonster,
103 CookieStoreTest,
104 CookieMonsterTestTraits);
105
106 INSTANTIATE_TYPED_TEST_CASE_P(CookieMonster,
107 MultiThreadedCookieStoreTest,
108 CookieMonsterTestTraits);
109
110 class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
111 protected:
112
113 CookieList GetAllCookies(CookieMonster* cm) {
114 DCHECK(cm);
115 GetCookieListCallback callback;
116 cm->GetAllCookiesAsync(
117 base::Bind(&GetCookieListCallback::Run,
118 base::Unretained(&callback)));
119 RunFor(kTimeout);
120 EXPECT_TRUE(callback.did_run());
121 return callback.cookies();
122 }
123
124 CookieList GetAllCookiesForURL(CookieMonster* cm,
125 const GURL& url) {
126 DCHECK(cm);
127 GetCookieListCallback callback;
128 cm->GetAllCookiesForURLAsync(
129 url, base::Bind(&GetCookieListCallback::Run,
130 base::Unretained(&callback)));
131 RunFor(kTimeout);
132 EXPECT_TRUE(callback.did_run());
133 return callback.cookies();
134 }
135
136 CookieList GetAllCookiesForURLWithOptions(CookieMonster* cm,
137 const GURL& url,
138 const CookieOptions& options) {
139 DCHECK(cm);
140 GetCookieListCallback callback;
141 cm->GetAllCookiesForURLWithOptionsAsync(
142 url, options, base::Bind(&GetCookieListCallback::Run,
143 base::Unretained(&callback)));
144 RunFor(kTimeout);
145 EXPECT_TRUE(callback.did_run());
146 return callback.cookies();
147 }
148
149 bool SetCookieWithDetails(CookieMonster* cm,
150 const GURL& url,
151 const std::string& name,
152 const std::string& value,
153 const std::string& domain,
154 const std::string& path,
155 const base::Time& expiration_time,
156 bool secure,
157 bool http_only,
158 CookiePriority priority) {
159 DCHECK(cm);
160 ResultSavingCookieCallback<bool> callback;
161 cm->SetCookieWithDetailsAsync(
162 url, name, value, domain, path, expiration_time, secure, http_only,
163 priority,
164 base::Bind(
165 &ResultSavingCookieCallback<bool>::Run,
166 base::Unretained(&callback)));
167 RunFor(kTimeout);
168 EXPECT_TRUE(callback.did_run());
169 return callback.result();
170 }
171
172 int DeleteAll(CookieMonster*cm) {
173 DCHECK(cm);
174 ResultSavingCookieCallback<int> callback;
175 cm->DeleteAllAsync(
176 base::Bind(
177 &ResultSavingCookieCallback<int>::Run,
178 base::Unretained(&callback)));
179 RunFor(kTimeout);
180 EXPECT_TRUE(callback.did_run());
181 return callback.result();
182 }
183
184 int DeleteAllCreatedBetween(CookieMonster*cm,
185 const base::Time& delete_begin,
186 const base::Time& delete_end) {
187 DCHECK(cm);
188 ResultSavingCookieCallback<int> callback;
189 cm->DeleteAllCreatedBetweenAsync(
190 delete_begin, delete_end,
191 base::Bind(
192 &ResultSavingCookieCallback<int>::Run,
193 base::Unretained(&callback)));
194 RunFor(kTimeout);
195 EXPECT_TRUE(callback.did_run());
196 return callback.result();
197 }
198
199 int DeleteAllCreatedBetweenForHost(CookieMonster* cm,
200 const base::Time delete_begin,
201 const base::Time delete_end,
202 const GURL& url) {
203 DCHECK(cm);
204 ResultSavingCookieCallback<int> callback;
205 cm->DeleteAllCreatedBetweenForHostAsync(
206 delete_begin, delete_end, url,
207 base::Bind(
208 &ResultSavingCookieCallback<int>::Run,
209 base::Unretained(&callback)));
210 RunFor(kTimeout);
211 EXPECT_TRUE(callback.did_run());
212 return callback.result();
213 }
214
215 int DeleteAllForHost(CookieMonster* cm,
216 const GURL& url) {
217 DCHECK(cm);
218 ResultSavingCookieCallback<int> callback;
219 cm->DeleteAllForHostAsync(
220 url, base::Bind(&ResultSavingCookieCallback<int>::Run,
221 base::Unretained(&callback)));
222 RunFor(kTimeout);
223 EXPECT_TRUE(callback.did_run());
224 return callback.result();
225 }
226
227 bool DeleteCanonicalCookie(CookieMonster* cm, const CanonicalCookie& cookie) {
228 DCHECK(cm);
229 ResultSavingCookieCallback<bool> callback;
230 cm->DeleteCanonicalCookieAsync(
231 cookie,
232 base::Bind(&ResultSavingCookieCallback<bool>::Run,
233 base::Unretained(&callback)));
234 RunFor(kTimeout);
235 EXPECT_TRUE(callback.did_run());
236 return callback.result();
237 }
238
239 // Helper for DeleteAllForHost test; repopulates CM with same layout
240 // each time.
241 void PopulateCmForDeleteAllForHost(scoped_refptr<CookieMonster> cm) {
242 GURL url_top_level_domain_plus_1(kTopLevelDomainPlus1);
243 GURL url_top_level_domain_plus_2(kTopLevelDomainPlus2);
244 GURL url_top_level_domain_plus_2_secure(kTopLevelDomainPlus2Secure);
245 GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3);
246 GURL url_other(kOtherDomain);
247
248 DeleteAll(cm.get());
249
250 // Static population for probe:
251 // * Three levels of domain cookie (.b.a, .c.b.a, .d.c.b.a)
252 // * Three levels of host cookie (w.b.a, w.c.b.a, w.d.c.b.a)
253 // * http_only cookie (w.c.b.a)
254 // * Two secure cookies (.c.b.a, w.c.b.a)
255 // * Two domain path cookies (.c.b.a/dir1, .c.b.a/dir1/dir2)
256 // * Two host path cookies (w.c.b.a/dir1, w.c.b.a/dir1/dir2)
257
258 // Domain cookies
259 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
260 url_top_level_domain_plus_1,
261 "dom_1",
262 "X",
263 ".harvard.edu",
264 "/",
265 base::Time(),
266 false,
267 false,
268 COOKIE_PRIORITY_DEFAULT));
269 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
270 url_top_level_domain_plus_2,
271 "dom_2",
272 "X",
273 ".math.harvard.edu",
274 "/",
275 base::Time(),
276 false,
277 false,
278 COOKIE_PRIORITY_DEFAULT));
279 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
280 url_top_level_domain_plus_3,
281 "dom_3",
282 "X",
283 ".bourbaki.math.harvard.edu",
284 "/",
285 base::Time(),
286 false,
287 false,
288 COOKIE_PRIORITY_DEFAULT));
289
290 // Host cookies
291 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
292 url_top_level_domain_plus_1,
293 "host_1",
294 "X",
295 std::string(),
296 "/",
297 base::Time(),
298 false,
299 false,
300 COOKIE_PRIORITY_DEFAULT));
301 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
302 url_top_level_domain_plus_2,
303 "host_2",
304 "X",
305 std::string(),
306 "/",
307 base::Time(),
308 false,
309 false,
310 COOKIE_PRIORITY_DEFAULT));
311 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
312 url_top_level_domain_plus_3,
313 "host_3",
314 "X",
315 std::string(),
316 "/",
317 base::Time(),
318 false,
319 false,
320 COOKIE_PRIORITY_DEFAULT));
321
322 // Http_only cookie
323 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
324 url_top_level_domain_plus_2,
325 "httpo_check",
326 "X",
327 std::string(),
328 "/",
329 base::Time(),
330 false,
331 true,
332 COOKIE_PRIORITY_DEFAULT));
333
334 // Secure cookies
335 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
336 url_top_level_domain_plus_2_secure,
337 "sec_dom",
338 "X",
339 ".math.harvard.edu",
340 "/",
341 base::Time(),
342 true,
343 false,
344 COOKIE_PRIORITY_DEFAULT));
345 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
346 url_top_level_domain_plus_2_secure,
347 "sec_host",
348 "X",
349 std::string(),
350 "/",
351 base::Time(),
352 true,
353 false,
354 COOKIE_PRIORITY_DEFAULT));
355
356 // Domain path cookies
357 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
358 url_top_level_domain_plus_2,
359 "dom_path_1",
360 "X",
361 ".math.harvard.edu",
362 "/dir1",
363 base::Time(),
364 false,
365 false,
366 COOKIE_PRIORITY_DEFAULT));
367 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
368 url_top_level_domain_plus_2,
369 "dom_path_2",
370 "X",
371 ".math.harvard.edu",
372 "/dir1/dir2",
373 base::Time(),
374 false,
375 false,
376 COOKIE_PRIORITY_DEFAULT));
377
378 // Host path cookies
379 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
380 url_top_level_domain_plus_2,
381 "host_path_1",
382 "X",
383 std::string(),
384 "/dir1",
385 base::Time(),
386 false,
387 false,
388 COOKIE_PRIORITY_DEFAULT));
389 EXPECT_TRUE(this->SetCookieWithDetails(cm.get(),
390 url_top_level_domain_plus_2,
391 "host_path_2",
392 "X",
393 std::string(),
394 "/dir1/dir2",
395 base::Time(),
396 false,
397 false,
398 COOKIE_PRIORITY_DEFAULT));
399
400 EXPECT_EQ(13U, this->GetAllCookies(cm.get()).size());
401 }
402
403 Time GetFirstCookieAccessDate(CookieMonster* cm) {
404 const CookieList all_cookies(this->GetAllCookies(cm));
405 return all_cookies.front().LastAccessDate();
406 }
407
408 bool FindAndDeleteCookie(CookieMonster* cm,
409 const std::string& domain,
410 const std::string& name) {
411 CookieList cookies = this->GetAllCookies(cm);
412 for (CookieList::iterator it = cookies.begin();
413 it != cookies.end(); ++it)
414 if (it->Domain() == domain && it->Name() == name)
415 return this->DeleteCanonicalCookie(cm, *it);
416 return false;
417 }
418
419 int CountInString(const std::string& str, char c) {
420 return std::count(str.begin(), str.end(), c);
421 }
422
423 void TestHostGarbageCollectHelper() {
424 int domain_max_cookies = CookieMonster::kDomainMaxCookies;
425 int domain_purge_cookies = CookieMonster::kDomainPurgeCookies;
426 const int more_than_enough_cookies =
427 (domain_max_cookies + domain_purge_cookies) * 2;
428 // Add a bunch of cookies on a single host, should purge them.
429 {
430 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
431 for (int i = 0; i < more_than_enough_cookies; ++i) {
432 std::string cookie = base::StringPrintf("a%03d=b", i);
433 EXPECT_TRUE(SetCookie(cm.get(), url_google_, cookie));
434 std::string cookies = this->GetCookies(cm.get(), url_google_);
435 // Make sure we find it in the cookies.
436 EXPECT_NE(cookies.find(cookie), std::string::npos);
437 // Count the number of cookies.
438 EXPECT_LE(CountInString(cookies, '='), domain_max_cookies);
439 }
440 }
441
442 // Add a bunch of cookies on multiple hosts within a single eTLD.
443 // Should keep at least kDomainMaxCookies - kDomainPurgeCookies
444 // between them. We shouldn't go above kDomainMaxCookies for both together.
445 GURL url_google_specific(kUrlGoogleSpecific);
446 {
447 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
448 for (int i = 0; i < more_than_enough_cookies; ++i) {
449 std::string cookie_general = base::StringPrintf("a%03d=b", i);
450 EXPECT_TRUE(SetCookie(cm.get(), url_google_, cookie_general));
451 std::string cookie_specific = base::StringPrintf("c%03d=b", i);
452 EXPECT_TRUE(SetCookie(cm.get(), url_google_specific, cookie_specific));
453 std::string cookies_general = this->GetCookies(cm.get(), url_google_);
454 EXPECT_NE(cookies_general.find(cookie_general), std::string::npos);
455 std::string cookies_specific =
456 this->GetCookies(cm.get(), url_google_specific);
457 EXPECT_NE(cookies_specific.find(cookie_specific), std::string::npos);
458 EXPECT_LE((CountInString(cookies_general, '=') +
459 CountInString(cookies_specific, '=')),
460 domain_max_cookies);
461 }
462 // After all this, there should be at least
463 // kDomainMaxCookies - kDomainPurgeCookies for both URLs.
464 std::string cookies_general = this->GetCookies(cm.get(), url_google_);
465 std::string cookies_specific =
466 this->GetCookies(cm.get(), url_google_specific);
467 int total_cookies = (CountInString(cookies_general, '=') +
468 CountInString(cookies_specific, '='));
469 EXPECT_GE(total_cookies, domain_max_cookies - domain_purge_cookies);
470 EXPECT_LE(total_cookies, domain_max_cookies);
471 }
472 }
473
474 CookiePriority CharToPriority(char ch) {
475 switch (ch) {
476 case 'L':
477 return COOKIE_PRIORITY_LOW;
478 case 'M':
479 return COOKIE_PRIORITY_MEDIUM;
480 case 'H':
481 return COOKIE_PRIORITY_HIGH;
482 }
483 NOTREACHED();
484 return COOKIE_PRIORITY_DEFAULT;
485 }
486
487 // Instantiates a CookieMonster, adds multiple cookies (to url_google_) with
488 // priorities specified by |coded_priority_str|, and tests priority-aware
489 // domain cookie eviction.
490 // |coded_priority_str| specifies a run-length-encoded string of priorities.
491 // Example: "2M 3L M 4H" means "MMLLLMHHHH", and speicifies sequential (i.e.,
492 // from least- to most-recently accessed) insertion of 2 medium-priority
493 // cookies, 3 low-priority cookies, 1 medium-priority cookie, and 4
494 // high-priority cookies.
495 // Within each priority, only the least-accessed cookies should be evicted.
496 // Thus, to describe expected suriving cookies, it suffices to specify the
497 // expected population of surviving cookies per priority, i.e.,
498 // |expected_low_count|, |expected_medium_count|, and |expected_high_count|.
499 void TestPriorityCookieCase(CookieMonster* cm,
500 const std::string& coded_priority_str,
501 size_t expected_low_count,
502 size_t expected_medium_count,
503 size_t expected_high_count) {
504 DeleteAll(cm);
505 int next_cookie_id = 0;
506 std::vector<CookiePriority> priority_list;
507 std::vector<int> id_list[3]; // Indexed by CookiePriority.
508
509 // Parse |coded_priority_str| and add cookies.
510 std::vector<std::string> priority_tok_list;
511 base::SplitString(coded_priority_str, ' ', &priority_tok_list);
512 for (std::vector<std::string>::iterator it = priority_tok_list.begin();
513 it != priority_tok_list.end(); ++it) {
514 size_t len = it->length();
515 DCHECK_NE(len, 0U);
516 // Take last character as priority.
517 CookiePriority priority = CharToPriority((*it)[len - 1]);
518 std::string priority_str = CookiePriorityToString(priority);
519 // The rest of the string (possibly empty) specifies repetition.
520 int rep = 1;
521 if (!it->empty()) {
522 bool result = base::StringToInt(
523 base::StringPiece(it->begin(), it->end() - 1), &rep);
524 DCHECK(result);
525 }
526 for (; rep > 0; --rep, ++next_cookie_id) {
527 std::string cookie = base::StringPrintf(
528 "a%d=b;priority=%s", next_cookie_id, priority_str.c_str());
529 EXPECT_TRUE(SetCookie(cm, url_google_, cookie));
530 priority_list.push_back(priority);
531 id_list[priority].push_back(next_cookie_id);
532 }
533 }
534
535 int num_cookies = static_cast<int>(priority_list.size());
536 std::vector<int> surviving_id_list[3]; // Indexed by CookiePriority.
537
538 // Parse the list of cookies
539 std::string cookie_str = this->GetCookies(cm, url_google_);
540 std::vector<std::string> cookie_tok_list;
541 base::SplitString(cookie_str, ';', &cookie_tok_list);
542 for (std::vector<std::string>::iterator it = cookie_tok_list.begin();
543 it != cookie_tok_list.end(); ++it) {
544 // Assuming *it is "a#=b", so extract and parse "#" portion.
545 int id = -1;
546 bool result = base::StringToInt(
547 base::StringPiece(it->begin() + 1, it->end() - 2), &id);
548 DCHECK(result);
549 DCHECK_GE(id, 0);
550 DCHECK_LT(id, num_cookies);
551 surviving_id_list[priority_list[id]].push_back(id);
552 }
553
554 // Validate each priority.
555 size_t expected_count[3] = {
556 expected_low_count, expected_medium_count, expected_high_count
557 };
558 for (int i = 0; i < 3; ++i) {
559 DCHECK_LE(surviving_id_list[i].size(), id_list[i].size());
560 EXPECT_EQ(expected_count[i], surviving_id_list[i].size());
561 // Verify that the remaining cookies are the most recent among those
562 // with the same priorities.
563 if (expected_count[i] == surviving_id_list[i].size()) {
564 std::sort(surviving_id_list[i].begin(), surviving_id_list[i].end());
565 EXPECT_TRUE(std::equal(surviving_id_list[i].begin(),
566 surviving_id_list[i].end(),
567 id_list[i].end() - expected_count[i]));
568 }
569 }
570 }
571
572 void TestPriorityAwareGarbageCollectHelper() {
573 // Hard-coding limits in the test, but use DCHECK_EQ to enforce constraint.
574 DCHECK_EQ(180U, CookieMonster::kDomainMaxCookies);
575 DCHECK_EQ(150U, CookieMonster::kDomainMaxCookies -
576 CookieMonster::kDomainPurgeCookies);
577 DCHECK_EQ(30U, CookieMonster::kDomainCookiesQuotaLow);
578 DCHECK_EQ(50U, CookieMonster::kDomainCookiesQuotaMedium);
579 DCHECK_EQ(70U, CookieMonster::kDomainCookiesQuotaHigh);
580
581 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
582
583 // Each test case adds 181 cookies, so 31 cookies are evicted.
584 // Cookie same priority, repeated for each priority.
585 TestPriorityCookieCase(cm.get(), "181L", 150U, 0U, 0U);
586 TestPriorityCookieCase(cm.get(), "181M", 0U, 150U, 0U);
587 TestPriorityCookieCase(cm.get(), "181H", 0U, 0U, 150U);
588
589 // Pairwise scenarios.
590 // Round 1 => none; round2 => 31M; round 3 => none.
591 TestPriorityCookieCase(cm.get(), "10H 171M", 0U, 140U, 10U);
592 // Round 1 => 10L; round2 => 21M; round 3 => none.
593 TestPriorityCookieCase(cm.get(), "141M 40L", 30U, 120U, 0U);
594 // Round 1 => none; round2 => none; round 3 => 31H.
595 TestPriorityCookieCase(cm.get(), "101H 80M", 0U, 80U, 70U);
596
597 // For {low, medium} priorities right on quota, different orders.
598 // Round 1 => 1L; round 2 => none, round3 => 30L.
599 TestPriorityCookieCase(cm.get(), "31L 50M 100H", 0U, 50U, 100U);
600 // Round 1 => none; round 2 => 1M, round3 => 30M.
601 TestPriorityCookieCase(cm.get(), "51M 100H 30L", 30U, 20U, 100U);
602 // Round 1 => none; round 2 => none; round3 => 31H.
603 TestPriorityCookieCase(cm.get(), "101H 50M 30L", 30U, 50U, 70U);
604
605 // Round 1 => 10L; round 2 => 10M; round3 => 11H.
606 TestPriorityCookieCase(cm.get(), "81H 60M 40L", 30U, 50U, 70U);
607
608 // More complex scenarios.
609 // Round 1 => 10L; round 2 => 10M; round 3 => 11H.
610 TestPriorityCookieCase(cm.get(), "21H 60M 40L 60H", 30U, 50U, 70U);
611 // Round 1 => 10L; round 2 => 11M, 10L; round 3 => none.
612 TestPriorityCookieCase(
613 cm.get(), "11H 10M 20L 110M 20L 10H", 20U, 109U, 21U);
614 // Round 1 => none; round 2 => none; round 3 => 11L, 10M, 10H.
615 TestPriorityCookieCase(cm.get(), "11L 10M 140H 10M 10L", 10U, 10U, 130U);
616 // Round 1 => none; round 2 => 1M; round 3 => 10L, 10M, 10H.
617 TestPriorityCookieCase(cm.get(), "11M 10H 10L 60M 90H", 0U, 60U, 90U);
618 // Round 1 => none; round 2 => 10L, 21M; round 3 => none.
619 TestPriorityCookieCase(cm.get(), "11M 10H 10L 90M 60H", 0U, 80U, 70U);
620 }
621
622 // Function for creating a CM with a number of cookies in it,
623 // no store (and hence no ability to affect access time).
624 CookieMonster* CreateMonsterForGC(int num_cookies) {
625 CookieMonster* cm(new CookieMonster(NULL, NULL));
626 for (int i = 0; i < num_cookies; i++) {
627 SetCookie(cm, GURL(base::StringPrintf("http://h%05d.izzle", i)), "a=1");
628 }
629 return cm;
630 }
631 };
632
633 // TODO(erikwright): Replace the other callbacks and synchronous helper methods
634 // in this test suite with these Mocks.
635 template<typename T, typename C> class MockCookieCallback {
636 public:
637 C AsCallback() {
638 return base::Bind(&T::Invoke, base::Unretained(static_cast<T*>(this)));
639 }
640 };
641
642 class MockGetCookiesCallback
643 : public MockCookieCallback<MockGetCookiesCallback,
644 CookieStore::GetCookiesCallback> {
645 public:
646 MOCK_METHOD1(Invoke, void(const std::string& cookies));
647 };
648
649 class MockSetCookiesCallback
650 : public MockCookieCallback<MockSetCookiesCallback,
651 CookieStore::SetCookiesCallback> {
652 public:
653 MOCK_METHOD1(Invoke, void(bool success));
654 };
655
656 class MockClosure
657 : public MockCookieCallback<MockClosure, base::Closure> {
658 public:
659 MOCK_METHOD0(Invoke, void(void));
660 };
661
662 class MockGetCookieListCallback
663 : public MockCookieCallback<MockGetCookieListCallback,
664 CookieMonster::GetCookieListCallback> {
665 public:
666 MOCK_METHOD1(Invoke, void(const CookieList& cookies));
667 };
668
669 class MockDeleteCallback
670 : public MockCookieCallback<MockDeleteCallback,
671 CookieMonster::DeleteCallback> {
672 public:
673 MOCK_METHOD1(Invoke, void(int num_deleted));
674 };
675
676 class MockDeleteCookieCallback
677 : public MockCookieCallback<MockDeleteCookieCallback,
678 CookieMonster::DeleteCookieCallback> {
679 public:
680 MOCK_METHOD1(Invoke, void(bool success));
681 };
682
683 struct CookiesInputInfo {
684 const GURL url;
685 const std::string name;
686 const std::string value;
687 const std::string domain;
688 const std::string path;
689 const base::Time expiration_time;
690 bool secure;
691 bool http_only;
692 CookiePriority priority;
693 };
694
695 ACTION(QuitCurrentMessageLoop) {
696 base::MessageLoop::current()->PostTask(FROM_HERE,
697 base::MessageLoop::QuitClosure());
698 }
699
700 // TODO(erikwright): When the synchronous helpers 'GetCookies' etc. are removed,
701 // rename these, removing the 'Action' suffix.
702 ACTION_P4(DeleteCookieAction, cookie_monster, url, name, callback) {
703 cookie_monster->DeleteCookieAsync(url, name, callback->AsCallback());
704 }
705 ACTION_P3(GetCookiesAction, cookie_monster, url, callback) {
706 cookie_monster->GetCookiesWithOptionsAsync(
707 url, CookieOptions(), callback->AsCallback());
708 }
709 ACTION_P4(SetCookieAction, cookie_monster, url, cookie_line, callback) {
710 cookie_monster->SetCookieWithOptionsAsync(
711 url, cookie_line, CookieOptions(), callback->AsCallback());
712 }
713 ACTION_P4(DeleteAllCreatedBetweenAction,
714 cookie_monster, delete_begin, delete_end, callback) {
715 cookie_monster->DeleteAllCreatedBetweenAsync(
716 delete_begin, delete_end, callback->AsCallback());
717 }
718 ACTION_P3(SetCookieWithDetailsAction, cookie_monster, cc, callback) {
719 cookie_monster->SetCookieWithDetailsAsync(
720 cc.url, cc.name, cc.value, cc.domain, cc.path, cc.expiration_time,
721 cc.secure, cc.http_only, cc.priority,
722 callback->AsCallback());
723 }
724
725 ACTION_P2(GetAllCookiesAction, cookie_monster, callback) {
726 cookie_monster->GetAllCookiesAsync(callback->AsCallback());
727 }
728
729 ACTION_P3(DeleteAllForHostAction, cookie_monster, url, callback) {
730 cookie_monster->DeleteAllForHostAsync(url, callback->AsCallback());
731 }
732
733 ACTION_P3(DeleteCanonicalCookieAction, cookie_monster, cookie, callback) {
734 cookie_monster->DeleteCanonicalCookieAsync(cookie, callback->AsCallback());
735 }
736
737 ACTION_P2(DeleteAllAction, cookie_monster, callback) {
738 cookie_monster->DeleteAllAsync(callback->AsCallback());
739 }
740
741 ACTION_P3(GetAllCookiesForUrlWithOptionsAction, cookie_monster, url, callback) {
742 cookie_monster->GetAllCookiesForURLWithOptionsAsync(
743 url, CookieOptions(), callback->AsCallback());
744 }
745
746 ACTION_P3(GetAllCookiesForUrlAction, cookie_monster, url, callback) {
747 cookie_monster->GetAllCookiesForURLAsync(url, callback->AsCallback());
748 }
749
750 ACTION_P(PushCallbackAction, callback_vector) {
751 callback_vector->push(arg1);
752 }
753
754 ACTION_P2(DeleteSessionCookiesAction, cookie_monster, callback) {
755 cookie_monster->DeleteSessionCookiesAsync(callback->AsCallback());
756 }
757
758 } // namespace
759
760 // This test suite verifies the task deferral behaviour of the CookieMonster.
761 // Specifically, for each asynchronous method, verify that:
762 // 1. invoking it on an uninitialized cookie store causes the store to begin
763 // chain-loading its backing data or loading data for a specific domain key
764 // (eTLD+1).
765 // 2. The initial invocation does not complete until the loading completes.
766 // 3. Invocations after the loading has completed complete immediately.
767 class DeferredCookieTaskTest : public CookieMonsterTest {
768 protected:
769 DeferredCookieTaskTest() {
770 persistent_store_ = new NewMockPersistentCookieStore();
771 cookie_monster_ = new CookieMonster(persistent_store_.get(), NULL);
772 }
773
774 // Defines a cookie to be returned from PersistentCookieStore::Load
775 void DeclareLoadedCookie(const std::string& key,
776 const std::string& cookie_line,
777 const base::Time& creation_time) {
778 AddCookieToList(key, cookie_line, creation_time, &loaded_cookies_);
779 }
780
781 // Runs the message loop, waiting until PersistentCookieStore::Load is called.
782 // Call CompleteLoadingAndWait to cause the load to complete.
783 void WaitForLoadCall() {
784 RunFor(kTimeout);
785
786 // Verify that PeristentStore::Load was called.
787 testing::Mock::VerifyAndClear(persistent_store_.get());
788 }
789
790 // Invokes the PersistentCookieStore::LoadCookiesForKey completion callbacks
791 // and PersistentCookieStore::Load completion callback and waits
792 // until the message loop is quit.
793 void CompleteLoadingAndWait() {
794 while (!loaded_for_key_callbacks_.empty()) {
795 loaded_for_key_callbacks_.front().Run(loaded_cookies_);
796 loaded_cookies_.clear();
797 loaded_for_key_callbacks_.pop();
798 }
799
800 loaded_callback_.Run(loaded_cookies_);
801 RunFor(kTimeout);
802 }
803
804 // Performs the provided action, expecting it to cause a call to
805 // PersistentCookieStore::Load. Call WaitForLoadCall to verify the load call
806 // is received.
807 void BeginWith(testing::Action<void(void)> action) {
808 EXPECT_CALL(*this, Begin()).WillOnce(action);
809 ExpectLoadCall();
810 Begin();
811 }
812
813 void BeginWithForDomainKey(std::string key,
814 testing::Action<void(void)> action) {
815 EXPECT_CALL(*this, Begin()).WillOnce(action);
816 ExpectLoadCall();
817 ExpectLoadForKeyCall(key, false);
818 Begin();
819 }
820
821 // Declares an expectation that PersistentCookieStore::Load will be called,
822 // saving the provided callback and sending a quit to the message loop.
823 void ExpectLoadCall() {
824 EXPECT_CALL(*persistent_store_.get(), Load(testing::_))
825 .WillOnce(testing::DoAll(testing::SaveArg<0>(&loaded_callback_),
826 QuitCurrentMessageLoop()));
827 }
828
829 // Declares an expectation that PersistentCookieStore::LoadCookiesForKey
830 // will be called, saving the provided callback and sending a quit to the
831 // message loop.
832 void ExpectLoadForKeyCall(std::string key, bool quit_queue) {
833 if (quit_queue)
834 EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
835 .WillOnce(
836 testing::DoAll(PushCallbackAction(&loaded_for_key_callbacks_),
837 QuitCurrentMessageLoop()));
838 else
839 EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
840 .WillOnce(PushCallbackAction(&loaded_for_key_callbacks_));
841 }
842
843 // Invokes the initial action.
844 MOCK_METHOD0(Begin, void(void));
845
846 // Returns the CookieMonster instance under test.
847 CookieMonster& cookie_monster() { return *cookie_monster_.get(); }
848
849 private:
850 // Declares that mock expectations in this test suite are strictly ordered.
851 testing::InSequence in_sequence_;
852 // Holds cookies to be returned from PersistentCookieStore::Load or
853 // PersistentCookieStore::LoadCookiesForKey.
854 std::vector<CanonicalCookie*> loaded_cookies_;
855 // Stores the callback passed from the CookieMonster to the
856 // PersistentCookieStore::Load
857 CookieMonster::PersistentCookieStore::LoadedCallback loaded_callback_;
858 // Stores the callback passed from the CookieMonster to the
859 // PersistentCookieStore::LoadCookiesForKey
860 std::queue<CookieMonster::PersistentCookieStore::LoadedCallback>
861 loaded_for_key_callbacks_;
862
863 // Stores the CookieMonster under test.
864 scoped_refptr<CookieMonster> cookie_monster_;
865 // Stores the mock PersistentCookieStore.
866 scoped_refptr<NewMockPersistentCookieStore> persistent_store_;
867 };
868
869 TEST_F(DeferredCookieTaskTest, DeferredGetCookies) {
870 DeclareLoadedCookie("www.google.izzle",
871 "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
872 Time::Now() + TimeDelta::FromDays(3));
873
874 MockGetCookiesCallback get_cookies_callback;
875
876 BeginWithForDomainKey("google.izzle", GetCookiesAction(
877 &cookie_monster(), url_google_, &get_cookies_callback));
878
879 WaitForLoadCall();
880
881 EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce(
882 GetCookiesAction(&cookie_monster(), url_google_, &get_cookies_callback));
883 EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce(
884 QuitCurrentMessageLoop());
885
886 CompleteLoadingAndWait();
887 }
888
889 TEST_F(DeferredCookieTaskTest, DeferredSetCookie) {
890 MockSetCookiesCallback set_cookies_callback;
891
892 BeginWithForDomainKey("google.izzle", SetCookieAction(
893 &cookie_monster(), url_google_, "A=B", &set_cookies_callback));
894
895 WaitForLoadCall();
896
897 EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
898 SetCookieAction(
899 &cookie_monster(), url_google_, "X=Y", &set_cookies_callback));
900 EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
901 QuitCurrentMessageLoop());
902
903 CompleteLoadingAndWait();
904 }
905
906 TEST_F(DeferredCookieTaskTest, DeferredDeleteCookie) {
907 MockClosure delete_cookie_callback;
908
909 BeginWithForDomainKey("google.izzle", DeleteCookieAction(
910 &cookie_monster(), url_google_, "A", &delete_cookie_callback));
911
912 WaitForLoadCall();
913
914 EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce(
915 DeleteCookieAction(
916 &cookie_monster(), url_google_, "X", &delete_cookie_callback));
917 EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce(
918 QuitCurrentMessageLoop());
919
920 CompleteLoadingAndWait();
921 }
922
923 TEST_F(DeferredCookieTaskTest, DeferredSetCookieWithDetails) {
924 MockSetCookiesCallback set_cookies_callback;
925
926 CookiesInputInfo cookie_info = {
927 url_google_foo_, "A", "B", std::string(), "/foo",
928 base::Time(), false, false, COOKIE_PRIORITY_DEFAULT
929 };
930 BeginWithForDomainKey("google.izzle", SetCookieWithDetailsAction(
931 &cookie_monster(), cookie_info, &set_cookies_callback));
932
933 WaitForLoadCall();
934
935 CookiesInputInfo cookie_info_exp = {
936 url_google_foo_, "A", "B", std::string(), "/foo",
937 base::Time(), false, false, COOKIE_PRIORITY_DEFAULT
938 };
939 EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
940 SetCookieWithDetailsAction(
941 &cookie_monster(), cookie_info_exp, &set_cookies_callback));
942 EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(
943 QuitCurrentMessageLoop());
944
945 CompleteLoadingAndWait();
946 }
947
948 TEST_F(DeferredCookieTaskTest, DeferredGetAllCookies) {
949 DeclareLoadedCookie("www.google.izzle",
950 "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
951 Time::Now() + TimeDelta::FromDays(3));
952
953 MockGetCookieListCallback get_cookie_list_callback;
954
955 BeginWith(GetAllCookiesAction(
956 &cookie_monster(), &get_cookie_list_callback));
957
958 WaitForLoadCall();
959
960 EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
961 GetAllCookiesAction(&cookie_monster(), &get_cookie_list_callback));
962 EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
963 QuitCurrentMessageLoop());
964
965 CompleteLoadingAndWait();
966 }
967
968 TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlCookies) {
969 DeclareLoadedCookie("www.google.izzle",
970 "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
971 Time::Now() + TimeDelta::FromDays(3));
972
973 MockGetCookieListCallback get_cookie_list_callback;
974
975 BeginWithForDomainKey("google.izzle", GetAllCookiesForUrlAction(
976 &cookie_monster(), url_google_, &get_cookie_list_callback));
977
978 WaitForLoadCall();
979
980 EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
981 GetAllCookiesForUrlAction(
982 &cookie_monster(), url_google_, &get_cookie_list_callback));
983 EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
984 QuitCurrentMessageLoop());
985
986 CompleteLoadingAndWait();
987 }
988
989 TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlWithOptionsCookies) {
990 DeclareLoadedCookie("www.google.izzle",
991 "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
992 Time::Now() + TimeDelta::FromDays(3));
993
994 MockGetCookieListCallback get_cookie_list_callback;
995
996 BeginWithForDomainKey("google.izzle", GetAllCookiesForUrlWithOptionsAction(
997 &cookie_monster(), url_google_, &get_cookie_list_callback));
998
999 WaitForLoadCall();
1000
1001 EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
1002 GetAllCookiesForUrlWithOptionsAction(
1003 &cookie_monster(), url_google_, &get_cookie_list_callback));
1004 EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce(
1005 QuitCurrentMessageLoop());
1006
1007 CompleteLoadingAndWait();
1008 }
1009
1010 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCookies) {
1011 MockDeleteCallback delete_callback;
1012
1013 BeginWith(DeleteAllAction(
1014 &cookie_monster(), &delete_callback));
1015
1016 WaitForLoadCall();
1017
1018 EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
1019 DeleteAllAction(&cookie_monster(), &delete_callback));
1020 EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
1021 QuitCurrentMessageLoop());
1022
1023 CompleteLoadingAndWait();
1024 }
1025
1026 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCreatedBetweenCookies) {
1027 MockDeleteCallback delete_callback;
1028
1029 BeginWith(DeleteAllCreatedBetweenAction(
1030 &cookie_monster(), base::Time(), base::Time::Now(), &delete_callback));
1031
1032 WaitForLoadCall();
1033
1034 EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
1035 DeleteAllCreatedBetweenAction(
1036 &cookie_monster(), base::Time(), base::Time::Now(),
1037 &delete_callback));
1038 EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
1039 QuitCurrentMessageLoop());
1040
1041 CompleteLoadingAndWait();
1042 }
1043
1044 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllForHostCookies) {
1045 MockDeleteCallback delete_callback;
1046
1047 BeginWithForDomainKey("google.izzle", DeleteAllForHostAction(
1048 &cookie_monster(), url_google_, &delete_callback));
1049
1050 WaitForLoadCall();
1051
1052 EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
1053 DeleteAllForHostAction(
1054 &cookie_monster(), url_google_, &delete_callback));
1055 EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
1056 QuitCurrentMessageLoop());
1057
1058 CompleteLoadingAndWait();
1059 }
1060
1061 TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) {
1062 std::vector<CanonicalCookie*> cookies;
1063 CanonicalCookie cookie = BuildCanonicalCookie(
1064 "www.google.com", "X=1; path=/", base::Time::Now());
1065
1066 MockDeleteCookieCallback delete_cookie_callback;
1067
1068 BeginWith(DeleteCanonicalCookieAction(
1069 &cookie_monster(), cookie, &delete_cookie_callback));
1070
1071 WaitForLoadCall();
1072
1073 EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce(
1074 DeleteCanonicalCookieAction(
1075 &cookie_monster(), cookie, &delete_cookie_callback));
1076 EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce(
1077 QuitCurrentMessageLoop());
1078
1079 CompleteLoadingAndWait();
1080 }
1081
1082 TEST_F(DeferredCookieTaskTest, DeferredDeleteSessionCookies) {
1083 MockDeleteCallback delete_callback;
1084
1085 BeginWith(DeleteSessionCookiesAction(
1086 &cookie_monster(), &delete_callback));
1087
1088 WaitForLoadCall();
1089
1090 EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
1091 DeleteSessionCookiesAction(&cookie_monster(), &delete_callback));
1092 EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
1093 QuitCurrentMessageLoop());
1094
1095 CompleteLoadingAndWait();
1096 }
1097
1098 // Verify that a series of queued tasks are executed in order upon loading of
1099 // the backing store and that new tasks received while the queued tasks are
1100 // being dispatched go to the end of the queue.
1101 TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) {
1102 DeclareLoadedCookie("www.google.izzle",
1103 "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
1104 Time::Now() + TimeDelta::FromDays(3));
1105
1106 MockGetCookiesCallback get_cookies_callback;
1107 MockSetCookiesCallback set_cookies_callback;
1108 MockGetCookiesCallback get_cookies_callback_deferred;
1109
1110 EXPECT_CALL(*this, Begin()).WillOnce(testing::DoAll(
1111 GetCookiesAction(
1112 &cookie_monster(), url_google_, &get_cookies_callback),
1113 SetCookieAction(
1114 &cookie_monster(), url_google_, "A=B", &set_cookies_callback)));
1115 ExpectLoadCall();
1116 ExpectLoadForKeyCall("google.izzle", false);
1117 Begin();
1118
1119 WaitForLoadCall();
1120 EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce(
1121 GetCookiesAction(
1122 &cookie_monster(), url_google_, &get_cookies_callback_deferred));
1123 EXPECT_CALL(set_cookies_callback, Invoke(true));
1124 EXPECT_CALL(get_cookies_callback_deferred, Invoke("A=B; X=1")).WillOnce(
1125 QuitCurrentMessageLoop());
1126
1127 CompleteLoadingAndWait();
1128 }
1129
1130 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
1131 scoped_refptr<MockPersistentCookieStore> store(
1132 new MockPersistentCookieStore);
1133 scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
1134 CookieOptions options;
1135 options.set_include_httponly();
1136
1137 EXPECT_TRUE(SetCookie(cm.get(), url_google_, kValidCookieLine));
1138 EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
1139
1140 EXPECT_TRUE(
1141 SetCookieWithOptions(cm.get(), url_google_, "C=D; httponly", options));
1142 EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm.get(), url_google_, options));
1143
1144 EXPECT_EQ(2, DeleteAll(cm.get()));
1145 EXPECT_EQ("", GetCookiesWithOptions(cm.get(), url_google_, options));
1146 EXPECT_EQ(0u, store->commands().size());
1147
1148 // Create a persistent cookie.
1149 EXPECT_TRUE(SetCookie(
1150 cm.get(),
1151 url_google_,
1152 std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
1153 ASSERT_EQ(1u, store->commands().size());
1154 EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
1155
1156 EXPECT_EQ(1, DeleteAll(cm.get())); // sync_to_store = true.
1157 ASSERT_EQ(2u, store->commands().size());
1158 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
1159
1160 EXPECT_EQ("", GetCookiesWithOptions(cm.get(), url_google_, options));
1161 }
1162
1163 TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
1164 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1165 Time now = Time::Now();
1166
1167 // Nothing has been added so nothing should be deleted.
1168 EXPECT_EQ(
1169 0,
1170 DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99), Time()));
1171
1172 // Create 3 cookies with creation date of today, yesterday and the day before.
1173 EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-0=Now", now));
1174 EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-1=Yesterday",
1175 now - TimeDelta::FromDays(1)));
1176 EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-2=DayBefore",
1177 now - TimeDelta::FromDays(2)));
1178 EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-3=ThreeDays",
1179 now - TimeDelta::FromDays(3)));
1180 EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-7=LastWeek",
1181 now - TimeDelta::FromDays(7)));
1182
1183 // Try to delete threedays and the daybefore.
1184 EXPECT_EQ(2,
1185 DeleteAllCreatedBetween(cm.get(),
1186 now - TimeDelta::FromDays(3),
1187 now - TimeDelta::FromDays(1)));
1188
1189 // Try to delete yesterday, also make sure that delete_end is not
1190 // inclusive.
1191 EXPECT_EQ(
1192 1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(2), now));
1193
1194 // Make sure the delete_begin is inclusive.
1195 EXPECT_EQ(
1196 1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(7), now));
1197
1198 // Delete the last (now) item.
1199 EXPECT_EQ(1, DeleteAllCreatedBetween(cm.get(), Time(), Time()));
1200
1201 // Really make sure everything is gone.
1202 EXPECT_EQ(0, DeleteAll(cm.get()));
1203 }
1204
1205 static const int kAccessDelayMs = kLastAccessThresholdMilliseconds + 20;
1206
1207 TEST_F(CookieMonsterTest, TestLastAccess) {
1208 scoped_refptr<CookieMonster> cm(
1209 new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
1210
1211 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
1212 const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
1213
1214 // Reading the cookie again immediately shouldn't update the access date,
1215 // since we're inside the threshold.
1216 EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
1217 EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm.get()));
1218
1219 // Reading after a short wait should update the access date.
1220 base::PlatformThread::Sleep(
1221 base::TimeDelta::FromMilliseconds(kAccessDelayMs));
1222 EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
1223 EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm.get()));
1224 }
1225
1226 TEST_F(CookieMonsterTest, TestHostGarbageCollection) {
1227 TestHostGarbageCollectHelper();
1228 }
1229
1230 TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollection) {
1231 TestPriorityAwareGarbageCollectHelper();
1232 }
1233
1234 TEST_F(CookieMonsterTest, TestDeleteSingleCookie) {
1235 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1236
1237 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
1238 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "C=D"));
1239 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "E=F"));
1240 EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), url_google_));
1241
1242 EXPECT_TRUE(FindAndDeleteCookie(cm.get(), url_google_.host(), "C"));
1243 EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
1244
1245 EXPECT_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
1246 EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
1247 }
1248
1249 TEST_F(CookieMonsterTest, SetCookieableSchemes) {
1250 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1251 scoped_refptr<CookieMonster> cm_foo(new CookieMonster(NULL, NULL));
1252
1253 // Only cm_foo should allow foo:// cookies.
1254 const char* kSchemes[] = {"foo"};
1255 cm_foo->SetCookieableSchemes(kSchemes, 1);
1256
1257 GURL foo_url("foo://host/path");
1258 GURL http_url("http://host/path");
1259
1260 EXPECT_TRUE(SetCookie(cm.get(), http_url, "x=1"));
1261 EXPECT_FALSE(SetCookie(cm.get(), foo_url, "x=1"));
1262 EXPECT_TRUE(SetCookie(cm_foo.get(), foo_url, "x=1"));
1263 EXPECT_FALSE(SetCookie(cm_foo.get(), http_url, "x=1"));
1264 }
1265
1266 TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
1267 scoped_refptr<CookieMonster> cm(
1268 new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
1269
1270 // Create an httponly cookie.
1271 CookieOptions options;
1272 options.set_include_httponly();
1273
1274 EXPECT_TRUE(
1275 SetCookieWithOptions(cm.get(), url_google_, "A=B; httponly", options));
1276 EXPECT_TRUE(SetCookieWithOptions(
1277 cm.get(), url_google_, "C=D; domain=.google.izzle", options));
1278 EXPECT_TRUE(SetCookieWithOptions(cm.get(),
1279 url_google_secure_,
1280 "E=F; domain=.google.izzle; secure",
1281 options));
1282
1283 const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
1284
1285 base::PlatformThread::Sleep(
1286 base::TimeDelta::FromMilliseconds(kAccessDelayMs));
1287
1288 // Check cookies for url.
1289 CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_);
1290 CookieList::iterator it = cookies.begin();
1291
1292 ASSERT_TRUE(it != cookies.end());
1293 EXPECT_EQ("www.google.izzle", it->Domain());
1294 EXPECT_EQ("A", it->Name());
1295
1296 ASSERT_TRUE(++it != cookies.end());
1297 EXPECT_EQ(".google.izzle", it->Domain());
1298 EXPECT_EQ("C", it->Name());
1299
1300 ASSERT_TRUE(++it == cookies.end());
1301
1302 // Check cookies for url excluding http-only cookies.
1303 cookies =
1304 GetAllCookiesForURLWithOptions(cm.get(), url_google_, CookieOptions());
1305 it = cookies.begin();
1306
1307 ASSERT_TRUE(it != cookies.end());
1308 EXPECT_EQ(".google.izzle", it->Domain());
1309 EXPECT_EQ("C", it->Name());
1310
1311 ASSERT_TRUE(++it == cookies.end());
1312
1313 // Test secure cookies.
1314 cookies = GetAllCookiesForURL(cm.get(), url_google_secure_);
1315 it = cookies.begin();
1316
1317 ASSERT_TRUE(it != cookies.end());
1318 EXPECT_EQ("www.google.izzle", it->Domain());
1319 EXPECT_EQ("A", it->Name());
1320
1321 ASSERT_TRUE(++it != cookies.end());
1322 EXPECT_EQ(".google.izzle", it->Domain());
1323 EXPECT_EQ("C", it->Name());
1324
1325 ASSERT_TRUE(++it != cookies.end());
1326 EXPECT_EQ(".google.izzle", it->Domain());
1327 EXPECT_EQ("E", it->Name());
1328
1329 ASSERT_TRUE(++it == cookies.end());
1330
1331 // Reading after a short wait should not update the access date.
1332 EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm.get()));
1333 }
1334
1335 TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
1336 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1337 CookieOptions options;
1338
1339 EXPECT_TRUE(SetCookieWithOptions(
1340 cm.get(), url_google_foo_, "A=B; path=/foo;", options));
1341 EXPECT_TRUE(SetCookieWithOptions(
1342 cm.get(), url_google_bar_, "C=D; path=/bar;", options));
1343 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "E=F;", options));
1344
1345 CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_foo_);
1346 CookieList::iterator it = cookies.begin();
1347
1348 ASSERT_TRUE(it != cookies.end());
1349 EXPECT_EQ("A", it->Name());
1350 EXPECT_EQ("/foo", it->Path());
1351
1352 ASSERT_TRUE(++it != cookies.end());
1353 EXPECT_EQ("E", it->Name());
1354 EXPECT_EQ("/", it->Path());
1355
1356 ASSERT_TRUE(++it == cookies.end());
1357
1358 cookies = GetAllCookiesForURL(cm.get(), url_google_bar_);
1359 it = cookies.begin();
1360
1361 ASSERT_TRUE(it != cookies.end());
1362 EXPECT_EQ("C", it->Name());
1363 EXPECT_EQ("/bar", it->Path());
1364
1365 ASSERT_TRUE(++it != cookies.end());
1366 EXPECT_EQ("E", it->Name());
1367 EXPECT_EQ("/", it->Path());
1368
1369 ASSERT_TRUE(++it == cookies.end());
1370 }
1371
1372 TEST_F(CookieMonsterTest, DeleteCookieByName) {
1373 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1374
1375 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A1; path=/"));
1376 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A2; path=/foo"));
1377 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A3; path=/bar"));
1378 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B1; path=/"));
1379 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B2; path=/foo"));
1380 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B3; path=/bar"));
1381
1382 DeleteCookie(cm.get(), GURL(std::string(kUrlGoogle) + "/foo/bar"), "A");
1383
1384 CookieList cookies = GetAllCookies(cm.get());
1385 size_t expected_size = 4;
1386 EXPECT_EQ(expected_size, cookies.size());
1387 for (CookieList::iterator it = cookies.begin();
1388 it != cookies.end(); ++it) {
1389 EXPECT_NE("A1", it->Value());
1390 EXPECT_NE("A2", it->Value());
1391 }
1392 }
1393
1394 TEST_F(CookieMonsterTest, ImportCookiesFromCookieMonster) {
1395 scoped_refptr<CookieMonster> cm_1(new CookieMonster(NULL, NULL));
1396 CookieOptions options;
1397
1398 EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_foo_,
1399 "A1=B; path=/foo;",
1400 options));
1401 EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_bar_,
1402 "A2=D; path=/bar;",
1403 options));
1404 EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_,
1405 "A3=F;",
1406 options));
1407
1408 CookieList cookies_1 = GetAllCookies(cm_1.get());
1409 scoped_refptr<CookieMonster> cm_2(new CookieMonster(NULL, NULL));
1410 ASSERT_TRUE(cm_2->ImportCookies(cookies_1));
1411 CookieList cookies_2 = GetAllCookies(cm_2.get());
1412
1413 size_t expected_size = 3;
1414 EXPECT_EQ(expected_size, cookies_2.size());
1415
1416 CookieList::iterator it = cookies_2.begin();
1417
1418 ASSERT_TRUE(it != cookies_2.end());
1419 EXPECT_EQ("A1", it->Name());
1420 EXPECT_EQ("/foo", it->Path());
1421
1422 ASSERT_TRUE(++it != cookies_2.end());
1423 EXPECT_EQ("A2", it->Name());
1424 EXPECT_EQ("/bar", it->Path());
1425
1426 ASSERT_TRUE(++it != cookies_2.end());
1427 EXPECT_EQ("A3", it->Name());
1428 EXPECT_EQ("/", it->Path());
1429 }
1430
1431 // Tests importing from a persistent cookie store that contains duplicate
1432 // equivalent cookies. This situation should be handled by removing the
1433 // duplicate cookie (both from the in-memory cache, and from the backing store).
1434 //
1435 // This is a regression test for: http://crbug.com/17855.
1436 TEST_F(CookieMonsterTest, DontImportDuplicateCookies) {
1437 scoped_refptr<MockPersistentCookieStore> store(
1438 new MockPersistentCookieStore);
1439
1440 // We will fill some initial cookies into the PersistentCookieStore,
1441 // to simulate a database with 4 duplicates. Note that we need to
1442 // be careful not to have any duplicate creation times at all (as it's a
1443 // violation of a CookieMonster invariant) even if Time::Now() doesn't
1444 // move between calls.
1445 std::vector<CanonicalCookie*> initial_cookies;
1446
1447 // Insert 4 cookies with name "X" on path "/", with varying creation
1448 // dates. We expect only the most recent one to be preserved following
1449 // the import.
1450
1451 AddCookieToList("www.google.com",
1452 "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
1453 Time::Now() + TimeDelta::FromDays(3),
1454 &initial_cookies);
1455
1456 AddCookieToList("www.google.com",
1457 "X=2; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
1458 Time::Now() + TimeDelta::FromDays(1),
1459 &initial_cookies);
1460
1461 // ===> This one is the WINNER (biggest creation time). <====
1462 AddCookieToList("www.google.com",
1463 "X=3; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
1464 Time::Now() + TimeDelta::FromDays(4),
1465 &initial_cookies);
1466
1467 AddCookieToList("www.google.com",
1468 "X=4; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
1469 Time::Now(),
1470 &initial_cookies);
1471
1472 // Insert 2 cookies with name "X" on path "/2", with varying creation
1473 // dates. We expect only the most recent one to be preserved the import.
1474
1475 // ===> This one is the WINNER (biggest creation time). <====
1476 AddCookieToList("www.google.com",
1477 "X=a1; path=/2; expires=Mon, 18-Apr-22 22:50:14 GMT",
1478 Time::Now() + TimeDelta::FromDays(9),
1479 &initial_cookies);
1480
1481 AddCookieToList("www.google.com",
1482 "X=a2; path=/2; expires=Mon, 18-Apr-22 22:50:14 GMT",
1483 Time::Now() + TimeDelta::FromDays(2),
1484 &initial_cookies);
1485
1486 // Insert 1 cookie with name "Y" on path "/".
1487 AddCookieToList("www.google.com",
1488 "Y=a; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
1489 Time::Now() + TimeDelta::FromDays(10),
1490 &initial_cookies);
1491
1492 // Inject our initial cookies into the mock PersistentCookieStore.
1493 store->SetLoadExpectation(true, initial_cookies);
1494
1495 scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
1496
1497 // Verify that duplicates were not imported for path "/".
1498 // (If this had failed, GetCookies() would have also returned X=1, X=2, X=4).
1499 EXPECT_EQ("X=3; Y=a", GetCookies(cm.get(), GURL("http://www.google.com/")));
1500
1501 // Verify that same-named cookie on a different path ("/x2") didn't get
1502 // messed up.
1503 EXPECT_EQ("X=a1; X=3; Y=a",
1504 GetCookies(cm.get(), GURL("http://www.google.com/2/x")));
1505
1506 // Verify that the PersistentCookieStore was told to kill its 4 duplicates.
1507 ASSERT_EQ(4u, store->commands().size());
1508 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[0].type);
1509 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
1510 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[2].type);
1511 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
1512 }
1513
1514 // Tests importing from a persistent cookie store that contains cookies
1515 // with duplicate creation times. This situation should be handled by
1516 // dropping the cookies before insertion/visibility to user.
1517 //
1518 // This is a regression test for: http://crbug.com/43188.
1519 TEST_F(CookieMonsterTest, DontImportDuplicateCreationTimes) {
1520 scoped_refptr<MockPersistentCookieStore> store(
1521 new MockPersistentCookieStore);
1522
1523 Time now(Time::Now());
1524 Time earlier(now - TimeDelta::FromDays(1));
1525
1526 // Insert 8 cookies, four with the current time as creation times, and
1527 // four with the earlier time as creation times. We should only get
1528 // two cookies remaining, but which two (other than that there should
1529 // be one from each set) will be random.
1530 std::vector<CanonicalCookie*> initial_cookies;
1531 AddCookieToList("www.google.com", "X=1; path=/", now, &initial_cookies);
1532 AddCookieToList("www.google.com", "X=2; path=/", now, &initial_cookies);
1533 AddCookieToList("www.google.com", "X=3; path=/", now, &initial_cookies);
1534 AddCookieToList("www.google.com", "X=4; path=/", now, &initial_cookies);
1535
1536 AddCookieToList("www.google.com", "Y=1; path=/", earlier, &initial_cookies);
1537 AddCookieToList("www.google.com", "Y=2; path=/", earlier, &initial_cookies);
1538 AddCookieToList("www.google.com", "Y=3; path=/", earlier, &initial_cookies);
1539 AddCookieToList("www.google.com", "Y=4; path=/", earlier, &initial_cookies);
1540
1541 // Inject our initial cookies into the mock PersistentCookieStore.
1542 store->SetLoadExpectation(true, initial_cookies);
1543
1544 scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
1545
1546 CookieList list(GetAllCookies(cm.get()));
1547 EXPECT_EQ(2U, list.size());
1548 // Confirm that we have one of each.
1549 std::string name1(list[0].Name());
1550 std::string name2(list[1].Name());
1551 EXPECT_TRUE(name1 == "X" || name2 == "X");
1552 EXPECT_TRUE(name1 == "Y" || name2 == "Y");
1553 EXPECT_NE(name1, name2);
1554 }
1555
1556 TEST_F(CookieMonsterTest, CookieMonsterDelegate) {
1557 scoped_refptr<MockPersistentCookieStore> store(
1558 new MockPersistentCookieStore);
1559 scoped_refptr<MockCookieMonsterDelegate> delegate(
1560 new MockCookieMonsterDelegate);
1561 scoped_refptr<CookieMonster> cm(
1562 new CookieMonster(store.get(), delegate.get()));
1563
1564 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
1565 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "C=D"));
1566 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "E=F"));
1567 EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), url_google_));
1568 ASSERT_EQ(3u, delegate->changes().size());
1569 EXPECT_FALSE(delegate->changes()[0].second);
1570 EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
1571 EXPECT_EQ("A", delegate->changes()[0].first.Name());
1572 EXPECT_EQ("B", delegate->changes()[0].first.Value());
1573 EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain());
1574 EXPECT_FALSE(delegate->changes()[1].second);
1575 EXPECT_EQ("C", delegate->changes()[1].first.Name());
1576 EXPECT_EQ("D", delegate->changes()[1].first.Value());
1577 EXPECT_EQ(url_google_.host(), delegate->changes()[2].first.Domain());
1578 EXPECT_FALSE(delegate->changes()[2].second);
1579 EXPECT_EQ("E", delegate->changes()[2].first.Name());
1580 EXPECT_EQ("F", delegate->changes()[2].first.Value());
1581 delegate->reset();
1582
1583 EXPECT_TRUE(FindAndDeleteCookie(cm.get(), url_google_.host(), "C"));
1584 EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
1585 ASSERT_EQ(1u, delegate->changes().size());
1586 EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
1587 EXPECT_TRUE(delegate->changes()[0].second);
1588 EXPECT_EQ("C", delegate->changes()[0].first.Name());
1589 EXPECT_EQ("D", delegate->changes()[0].first.Value());
1590 delegate->reset();
1591
1592 EXPECT_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
1593 EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
1594 EXPECT_EQ(0u, delegate->changes().size());
1595
1596 // Insert a cookie "a" for path "/path1"
1597 EXPECT_TRUE(SetCookie(cm.get(),
1598 url_google_,
1599 "a=val1; path=/path1; "
1600 "expires=Mon, 18-Apr-22 22:50:13 GMT"));
1601 ASSERT_EQ(1u, store->commands().size());
1602 EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
1603 ASSERT_EQ(1u, delegate->changes().size());
1604 EXPECT_FALSE(delegate->changes()[0].second);
1605 EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
1606 EXPECT_EQ("a", delegate->changes()[0].first.Name());
1607 EXPECT_EQ("val1", delegate->changes()[0].first.Value());
1608 delegate->reset();
1609
1610 // Insert a cookie "a" for path "/path1", that is httponly. This should
1611 // overwrite the non-http-only version.
1612 CookieOptions allow_httponly;
1613 allow_httponly.set_include_httponly();
1614 EXPECT_TRUE(SetCookieWithOptions(cm.get(),
1615 url_google_,
1616 "a=val2; path=/path1; httponly; "
1617 "expires=Mon, 18-Apr-22 22:50:14 GMT",
1618 allow_httponly));
1619 ASSERT_EQ(3u, store->commands().size());
1620 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
1621 EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
1622 ASSERT_EQ(2u, delegate->changes().size());
1623 EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
1624 EXPECT_TRUE(delegate->changes()[0].second);
1625 EXPECT_EQ("a", delegate->changes()[0].first.Name());
1626 EXPECT_EQ("val1", delegate->changes()[0].first.Value());
1627 EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain());
1628 EXPECT_FALSE(delegate->changes()[1].second);
1629 EXPECT_EQ("a", delegate->changes()[1].first.Name());
1630 EXPECT_EQ("val2", delegate->changes()[1].first.Value());
1631 delegate->reset();
1632 }
1633
1634 TEST_F(CookieMonsterTest, SetCookieWithDetails) {
1635 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1636
1637 EXPECT_TRUE(SetCookieWithDetails(cm.get(),
1638 url_google_foo_,
1639 "A",
1640 "B",
1641 std::string(),
1642 "/foo",
1643 base::Time(),
1644 false,
1645 false,
1646 COOKIE_PRIORITY_DEFAULT));
1647 EXPECT_TRUE(SetCookieWithDetails(cm.get(),
1648 url_google_bar_,
1649 "C",
1650 "D",
1651 "google.izzle",
1652 "/bar",
1653 base::Time(),
1654 false,
1655 true,
1656 COOKIE_PRIORITY_DEFAULT));
1657 EXPECT_TRUE(SetCookieWithDetails(cm.get(),
1658 url_google_,
1659 "E",
1660 "F",
1661 std::string(),
1662 std::string(),
1663 base::Time(),
1664 true,
1665 false,
1666 COOKIE_PRIORITY_DEFAULT));
1667
1668 // Test that malformed attributes fail to set the cookie.
1669 EXPECT_FALSE(SetCookieWithDetails(cm.get(),
1670 url_google_foo_,
1671 " A",
1672 "B",
1673 std::string(),
1674 "/foo",
1675 base::Time(),
1676 false,
1677 false,
1678 COOKIE_PRIORITY_DEFAULT));
1679 EXPECT_FALSE(SetCookieWithDetails(cm.get(),
1680 url_google_foo_,
1681 "A;",
1682 "B",
1683 std::string(),
1684 "/foo",
1685 base::Time(),
1686 false,
1687 false,
1688 COOKIE_PRIORITY_DEFAULT));
1689 EXPECT_FALSE(SetCookieWithDetails(cm.get(),
1690 url_google_foo_,
1691 "A=",
1692 "B",
1693 std::string(),
1694 "/foo",
1695 base::Time(),
1696 false,
1697 false,
1698 COOKIE_PRIORITY_DEFAULT));
1699 EXPECT_FALSE(SetCookieWithDetails(cm.get(),
1700 url_google_foo_,
1701 "A",
1702 "B",
1703 "google.ozzzzzzle",
1704 "foo",
1705 base::Time(),
1706 false,
1707 false,
1708 COOKIE_PRIORITY_DEFAULT));
1709 EXPECT_FALSE(SetCookieWithDetails(cm.get(),
1710 url_google_foo_,
1711 "A=",
1712 "B",
1713 std::string(),
1714 "foo",
1715 base::Time(),
1716 false,
1717 false,
1718 COOKIE_PRIORITY_DEFAULT));
1719
1720 CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_foo_);
1721 CookieList::iterator it = cookies.begin();
1722
1723 ASSERT_TRUE(it != cookies.end());
1724 EXPECT_EQ("A", it->Name());
1725 EXPECT_EQ("B", it->Value());
1726 EXPECT_EQ("www.google.izzle", it->Domain());
1727 EXPECT_EQ("/foo", it->Path());
1728 EXPECT_FALSE(it->IsPersistent());
1729 EXPECT_FALSE(it->IsSecure());
1730 EXPECT_FALSE(it->IsHttpOnly());
1731
1732 ASSERT_TRUE(++it == cookies.end());
1733
1734 cookies = GetAllCookiesForURL(cm.get(), url_google_bar_);
1735 it = cookies.begin();
1736
1737 ASSERT_TRUE(it != cookies.end());
1738 EXPECT_EQ("C", it->Name());
1739 EXPECT_EQ("D", it->Value());
1740 EXPECT_EQ(".google.izzle", it->Domain());
1741 EXPECT_EQ("/bar", it->Path());
1742 EXPECT_FALSE(it->IsSecure());
1743 EXPECT_TRUE(it->IsHttpOnly());
1744
1745 ASSERT_TRUE(++it == cookies.end());
1746
1747 cookies = GetAllCookiesForURL(cm.get(), url_google_secure_);
1748 it = cookies.begin();
1749
1750 ASSERT_TRUE(it != cookies.end());
1751 EXPECT_EQ("E", it->Name());
1752 EXPECT_EQ("F", it->Value());
1753 EXPECT_EQ("/", it->Path());
1754 EXPECT_EQ("www.google.izzle", it->Domain());
1755 EXPECT_TRUE(it->IsSecure());
1756 EXPECT_FALSE(it->IsHttpOnly());
1757
1758 ASSERT_TRUE(++it == cookies.end());
1759 }
1760
1761 TEST_F(CookieMonsterTest, DeleteAllForHost) {
1762 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1763
1764 // Test probes:
1765 // * Non-secure URL, mid-level (http://w.c.b.a)
1766 // * Secure URL, mid-level (https://w.c.b.a)
1767 // * URL with path, mid-level (https:/w.c.b.a/dir1/xx)
1768 // All three tests should nuke only the midlevel host cookie,
1769 // the http_only cookie, the host secure cookie, and the two host
1770 // path cookies. http_only, secure, and paths are ignored by
1771 // this call, and domain cookies arent touched.
1772 PopulateCmForDeleteAllForHost(cm);
1773 EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
1774 GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
1775 EXPECT_EQ("dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X",
1776 GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
1777 EXPECT_EQ("dom_1=X; host_1=X",
1778 GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
1779 EXPECT_EQ("dom_path_2=X; host_path_2=X; dom_path_1=X; host_path_1=X; "
1780 "dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X",
1781 GetCookies(cm.get(),
1782 GURL(kTopLevelDomainPlus2Secure +
1783 std::string("/dir1/dir2/xxx"))));
1784
1785 EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2)));
1786 EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
1787
1788 EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
1789 GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
1790 EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
1791 GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
1792 EXPECT_EQ("dom_1=X; host_1=X",
1793 GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
1794 EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
1795 GetCookies(cm.get(),
1796 GURL(kTopLevelDomainPlus2Secure +
1797 std::string("/dir1/dir2/xxx"))));
1798
1799 PopulateCmForDeleteAllForHost(cm);
1800 EXPECT_EQ(5, DeleteAllForHost(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
1801 EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
1802
1803 EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
1804 GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
1805 EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
1806 GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
1807 EXPECT_EQ("dom_1=X; host_1=X",
1808 GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
1809 EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
1810 GetCookies(cm.get(),
1811 GURL(kTopLevelDomainPlus2Secure +
1812 std::string("/dir1/dir2/xxx"))));
1813
1814 PopulateCmForDeleteAllForHost(cm);
1815 EXPECT_EQ(5,
1816 DeleteAllForHost(
1817 cm.get(),
1818 GURL(kTopLevelDomainPlus2Secure + std::string("/dir1/xxx"))));
1819 EXPECT_EQ(8U, GetAllCookies(cm.get()).size());
1820
1821 EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X",
1822 GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
1823 EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X",
1824 GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
1825 EXPECT_EQ("dom_1=X; host_1=X",
1826 GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
1827 EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X",
1828 GetCookies(cm.get(),
1829 GURL(kTopLevelDomainPlus2Secure +
1830 std::string("/dir1/dir2/xxx"))));
1831 }
1832
1833 TEST_F(CookieMonsterTest, UniqueCreationTime) {
1834 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1835 CookieOptions options;
1836
1837 // Add in three cookies through every public interface to the
1838 // CookieMonster and confirm that none of them have duplicate
1839 // creation times.
1840
1841 // SetCookieWithCreationTime and SetCookieWithCreationTimeAndOptions
1842 // are not included as they aren't going to be public for very much
1843 // longer.
1844
1845 // SetCookie, SetCookieWithOptions, SetCookieWithDetails
1846
1847 SetCookie(cm.get(), url_google_, "SetCookie1=A");
1848 SetCookie(cm.get(), url_google_, "SetCookie2=A");
1849 SetCookie(cm.get(), url_google_, "SetCookie3=A");
1850
1851 SetCookieWithOptions(
1852 cm.get(), url_google_, "setCookieWithOptions1=A", options);
1853 SetCookieWithOptions(
1854 cm.get(), url_google_, "setCookieWithOptions2=A", options);
1855 SetCookieWithOptions(
1856 cm.get(), url_google_, "setCookieWithOptions3=A", options);
1857
1858 SetCookieWithDetails(cm.get(),
1859 url_google_,
1860 "setCookieWithDetails1",
1861 "A",
1862 ".google.com",
1863 "/",
1864 Time(),
1865 false,
1866 false,
1867 COOKIE_PRIORITY_DEFAULT);
1868 SetCookieWithDetails(cm.get(),
1869 url_google_,
1870 "setCookieWithDetails2",
1871 "A",
1872 ".google.com",
1873 "/",
1874 Time(),
1875 false,
1876 false,
1877 COOKIE_PRIORITY_DEFAULT);
1878 SetCookieWithDetails(cm.get(),
1879 url_google_,
1880 "setCookieWithDetails3",
1881 "A",
1882 ".google.com",
1883 "/",
1884 Time(),
1885 false,
1886 false,
1887 COOKIE_PRIORITY_DEFAULT);
1888
1889 // Now we check
1890 CookieList cookie_list(GetAllCookies(cm.get()));
1891 typedef std::map<int64, CanonicalCookie> TimeCookieMap;
1892 TimeCookieMap check_map;
1893 for (CookieList::const_iterator it = cookie_list.begin();
1894 it != cookie_list.end(); it++) {
1895 const int64 creation_date = it->CreationDate().ToInternalValue();
1896 TimeCookieMap::const_iterator
1897 existing_cookie_it(check_map.find(creation_date));
1898 EXPECT_TRUE(existing_cookie_it == check_map.end())
1899 << "Cookie " << it->Name() << " has same creation date ("
1900 << it->CreationDate().ToInternalValue()
1901 << ") as previously entered cookie "
1902 << existing_cookie_it->second.Name();
1903
1904 if (existing_cookie_it == check_map.end()) {
1905 check_map.insert(TimeCookieMap::value_type(
1906 it->CreationDate().ToInternalValue(), *it));
1907 }
1908 }
1909 }
1910
1911 // Mainly a test of GetEffectiveDomain, or more specifically, of the
1912 // expected behavior of GetEffectiveDomain within the CookieMonster.
1913 TEST_F(CookieMonsterTest, GetKey) {
1914 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
1915
1916 // This test is really only interesting if GetKey() actually does something.
1917 EXPECT_EQ("google.com", cm->GetKey("www.google.com"));
1918 EXPECT_EQ("google.izzie", cm->GetKey("www.google.izzie"));
1919 EXPECT_EQ("google.izzie", cm->GetKey(".google.izzie"));
1920 EXPECT_EQ("bbc.co.uk", cm->GetKey("bbc.co.uk"));
1921 EXPECT_EQ("bbc.co.uk", cm->GetKey("a.b.c.d.bbc.co.uk"));
1922 EXPECT_EQ("apple.com", cm->GetKey("a.b.c.d.apple.com"));
1923 EXPECT_EQ("apple.izzie", cm->GetKey("a.b.c.d.apple.izzie"));
1924
1925 // Cases where the effective domain is null, so we use the host
1926 // as the key.
1927 EXPECT_EQ("co.uk", cm->GetKey("co.uk"));
1928 const std::string extension_name("iehocdgbbocmkdidlbnnfbmbinnahbae");
1929 EXPECT_EQ(extension_name, cm->GetKey(extension_name));
1930 EXPECT_EQ("com", cm->GetKey("com"));
1931 EXPECT_EQ("hostalias", cm->GetKey("hostalias"));
1932 EXPECT_EQ("localhost", cm->GetKey("localhost"));
1933 }
1934
1935 // Test that cookies transfer from/to the backing store correctly.
1936 TEST_F(CookieMonsterTest, BackingStoreCommunication) {
1937 // Store details for cookies transforming through the backing store interface.
1938
1939 base::Time current(base::Time::Now());
1940 scoped_refptr<MockSimplePersistentCookieStore> store(
1941 new MockSimplePersistentCookieStore);
1942 base::Time new_access_time;
1943 base::Time expires(base::Time::Now() + base::TimeDelta::FromSeconds(100));
1944
1945 const CookiesInputInfo input_info[] = {
1946 {GURL("http://a.b.google.com"), "a", "1", "", "/path/to/cookie", expires,
1947 false, false, COOKIE_PRIORITY_DEFAULT},
1948 {GURL("https://www.google.com"), "b", "2", ".google.com",
1949 "/path/from/cookie", expires + TimeDelta::FromSeconds(10),
1950 true, true, COOKIE_PRIORITY_DEFAULT},
1951 {GURL("https://google.com"), "c", "3", "", "/another/path/to/cookie",
1952 base::Time::Now() + base::TimeDelta::FromSeconds(100),
1953 true, false, COOKIE_PRIORITY_DEFAULT}
1954 };
1955 const int INPUT_DELETE = 1;
1956
1957 // Create new cookies and flush them to the store.
1958 {
1959 scoped_refptr<CookieMonster> cmout(new CookieMonster(store.get(), NULL));
1960 for (const CookiesInputInfo* p = input_info;
1961 p < &input_info[ARRAYSIZE_UNSAFE(input_info)];
1962 p++) {
1963 EXPECT_TRUE(SetCookieWithDetails(cmout.get(),
1964 p->url,
1965 p->name,
1966 p->value,
1967 p->domain,
1968 p->path,
1969 p->expiration_time,
1970 p->secure,
1971 p->http_only,
1972 p->priority));
1973 }
1974 GURL del_url(input_info[INPUT_DELETE].url.Resolve(
1975 input_info[INPUT_DELETE].path).spec());
1976 DeleteCookie(cmout.get(), del_url, input_info[INPUT_DELETE].name);
1977 }
1978
1979 // Create a new cookie monster and make sure that everything is correct
1980 {
1981 scoped_refptr<CookieMonster> cmin(new CookieMonster(store.get(), NULL));
1982 CookieList cookies(GetAllCookies(cmin.get()));
1983 ASSERT_EQ(2u, cookies.size());
1984 // Ordering is path length, then creation time. So second cookie
1985 // will come first, and we need to swap them.
1986 std::swap(cookies[0], cookies[1]);
1987 for (int output_index = 0; output_index < 2; output_index++) {
1988 int input_index = output_index * 2;
1989 const CookiesInputInfo* input = &input_info[input_index];
1990 const CanonicalCookie* output = &cookies[output_index];
1991
1992 EXPECT_EQ(input->name, output->Name());
1993 EXPECT_EQ(input->value, output->Value());
1994 EXPECT_EQ(input->url.host(), output->Domain());
1995 EXPECT_EQ(input->path, output->Path());
1996 EXPECT_LE(current.ToInternalValue(),
1997 output->CreationDate().ToInternalValue());
1998 EXPECT_EQ(input->secure, output->IsSecure());
1999 EXPECT_EQ(input->http_only, output->IsHttpOnly());
2000 EXPECT_TRUE(output->IsPersistent());
2001 EXPECT_EQ(input->expiration_time.ToInternalValue(),
2002 output->ExpiryDate().ToInternalValue());
2003 }
2004 }
2005 }
2006
2007 TEST_F(CookieMonsterTest, CookieListOrdering) {
2008 // Put a random set of cookies into a monster and make sure
2009 // they're returned in the right order.
2010 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2011 EXPECT_TRUE(
2012 SetCookie(cm.get(), GURL("http://d.c.b.a.google.com/aa/x.html"), "c=1"));
2013 EXPECT_TRUE(SetCookie(cm.get(),
2014 GURL("http://b.a.google.com/aa/bb/cc/x.html"),
2015 "d=1; domain=b.a.google.com"));
2016 EXPECT_TRUE(SetCookie(cm.get(),
2017 GURL("http://b.a.google.com/aa/bb/cc/x.html"),
2018 "a=4; domain=b.a.google.com"));
2019 EXPECT_TRUE(SetCookie(cm.get(),
2020 GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
2021 "e=1; domain=c.b.a.google.com"));
2022 EXPECT_TRUE(SetCookie(
2023 cm.get(), GURL("http://d.c.b.a.google.com/aa/bb/x.html"), "b=1"));
2024 EXPECT_TRUE(SetCookie(
2025 cm.get(), GURL("http://news.bbc.co.uk/midpath/x.html"), "g=10"));
2026 {
2027 unsigned int i = 0;
2028 CookieList cookies(GetAllCookiesForURL(
2029 cm.get(), GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
2030 ASSERT_EQ(5u, cookies.size());
2031 EXPECT_EQ("d", cookies[i++].Name());
2032 EXPECT_EQ("a", cookies[i++].Name());
2033 EXPECT_EQ("e", cookies[i++].Name());
2034 EXPECT_EQ("b", cookies[i++].Name());
2035 EXPECT_EQ("c", cookies[i++].Name());
2036 }
2037
2038 {
2039 unsigned int i = 0;
2040 CookieList cookies(GetAllCookies(cm.get()));
2041 ASSERT_EQ(6u, cookies.size());
2042 EXPECT_EQ("d", cookies[i++].Name());
2043 EXPECT_EQ("a", cookies[i++].Name());
2044 EXPECT_EQ("e", cookies[i++].Name());
2045 EXPECT_EQ("g", cookies[i++].Name());
2046 EXPECT_EQ("b", cookies[i++].Name());
2047 EXPECT_EQ("c", cookies[i++].Name());
2048 }
2049 }
2050
2051 // This test and CookieMonstertest.TestGCTimes (in cookie_monster_perftest.cc)
2052 // are somewhat complementary twins. This test is probing for whether
2053 // garbage collection always happens when it should (i.e. that we actually
2054 // get rid of cookies when we should). The perftest is probing for
2055 // whether garbage collection happens when it shouldn't. See comments
2056 // before that test for more details.
2057
2058 // Disabled on Windows, see crbug.com/126095
2059 #if defined(OS_WIN)
2060 #define MAYBE_GarbageCollectionTriggers DISABLED_GarbageCollectionTriggers
2061 #else
2062 #define MAYBE_GarbageCollectionTriggers GarbageCollectionTriggers
2063 #endif
2064
2065 TEST_F(CookieMonsterTest, MAYBE_GarbageCollectionTriggers) {
2066 // First we check to make sure that a whole lot of recent cookies
2067 // doesn't get rid of anything after garbage collection is checked for.
2068 {
2069 scoped_refptr<CookieMonster> cm(
2070 CreateMonsterForGC(CookieMonster::kMaxCookies * 2));
2071 EXPECT_EQ(CookieMonster::kMaxCookies * 2, GetAllCookies(cm.get()).size());
2072 SetCookie(cm.get(), GURL("http://newdomain.com"), "b=2");
2073 EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1,
2074 GetAllCookies(cm.get()).size());
2075 }
2076
2077 // Now we explore a series of relationships between cookie last access
2078 // time and size of store to make sure we only get rid of cookies when
2079 // we really should.
2080 const struct TestCase {
2081 size_t num_cookies;
2082 size_t num_old_cookies;
2083 size_t expected_initial_cookies;
2084 // Indexed by ExpiryAndKeyScheme
2085 size_t expected_cookies_after_set;
2086 } test_cases[] = {
2087 {
2088 // A whole lot of recent cookies; gc shouldn't happen.
2089 CookieMonster::kMaxCookies * 2,
2090 0,
2091 CookieMonster::kMaxCookies * 2,
2092 CookieMonster::kMaxCookies * 2 + 1
2093 }, {
2094 // Some old cookies, but still overflowing max.
2095 CookieMonster::kMaxCookies * 2,
2096 CookieMonster::kMaxCookies / 2,
2097 CookieMonster::kMaxCookies * 2,
2098 CookieMonster::kMaxCookies * 2 - CookieMonster::kMaxCookies / 2 + 1
2099 }, {
2100 // Old cookies enough to bring us right down to our purge line.
2101 CookieMonster::kMaxCookies * 2,
2102 CookieMonster::kMaxCookies + CookieMonster::kPurgeCookies + 1,
2103 CookieMonster::kMaxCookies * 2,
2104 CookieMonster::kMaxCookies - CookieMonster::kPurgeCookies
2105 }, {
2106 // Old cookies enough to bring below our purge line (which we
2107 // shouldn't do).
2108 CookieMonster::kMaxCookies * 2,
2109 CookieMonster::kMaxCookies * 3 / 2,
2110 CookieMonster::kMaxCookies * 2,
2111 CookieMonster::kMaxCookies - CookieMonster::kPurgeCookies
2112 }
2113 };
2114
2115 for (int ci = 0; ci < static_cast<int>(ARRAYSIZE_UNSAFE(test_cases)); ++ci) {
2116 const TestCase *test_case = &test_cases[ci];
2117 scoped_refptr<CookieMonster> cm(
2118 CreateMonsterFromStoreForGC(
2119 test_case->num_cookies, test_case->num_old_cookies,
2120 CookieMonster::kSafeFromGlobalPurgeDays * 2));
2121 EXPECT_EQ(test_case->expected_initial_cookies,
2122 GetAllCookies(cm.get()).size()) << "For test case " << ci;
2123 // Will trigger GC
2124 SetCookie(cm.get(), GURL("http://newdomain.com"), "b=2");
2125 EXPECT_EQ(test_case->expected_cookies_after_set,
2126 GetAllCookies(cm.get()).size()) << "For test case " << ci;
2127 }
2128 }
2129
2130 // This test checks that keep expired cookies flag is working.
2131 TEST_F(CookieMonsterTest, KeepExpiredCookies) {
2132 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2133 cm->SetKeepExpiredCookies();
2134 CookieOptions options;
2135
2136 // Set a persistent cookie.
2137 ASSERT_TRUE(SetCookieWithOptions(
2138 cm.get(),
2139 url_google_,
2140 std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT",
2141 options));
2142
2143 // Get the canonical cookie.
2144 CookieList cookie_list = GetAllCookies(cm.get());
2145 ASSERT_EQ(1U, cookie_list.size());
2146
2147 // Use a past expiry date to delete the cookie.
2148 ASSERT_TRUE(SetCookieWithOptions(
2149 cm.get(),
2150 url_google_,
2151 std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
2152 options));
2153
2154 // Check that the cookie with the past expiry date is still there.
2155 // GetAllCookies() also triggers garbage collection.
2156 cookie_list = GetAllCookies(cm.get());
2157 ASSERT_EQ(1U, cookie_list.size());
2158 ASSERT_TRUE(cookie_list[0].IsExpired(Time::Now()));
2159 }
2160
2161 namespace {
2162
2163 // Mock PersistentCookieStore that keeps track of the number of Flush() calls.
2164 class FlushablePersistentStore : public CookieMonster::PersistentCookieStore {
2165 public:
2166 FlushablePersistentStore() : flush_count_(0) {}
2167
2168 virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE {
2169 std::vector<CanonicalCookie*> out_cookies;
2170 base::MessageLoop::current()->PostTask(
2171 FROM_HERE,
2172 base::Bind(&net::LoadedCallbackTask::Run,
2173 new net::LoadedCallbackTask(loaded_callback, out_cookies)));
2174 }
2175
2176 virtual void LoadCookiesForKey(
2177 const std::string& key,
2178 const LoadedCallback& loaded_callback) OVERRIDE {
2179 Load(loaded_callback);
2180 }
2181
2182 virtual void AddCookie(const CanonicalCookie&) OVERRIDE {}
2183 virtual void UpdateCookieAccessTime(const CanonicalCookie&) OVERRIDE {}
2184 virtual void DeleteCookie(const CanonicalCookie&) OVERRIDE {}
2185 virtual void SetForceKeepSessionState() OVERRIDE {}
2186
2187 virtual void Flush(const base::Closure& callback) OVERRIDE {
2188 ++flush_count_;
2189 if (!callback.is_null())
2190 callback.Run();
2191 }
2192
2193 int flush_count() {
2194 return flush_count_;
2195 }
2196
2197 private:
2198 virtual ~FlushablePersistentStore() {}
2199
2200 volatile int flush_count_;
2201 };
2202
2203 // Counts the number of times Callback() has been run.
2204 class CallbackCounter : public base::RefCountedThreadSafe<CallbackCounter> {
2205 public:
2206 CallbackCounter() : callback_count_(0) {}
2207
2208 void Callback() {
2209 ++callback_count_;
2210 }
2211
2212 int callback_count() {
2213 return callback_count_;
2214 }
2215
2216 private:
2217 friend class base::RefCountedThreadSafe<CallbackCounter>;
2218 ~CallbackCounter() {}
2219
2220 volatile int callback_count_;
2221 };
2222
2223 } // namespace
2224
2225 // Test that FlushStore() is forwarded to the store and callbacks are posted.
2226 TEST_F(CookieMonsterTest, FlushStore) {
2227 scoped_refptr<CallbackCounter> counter(new CallbackCounter());
2228 scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
2229 scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
2230
2231 ASSERT_EQ(0, store->flush_count());
2232 ASSERT_EQ(0, counter->callback_count());
2233
2234 // Before initialization, FlushStore() should just run the callback.
2235 cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
2236 base::MessageLoop::current()->RunUntilIdle();
2237
2238 ASSERT_EQ(0, store->flush_count());
2239 ASSERT_EQ(1, counter->callback_count());
2240
2241 // NULL callback is safe.
2242 cm->FlushStore(base::Closure());
2243 base::MessageLoop::current()->RunUntilIdle();
2244
2245 ASSERT_EQ(0, store->flush_count());
2246 ASSERT_EQ(1, counter->callback_count());
2247
2248 // After initialization, FlushStore() should delegate to the store.
2249 GetAllCookies(cm.get()); // Force init.
2250 cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
2251 base::MessageLoop::current()->RunUntilIdle();
2252
2253 ASSERT_EQ(1, store->flush_count());
2254 ASSERT_EQ(2, counter->callback_count());
2255
2256 // NULL callback is still safe.
2257 cm->FlushStore(base::Closure());
2258 base::MessageLoop::current()->RunUntilIdle();
2259
2260 ASSERT_EQ(2, store->flush_count());
2261 ASSERT_EQ(2, counter->callback_count());
2262
2263 // If there's no backing store, FlushStore() is always a safe no-op.
2264 cm = new CookieMonster(NULL, NULL);
2265 GetAllCookies(cm.get()); // Force init.
2266 cm->FlushStore(base::Closure());
2267 base::MessageLoop::current()->RunUntilIdle();
2268
2269 ASSERT_EQ(2, counter->callback_count());
2270
2271 cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
2272 base::MessageLoop::current()->RunUntilIdle();
2273
2274 ASSERT_EQ(3, counter->callback_count());
2275 }
2276
2277 TEST_F(CookieMonsterTest, HistogramCheck) {
2278 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2279 // Should match call in InitializeHistograms, but doesn't really matter
2280 // since the histogram should have been initialized by the CM construction
2281 // above.
2282 base::HistogramBase* expired_histogram =
2283 base::Histogram::FactoryGet(
2284 "Cookie.ExpirationDurationMinutes", 1, 10 * 365 * 24 * 60, 50,
2285 base::Histogram::kUmaTargetedHistogramFlag);
2286
2287 scoped_ptr<base::HistogramSamples> samples1(
2288 expired_histogram->SnapshotSamples());
2289 ASSERT_TRUE(
2290 SetCookieWithDetails(cm.get(),
2291 GURL("http://fake.a.url"),
2292 "a",
2293 "b",
2294 "a.url",
2295 "/",
2296 base::Time::Now() + base::TimeDelta::FromMinutes(59),
2297 false,
2298 false,
2299 COOKIE_PRIORITY_DEFAULT));
2300
2301 scoped_ptr<base::HistogramSamples> samples2(
2302 expired_histogram->SnapshotSamples());
2303 EXPECT_EQ(samples1->TotalCount() + 1, samples2->TotalCount());
2304
2305 // kValidCookieLine creates a session cookie.
2306 ASSERT_TRUE(SetCookie(cm.get(), url_google_, kValidCookieLine));
2307
2308 scoped_ptr<base::HistogramSamples> samples3(
2309 expired_histogram->SnapshotSamples());
2310 EXPECT_EQ(samples2->TotalCount(), samples3->TotalCount());
2311 }
2312
2313 namespace {
2314
2315 class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
2316 public:
2317 MultiThreadedCookieMonsterTest() : other_thread_("CMTthread") {}
2318
2319 // Helper methods for calling the asynchronous CookieMonster methods
2320 // from a different thread.
2321
2322 void GetAllCookiesTask(CookieMonster* cm,
2323 GetCookieListCallback* callback) {
2324 cm->GetAllCookiesAsync(
2325 base::Bind(&GetCookieListCallback::Run, base::Unretained(callback)));
2326 }
2327
2328 void GetAllCookiesForURLTask(CookieMonster* cm,
2329 const GURL& url,
2330 GetCookieListCallback* callback) {
2331 cm->GetAllCookiesForURLAsync(
2332 url,
2333 base::Bind(&GetCookieListCallback::Run, base::Unretained(callback)));
2334 }
2335
2336 void GetAllCookiesForURLWithOptionsTask(CookieMonster* cm,
2337 const GURL& url,
2338 const CookieOptions& options,
2339 GetCookieListCallback* callback) {
2340 cm->GetAllCookiesForURLWithOptionsAsync(
2341 url, options,
2342 base::Bind(&GetCookieListCallback::Run, base::Unretained(callback)));
2343 }
2344
2345 void SetCookieWithDetailsTask(CookieMonster* cm, const GURL& url,
2346 ResultSavingCookieCallback<bool>* callback) {
2347 // Define the parameters here instead of in the calling fucntion.
2348 // The maximum number of parameters for Bind function is 6.
2349 std::string name = "A";
2350 std::string value = "B";
2351 std::string domain = std::string();
2352 std::string path = "/foo";
2353 base::Time expiration_time = base::Time();
2354 bool secure = false;
2355 bool http_only = false;
2356 CookiePriority priority = COOKIE_PRIORITY_DEFAULT;
2357 cm->SetCookieWithDetailsAsync(
2358 url, name, value, domain, path, expiration_time, secure, http_only,
2359 priority,
2360 base::Bind(
2361 &ResultSavingCookieCallback<bool>::Run,
2362 base::Unretained(callback)));
2363 }
2364
2365 void DeleteAllCreatedBetweenTask(CookieMonster* cm,
2366 const base::Time& delete_begin,
2367 const base::Time& delete_end,
2368 ResultSavingCookieCallback<int>* callback) {
2369 cm->DeleteAllCreatedBetweenAsync(
2370 delete_begin, delete_end,
2371 base::Bind(
2372 &ResultSavingCookieCallback<int>::Run, base::Unretained(callback)));
2373 }
2374
2375 void DeleteAllForHostTask(CookieMonster* cm,
2376 const GURL& url,
2377 ResultSavingCookieCallback<int>* callback) {
2378 cm->DeleteAllForHostAsync(
2379 url,
2380 base::Bind(
2381 &ResultSavingCookieCallback<int>::Run, base::Unretained(callback)));
2382 }
2383
2384 void DeleteAllCreatedBetweenForHostTask(
2385 CookieMonster* cm,
2386 const base::Time delete_begin,
2387 const base::Time delete_end,
2388 const GURL& url,
2389 ResultSavingCookieCallback<int>* callback) {
2390 cm->DeleteAllCreatedBetweenForHostAsync(
2391 delete_begin, delete_end, url,
2392 base::Bind(
2393 &ResultSavingCookieCallback<int>::Run,
2394 base::Unretained(callback)));
2395 }
2396
2397 void DeleteCanonicalCookieTask(CookieMonster* cm,
2398 const CanonicalCookie& cookie,
2399 ResultSavingCookieCallback<bool>* callback) {
2400 cm->DeleteCanonicalCookieAsync(
2401 cookie,
2402 base::Bind(
2403 &ResultSavingCookieCallback<bool>::Run,
2404 base::Unretained(callback)));
2405 }
2406
2407 protected:
2408 void RunOnOtherThread(const base::Closure& task) {
2409 other_thread_.Start();
2410 other_thread_.message_loop()->PostTask(FROM_HERE, task);
2411 RunFor(kTimeout);
2412 other_thread_.Stop();
2413 }
2414
2415 Thread other_thread_;
2416 };
2417
2418 } // namespace
2419
2420 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
2421 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2422 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
2423 CookieList cookies = GetAllCookies(cm.get());
2424 CookieList::const_iterator it = cookies.begin();
2425 ASSERT_TRUE(it != cookies.end());
2426 EXPECT_EQ("www.google.izzle", it->Domain());
2427 EXPECT_EQ("A", it->Name());
2428 ASSERT_TRUE(++it == cookies.end());
2429 GetCookieListCallback callback(&other_thread_);
2430 base::Closure task =
2431 base::Bind(&net::MultiThreadedCookieMonsterTest::GetAllCookiesTask,
2432 base::Unretained(this),
2433 cm, &callback);
2434 RunOnOtherThread(task);
2435 EXPECT_TRUE(callback.did_run());
2436 it = callback.cookies().begin();
2437 ASSERT_TRUE(it != callback.cookies().end());
2438 EXPECT_EQ("www.google.izzle", it->Domain());
2439 EXPECT_EQ("A", it->Name());
2440 ASSERT_TRUE(++it == callback.cookies().end());
2441 }
2442
2443 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) {
2444 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2445 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
2446 CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_);
2447 CookieList::const_iterator it = cookies.begin();
2448 ASSERT_TRUE(it != cookies.end());
2449 EXPECT_EQ("www.google.izzle", it->Domain());
2450 EXPECT_EQ("A", it->Name());
2451 ASSERT_TRUE(++it == cookies.end());
2452 GetCookieListCallback callback(&other_thread_);
2453 base::Closure task =
2454 base::Bind(&net::MultiThreadedCookieMonsterTest::GetAllCookiesForURLTask,
2455 base::Unretained(this),
2456 cm, url_google_, &callback);
2457 RunOnOtherThread(task);
2458 EXPECT_TRUE(callback.did_run());
2459 it = callback.cookies().begin();
2460 ASSERT_TRUE(it != callback.cookies().end());
2461 EXPECT_EQ("www.google.izzle", it->Domain());
2462 EXPECT_EQ("A", it->Name());
2463 ASSERT_TRUE(++it == callback.cookies().end());
2464 }
2465
2466 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURLWithOpt) {
2467 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2468 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
2469 CookieOptions options;
2470 CookieList cookies =
2471 GetAllCookiesForURLWithOptions(cm.get(), url_google_, options);
2472 CookieList::const_iterator it = cookies.begin();
2473 ASSERT_TRUE(it != cookies.end());
2474 EXPECT_EQ("www.google.izzle", it->Domain());
2475 EXPECT_EQ("A", it->Name());
2476 ASSERT_TRUE(++it == cookies.end());
2477 GetCookieListCallback callback(&other_thread_);
2478 base::Closure task = base::Bind(
2479 &net::MultiThreadedCookieMonsterTest::GetAllCookiesForURLWithOptionsTask,
2480 base::Unretained(this),
2481 cm, url_google_, options, &callback);
2482 RunOnOtherThread(task);
2483 EXPECT_TRUE(callback.did_run());
2484 it = callback.cookies().begin();
2485 ASSERT_TRUE(it != callback.cookies().end());
2486 EXPECT_EQ("www.google.izzle", it->Domain());
2487 EXPECT_EQ("A", it->Name());
2488 ASSERT_TRUE(++it == callback.cookies().end());
2489 }
2490
2491 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckSetCookieWithDetails) {
2492 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2493 EXPECT_TRUE(SetCookieWithDetails(cm.get(),
2494 url_google_foo_,
2495 "A",
2496 "B",
2497 std::string(),
2498 "/foo",
2499 base::Time(),
2500 false,
2501 false,
2502 COOKIE_PRIORITY_DEFAULT));
2503 ResultSavingCookieCallback<bool> callback(&other_thread_);
2504 base::Closure task = base::Bind(
2505 &net::MultiThreadedCookieMonsterTest::SetCookieWithDetailsTask,
2506 base::Unretained(this),
2507 cm, url_google_foo_, &callback);
2508 RunOnOtherThread(task);
2509 EXPECT_TRUE(callback.did_run());
2510 EXPECT_TRUE(callback.result());
2511 }
2512
2513 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
2514 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2515 CookieOptions options;
2516 Time now = Time::Now();
2517 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
2518 EXPECT_EQ(
2519 1,
2520 DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99), Time()));
2521 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
2522 ResultSavingCookieCallback<int> callback(&other_thread_);
2523 base::Closure task = base::Bind(
2524 &net::MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask,
2525 base::Unretained(this),
2526 cm, now - TimeDelta::FromDays(99),
2527 Time(), &callback);
2528 RunOnOtherThread(task);
2529 EXPECT_TRUE(callback.did_run());
2530 EXPECT_EQ(1, callback.result());
2531 }
2532
2533 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
2534 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2535 CookieOptions options;
2536 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
2537 EXPECT_EQ(1, DeleteAllForHost(cm.get(), url_google_));
2538 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
2539 ResultSavingCookieCallback<int> callback(&other_thread_);
2540 base::Closure task = base::Bind(
2541 &net::MultiThreadedCookieMonsterTest::DeleteAllForHostTask,
2542 base::Unretained(this),
2543 cm, url_google_, &callback);
2544 RunOnOtherThread(task);
2545 EXPECT_TRUE(callback.did_run());
2546 EXPECT_EQ(1, callback.result());
2547 }
2548
2549 TEST_F(MultiThreadedCookieMonsterTest,
2550 ThreadCheckDeleteAllCreatedBetweenForHost) {
2551 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2552 GURL url_not_google("http://www.notgoogle.com");
2553
2554 CookieOptions options;
2555 Time now = Time::Now();
2556 // ago1 < ago2 < ago3 < now.
2557 Time ago1 = now - TimeDelta::FromDays(101);
2558 Time ago2 = now - TimeDelta::FromDays(100);
2559 Time ago3 = now - TimeDelta::FromDays(99);
2560
2561 // These 3 cookies match the first deletion.
2562 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
2563 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "C=D", options));
2564 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "Y=Z", options));
2565
2566 // This cookie does not match host.
2567 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_not_google, "E=F", options));
2568
2569 // This cookie does not match time range: [ago3, inf], for first deletion, but
2570 // matches for the second deletion.
2571 EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "G=H", ago2));
2572
2573 // 1. First set of deletions.
2574 EXPECT_EQ(
2575 3, // Deletes A=B, C=D, Y=Z
2576 DeleteAllCreatedBetweenForHost(
2577 cm.get(), ago3, Time::Max(), url_google_));
2578
2579 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
2580 ResultSavingCookieCallback<int> callback(&other_thread_);
2581
2582 // 2. Second set of deletions.
2583 base::Closure task = base::Bind(
2584 &net::MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenForHostTask,
2585 base::Unretained(this),
2586 cm, ago1, Time(), url_google_,
2587 &callback);
2588 RunOnOtherThread(task);
2589 EXPECT_TRUE(callback.did_run());
2590 EXPECT_EQ(2, callback.result()); // Deletes A=B, G=H.
2591 }
2592
2593 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) {
2594 scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
2595 CookieOptions options;
2596 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
2597 CookieList cookies = GetAllCookies(cm.get());
2598 CookieList::iterator it = cookies.begin();
2599 EXPECT_TRUE(DeleteCanonicalCookie(cm.get(), *it));
2600
2601 EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
2602 ResultSavingCookieCallback<bool> callback(&other_thread_);
2603 cookies = GetAllCookies(cm.get());
2604 it = cookies.begin();
2605 base::Closure task = base::Bind(
2606 &net::MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask,
2607 base::Unretained(this),
2608 cm, *it, &callback);
2609 RunOnOtherThread(task);
2610 EXPECT_TRUE(callback.did_run());
2611 EXPECT_TRUE(callback.result());
2612 }
2613
2614 TEST_F(CookieMonsterTest, InvalidExpiryTime) {
2615 std::string cookie_line =
2616 std::string(kValidCookieLine) + "; expires=Blarg arg arg";
2617 scoped_ptr<CanonicalCookie> cookie(
2618 CanonicalCookie::Create(url_google_, cookie_line, Time::Now(),
2619 CookieOptions()));
2620 ASSERT_FALSE(cookie->IsPersistent());
2621 }
2622
2623 // Test that CookieMonster writes session cookies into the underlying
2624 // CookieStore if the "persist session cookies" option is on.
2625 TEST_F(CookieMonsterTest, PersistSessionCookies) {
2626 scoped_refptr<MockPersistentCookieStore> store(
2627 new MockPersistentCookieStore);
2628 scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
2629 cm->SetPersistSessionCookies(true);
2630
2631 // All cookies set with SetCookie are session cookies.
2632 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
2633 EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
2634
2635 // The cookie was written to the backing store.
2636 EXPECT_EQ(1u, store->commands().size());
2637 EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
2638 EXPECT_EQ("A", store->commands()[0].cookie.Name());
2639 EXPECT_EQ("B", store->commands()[0].cookie.Value());
2640
2641 // Modify the cookie.
2642 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=C"));
2643 EXPECT_EQ("A=C", GetCookies(cm.get(), url_google_));
2644 EXPECT_EQ(3u, store->commands().size());
2645 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
2646 EXPECT_EQ("A", store->commands()[1].cookie.Name());
2647 EXPECT_EQ("B", store->commands()[1].cookie.Value());
2648 EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
2649 EXPECT_EQ("A", store->commands()[2].cookie.Name());
2650 EXPECT_EQ("C", store->commands()[2].cookie.Value());
2651
2652 // Delete the cookie.
2653 DeleteCookie(cm.get(), url_google_, "A");
2654 EXPECT_EQ("", GetCookies(cm.get(), url_google_));
2655 EXPECT_EQ(4u, store->commands().size());
2656 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
2657 EXPECT_EQ("A", store->commands()[3].cookie.Name());
2658 EXPECT_EQ("C", store->commands()[3].cookie.Value());
2659 }
2660
2661 // Test the commands sent to the persistent cookie store.
2662 TEST_F(CookieMonsterTest, PersisentCookieStorageTest) {
2663 scoped_refptr<MockPersistentCookieStore> store(
2664 new MockPersistentCookieStore);
2665 scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
2666
2667 // Add a cookie.
2668 EXPECT_TRUE(SetCookie(
2669 cm.get(), url_google_, "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
2670 this->MatchCookieLines("A=B", GetCookies(cm.get(), url_google_));
2671 ASSERT_EQ(1u, store->commands().size());
2672 EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
2673 // Remove it.
2674 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B; max-age=0"));
2675 this->MatchCookieLines(std::string(), GetCookies(cm.get(), url_google_));
2676 ASSERT_EQ(2u, store->commands().size());
2677 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
2678
2679 // Add a cookie.
2680 EXPECT_TRUE(SetCookie(
2681 cm.get(), url_google_, "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
2682 this->MatchCookieLines("A=B", GetCookies(cm.get(), url_google_));
2683 ASSERT_EQ(3u, store->commands().size());
2684 EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
2685 // Overwrite it.
2686 EXPECT_TRUE(SetCookie(
2687 cm.get(), url_google_, "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT"));
2688 this->MatchCookieLines("A=Foo", GetCookies(cm.get(), url_google_));
2689 ASSERT_EQ(5u, store->commands().size());
2690 EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
2691 EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
2692
2693 // Create some non-persistent cookies and check that they don't go to the
2694 // persistent storage.
2695 EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=Bar"));
2696 this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm.get(), url_google_));
2697 EXPECT_EQ(5u, store->commands().size());
2698 }
2699
2700 // Test to assure that cookies with control characters are purged appropriately.
2701 // See http://crbug.com/238041 for background.
2702 TEST_F(CookieMonsterTest, ControlCharacterPurge) {
2703 const Time now1(Time::Now());
2704 const Time now2(Time::Now() + TimeDelta::FromSeconds(1));
2705 const Time now3(Time::Now() + TimeDelta::FromSeconds(2));
2706 const Time later(now1 + TimeDelta::FromDays(1));
2707 const GURL url("http://host/path");
2708 const std::string domain("host");
2709 const std::string path("/path");
2710
2711 scoped_refptr<MockPersistentCookieStore> store(
2712 new MockPersistentCookieStore);
2713
2714 std::vector<CanonicalCookie*> initial_cookies;
2715
2716 AddCookieToList(domain,
2717 "foo=bar; path=" + path,
2718 now1,
2719 &initial_cookies);
2720
2721 // We have to manually build this cookie because it contains a control
2722 // character, and our cookie line parser rejects control characters.
2723 CanonicalCookie *cc = new CanonicalCookie(url, "baz", "\x05" "boo", domain,
2724 path, now2, later, now2, false,
2725 false, COOKIE_PRIORITY_DEFAULT);
2726 initial_cookies.push_back(cc);
2727
2728 AddCookieToList(domain,
2729 "hello=world; path=" + path,
2730 now3,
2731 &initial_cookies);
2732
2733 // Inject our initial cookies into the mock PersistentCookieStore.
2734 store->SetLoadExpectation(true, initial_cookies);
2735
2736 scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
2737
2738 EXPECT_EQ("foo=bar; hello=world", GetCookies(cm.get(), url));
2739 }
2740
2741 } // namespace net