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 #ifndef NET_COOKIES_COOKIE_STORE_UNITTEST_H_ 6 #define NET_COOKIES_COOKIE_STORE_UNITTEST_H_ 7 8 #include "base/bind.h" 9 #include "base/message_loop/message_loop.h" 10 #include "base/strings/string_tokenizer.h" 11 #include "base/threading/thread.h" 12 #include "net/cookies/cookie_monster.h" 13 #include "net/cookies/cookie_store.h" 14 #include "net/cookies/cookie_store_test_callbacks.h" 15 #include "testing/gtest/include/gtest/gtest.h" 16 #include "url/gurl.h" 17 18 // This file declares unittest templates that can be used to test common 19 // behavior of any CookieStore implementation. 20 // See cookie_monster_unittest.cc for an example of an implementation. 21 22 namespace net { 23 24 using base::Thread; 25 26 const int kTimeout = 1000; 27 28 const char kUrlFtp[] = "ftp://ftp.google.izzle/"; 29 const char kUrlGoogle[] = "http://www.google.izzle"; 30 const char kUrlGoogleFoo[] = "http://www.google.izzle/foo"; 31 const char kUrlGoogleBar[] = "http://www.google.izzle/bar"; 32 const char kUrlGoogleSecure[] = "https://www.google.izzle"; 33 const char kValidCookieLine[] = "A=B; path=/"; 34 const char kValidDomainCookieLine[] = "A=B; path=/; domain=google.izzle"; 35 36 // The CookieStoreTestTraits must have the following members: 37 // struct CookieStoreTestTraits { 38 // // Factory function. 39 // static scoped_refptr<CookieStore> Create(); 40 // 41 // // The cookie store is a CookieMonster. Only used to test 42 // // GetCookieMonster(). 43 // static const bool is_cookie_monster; 44 // 45 // // The cookie store supports cookies with the exclude_httponly() option. 46 // static const bool supports_http_only; 47 // 48 // // The cookie store is able to make the difference between the ".com" 49 // // and the "com" domains. 50 // static const bool supports_non_dotted_domains; 51 // 52 // // The cookie store handles the domains with trailing dots (such as "com.") 53 // // correctly. 54 // static const bool supports_trailing_dots; 55 // 56 // // The cookie store rejects cookies for invalid schemes such as ftp. 57 // static const bool filters_schemes; 58 // 59 // // The cookie store has a bug happening when a path is a substring of 60 // // another. 61 // static const bool has_path_prefix_bug; 62 // 63 // // Time to wait between two cookie insertions to ensure that cookies have 64 // // different creation times. 65 // static const int creation_time_granularity_in_ms; 66 // }; 67 68 template <class CookieStoreTestTraits> 69 class CookieStoreTest : public testing::Test { 70 protected: 71 CookieStoreTest() 72 : url_google_(kUrlGoogle), 73 url_google_secure_(kUrlGoogleSecure), 74 url_google_foo_(kUrlGoogleFoo), 75 url_google_bar_(kUrlGoogleBar) { 76 // This test may be used outside of the net test suite, and thus may not 77 // have a message loop. 78 if (!base::MessageLoop::current()) 79 message_loop_.reset(new base::MessageLoop); 80 weak_factory_.reset(new base::WeakPtrFactory<base::MessageLoop>( 81 base::MessageLoop::current())); 82 } 83 84 // Helper methods for the asynchronous Cookie Store API that call the 85 // asynchronous method and then pump the loop until the callback is invoked, 86 // finally returning the value. 87 88 std::string GetCookies(CookieStore* cs, const GURL& url) { 89 DCHECK(cs); 90 CookieOptions options; 91 if (!CookieStoreTestTraits::supports_http_only) 92 options.set_include_httponly(); 93 StringResultCookieCallback callback; 94 cs->GetCookiesWithOptionsAsync( 95 url, options, 96 base::Bind(&StringResultCookieCallback::Run, 97 base::Unretained(&callback))); 98 RunFor(kTimeout); 99 EXPECT_TRUE(callback.did_run()); 100 return callback.result(); 101 } 102 103 std::string GetCookiesWithOptions(CookieStore* cs, 104 const GURL& url, 105 const CookieOptions& options) { 106 DCHECK(cs); 107 StringResultCookieCallback callback; 108 cs->GetCookiesWithOptionsAsync( 109 url, options, base::Bind(&StringResultCookieCallback::Run, 110 base::Unretained(&callback))); 111 RunFor(kTimeout); 112 EXPECT_TRUE(callback.did_run()); 113 return callback.result(); 114 } 115 116 bool SetCookieWithOptions(CookieStore* cs, 117 const GURL& url, 118 const std::string& cookie_line, 119 const CookieOptions& options) { 120 DCHECK(cs); 121 ResultSavingCookieCallback<bool> callback; 122 cs->SetCookieWithOptionsAsync( 123 url, cookie_line, options, 124 base::Bind( 125 &ResultSavingCookieCallback<bool>::Run, 126 base::Unretained(&callback))); 127 RunFor(kTimeout); 128 EXPECT_TRUE(callback.did_run()); 129 return callback.result(); 130 } 131 132 bool SetCookieWithServerTime(CookieStore* cs, 133 const GURL& url, 134 const std::string& cookie_line, 135 const base::Time& server_time) { 136 CookieOptions options; 137 if (!CookieStoreTestTraits::supports_http_only) 138 options.set_include_httponly(); 139 options.set_server_time(server_time); 140 return SetCookieWithOptions(cs, url, cookie_line, options); 141 } 142 143 bool SetCookie(CookieStore* cs, 144 const GURL& url, 145 const std::string& cookie_line) { 146 CookieOptions options; 147 if (!CookieStoreTestTraits::supports_http_only) 148 options.set_include_httponly(); 149 return SetCookieWithOptions(cs, url, cookie_line, options); 150 } 151 152 void DeleteCookie(CookieStore* cs, 153 const GURL& url, 154 const std::string& cookie_name) { 155 DCHECK(cs); 156 NoResultCookieCallback callback; 157 cs->DeleteCookieAsync( 158 url, cookie_name, 159 base::Bind(&NoResultCookieCallback::Run, base::Unretained(&callback))); 160 RunFor(kTimeout); 161 EXPECT_TRUE(callback.did_run()); 162 } 163 164 int DeleteCreatedBetween(CookieStore* cs, 165 const base::Time& delete_begin, 166 const base::Time& delete_end) { 167 DCHECK(cs); 168 ResultSavingCookieCallback<int> callback; 169 cs->DeleteAllCreatedBetweenAsync( 170 delete_begin, delete_end, 171 base::Bind( 172 &ResultSavingCookieCallback<int>::Run, 173 base::Unretained(&callback))); 174 RunFor(kTimeout); 175 EXPECT_TRUE(callback.did_run()); 176 return callback.result(); 177 } 178 179 int DeleteAllCreatedBetweenForHost(CookieStore* cs, 180 const base::Time delete_begin, 181 const base::Time delete_end, 182 const GURL& url) { 183 DCHECK(cs); 184 ResultSavingCookieCallback<int> callback; 185 cs->DeleteAllCreatedBetweenForHostAsync( 186 delete_begin, delete_end, url, 187 base::Bind( 188 &ResultSavingCookieCallback<int>::Run, 189 base::Unretained(&callback))); 190 RunFor(kTimeout); 191 EXPECT_TRUE(callback.did_run()); 192 return callback.result(); 193 } 194 195 int DeleteSessionCookies(CookieStore* cs) { 196 DCHECK(cs); 197 ResultSavingCookieCallback<int> callback; 198 cs->DeleteSessionCookiesAsync( 199 base::Bind( 200 &ResultSavingCookieCallback<int>::Run, 201 base::Unretained(&callback))); 202 RunFor(kTimeout); 203 EXPECT_TRUE(callback.did_run()); 204 return callback.result(); 205 } 206 207 void RunFor(int ms) { 208 // Runs the test thread message loop for up to |ms| milliseconds. 209 base::MessageLoop::current()->PostDelayedTask( 210 FROM_HERE, 211 base::Bind(&base::MessageLoop::Quit, weak_factory_->GetWeakPtr()), 212 base::TimeDelta::FromMilliseconds(ms)); 213 base::MessageLoop::current()->Run(); 214 weak_factory_->InvalidateWeakPtrs(); 215 } 216 217 scoped_refptr<CookieStore> GetCookieStore() { 218 return CookieStoreTestTraits::Create(); 219 } 220 221 // Compares two cookie lines. 222 void MatchCookieLines(const std::string& line1, const std::string& line2) { 223 EXPECT_EQ(TokenizeCookieLine(line1), TokenizeCookieLine(line2)); 224 } 225 226 // Check the cookie line by polling until equality or a timeout is reached. 227 void MatchCookieLineWithTimeout(CookieStore* cs, 228 const GURL& url, 229 const std::string& line) { 230 std::string cookies = GetCookies(cs, url); 231 bool matched = (TokenizeCookieLine(line) == TokenizeCookieLine(cookies)); 232 base::Time polling_end_date = base::Time::Now() + 233 base::TimeDelta::FromMilliseconds( 234 CookieStoreTestTraits::creation_time_granularity_in_ms); 235 236 while (!matched && base::Time::Now() <= polling_end_date) { 237 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); 238 cookies = GetCookies(cs, url); 239 matched = (TokenizeCookieLine(line) == TokenizeCookieLine(cookies)); 240 } 241 242 EXPECT_TRUE(matched) << "\"" << cookies 243 << "\" does not match \"" << line << "\""; 244 } 245 246 GURL url_google_; 247 GURL url_google_secure_; 248 GURL url_google_foo_; 249 GURL url_google_bar_; 250 251 scoped_ptr<base::WeakPtrFactory<base::MessageLoop> > weak_factory_; 252 scoped_ptr<base::MessageLoop> message_loop_; 253 254 private: 255 // Returns a set of strings of type "name=value". Fails in case of duplicate. 256 std::set<std::string> TokenizeCookieLine(const std::string& line) { 257 std::set<std::string> tokens; 258 base::StringTokenizer tokenizer(line, " ;"); 259 while (tokenizer.GetNext()) 260 EXPECT_TRUE(tokens.insert(tokenizer.token()).second); 261 return tokens; 262 } 263 }; 264 265 TYPED_TEST_CASE_P(CookieStoreTest); 266 267 TYPED_TEST_P(CookieStoreTest, TypeTest) { 268 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 269 EXPECT_EQ(cs->GetCookieMonster(), 270 (TypeParam::is_cookie_monster) ? 271 static_cast<CookieMonster*>(cs.get()) : NULL); 272 } 273 274 TYPED_TEST_P(CookieStoreTest, DomainTest) { 275 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 276 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B")); 277 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 278 EXPECT_TRUE(this->SetCookie( 279 cs.get(), this->url_google_, "C=D; domain=.google.izzle")); 280 this->MatchCookieLines("A=B; C=D", 281 this->GetCookies(cs.get(), this->url_google_)); 282 283 // Verify that A=B was set as a host cookie rather than a domain 284 // cookie -- should not be accessible from a sub sub-domain. 285 this->MatchCookieLines( 286 "C=D", this->GetCookies(cs.get(), GURL("http://foo.www.google.izzle"))); 287 288 // Test and make sure we find domain cookies on the same domain. 289 EXPECT_TRUE(this->SetCookie( 290 cs.get(), this->url_google_, "E=F; domain=.www.google.izzle")); 291 this->MatchCookieLines("A=B; C=D; E=F", 292 this->GetCookies(cs.get(), this->url_google_)); 293 294 // Test setting a domain= that doesn't start w/ a dot, should 295 // treat it as a domain cookie, as if there was a pre-pended dot. 296 EXPECT_TRUE(this->SetCookie( 297 cs.get(), this->url_google_, "G=H; domain=www.google.izzle")); 298 this->MatchCookieLines("A=B; C=D; E=F; G=H", 299 this->GetCookies(cs.get(), this->url_google_)); 300 301 // Test domain enforcement, should fail on a sub-domain or something too deep. 302 EXPECT_FALSE( 303 this->SetCookie(cs.get(), this->url_google_, "I=J; domain=.izzle")); 304 this->MatchCookieLines(std::string(), 305 this->GetCookies(cs.get(), GURL("http://a.izzle"))); 306 EXPECT_FALSE(this->SetCookie( 307 cs.get(), this->url_google_, "K=L; domain=.bla.www.google.izzle")); 308 this->MatchCookieLines( 309 "C=D; E=F; G=H", 310 this->GetCookies(cs.get(), GURL("http://bla.www.google.izzle"))); 311 this->MatchCookieLines("A=B; C=D; E=F; G=H", 312 this->GetCookies(cs.get(), this->url_google_)); 313 } 314 315 // FireFox recognizes domains containing trailing periods as valid. 316 // IE and Safari do not. Assert the expected policy here. 317 TYPED_TEST_P(CookieStoreTest, DomainWithTrailingDotTest) { 318 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 319 EXPECT_FALSE(this->SetCookie( 320 cs.get(), this->url_google_, "a=1; domain=.www.google.com.")); 321 EXPECT_FALSE(this->SetCookie( 322 cs.get(), this->url_google_, "b=2; domain=.www.google.com..")); 323 this->MatchCookieLines(std::string(), 324 this->GetCookies(cs.get(), this->url_google_)); 325 } 326 327 // Test that cookies can bet set on higher level domains. 328 // http://b/issue?id=896491 329 TYPED_TEST_P(CookieStoreTest, ValidSubdomainTest) { 330 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 331 GURL url_abcd("http://a.b.c.d.com"); 332 GURL url_bcd("http://b.c.d.com"); 333 GURL url_cd("http://c.d.com"); 334 GURL url_d("http://d.com"); 335 336 EXPECT_TRUE(this->SetCookie(cs.get(), url_abcd, "a=1; domain=.a.b.c.d.com")); 337 EXPECT_TRUE(this->SetCookie(cs.get(), url_abcd, "b=2; domain=.b.c.d.com")); 338 EXPECT_TRUE(this->SetCookie(cs.get(), url_abcd, "c=3; domain=.c.d.com")); 339 EXPECT_TRUE(this->SetCookie(cs.get(), url_abcd, "d=4; domain=.d.com")); 340 341 this->MatchCookieLines("a=1; b=2; c=3; d=4", 342 this->GetCookies(cs.get(), url_abcd)); 343 this->MatchCookieLines("b=2; c=3; d=4", this->GetCookies(cs.get(), url_bcd)); 344 this->MatchCookieLines("c=3; d=4", this->GetCookies(cs.get(), url_cd)); 345 this->MatchCookieLines("d=4", this->GetCookies(cs.get(), url_d)); 346 347 // Check that the same cookie can exist on different sub-domains. 348 EXPECT_TRUE(this->SetCookie(cs.get(), url_bcd, "X=bcd; domain=.b.c.d.com")); 349 EXPECT_TRUE(this->SetCookie(cs.get(), url_bcd, "X=cd; domain=.c.d.com")); 350 this->MatchCookieLines("b=2; c=3; d=4; X=bcd; X=cd", 351 this->GetCookies(cs.get(), url_bcd)); 352 this->MatchCookieLines("c=3; d=4; X=cd", this->GetCookies(cs.get(), url_cd)); 353 } 354 355 // Test that setting a cookie which specifies an invalid domain has 356 // no side-effect. An invalid domain in this context is one which does 357 // not match the originating domain. 358 // http://b/issue?id=896472 359 TYPED_TEST_P(CookieStoreTest, InvalidDomainTest) { 360 { 361 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 362 GURL url_foobar("http://foo.bar.com"); 363 364 // More specific sub-domain than allowed. 365 EXPECT_FALSE( 366 this->SetCookie(cs.get(), url_foobar, "a=1; domain=.yo.foo.bar.com")); 367 368 EXPECT_FALSE(this->SetCookie(cs.get(), url_foobar, "b=2; domain=.foo.com")); 369 EXPECT_FALSE( 370 this->SetCookie(cs.get(), url_foobar, "c=3; domain=.bar.foo.com")); 371 372 // Different TLD, but the rest is a substring. 373 EXPECT_FALSE( 374 this->SetCookie(cs.get(), url_foobar, "d=4; domain=.foo.bar.com.net")); 375 376 // A substring that isn't really a parent domain. 377 EXPECT_FALSE(this->SetCookie(cs.get(), url_foobar, "e=5; domain=ar.com")); 378 379 // Completely invalid domains: 380 EXPECT_FALSE(this->SetCookie(cs.get(), url_foobar, "f=6; domain=.")); 381 EXPECT_FALSE(this->SetCookie(cs.get(), url_foobar, "g=7; domain=/")); 382 EXPECT_FALSE(this->SetCookie( 383 cs.get(), url_foobar, "h=8; domain=http://foo.bar.com")); 384 EXPECT_FALSE( 385 this->SetCookie(cs.get(), url_foobar, "i=9; domain=..foo.bar.com")); 386 EXPECT_FALSE( 387 this->SetCookie(cs.get(), url_foobar, "j=10; domain=..bar.com")); 388 389 // Make sure there isn't something quirky in the domain canonicalization 390 // that supports full URL semantics. 391 EXPECT_FALSE(this->SetCookie( 392 cs.get(), url_foobar, "k=11; domain=.foo.bar.com?blah")); 393 EXPECT_FALSE(this->SetCookie( 394 cs.get(), url_foobar, "l=12; domain=.foo.bar.com/blah")); 395 EXPECT_FALSE( 396 this->SetCookie(cs.get(), url_foobar, "m=13; domain=.foo.bar.com:80")); 397 EXPECT_FALSE( 398 this->SetCookie(cs.get(), url_foobar, "n=14; domain=.foo.bar.com:")); 399 EXPECT_FALSE( 400 this->SetCookie(cs.get(), url_foobar, "o=15; domain=.foo.bar.com#sup")); 401 402 this->MatchCookieLines(std::string(), 403 this->GetCookies(cs.get(), url_foobar)); 404 } 405 406 { 407 // Make sure the cookie code hasn't gotten its subdomain string handling 408 // reversed, missed a suffix check, etc. It's important here that the two 409 // hosts below have the same domain + registry. 410 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 411 GURL url_foocom("http://foo.com.com"); 412 EXPECT_FALSE( 413 this->SetCookie(cs.get(), url_foocom, "a=1; domain=.foo.com.com.com")); 414 this->MatchCookieLines(std::string(), 415 this->GetCookies(cs.get(), url_foocom)); 416 } 417 } 418 419 // Test the behavior of omitting dot prefix from domain, should 420 // function the same as FireFox. 421 // http://b/issue?id=889898 422 TYPED_TEST_P(CookieStoreTest, DomainWithoutLeadingDotTest) { 423 { // The omission of dot results in setting a domain cookie. 424 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 425 GURL url_hosted("http://manage.hosted.filefront.com"); 426 GURL url_filefront("http://www.filefront.com"); 427 EXPECT_TRUE( 428 this->SetCookie(cs.get(), url_hosted, "sawAd=1; domain=filefront.com")); 429 this->MatchCookieLines("sawAd=1", this->GetCookies(cs.get(), url_hosted)); 430 this->MatchCookieLines("sawAd=1", 431 this->GetCookies(cs.get(), url_filefront)); 432 } 433 434 { // Even when the domains match exactly, don't consider it host cookie. 435 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 436 GURL url("http://www.google.com"); 437 EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1; domain=www.google.com")); 438 this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url)); 439 this->MatchCookieLines( 440 "a=1", this->GetCookies(cs.get(), GURL("http://sub.www.google.com"))); 441 this->MatchCookieLines( 442 std::string(), 443 this->GetCookies(cs.get(), GURL("http://something-else.com"))); 444 } 445 } 446 447 // Test that the domain specified in cookie string is treated case-insensitive 448 // http://b/issue?id=896475. 449 TYPED_TEST_P(CookieStoreTest, CaseInsensitiveDomainTest) { 450 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 451 GURL url("http://www.google.com"); 452 EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1; domain=.GOOGLE.COM")); 453 EXPECT_TRUE(this->SetCookie(cs.get(), url, "b=2; domain=.wWw.gOOgLE.coM")); 454 this->MatchCookieLines("a=1; b=2", this->GetCookies(cs.get(), url)); 455 } 456 457 TYPED_TEST_P(CookieStoreTest, TestIpAddress) { 458 GURL url_ip("http://1.2.3.4/weee"); 459 { 460 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 461 EXPECT_TRUE(this->SetCookie(cs.get(), url_ip, kValidCookieLine)); 462 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), url_ip)); 463 } 464 465 { // IP addresses should not be able to set domain cookies. 466 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 467 EXPECT_FALSE(this->SetCookie(cs.get(), url_ip, "b=2; domain=.1.2.3.4")); 468 EXPECT_FALSE(this->SetCookie(cs.get(), url_ip, "c=3; domain=.3.4")); 469 this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url_ip)); 470 // It should be allowed to set a cookie if domain= matches the IP address 471 // exactly. This matches IE/Firefox, even though it seems a bit wrong. 472 EXPECT_FALSE(this->SetCookie(cs.get(), url_ip, "b=2; domain=1.2.3.3")); 473 this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url_ip)); 474 EXPECT_TRUE(this->SetCookie(cs.get(), url_ip, "b=2; domain=1.2.3.4")); 475 this->MatchCookieLines("b=2", this->GetCookies(cs.get(), url_ip)); 476 } 477 } 478 479 // Test host cookies, and setting of cookies on TLD. 480 TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) { 481 { 482 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 483 GURL url("http://com/"); 484 // Allow setting on "com", (but only as a host cookie). 485 EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1")); 486 EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=.com")); 487 EXPECT_FALSE(this->SetCookie(cs.get(), url, "c=3; domain=com")); 488 this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url)); 489 // Make sure it doesn't show up for a normal .com, it should be a host 490 // not a domain cookie. 491 this->MatchCookieLines( 492 std::string(), 493 this->GetCookies(cs.get(), GURL("http://hopefully-no-cookies.com/"))); 494 if (TypeParam::supports_non_dotted_domains) { 495 this->MatchCookieLines(std::string(), 496 this->GetCookies(cs.get(), GURL("http://.com/"))); 497 } 498 } 499 500 { 501 // http://com. should be treated the same as http://com. 502 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 503 GURL url("http://com./index.html"); 504 if (TypeParam::supports_trailing_dots) { 505 EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1")); 506 this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url)); 507 this->MatchCookieLines( 508 std::string(), 509 this->GetCookies(cs.get(), 510 GURL("http://hopefully-no-cookies.com./"))); 511 } else { 512 EXPECT_FALSE(this->SetCookie(cs.get(), url, "a=1")); 513 } 514 } 515 516 { // Should not be able to set host cookie from a subdomain. 517 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 518 GURL url("http://a.b"); 519 EXPECT_FALSE(this->SetCookie(cs.get(), url, "a=1; domain=.b")); 520 EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=b")); 521 this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url)); 522 } 523 524 { // Same test as above, but explicitly on a known TLD (com). 525 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 526 GURL url("http://google.com"); 527 EXPECT_FALSE(this->SetCookie(cs.get(), url, "a=1; domain=.com")); 528 EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=com")); 529 this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url)); 530 } 531 532 { // Make sure can't set cookie on TLD which is dotted. 533 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 534 GURL url("http://google.co.uk"); 535 EXPECT_FALSE(this->SetCookie(cs.get(), url, "a=1; domain=.co.uk")); 536 EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=.uk")); 537 this->MatchCookieLines(std::string(), this->GetCookies(cs.get(), url)); 538 this->MatchCookieLines( 539 std::string(), 540 this->GetCookies(cs.get(), GURL("http://something-else.co.uk"))); 541 this->MatchCookieLines( 542 std::string(), 543 this->GetCookies(cs.get(), GURL("http://something-else.uk"))); 544 } 545 546 { // Intranet URLs should only be able to set host cookies. 547 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 548 GURL url("http://b"); 549 EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1")); 550 EXPECT_FALSE(this->SetCookie(cs.get(), url, "b=2; domain=.b")); 551 EXPECT_FALSE(this->SetCookie(cs.get(), url, "c=3; domain=b")); 552 this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url)); 553 } 554 } 555 556 // Test reading/writing cookies when the domain ends with a period, 557 // as in "www.google.com." 558 TYPED_TEST_P(CookieStoreTest, TestHostEndsWithDot) { 559 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 560 GURL url("http://www.google.com"); 561 GURL url_with_dot("http://www.google.com."); 562 EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1")); 563 this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url)); 564 565 if (TypeParam::supports_trailing_dots) { 566 // Do not share cookie space with the dot version of domain. 567 // Note: this is not what FireFox does, but it _is_ what IE+Safari do. 568 EXPECT_FALSE( 569 this->SetCookie(cs.get(), url, "b=2; domain=.www.google.com.")); 570 this->MatchCookieLines("a=1", this->GetCookies(cs.get(), url)); 571 572 EXPECT_TRUE( 573 this->SetCookie(cs.get(), url_with_dot, "b=2; domain=.google.com.")); 574 this->MatchCookieLines("b=2", this->GetCookies(cs.get(), url_with_dot)); 575 } else { 576 EXPECT_TRUE(this->SetCookie(cs.get(), url, "b=2; domain=.www.google.com.")); 577 EXPECT_FALSE( 578 this->SetCookie(cs.get(), url_with_dot, "b=2; domain=.google.com.")); 579 } 580 581 // Make sure there weren't any side effects. 582 this->MatchCookieLines( 583 std::string(), 584 this->GetCookies(cs.get(), GURL("http://hopefully-no-cookies.com/"))); 585 this->MatchCookieLines(std::string(), 586 this->GetCookies(cs.get(), GURL("http://.com/"))); 587 } 588 589 TYPED_TEST_P(CookieStoreTest, InvalidScheme) { 590 if (!TypeParam::filters_schemes) 591 return; 592 593 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 594 EXPECT_FALSE(this->SetCookie(cs.get(), GURL(kUrlFtp), kValidCookieLine)); 595 } 596 597 TYPED_TEST_P(CookieStoreTest, InvalidScheme_Read) { 598 if (!TypeParam::filters_schemes) 599 return; 600 601 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 602 EXPECT_TRUE( 603 this->SetCookie(cs.get(), GURL(kUrlGoogle), kValidDomainCookieLine)); 604 this->MatchCookieLines(std::string(), 605 this->GetCookies(cs.get(), GURL(kUrlFtp))); 606 } 607 608 TYPED_TEST_P(CookieStoreTest, PathTest) { 609 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 610 std::string url("http://www.google.izzle"); 611 EXPECT_TRUE(this->SetCookie(cs.get(), GURL(url), "A=B; path=/wee")); 612 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), GURL(url + "/wee"))); 613 this->MatchCookieLines("A=B", 614 this->GetCookies(cs.get(), GURL(url + "/wee/"))); 615 this->MatchCookieLines("A=B", 616 this->GetCookies(cs.get(), GURL(url + "/wee/war"))); 617 this->MatchCookieLines( 618 "A=B", this->GetCookies(cs.get(), GURL(url + "/wee/war/more/more"))); 619 if (!TypeParam::has_path_prefix_bug) 620 this->MatchCookieLines(std::string(), 621 this->GetCookies(cs.get(), GURL(url + "/weehee"))); 622 this->MatchCookieLines(std::string(), 623 this->GetCookies(cs.get(), GURL(url + "/"))); 624 625 // If we add a 0 length path, it should default to / 626 EXPECT_TRUE(this->SetCookie(cs.get(), GURL(url), "A=C; path=")); 627 this->MatchCookieLines("A=B; A=C", 628 this->GetCookies(cs.get(), GURL(url + "/wee"))); 629 this->MatchCookieLines("A=C", this->GetCookies(cs.get(), GURL(url + "/"))); 630 } 631 632 TYPED_TEST_P(CookieStoreTest, EmptyExpires) { 633 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 634 CookieOptions options; 635 if (!TypeParam::supports_http_only) 636 options.set_include_httponly(); 637 GURL url("http://www7.ipdl.inpit.go.jp/Tokujitu/tjkta.ipdl?N0000=108"); 638 std::string set_cookie_line = 639 "ACSTM=20130308043820420042; path=/; domain=ipdl.inpit.go.jp; Expires="; 640 std::string cookie_line = "ACSTM=20130308043820420042"; 641 642 this->SetCookieWithOptions(cs.get(), url, set_cookie_line, options); 643 this->MatchCookieLines(cookie_line, 644 this->GetCookiesWithOptions(cs.get(), url, options)); 645 646 options.set_server_time(base::Time::Now() - base::TimeDelta::FromHours(1)); 647 this->SetCookieWithOptions(cs.get(), url, set_cookie_line, options); 648 this->MatchCookieLines(cookie_line, 649 this->GetCookiesWithOptions(cs.get(), url, options)); 650 651 options.set_server_time(base::Time::Now() + base::TimeDelta::FromHours(1)); 652 this->SetCookieWithOptions(cs.get(), url, set_cookie_line, options); 653 this->MatchCookieLines(cookie_line, 654 this->GetCookiesWithOptions(cs.get(), url, options)); 655 } 656 657 TYPED_TEST_P(CookieStoreTest, HttpOnlyTest) { 658 if (!TypeParam::supports_http_only) 659 return; 660 661 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 662 CookieOptions options; 663 options.set_include_httponly(); 664 665 // Create a httponly cookie. 666 EXPECT_TRUE(this->SetCookieWithOptions( 667 cs.get(), this->url_google_, "A=B; httponly", options)); 668 669 // Check httponly read protection. 670 this->MatchCookieLines(std::string(), 671 this->GetCookies(cs.get(), this->url_google_)); 672 this->MatchCookieLines( 673 "A=B", this->GetCookiesWithOptions(cs.get(), this->url_google_, options)); 674 675 // Check httponly overwrite protection. 676 EXPECT_FALSE(this->SetCookie(cs.get(), this->url_google_, "A=C")); 677 this->MatchCookieLines(std::string(), 678 this->GetCookies(cs.get(), this->url_google_)); 679 this->MatchCookieLines( 680 "A=B", this->GetCookiesWithOptions(cs.get(), this->url_google_, options)); 681 EXPECT_TRUE( 682 this->SetCookieWithOptions(cs.get(), this->url_google_, "A=C", options)); 683 this->MatchCookieLines("A=C", this->GetCookies(cs.get(), this->url_google_)); 684 685 // Check httponly create protection. 686 EXPECT_FALSE(this->SetCookie(cs.get(), this->url_google_, "B=A; httponly")); 687 this->MatchCookieLines( 688 "A=C", this->GetCookiesWithOptions(cs.get(), this->url_google_, options)); 689 EXPECT_TRUE(this->SetCookieWithOptions( 690 cs.get(), this->url_google_, "B=A; httponly", options)); 691 this->MatchCookieLines( 692 "A=C; B=A", 693 this->GetCookiesWithOptions(cs.get(), this->url_google_, options)); 694 this->MatchCookieLines("A=C", this->GetCookies(cs.get(), this->url_google_)); 695 } 696 697 TYPED_TEST_P(CookieStoreTest, TestCookieDeletion) { 698 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 699 700 // Create a session cookie. 701 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, kValidCookieLine)); 702 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 703 // Delete it via Max-Age. 704 EXPECT_TRUE(this->SetCookie(cs.get(), 705 this->url_google_, 706 std::string(kValidCookieLine) + "; max-age=0")); 707 this->MatchCookieLineWithTimeout(cs.get(), this->url_google_, std::string()); 708 709 // Create a session cookie. 710 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, kValidCookieLine)); 711 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 712 // Delete it via Expires. 713 EXPECT_TRUE(this->SetCookie(cs.get(), 714 this->url_google_, 715 std::string(kValidCookieLine) + 716 "; expires=Mon, 18-Apr-1977 22:50:13 GMT")); 717 this->MatchCookieLines(std::string(), 718 this->GetCookies(cs.get(), this->url_google_)); 719 720 // Create a persistent cookie. 721 EXPECT_TRUE(this->SetCookie( 722 cs.get(), 723 this->url_google_, 724 std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT")); 725 726 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 727 // Delete it via Max-Age. 728 EXPECT_TRUE(this->SetCookie(cs.get(), 729 this->url_google_, 730 std::string(kValidCookieLine) + "; max-age=0")); 731 this->MatchCookieLineWithTimeout(cs.get(), this->url_google_, std::string()); 732 733 // Create a persistent cookie. 734 EXPECT_TRUE(this->SetCookie( 735 cs.get(), 736 this->url_google_, 737 std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT")); 738 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 739 // Delete it via Expires. 740 EXPECT_TRUE(this->SetCookie(cs.get(), 741 this->url_google_, 742 std::string(kValidCookieLine) + 743 "; expires=Mon, 18-Apr-1977 22:50:13 GMT")); 744 this->MatchCookieLines(std::string(), 745 this->GetCookies(cs.get(), this->url_google_)); 746 747 // Create a persistent cookie. 748 EXPECT_TRUE(this->SetCookie( 749 cs.get(), 750 this->url_google_, 751 std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT")); 752 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 753 // Check that it is not deleted with significant enough clock skew. 754 base::Time server_time; 755 EXPECT_TRUE(base::Time::FromString("Sun, 17-Apr-1977 22:50:13 GMT", 756 &server_time)); 757 EXPECT_TRUE(this->SetCookieWithServerTime( 758 cs.get(), 759 this->url_google_, 760 std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT", 761 server_time)); 762 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 763 764 // Create a persistent cookie. 765 EXPECT_TRUE(this->SetCookie( 766 cs.get(), 767 this->url_google_, 768 std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT")); 769 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 770 // Delete it via Expires, with a unix epoch of 0. 771 EXPECT_TRUE(this->SetCookie(cs.get(), 772 this->url_google_, 773 std::string(kValidCookieLine) + 774 "; expires=Thu, 1-Jan-1970 00:00:00 GMT")); 775 this->MatchCookieLines(std::string(), 776 this->GetCookies(cs.get(), this->url_google_)); 777 } 778 779 TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) { 780 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 781 const base::Time last_month = base::Time::Now() - 782 base::TimeDelta::FromDays(30); 783 const base::Time last_minute = base::Time::Now() - 784 base::TimeDelta::FromMinutes(1); 785 const base::Time next_minute = base::Time::Now() + 786 base::TimeDelta::FromMinutes(1); 787 const base::Time next_month = base::Time::Now() + 788 base::TimeDelta::FromDays(30); 789 790 // Add a cookie. 791 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B")); 792 // Check that the cookie is in the store. 793 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 794 795 // Remove cookies in empty intervals. 796 EXPECT_EQ(0, this->DeleteCreatedBetween(cs.get(), last_month, last_minute)); 797 EXPECT_EQ(0, this->DeleteCreatedBetween(cs.get(), next_minute, next_month)); 798 // Check that the cookie is still there. 799 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 800 801 // Remove the cookie with an interval defined by two dates. 802 EXPECT_EQ(1, this->DeleteCreatedBetween(cs.get(), last_minute, next_minute)); 803 // Check that the cookie disappeared. 804 this->MatchCookieLines(std::string(), 805 this->GetCookies(cs.get(), this->url_google_)); 806 807 // Add another cookie. 808 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "C=D")); 809 // Check that the cookie is in the store. 810 this->MatchCookieLines("C=D", this->GetCookies(cs.get(), this->url_google_)); 811 812 // Remove the cookie with a null ending time. 813 EXPECT_EQ(1, this->DeleteCreatedBetween(cs.get(), last_minute, base::Time())); 814 // Check that the cookie disappeared. 815 this->MatchCookieLines(std::string(), 816 this->GetCookies(cs.get(), this->url_google_)); 817 } 818 819 TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetweenForHost) { 820 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 821 GURL url_not_google("http://www.notgoogle.com"); 822 base::Time now = base::Time::Now(); 823 824 // These 3 cookies match the time range and host. 825 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B")); 826 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "C=D")); 827 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "Y=Z")); 828 829 // This cookie does not match host. 830 EXPECT_TRUE(this->SetCookie(cs.get(), url_not_google, "E=F")); 831 832 // Delete cookies. 833 EXPECT_EQ( 834 3, // Deletes A=B, C=D, Y=Z 835 this->DeleteAllCreatedBetweenForHost( 836 cs.get(), now, base::Time::Max(), this->url_google_)); 837 } 838 839 TYPED_TEST_P(CookieStoreTest, TestSecure) { 840 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 841 842 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B")); 843 this->MatchCookieLines("A=B", 844 this->GetCookies(cs.get(), this->url_google_)); 845 this->MatchCookieLines( 846 "A=B", this->GetCookies(cs.get(), this->url_google_secure_)); 847 848 EXPECT_TRUE( 849 this->SetCookie(cs.get(), this->url_google_secure_, "A=B; secure")); 850 // The secure should overwrite the non-secure. 851 this->MatchCookieLines(std::string(), 852 this->GetCookies(cs.get(), this->url_google_)); 853 this->MatchCookieLines("A=B", 854 this->GetCookies(cs.get(), this->url_google_secure_)); 855 856 EXPECT_TRUE( 857 this->SetCookie(cs.get(), this->url_google_secure_, "D=E; secure")); 858 this->MatchCookieLines(std::string(), 859 this->GetCookies(cs.get(), this->url_google_)); 860 this->MatchCookieLines("A=B; D=E", 861 this->GetCookies(cs.get(), this->url_google_secure_)); 862 863 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_secure_, "A=B")); 864 // The non-secure should overwrite the secure. 865 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 866 this->MatchCookieLines("D=E; A=B", 867 this->GetCookies(cs.get(), this->url_google_secure_)); 868 } 869 870 static const int kLastAccessThresholdMilliseconds = 200; 871 872 // Formerly NetUtilTest.CookieTest back when we used wininet's cookie handling. 873 TYPED_TEST_P(CookieStoreTest, NetUtilCookieTest) { 874 const GURL test_url("http://mojo.jojo.google.izzle/"); 875 876 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 877 878 EXPECT_TRUE(this->SetCookie(cs.get(), test_url, "foo=bar")); 879 std::string value = this->GetCookies(cs.get(), test_url); 880 this->MatchCookieLines("foo=bar", value); 881 882 // test that we can retrieve all cookies: 883 EXPECT_TRUE(this->SetCookie(cs.get(), test_url, "x=1")); 884 EXPECT_TRUE(this->SetCookie(cs.get(), test_url, "y=2")); 885 886 std::string result = this->GetCookies(cs.get(), test_url); 887 EXPECT_FALSE(result.empty()); 888 EXPECT_NE(result.find("x=1"), std::string::npos) << result; 889 EXPECT_NE(result.find("y=2"), std::string::npos) << result; 890 } 891 892 TYPED_TEST_P(CookieStoreTest, OverwritePersistentCookie) { 893 GURL url_google("http://www.google.com/"); 894 GURL url_chromium("http://chromium.org"); 895 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 896 897 // Insert a cookie "a" for path "/path1" 898 EXPECT_TRUE(this->SetCookie(cs.get(), 899 url_google, 900 "a=val1; path=/path1; " 901 "expires=Mon, 18-Apr-22 22:50:13 GMT")); 902 903 // Insert a cookie "b" for path "/path1" 904 EXPECT_TRUE(this->SetCookie(cs.get(), 905 url_google, 906 "b=val1; path=/path1; " 907 "expires=Mon, 18-Apr-22 22:50:14 GMT")); 908 909 // Insert a cookie "b" for path "/path1", that is httponly. This should 910 // overwrite the non-http-only version. 911 CookieOptions allow_httponly; 912 allow_httponly.set_include_httponly(); 913 EXPECT_TRUE(this->SetCookieWithOptions(cs.get(), 914 url_google, 915 "b=val2; path=/path1; httponly; " 916 "expires=Mon, 18-Apr-22 22:50:14 GMT", 917 allow_httponly)); 918 919 // Insert a cookie "a" for path "/path1". This should overwrite. 920 EXPECT_TRUE(this->SetCookie(cs.get(), 921 url_google, 922 "a=val33; path=/path1; " 923 "expires=Mon, 18-Apr-22 22:50:14 GMT")); 924 925 // Insert a cookie "a" for path "/path2". This should NOT overwrite 926 // cookie "a", since the path is different. 927 EXPECT_TRUE(this->SetCookie(cs.get(), 928 url_google, 929 "a=val9; path=/path2; " 930 "expires=Mon, 18-Apr-22 22:50:14 GMT")); 931 932 // Insert a cookie "a" for path "/path1", but this time for "chromium.org". 933 // Although the name and path match, the hostnames do not, so shouldn't 934 // overwrite. 935 EXPECT_TRUE(this->SetCookie(cs.get(), 936 url_chromium, 937 "a=val99; path=/path1; " 938 "expires=Mon, 18-Apr-22 22:50:14 GMT")); 939 940 if (TypeParam::supports_http_only) { 941 this->MatchCookieLines( 942 "a=val33", 943 this->GetCookies(cs.get(), GURL("http://www.google.com/path1"))); 944 } else { 945 this->MatchCookieLines( 946 "a=val33; b=val2", 947 this->GetCookies(cs.get(), GURL("http://www.google.com/path1"))); 948 } 949 this->MatchCookieLines( 950 "a=val9", 951 this->GetCookies(cs.get(), GURL("http://www.google.com/path2"))); 952 this->MatchCookieLines( 953 "a=val99", this->GetCookies(cs.get(), GURL("http://chromium.org/path1"))); 954 } 955 956 TYPED_TEST_P(CookieStoreTest, CookieOrdering) { 957 // Put a random set of cookies into a store and make sure they're returned in 958 // the right order. 959 // Cookies should be sorted by path length and creation time, as per RFC6265. 960 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 961 EXPECT_TRUE(this->SetCookie( 962 cs.get(), GURL("http://d.c.b.a.google.com/aa/x.html"), "c=1")); 963 EXPECT_TRUE(this->SetCookie(cs.get(), 964 GURL("http://b.a.google.com/aa/bb/cc/x.html"), 965 "d=1; domain=b.a.google.com")); 966 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 967 TypeParam::creation_time_granularity_in_ms)); 968 EXPECT_TRUE(this->SetCookie(cs.get(), 969 GURL("http://b.a.google.com/aa/bb/cc/x.html"), 970 "a=4; domain=b.a.google.com")); 971 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 972 TypeParam::creation_time_granularity_in_ms)); 973 EXPECT_TRUE(this->SetCookie(cs.get(), 974 GURL("http://c.b.a.google.com/aa/bb/cc/x.html"), 975 "e=1; domain=c.b.a.google.com")); 976 EXPECT_TRUE(this->SetCookie( 977 cs.get(), GURL("http://d.c.b.a.google.com/aa/bb/x.html"), "b=1")); 978 EXPECT_TRUE(this->SetCookie( 979 cs.get(), GURL("http://news.bbc.co.uk/midpath/x.html"), "g=10")); 980 EXPECT_EQ("d=1; a=4; e=1; b=1; c=1", 981 this->GetCookies(cs.get(), 982 GURL("http://d.c.b.a.google.com/aa/bb/cc/dd"))); 983 } 984 985 TYPED_TEST_P(CookieStoreTest, DeleteSessionCookie) { 986 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 987 // Create a session cookie and a persistent cookie. 988 EXPECT_TRUE(this->SetCookie( 989 cs.get(), this->url_google_, std::string(kValidCookieLine))); 990 EXPECT_TRUE(this->SetCookie(cs.get(), 991 this->url_google_, 992 "C=D; path=/; domain=google.izzle;" 993 "expires=Mon, 18-Apr-22 22:50:13 GMT")); 994 this->MatchCookieLines("A=B; C=D", 995 this->GetCookies(cs.get(), this->url_google_)); 996 // Delete the session cookie. 997 this->DeleteSessionCookies(cs.get()); 998 // Check that the session cookie has been deleted but not the persistent one. 999 EXPECT_EQ("C=D", this->GetCookies(cs.get(), this->url_google_)); 1000 } 1001 1002 REGISTER_TYPED_TEST_CASE_P(CookieStoreTest, 1003 TypeTest, 1004 DomainTest, 1005 DomainWithTrailingDotTest, 1006 ValidSubdomainTest, 1007 InvalidDomainTest, 1008 DomainWithoutLeadingDotTest, 1009 CaseInsensitiveDomainTest, 1010 TestIpAddress, 1011 TestNonDottedAndTLD, 1012 TestHostEndsWithDot, 1013 InvalidScheme, 1014 InvalidScheme_Read, 1015 PathTest, 1016 EmptyExpires, 1017 HttpOnlyTest, 1018 TestCookieDeletion, 1019 TestDeleteAllCreatedBetween, 1020 TestDeleteAllCreatedBetweenForHost, 1021 TestSecure, 1022 NetUtilCookieTest, 1023 OverwritePersistentCookie, 1024 CookieOrdering, 1025 DeleteSessionCookie); 1026 1027 template<class CookieStoreTestTraits> 1028 class MultiThreadedCookieStoreTest : 1029 public CookieStoreTest<CookieStoreTestTraits> { 1030 public: 1031 MultiThreadedCookieStoreTest() : other_thread_("CMTthread") {} 1032 1033 // Helper methods for calling the asynchronous CookieStore methods 1034 // from a different thread. 1035 1036 void GetCookiesTask(CookieStore* cs, 1037 const GURL& url, 1038 StringResultCookieCallback* callback) { 1039 CookieOptions options; 1040 if (!CookieStoreTestTraits::supports_http_only) 1041 options.set_include_httponly(); 1042 cs->GetCookiesWithOptionsAsync( 1043 url, options, 1044 base::Bind(&StringResultCookieCallback::Run, 1045 base::Unretained(callback))); 1046 } 1047 1048 void GetCookiesWithOptionsTask(CookieStore* cs, 1049 const GURL& url, 1050 const CookieOptions& options, 1051 StringResultCookieCallback* callback) { 1052 cs->GetCookiesWithOptionsAsync( 1053 url, options, 1054 base::Bind(&StringResultCookieCallback::Run, 1055 base::Unretained(callback))); 1056 } 1057 1058 void SetCookieWithOptionsTask(CookieStore* cs, 1059 const GURL& url, 1060 const std::string& cookie_line, 1061 const CookieOptions& options, 1062 ResultSavingCookieCallback<bool>* callback) { 1063 cs->SetCookieWithOptionsAsync( 1064 url, cookie_line, options, 1065 base::Bind( 1066 &ResultSavingCookieCallback<bool>::Run, 1067 base::Unretained(callback))); 1068 } 1069 1070 void DeleteCookieTask(CookieStore* cs, 1071 const GURL& url, 1072 const std::string& cookie_name, 1073 NoResultCookieCallback* callback) { 1074 cs->DeleteCookieAsync( 1075 url, cookie_name, 1076 base::Bind(&NoResultCookieCallback::Run, base::Unretained(callback))); 1077 } 1078 1079 void DeleteSessionCookiesTask(CookieStore* cs, 1080 ResultSavingCookieCallback<int>* callback) { 1081 cs->DeleteSessionCookiesAsync( 1082 base::Bind( 1083 &ResultSavingCookieCallback<int>::Run, 1084 base::Unretained(callback))); 1085 } 1086 1087 protected: 1088 void RunOnOtherThread(const base::Closure& task) { 1089 other_thread_.Start(); 1090 other_thread_.message_loop()->PostTask(FROM_HERE, task); 1091 CookieStoreTest<CookieStoreTestTraits>::RunFor(kTimeout); 1092 other_thread_.Stop(); 1093 } 1094 1095 Thread other_thread_; 1096 }; 1097 1098 TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest); 1099 1100 // TODO(ycxiao): Eventually, we will need to create a separate thread, create 1101 // the cookie store on that thread (or at least its store, i.e., the DB 1102 // thread). 1103 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookies) { 1104 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 1105 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B")); 1106 this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_)); 1107 StringResultCookieCallback callback(&this->other_thread_); 1108 base::Closure task = base::Bind( 1109 &net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesTask, 1110 base::Unretained(this), 1111 cs, this->url_google_, &callback); 1112 this->RunOnOtherThread(task); 1113 EXPECT_TRUE(callback.did_run()); 1114 EXPECT_EQ("A=B", callback.result()); 1115 } 1116 1117 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookiesWithOptions) { 1118 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 1119 CookieOptions options; 1120 if (!TypeParam::supports_http_only) 1121 options.set_include_httponly(); 1122 EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B")); 1123 this->MatchCookieLines( 1124 "A=B", this->GetCookiesWithOptions(cs.get(), this->url_google_, options)); 1125 StringResultCookieCallback callback(&this->other_thread_); 1126 base::Closure task = base::Bind( 1127 &net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesWithOptionsTask, 1128 base::Unretained(this), 1129 cs, this->url_google_, options, &callback); 1130 this->RunOnOtherThread(task); 1131 EXPECT_TRUE(callback.did_run()); 1132 EXPECT_EQ("A=B", callback.result()); 1133 } 1134 1135 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckSetCookieWithOptions) { 1136 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 1137 CookieOptions options; 1138 if (!TypeParam::supports_http_only) 1139 options.set_include_httponly(); 1140 EXPECT_TRUE( 1141 this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options)); 1142 ResultSavingCookieCallback<bool> callback(&this->other_thread_); 1143 base::Closure task = base::Bind( 1144 &net::MultiThreadedCookieStoreTest<TypeParam>::SetCookieWithOptionsTask, 1145 base::Unretained(this), 1146 cs, this->url_google_, "A=B", options, &callback); 1147 this->RunOnOtherThread(task); 1148 EXPECT_TRUE(callback.did_run()); 1149 EXPECT_TRUE(callback.result()); 1150 } 1151 1152 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteCookie) { 1153 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 1154 CookieOptions options; 1155 if (!TypeParam::supports_http_only) 1156 options.set_include_httponly(); 1157 EXPECT_TRUE( 1158 this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options)); 1159 this->DeleteCookie(cs.get(), this->url_google_, "A"); 1160 EXPECT_TRUE( 1161 this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options)); 1162 NoResultCookieCallback callback(&this->other_thread_); 1163 base::Closure task = base::Bind( 1164 &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteCookieTask, 1165 base::Unretained(this), 1166 cs, this->url_google_, "A", &callback); 1167 this->RunOnOtherThread(task); 1168 EXPECT_TRUE(callback.did_run()); 1169 } 1170 1171 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteSessionCookies) { 1172 scoped_refptr<CookieStore> cs(this->GetCookieStore()); 1173 CookieOptions options; 1174 if (!TypeParam::supports_http_only) 1175 options.set_include_httponly(); 1176 EXPECT_TRUE( 1177 this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options)); 1178 EXPECT_TRUE( 1179 this->SetCookieWithOptions(cs.get(), 1180 this->url_google_, 1181 "B=C; expires=Mon, 18-Apr-22 22:50:13 GMT", 1182 options)); 1183 EXPECT_EQ(1, this->DeleteSessionCookies(cs.get())); 1184 EXPECT_EQ(0, this->DeleteSessionCookies(cs.get())); 1185 EXPECT_TRUE( 1186 this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options)); 1187 ResultSavingCookieCallback<int> callback(&this->other_thread_); 1188 base::Closure task = base::Bind( 1189 &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteSessionCookiesTask, 1190 base::Unretained(this), 1191 cs, &callback); 1192 this->RunOnOtherThread(task); 1193 EXPECT_TRUE(callback.did_run()); 1194 EXPECT_EQ(1, callback.result()); 1195 } 1196 1197 REGISTER_TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest, 1198 ThreadCheckGetCookies, 1199 ThreadCheckGetCookiesWithOptions, 1200 ThreadCheckSetCookieWithOptions, 1201 ThreadCheckDeleteCookie, 1202 ThreadCheckDeleteSessionCookies); 1203 1204 } // namespace net 1205 1206 #endif // NET_COOKIES_COOKIE_STORE_UNITTEST_H_ 1207
