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