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