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