| // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "net/cookies/cookie_store_unittest.h" | |
| #include <string> | |
| #include "base/basictypes.h" | |
| #include "base/bind.h" | |
| #include "base/memory/ref_counted.h" | |
| #include "base/memory/scoped_ptr.h" | |
| #include "base/message_loop.h" | |
| #include "base/metrics/histogram.h" | |
| #include "base/metrics/histogram_samples.h" | |
| #include "base/stringprintf.h" | |
| #include "base/string_tokenizer.h" | |
| #include "base/threading/thread.h" | |
| #include "base/time.h" | |
| #include "googleurl/src/gurl.h" | |
| #include "net/cookies/canonical_cookie.h" | |
| #include "net/cookies/cookie_monster.h" | |
| #include "net/cookies/cookie_monster_store_test.h" // For CookieStore mock | |
| #include "net/cookies/cookie_util.h" | |
| #include "net/cookies/parsed_cookie.h" | |
| #include "testing/gmock/include/gmock/gmock.h" | |
| #include "testing/gtest/include/gtest/gtest.h" | |
| namespace net { | |
| using base::Time; | |
| using base::TimeDelta; | |
| namespace { | |
| // TODO(erikwright): Replace the pre-existing MockPersistentCookieStore (and | |
| // brethren) with this one, and remove the 'New' prefix. | |
| class NewMockPersistentCookieStore | |
| : public CookieMonster::PersistentCookieStore { | |
| public: | |
| MOCK_METHOD1(Load, void(const LoadedCallback& loaded_callback)); | |
| MOCK_METHOD2(LoadCookiesForKey, void(const std::string& key, | |
| const LoadedCallback& loaded_callback)); | |
| MOCK_METHOD1(AddCookie, void(const CanonicalCookie& cc)); | |
| MOCK_METHOD1(UpdateCookieAccessTime, void(const CanonicalCookie& cc)); | |
| MOCK_METHOD1(DeleteCookie, void(const CanonicalCookie& cc)); | |
| MOCK_METHOD1(Flush, void(const base::Closure& callback)); | |
| MOCK_METHOD0(SetForceKeepSessionState, void()); | |
| private: | |
| virtual ~NewMockPersistentCookieStore() {} | |
| }; | |
| const char* kTopLevelDomainPlus1 = "http://www.harvard.edu"; | |
| const char* kTopLevelDomainPlus2 = "http://www.math.harvard.edu"; | |
| const char* kTopLevelDomainPlus2Secure = "https://www.math.harvard.edu"; | |
| const char* kTopLevelDomainPlus3 = | |
| "http://www.bourbaki.math.harvard.edu"; | |
| const char* kOtherDomain = "http://www.mit.edu"; | |
| const char kUrlGoogleSpecific[] = "http://www.gmail.google.izzle"; | |
| class GetCookieListCallback : public CookieCallback { | |
| public: | |
| GetCookieListCallback() {} | |
| explicit GetCookieListCallback(Thread* run_in_thread) | |
| : CookieCallback(run_in_thread) {} | |
| void Run(const CookieList& cookies) { | |
| cookies_ = cookies; | |
| CallbackEpilogue(); | |
| } | |
| const CookieList& cookies() { return cookies_; } | |
| private: | |
| CookieList cookies_; | |
| }; | |
| struct CookieMonsterTestTraits { | |
| static scoped_refptr<CookieStore> Create() { | |
| return new CookieMonster(NULL, NULL); | |
| } | |
| static const bool is_cookie_monster = true; | |
| static const bool supports_http_only = true; | |
| static const bool supports_cookies_with_info = true; | |
| static const bool supports_non_dotted_domains = true; | |
| static const bool supports_trailing_dots = true; | |
| static const bool filters_schemes = true; | |
| static const bool has_path_prefix_bug = false; | |
| static const int creation_time_granularity_in_ms = 0; | |
| }; | |
| INSTANTIATE_TYPED_TEST_CASE_P(CookieMonster, | |
| CookieStoreTest, | |
| CookieMonsterTestTraits); | |
| INSTANTIATE_TYPED_TEST_CASE_P(CookieMonster, | |
| MultiThreadedCookieStoreTest, | |
| CookieMonsterTestTraits); | |
| class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> { | |
| protected: | |
| CookieList GetAllCookies(CookieMonster* cm) { | |
| DCHECK(cm); | |
| GetCookieListCallback callback; | |
| cm->GetAllCookiesAsync( | |
| base::Bind(&GetCookieListCallback::Run, | |
| base::Unretained(&callback))); | |
| RunFor(kTimeout); | |
| EXPECT_TRUE(callback.did_run()); | |
| return callback.cookies(); | |
| } | |
| CookieList GetAllCookiesForURL(CookieMonster* cm, | |
| const GURL& url) { | |
| DCHECK(cm); | |
| GetCookieListCallback callback; | |
| cm->GetAllCookiesForURLAsync( | |
| url, base::Bind(&GetCookieListCallback::Run, | |
| base::Unretained(&callback))); | |
| RunFor(kTimeout); | |
| EXPECT_TRUE(callback.did_run()); | |
| return callback.cookies(); | |
| } | |
| CookieList GetAllCookiesForURLWithOptions(CookieMonster* cm, | |
| const GURL& url, | |
| const CookieOptions& options) { | |
| DCHECK(cm); | |
| GetCookieListCallback callback; | |
| cm->GetAllCookiesForURLWithOptionsAsync( | |
| url, options, base::Bind(&GetCookieListCallback::Run, | |
| base::Unretained(&callback))); | |
| RunFor(kTimeout); | |
| EXPECT_TRUE(callback.did_run()); | |
| return callback.cookies(); | |
| } | |
| bool SetCookieWithDetails(CookieMonster* cm, | |
| const GURL& url, | |
| const std::string& name, | |
| const std::string& value, | |
| const std::string& domain, | |
| const std::string& path, | |
| const base::Time& expiration_time, | |
| bool secure, bool http_only) { | |
| DCHECK(cm); | |
| SetCookieCallback callback; | |
| cm->SetCookieWithDetailsAsync( | |
| url, name, value, domain, path, expiration_time, secure, http_only, | |
| base::Bind(&SetCookieCallback::Run, base::Unretained(&callback))); | |
| RunFor(kTimeout); | |
| EXPECT_TRUE(callback.did_run()); | |
| return callback.result(); | |
| } | |
| int DeleteAll(CookieMonster*cm) { | |
| DCHECK(cm); | |
| DeleteCallback callback; | |
| cm->DeleteAllAsync( | |
| base::Bind(&DeleteCallback::Run, base::Unretained(&callback))); | |
| RunFor(kTimeout); | |
| EXPECT_TRUE(callback.did_run()); | |
| return callback.num_deleted(); | |
| } | |
| int DeleteAllCreatedBetween(CookieMonster*cm, | |
| const base::Time& delete_begin, | |
| const base::Time& delete_end) { | |
| DCHECK(cm); | |
| DeleteCallback callback; | |
| cm->DeleteAllCreatedBetweenAsync( | |
| delete_begin, delete_end, | |
| base::Bind(&DeleteCallback::Run, base::Unretained(&callback))); | |
| RunFor(kTimeout); | |
| EXPECT_TRUE(callback.did_run()); | |
| return callback.num_deleted(); | |
| } | |
| int DeleteAllForHost(CookieMonster*cm, | |
| const GURL& url) { | |
| DCHECK(cm); | |
| DeleteCallback callback; | |
| cm->DeleteAllForHostAsync( | |
| url, base::Bind(&DeleteCallback::Run, base::Unretained(&callback))); | |
| RunFor(kTimeout); | |
| EXPECT_TRUE(callback.did_run()); | |
| return callback.num_deleted(); | |
| } | |
| bool DeleteCanonicalCookie(CookieMonster*cm, const CanonicalCookie& cookie) { | |
| DCHECK(cm); | |
| SetCookieCallback callback; | |
| cm->DeleteCanonicalCookieAsync( | |
| cookie, | |
| base::Bind(&SetCookieCallback::Run, base::Unretained(&callback))); | |
| RunFor(kTimeout); | |
| EXPECT_TRUE(callback.did_run()); | |
| return callback.result(); | |
| } | |
| // Helper for DeleteAllForHost test; repopulates CM with same layout | |
| // each time. | |
| void PopulateCmForDeleteAllForHost(scoped_refptr<CookieMonster> cm) { | |
| GURL url_top_level_domain_plus_1(kTopLevelDomainPlus1); | |
| GURL url_top_level_domain_plus_2(kTopLevelDomainPlus2); | |
| GURL url_top_level_domain_plus_2_secure(kTopLevelDomainPlus2Secure); | |
| GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3); | |
| GURL url_other(kOtherDomain); | |
| DeleteAll(cm); | |
| // Static population for probe: | |
| // * Three levels of domain cookie (.b.a, .c.b.a, .d.c.b.a) | |
| // * Three levels of host cookie (w.b.a, w.c.b.a, w.d.c.b.a) | |
| // * http_only cookie (w.c.b.a) | |
| // * Two secure cookies (.c.b.a, w.c.b.a) | |
| // * Two domain path cookies (.c.b.a/dir1, .c.b.a/dir1/dir2) | |
| // * Two host path cookies (w.c.b.a/dir1, w.c.b.a/dir1/dir2) | |
| // Domain cookies | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_1, | |
| "dom_1", "X", ".harvard.edu", "/", | |
| base::Time(), false, false)); | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, | |
| "dom_2", "X", ".math.harvard.edu", | |
| "/", base::Time(), false, false)); | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_3, | |
| "dom_3", "X", | |
| ".bourbaki.math.harvard.edu", "/", | |
| base::Time(), false, false)); | |
| // Host cookies | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_1, | |
| "host_1", "X", "", "/", | |
| base::Time(), false, false)); | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, | |
| "host_2", "X", "", "/", | |
| base::Time(), false, false)); | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_3, | |
| "host_3", "X", "", "/", | |
| base::Time(), false, false)); | |
| // Http_only cookie | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, | |
| "httpo_check", "X", "", "/", | |
| base::Time(), false, true)); | |
| // Secure cookies | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, | |
| url_top_level_domain_plus_2_secure, | |
| "sec_dom", "X", ".math.harvard.edu", | |
| "/", base::Time(), true, false)); | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, | |
| url_top_level_domain_plus_2_secure, | |
| "sec_host", "X", "", "/", | |
| base::Time(), true, false)); | |
| // Domain path cookies | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, | |
| "dom_path_1", "X", | |
| ".math.harvard.edu", "/dir1", | |
| base::Time(), false, false)); | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, | |
| "dom_path_2", "X", | |
| ".math.harvard.edu", "/dir1/dir2", | |
| base::Time(), false, false)); | |
| // Host path cookies | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, | |
| "host_path_1", "X", | |
| "", "/dir1", | |
| base::Time(), false, false)); | |
| EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, | |
| "host_path_2", "X", | |
| "", "/dir1/dir2", | |
| base::Time(), false, false)); | |
| EXPECT_EQ(13U, this->GetAllCookies(cm).size()); | |
| } | |
| Time GetFirstCookieAccessDate(CookieMonster* cm) { | |
| const CookieList all_cookies(this->GetAllCookies(cm)); | |
| return all_cookies.front().LastAccessDate(); | |
| } | |
| bool FindAndDeleteCookie(CookieMonster* cm, | |
| const std::string& domain, | |
| const std::string& name) { | |
| CookieList cookies = this->GetAllCookies(cm); | |
| for (CookieList::iterator it = cookies.begin(); | |
| it != cookies.end(); ++it) | |
| if (it->Domain() == domain && it->Name() == name) | |
| return this->DeleteCanonicalCookie(cm, *it); | |
| return false; | |
| } | |
| int CountInString(const std::string& str, char c) { | |
| return std::count(str.begin(), str.end(), c); | |
| } | |
| void TestHostGarbageCollectHelper( | |
| int domain_max_cookies, | |
| int domain_purge_cookies) { | |
| const int more_than_enough_cookies = | |
| (domain_max_cookies + domain_purge_cookies) * 2; | |
| // Add a bunch of cookies on a single host, should purge them. | |
| { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| for (int i = 0; i < more_than_enough_cookies; ++i) { | |
| std::string cookie = base::StringPrintf("a%03d=b", i); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, cookie)); | |
| std::string cookies = this->GetCookies(cm, url_google_); | |
| // Make sure we find it in the cookies. | |
| EXPECT_NE(cookies.find(cookie), std::string::npos); | |
| // Count the number of cookies. | |
| EXPECT_LE(CountInString(cookies, '='), domain_max_cookies); | |
| } | |
| } | |
| // Add a bunch of cookies on multiple hosts within a single eTLD. | |
| // Should keep at least kDomainMaxCookies - kDomainPurgeCookies | |
| // between them. We shouldn't go above kDomainMaxCookies for both together. | |
| GURL url_google_specific(kUrlGoogleSpecific); | |
| { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| for (int i = 0; i < more_than_enough_cookies; ++i) { | |
| std::string cookie_general = base::StringPrintf("a%03d=b", i); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, cookie_general)); | |
| std::string cookie_specific = base::StringPrintf("c%03d=b", i); | |
| EXPECT_TRUE(SetCookie(cm, url_google_specific, cookie_specific)); | |
| std::string cookies_general = this->GetCookies(cm, url_google_); | |
| EXPECT_NE(cookies_general.find(cookie_general), std::string::npos); | |
| std::string cookies_specific = | |
| this->GetCookies(cm, url_google_specific); | |
| EXPECT_NE(cookies_specific.find(cookie_specific), std::string::npos); | |
| EXPECT_LE((CountInString(cookies_general, '=') + | |
| CountInString(cookies_specific, '=')), | |
| domain_max_cookies); | |
| } | |
| // After all this, there should be at least | |
| // kDomainMaxCookies - kDomainPurgeCookies for both URLs. | |
| std::string cookies_general = this->GetCookies(cm, url_google_); | |
| std::string cookies_specific = this->GetCookies(cm, url_google_specific); | |
| int total_cookies = (CountInString(cookies_general, '=') + | |
| CountInString(cookies_specific, '=')); | |
| EXPECT_GE(total_cookies, | |
| domain_max_cookies - domain_purge_cookies); | |
| EXPECT_LE(total_cookies, domain_max_cookies); | |
| } | |
| } | |
| // Function for creating a CM with a number of cookies in it, | |
| // no store (and hence no ability to affect access time). | |
| CookieMonster* CreateMonsterForGC(int num_cookies) { | |
| CookieMonster* cm(new CookieMonster(NULL, NULL)); | |
| for (int i = 0; i < num_cookies; i++) { | |
| SetCookie(cm, GURL(StringPrintf("http://h%05d.izzle", i)), "a=1"); | |
| } | |
| return cm; | |
| } | |
| }; | |
| // TODO(erikwright): Replace the other callbacks and synchronous helper methods | |
| // in this test suite with these Mocks. | |
| template<typename T, typename C> class MockCookieCallback { | |
| public: | |
| C AsCallback() { | |
| return base::Bind(&T::Invoke, base::Unretained(static_cast<T*>(this))); | |
| } | |
| }; | |
| class MockGetCookiesCallback | |
| : public MockCookieCallback<MockGetCookiesCallback, | |
| CookieStore::GetCookiesCallback> { | |
| public: | |
| MOCK_METHOD1(Invoke, void(const std::string& cookies)); | |
| }; | |
| class MockGetCookieInfoCallback | |
| : public MockCookieCallback<MockGetCookieInfoCallback, | |
| CookieStore::GetCookieInfoCallback> { | |
| public: | |
| MOCK_METHOD2(Invoke, | |
| void(const std::string& cookies, | |
| const std::vector<CookieStore::CookieInfo>& cookie_infos)); | |
| }; | |
| class MockSetCookiesCallback | |
| : public MockCookieCallback<MockSetCookiesCallback, | |
| CookieStore::SetCookiesCallback> { | |
| public: | |
| MOCK_METHOD1(Invoke, void(bool success)); | |
| }; | |
| class MockClosure | |
| : public MockCookieCallback<MockClosure, base::Closure> { | |
| public: | |
| MOCK_METHOD0(Invoke, void(void)); | |
| }; | |
| class MockGetCookieListCallback | |
| : public MockCookieCallback<MockGetCookieListCallback, | |
| CookieMonster::GetCookieListCallback> { | |
| public: | |
| MOCK_METHOD1(Invoke, void(const CookieList& cookies)); | |
| }; | |
| class MockDeleteCallback | |
| : public MockCookieCallback<MockDeleteCallback, | |
| CookieMonster::DeleteCallback> { | |
| public: | |
| MOCK_METHOD1(Invoke, void(int num_deleted)); | |
| }; | |
| class MockDeleteCookieCallback | |
| : public MockCookieCallback<MockDeleteCookieCallback, | |
| CookieMonster::DeleteCookieCallback> { | |
| public: | |
| MOCK_METHOD1(Invoke, void(bool success)); | |
| }; | |
| ACTION(QuitCurrentMessageLoop) { | |
| MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure()); | |
| } | |
| // TODO(erikwright): When the synchronous helpers 'GetCookies' etc. are removed, | |
| // rename these, removing the 'Action' suffix. | |
| ACTION_P4(DeleteCookieAction, cookie_monster, url, name, callback) { | |
| cookie_monster->DeleteCookieAsync(url, name, callback->AsCallback()); | |
| } | |
| ACTION_P3(GetCookiesAction, cookie_monster, url, callback) { | |
| cookie_monster->GetCookiesWithOptionsAsync( | |
| url, CookieOptions(), callback->AsCallback()); | |
| } | |
| ACTION_P3(GetCookiesWithInfoAction, cookie_monster, url, callback) { | |
| cookie_monster->GetCookiesWithInfoAsync( | |
| url, CookieOptions(), callback->AsCallback()); | |
| } | |
| ACTION_P4(SetCookieAction, cookie_monster, url, cookie_line, callback) { | |
| cookie_monster->SetCookieWithOptionsAsync( | |
| url, cookie_line, CookieOptions(), callback->AsCallback()); | |
| } | |
| ACTION_P4(DeleteAllCreatedBetweenAction, | |
| cookie_monster, delete_begin, delete_end, callback) { | |
| cookie_monster->DeleteAllCreatedBetweenAsync( | |
| delete_begin, delete_end, callback->AsCallback()); | |
| } | |
| ACTION_P10(SetCookieWithDetailsAction, | |
| cookie_monster, url, name, value, domain, path, expiration_time, | |
| secure, http_only, callback) { | |
| cookie_monster->SetCookieWithDetailsAsync( | |
| url, name, value, domain, path, expiration_time, secure, http_only, | |
| callback->AsCallback()); | |
| } | |
| ACTION_P2(GetAllCookiesAction, cookie_monster, callback) { | |
| cookie_monster->GetAllCookiesAsync(callback->AsCallback()); | |
| } | |
| ACTION_P3(DeleteAllForHostAction, cookie_monster, url, callback) { | |
| cookie_monster->DeleteAllForHostAsync(url, callback->AsCallback()); | |
| } | |
| ACTION_P3(DeleteCanonicalCookieAction, cookie_monster, cookie, callback) { | |
| cookie_monster->DeleteCanonicalCookieAsync(cookie, callback->AsCallback()); | |
| } | |
| ACTION_P2(DeleteAllAction, cookie_monster, callback) { | |
| cookie_monster->DeleteAllAsync(callback->AsCallback()); | |
| } | |
| ACTION_P3(GetAllCookiesForUrlWithOptionsAction, cookie_monster, url, callback) { | |
| cookie_monster->GetAllCookiesForURLWithOptionsAsync( | |
| url, CookieOptions(), callback->AsCallback()); | |
| } | |
| ACTION_P3(GetAllCookiesForUrlAction, cookie_monster, url, callback) { | |
| cookie_monster->GetAllCookiesForURLAsync(url, callback->AsCallback()); | |
| } | |
| ACTION_P(PushCallbackAction, callback_vector) { | |
| callback_vector->push(arg1); | |
| } | |
| ACTION_P2(DeleteSessionCookiesAction, cookie_monster, callback) { | |
| cookie_monster->DeleteSessionCookiesAsync(callback->AsCallback()); | |
| } | |
| } // namespace | |
| // This test suite verifies the task deferral behaviour of the CookieMonster. | |
| // Specifically, for each asynchronous method, verify that: | |
| // 1. invoking it on an uninitialized cookie store causes the store to begin | |
| // chain-loading its backing data or loading data for a specific domain key | |
| // (eTLD+1). | |
| // 2. The initial invocation does not complete until the loading completes. | |
| // 3. Invocations after the loading has completed complete immediately. | |
| class DeferredCookieTaskTest : public CookieMonsterTest { | |
| protected: | |
| DeferredCookieTaskTest() { | |
| persistent_store_ = new NewMockPersistentCookieStore(); | |
| cookie_monster_ = new CookieMonster(persistent_store_.get(), NULL); | |
| } | |
| // Defines a cookie to be returned from PersistentCookieStore::Load | |
| void DeclareLoadedCookie(const std::string& key, | |
| const std::string& cookie_line, | |
| const base::Time& creation_time) { | |
| AddCookieToList(key, cookie_line, creation_time, &loaded_cookies_); | |
| } | |
| // Runs the message loop, waiting until PersistentCookieStore::Load is called. | |
| // Call CompleteLoadingAndWait to cause the load to complete. | |
| void WaitForLoadCall() { | |
| RunFor(kTimeout); | |
| // Verify that PeristentStore::Load was called. | |
| testing::Mock::VerifyAndClear(persistent_store_.get()); | |
| } | |
| // Invokes the PersistentCookieStore::LoadCookiesForKey completion callbacks | |
| // and PersistentCookieStore::Load completion callback and waits | |
| // until the message loop is quit. | |
| void CompleteLoadingAndWait() { | |
| while (!loaded_for_key_callbacks_.empty()) { | |
| loaded_for_key_callbacks_.front().Run(loaded_cookies_); | |
| loaded_cookies_.clear(); | |
| loaded_for_key_callbacks_.pop(); | |
| } | |
| loaded_callback_.Run(loaded_cookies_); | |
| RunFor(kTimeout); | |
| } | |
| // Performs the provided action, expecting it to cause a call to | |
| // PersistentCookieStore::Load. Call WaitForLoadCall to verify the load call | |
| // is received. | |
| void BeginWith(testing::Action<void(void)> action) { | |
| EXPECT_CALL(*this, Begin()).WillOnce(action); | |
| ExpectLoadCall(); | |
| Begin(); | |
| } | |
| void BeginWithForDomainKey(std::string key, | |
| testing::Action<void(void)> action) { | |
| EXPECT_CALL(*this, Begin()).WillOnce(action); | |
| ExpectLoadCall(); | |
| ExpectLoadForKeyCall(key, false); | |
| Begin(); | |
| } | |
| // Declares an expectation that PersistentCookieStore::Load will be called, | |
| // saving the provided callback and sending a quit to the message loop. | |
| void ExpectLoadCall() { | |
| EXPECT_CALL(*persistent_store_, Load(testing::_)).WillOnce(testing::DoAll( | |
| testing::SaveArg<0>(&loaded_callback_), | |
| QuitCurrentMessageLoop())); | |
| } | |
| // Declares an expectation that PersistentCookieStore::LoadCookiesForKey | |
| // will be called, saving the provided callback and sending a quit to the | |
| // message loop. | |
| void ExpectLoadForKeyCall(std::string key, bool quit_queue) { | |
| if (quit_queue) | |
| EXPECT_CALL(*persistent_store_, LoadCookiesForKey(key, testing::_)). | |
| WillOnce(testing::DoAll( | |
| PushCallbackAction(&loaded_for_key_callbacks_), | |
| QuitCurrentMessageLoop())); | |
| else | |
| EXPECT_CALL(*persistent_store_, LoadCookiesForKey(key, testing::_)). | |
| WillOnce(PushCallbackAction(&loaded_for_key_callbacks_)); | |
| } | |
| // Invokes the initial action. | |
| MOCK_METHOD0(Begin, void(void)); | |
| // Returns the CookieMonster instance under test. | |
| CookieMonster& cookie_monster() { return *cookie_monster_; } | |
| private: | |
| // Declares that mock expectations in this test suite are strictly ordered. | |
| testing::InSequence in_sequence_; | |
| // Holds cookies to be returned from PersistentCookieStore::Load or | |
| // PersistentCookieStore::LoadCookiesForKey. | |
| std::vector<CanonicalCookie*> loaded_cookies_; | |
| // Stores the callback passed from the CookieMonster to the | |
| // PersistentCookieStore::Load | |
| CookieMonster::PersistentCookieStore::LoadedCallback loaded_callback_; | |
| // Stores the callback passed from the CookieMonster to the | |
| // PersistentCookieStore::LoadCookiesForKey | |
| std::queue<CookieMonster::PersistentCookieStore::LoadedCallback> | |
| loaded_for_key_callbacks_; | |
| // Stores the CookieMonster under test. | |
| scoped_refptr<CookieMonster> cookie_monster_; | |
| // Stores the mock PersistentCookieStore. | |
| scoped_refptr<NewMockPersistentCookieStore> persistent_store_; | |
| }; | |
| TEST_F(DeferredCookieTaskTest, DeferredGetCookies) { | |
| DeclareLoadedCookie("www.google.izzle", | |
| "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(3)); | |
| MockGetCookiesCallback get_cookies_callback; | |
| BeginWithForDomainKey("google.izzle", GetCookiesAction( | |
| &cookie_monster(), url_google_, &get_cookies_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce( | |
| GetCookiesAction(&cookie_monster(), url_google_, &get_cookies_callback)); | |
| EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredGetCookiesWithInfo) { | |
| DeclareLoadedCookie("www.google.izzle", | |
| "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(3)); | |
| MockGetCookieInfoCallback get_cookie_info_callback; | |
| BeginWithForDomainKey("google.izzle", GetCookiesWithInfoAction( | |
| &cookie_monster(), url_google_, &get_cookie_info_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(get_cookie_info_callback, Invoke("X=1", testing::_)).WillOnce( | |
| GetCookiesWithInfoAction( | |
| &cookie_monster(), url_google_, &get_cookie_info_callback)); | |
| EXPECT_CALL(get_cookie_info_callback, Invoke("X=1", testing::_)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredSetCookie) { | |
| MockSetCookiesCallback set_cookies_callback; | |
| BeginWithForDomainKey("google.izzle", SetCookieAction( | |
| &cookie_monster(), url_google_, "A=B", &set_cookies_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce( | |
| SetCookieAction( | |
| &cookie_monster(), url_google_, "X=Y", &set_cookies_callback)); | |
| EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredDeleteCookie) { | |
| MockClosure delete_cookie_callback; | |
| BeginWithForDomainKey("google.izzle", DeleteCookieAction( | |
| &cookie_monster(), url_google_, "A", &delete_cookie_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce( | |
| DeleteCookieAction( | |
| &cookie_monster(), url_google_, "X", &delete_cookie_callback)); | |
| EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredSetCookieWithDetails) { | |
| MockSetCookiesCallback set_cookies_callback; | |
| BeginWithForDomainKey("google.izzle", SetCookieWithDetailsAction( | |
| &cookie_monster(), url_google_foo_, "A", "B", std::string(), "/foo", | |
| base::Time(), false, false, &set_cookies_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce( | |
| SetCookieWithDetailsAction( | |
| &cookie_monster(), url_google_foo_, "A", "B", std::string(), "/foo", | |
| base::Time(), false, false, &set_cookies_callback)); | |
| EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredGetAllCookies) { | |
| DeclareLoadedCookie("www.google.izzle", | |
| "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(3)); | |
| MockGetCookieListCallback get_cookie_list_callback; | |
| BeginWith(GetAllCookiesAction( | |
| &cookie_monster(), &get_cookie_list_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce( | |
| GetAllCookiesAction(&cookie_monster(), &get_cookie_list_callback)); | |
| EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlCookies) { | |
| DeclareLoadedCookie("www.google.izzle", | |
| "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(3)); | |
| MockGetCookieListCallback get_cookie_list_callback; | |
| BeginWithForDomainKey("google.izzle", GetAllCookiesForUrlAction( | |
| &cookie_monster(), url_google_, &get_cookie_list_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce( | |
| GetAllCookiesForUrlAction( | |
| &cookie_monster(), url_google_, &get_cookie_list_callback)); | |
| EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlWithOptionsCookies) { | |
| DeclareLoadedCookie("www.google.izzle", | |
| "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(3)); | |
| MockGetCookieListCallback get_cookie_list_callback; | |
| BeginWithForDomainKey("google.izzle", GetAllCookiesForUrlWithOptionsAction( | |
| &cookie_monster(), url_google_, &get_cookie_list_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce( | |
| GetAllCookiesForUrlWithOptionsAction( | |
| &cookie_monster(), url_google_, &get_cookie_list_callback)); | |
| EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCookies) { | |
| MockDeleteCallback delete_callback; | |
| BeginWith(DeleteAllAction( | |
| &cookie_monster(), &delete_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(delete_callback, Invoke(false)).WillOnce( | |
| DeleteAllAction(&cookie_monster(), &delete_callback)); | |
| EXPECT_CALL(delete_callback, Invoke(false)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCreatedBetweenCookies) { | |
| MockDeleteCallback delete_callback; | |
| BeginWith(DeleteAllCreatedBetweenAction( | |
| &cookie_monster(), base::Time(), base::Time::Now(), &delete_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(delete_callback, Invoke(false)).WillOnce( | |
| DeleteAllCreatedBetweenAction( | |
| &cookie_monster(), base::Time(), base::Time::Now(), | |
| &delete_callback)); | |
| EXPECT_CALL(delete_callback, Invoke(false)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredDeleteAllForHostCookies) { | |
| MockDeleteCallback delete_callback; | |
| BeginWithForDomainKey("google.izzle", DeleteAllForHostAction( | |
| &cookie_monster(), url_google_, &delete_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(delete_callback, Invoke(false)).WillOnce( | |
| DeleteAllForHostAction( | |
| &cookie_monster(), url_google_, &delete_callback)); | |
| EXPECT_CALL(delete_callback, Invoke(false)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) { | |
| std::vector<CanonicalCookie*> cookies; | |
| CanonicalCookie cookie = BuildCanonicalCookie( | |
| "www.google.com", "X=1; path=/", base::Time::Now()); | |
| MockDeleteCookieCallback delete_cookie_callback; | |
| BeginWith(DeleteCanonicalCookieAction( | |
| &cookie_monster(), cookie, &delete_cookie_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce( | |
| DeleteCanonicalCookieAction( | |
| &cookie_monster(), cookie, &delete_cookie_callback)); | |
| EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(DeferredCookieTaskTest, DeferredDeleteSessionCookies) { | |
| MockDeleteCallback delete_callback; | |
| BeginWith(DeleteSessionCookiesAction( | |
| &cookie_monster(), &delete_callback)); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(delete_callback, Invoke(false)).WillOnce( | |
| DeleteSessionCookiesAction(&cookie_monster(), &delete_callback)); | |
| EXPECT_CALL(delete_callback, Invoke(false)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| CompleteLoadingAndWait(); | |
| } | |
| // Verify that a series of queued tasks are executed in order upon loading of | |
| // the backing store and that new tasks received while the queued tasks are | |
| // being dispatched go to the end of the queue. | |
| TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) { | |
| DeclareLoadedCookie("www.google.izzle", | |
| "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(3)); | |
| MockGetCookiesCallback get_cookies_callback; | |
| MockSetCookiesCallback set_cookies_callback; | |
| MockClosure delete_cookie_callback; | |
| MockGetCookieInfoCallback get_cookie_info_callback; | |
| EXPECT_CALL(*this, Begin()).WillOnce(testing::DoAll( | |
| GetCookiesAction( | |
| &cookie_monster(), url_google_, &get_cookies_callback), | |
| SetCookieAction( | |
| &cookie_monster(), url_google_, "A=B", &set_cookies_callback), | |
| DeleteCookieAction( | |
| &cookie_monster(), url_google_, "A", &delete_cookie_callback))); | |
| ExpectLoadCall(); | |
| ExpectLoadForKeyCall("google.izzle", false); | |
| Begin(); | |
| WaitForLoadCall(); | |
| EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce( | |
| GetCookiesWithInfoAction( | |
| &cookie_monster(), url_google_, &get_cookie_info_callback)); | |
| EXPECT_CALL(get_cookie_info_callback, Invoke("X=1", testing::_)).WillOnce( | |
| QuitCurrentMessageLoop()); | |
| EXPECT_CALL(set_cookies_callback, Invoke(true)); | |
| EXPECT_CALL(delete_cookie_callback, Invoke()); | |
| CompleteLoadingAndWait(); | |
| } | |
| TEST_F(CookieMonsterTest, TestCookieDeleteAll) { | |
| scoped_refptr<MockPersistentCookieStore> store( | |
| new MockPersistentCookieStore); | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL)); | |
| CookieOptions options; | |
| options.set_include_httponly(); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine)); | |
| EXPECT_EQ("A=B", GetCookies(cm, url_google_)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "C=D; httponly", options)); | |
| EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm, url_google_, options)); | |
| EXPECT_EQ(2, DeleteAll(cm)); | |
| EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options)); | |
| EXPECT_EQ(0u, store->commands().size()); | |
| // Create a persistent cookie. | |
| EXPECT_TRUE(SetCookie(cm, url_google_, | |
| std::string(kValidCookieLine) + | |
| "; expires=Mon, 18-Apr-22 22:50:13 GMT")); | |
| ASSERT_EQ(1u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type); | |
| EXPECT_EQ(1, DeleteAll(cm)); // sync_to_store = true. | |
| ASSERT_EQ(2u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type); | |
| EXPECT_EQ("", GetCookiesWithOptions(cm, url_google_, options)); | |
| } | |
| TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| Time now = Time::Now(); | |
| // Nothing has been added so nothing should be deleted. | |
| EXPECT_EQ(0, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99), | |
| Time())); | |
| // Create 3 cookies with creation date of today, yesterday and the day before. | |
| EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-0=Now", now)); | |
| EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-1=Yesterday", | |
| now - TimeDelta::FromDays(1))); | |
| EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-2=DayBefore", | |
| now - TimeDelta::FromDays(2))); | |
| EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-3=ThreeDays", | |
| now - TimeDelta::FromDays(3))); | |
| EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-7=LastWeek", | |
| now - TimeDelta::FromDays(7))); | |
| // Try to delete threedays and the daybefore. | |
| EXPECT_EQ(2, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(3), | |
| now - TimeDelta::FromDays(1))); | |
| // Try to delete yesterday, also make sure that delete_end is not | |
| // inclusive. | |
| EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(2), | |
| now)); | |
| // Make sure the delete_begin is inclusive. | |
| EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(7), | |
| now)); | |
| // Delete the last (now) item. | |
| EXPECT_EQ(1, DeleteAllCreatedBetween(cm, Time(), Time())); | |
| // Really make sure everything is gone. | |
| EXPECT_EQ(0, DeleteAll(cm)); | |
| } | |
| static const int kAccessDelayMs = kLastAccessThresholdMilliseconds + 20; | |
| TEST_F(CookieMonsterTest, TestLastAccess) { | |
| scoped_refptr<CookieMonster> cm( | |
| new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds)); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=B")); | |
| const Time last_access_date(GetFirstCookieAccessDate(cm)); | |
| // Reading the cookie again immediately shouldn't update the access date, | |
| // since we're inside the threshold. | |
| EXPECT_EQ("A=B", GetCookies(cm, url_google_)); | |
| EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm)); | |
| // Reading after a short wait should update the access date. | |
| base::PlatformThread::Sleep( | |
| base::TimeDelta::FromMilliseconds(kAccessDelayMs)); | |
| EXPECT_EQ("A=B", GetCookies(cm, url_google_)); | |
| EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm)); | |
| } | |
| TEST_F(CookieMonsterTest, TestHostGarbageCollection) { | |
| TestHostGarbageCollectHelper( | |
| CookieMonster::kDomainMaxCookies, CookieMonster::kDomainPurgeCookies); | |
| } | |
| TEST_F(CookieMonsterTest, TestDeleteSingleCookie) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=B")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "C=D")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "E=F")); | |
| EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_)); | |
| EXPECT_TRUE(FindAndDeleteCookie(cm, url_google_.host(), "C")); | |
| EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_)); | |
| EXPECT_FALSE(FindAndDeleteCookie(cm, "random.host", "E")); | |
| EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_)); | |
| } | |
| TEST_F(CookieMonsterTest, SetCookieableSchemes) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| scoped_refptr<CookieMonster> cm_foo(new CookieMonster(NULL, NULL)); | |
| // Only cm_foo should allow foo:// cookies. | |
| const char* kSchemes[] = {"foo"}; | |
| cm_foo->SetCookieableSchemes(kSchemes, 1); | |
| GURL foo_url("foo://host/path"); | |
| GURL http_url("http://host/path"); | |
| EXPECT_TRUE(SetCookie(cm, http_url, "x=1")); | |
| EXPECT_FALSE(SetCookie(cm, foo_url, "x=1")); | |
| EXPECT_TRUE(SetCookie(cm_foo, foo_url, "x=1")); | |
| EXPECT_FALSE(SetCookie(cm_foo, http_url, "x=1")); | |
| } | |
| TEST_F(CookieMonsterTest, GetAllCookiesForURL) { | |
| scoped_refptr<CookieMonster> cm( | |
| new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds)); | |
| // Create an httponly cookie. | |
| CookieOptions options; | |
| options.set_include_httponly(); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B; httponly", options)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, | |
| "C=D; domain=.google.izzle", | |
| options)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_secure_, | |
| "E=F; domain=.google.izzle; secure", | |
| options)); | |
| const Time last_access_date(GetFirstCookieAccessDate(cm)); | |
| base::PlatformThread::Sleep( | |
| base::TimeDelta::FromMilliseconds(kAccessDelayMs)); | |
| // Check cookies for url. | |
| CookieList cookies = GetAllCookiesForURL(cm, url_google_); | |
| CookieList::iterator it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("A", it->Name()); | |
| ASSERT_TRUE(++it != cookies.end()); | |
| EXPECT_EQ(".google.izzle", it->Domain()); | |
| EXPECT_EQ("C", it->Name()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| // Check cookies for url excluding http-only cookies. | |
| cookies = | |
| GetAllCookiesForURLWithOptions(cm, url_google_, CookieOptions()); | |
| it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ(".google.izzle", it->Domain()); | |
| EXPECT_EQ("C", it->Name()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| // Test secure cookies. | |
| cookies = GetAllCookiesForURL(cm, url_google_secure_); | |
| it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("A", it->Name()); | |
| ASSERT_TRUE(++it != cookies.end()); | |
| EXPECT_EQ(".google.izzle", it->Domain()); | |
| EXPECT_EQ("C", it->Name()); | |
| ASSERT_TRUE(++it != cookies.end()); | |
| EXPECT_EQ(".google.izzle", it->Domain()); | |
| EXPECT_EQ("E", it->Name()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| // Reading after a short wait should not update the access date. | |
| EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm)); | |
| } | |
| TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| CookieOptions options; | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_foo_, | |
| "A=B; path=/foo;", options)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_bar_, | |
| "C=D; path=/bar;", options)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, | |
| "E=F;", options)); | |
| CookieList cookies = GetAllCookiesForURL(cm, url_google_foo_); | |
| CookieList::iterator it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("A", it->Name()); | |
| EXPECT_EQ("/foo", it->Path()); | |
| ASSERT_TRUE(++it != cookies.end()); | |
| EXPECT_EQ("E", it->Name()); | |
| EXPECT_EQ("/", it->Path()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| cookies = GetAllCookiesForURL(cm, url_google_bar_); | |
| it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("C", it->Name()); | |
| EXPECT_EQ("/bar", it->Path()); | |
| ASSERT_TRUE(++it != cookies.end()); | |
| EXPECT_EQ("E", it->Name()); | |
| EXPECT_EQ("/", it->Path()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| } | |
| TEST_F(CookieMonsterTest, DeleteCookieByName) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=A1; path=/")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=A2; path=/foo")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=A3; path=/bar")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "B=B1; path=/")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "B=B2; path=/foo")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "B=B3; path=/bar")); | |
| DeleteCookie(cm, GURL(std::string(kUrlGoogle) + "/foo/bar"), "A"); | |
| CookieList cookies = GetAllCookies(cm); | |
| size_t expected_size = 4; | |
| EXPECT_EQ(expected_size, cookies.size()); | |
| for (CookieList::iterator it = cookies.begin(); | |
| it != cookies.end(); ++it) { | |
| EXPECT_NE("A1", it->Value()); | |
| EXPECT_NE("A2", it->Value()); | |
| } | |
| } | |
| TEST_F(CookieMonsterTest, InitializeFromCookieMonster) { | |
| scoped_refptr<CookieMonster> cm_1(new CookieMonster(NULL, NULL)); | |
| CookieOptions options; | |
| EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_foo_, | |
| "A1=B; path=/foo;", | |
| options)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_bar_, | |
| "A2=D; path=/bar;", | |
| options)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_, | |
| "A3=F;", | |
| options)); | |
| CookieList cookies_1 = GetAllCookies(cm_1); | |
| scoped_refptr<CookieMonster> cm_2(new CookieMonster(NULL, NULL)); | |
| ASSERT_TRUE(cm_2->InitializeFrom(cookies_1)); | |
| CookieList cookies_2 = GetAllCookies(cm_2); | |
| size_t expected_size = 3; | |
| EXPECT_EQ(expected_size, cookies_2.size()); | |
| CookieList::iterator it = cookies_2.begin(); | |
| ASSERT_TRUE(it != cookies_2.end()); | |
| EXPECT_EQ("A1", it->Name()); | |
| EXPECT_EQ("/foo", it->Path()); | |
| ASSERT_TRUE(++it != cookies_2.end()); | |
| EXPECT_EQ("A2", it->Name()); | |
| EXPECT_EQ("/bar", it->Path()); | |
| ASSERT_TRUE(++it != cookies_2.end()); | |
| EXPECT_EQ("A3", it->Name()); | |
| EXPECT_EQ("/", it->Path()); | |
| } | |
| // Tests importing from a persistent cookie store that contains duplicate | |
| // equivalent cookies. This situation should be handled by removing the | |
| // duplicate cookie (both from the in-memory cache, and from the backing store). | |
| // | |
| // This is a regression test for: http://crbug.com/17855. | |
| TEST_F(CookieMonsterTest, DontImportDuplicateCookies) { | |
| scoped_refptr<MockPersistentCookieStore> store( | |
| new MockPersistentCookieStore); | |
| // We will fill some initial cookies into the PersistentCookieStore, | |
| // to simulate a database with 4 duplicates. Note that we need to | |
| // be careful not to have any duplicate creation times at all (as it's a | |
| // violation of a CookieMonster invariant) even if Time::Now() doesn't | |
| // move between calls. | |
| std::vector<CanonicalCookie*> initial_cookies; | |
| // Insert 4 cookies with name "X" on path "/", with varying creation | |
| // dates. We expect only the most recent one to be preserved following | |
| // the import. | |
| AddCookieToList("www.google.com", | |
| "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(3), | |
| &initial_cookies); | |
| AddCookieToList("www.google.com", | |
| "X=2; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(1), | |
| &initial_cookies); | |
| // ===> This one is the WINNER (biggest creation time). <==== | |
| AddCookieToList("www.google.com", | |
| "X=3; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(4), | |
| &initial_cookies); | |
| AddCookieToList("www.google.com", | |
| "X=4; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now(), | |
| &initial_cookies); | |
| // Insert 2 cookies with name "X" on path "/2", with varying creation | |
| // dates. We expect only the most recent one to be preserved the import. | |
| // ===> This one is the WINNER (biggest creation time). <==== | |
| AddCookieToList("www.google.com", | |
| "X=a1; path=/2; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(9), | |
| &initial_cookies); | |
| AddCookieToList("www.google.com", | |
| "X=a2; path=/2; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(2), | |
| &initial_cookies); | |
| // Insert 1 cookie with name "Y" on path "/". | |
| AddCookieToList("www.google.com", | |
| "Y=a; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| Time::Now() + TimeDelta::FromDays(10), | |
| &initial_cookies); | |
| // Inject our initial cookies into the mock PersistentCookieStore. | |
| store->SetLoadExpectation(true, initial_cookies); | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL)); | |
| // Verify that duplicates were not imported for path "/". | |
| // (If this had failed, GetCookies() would have also returned X=1, X=2, X=4). | |
| EXPECT_EQ("X=3; Y=a", GetCookies(cm, GURL("http://www.google.com/"))); | |
| // Verify that same-named cookie on a different path ("/x2") didn't get | |
| // messed up. | |
| EXPECT_EQ("X=a1; X=3; Y=a", | |
| GetCookies(cm, GURL("http://www.google.com/2/x"))); | |
| // Verify that the PersistentCookieStore was told to kill its 4 duplicates. | |
| ASSERT_EQ(4u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[0].type); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[2].type); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type); | |
| } | |
| // Tests importing from a persistent cookie store that contains cookies | |
| // with duplicate creation times. This situation should be handled by | |
| // dropping the cookies before insertion/visibility to user. | |
| // | |
| // This is a regression test for: http://crbug.com/43188. | |
| TEST_F(CookieMonsterTest, DontImportDuplicateCreationTimes) { | |
| scoped_refptr<MockPersistentCookieStore> store( | |
| new MockPersistentCookieStore); | |
| Time now(Time::Now()); | |
| Time earlier(now - TimeDelta::FromDays(1)); | |
| // Insert 8 cookies, four with the current time as creation times, and | |
| // four with the earlier time as creation times. We should only get | |
| // two cookies remaining, but which two (other than that there should | |
| // be one from each set) will be random. | |
| std::vector<CanonicalCookie*> initial_cookies; | |
| AddCookieToList("www.google.com", "X=1; path=/", now, &initial_cookies); | |
| AddCookieToList("www.google.com", "X=2; path=/", now, &initial_cookies); | |
| AddCookieToList("www.google.com", "X=3; path=/", now, &initial_cookies); | |
| AddCookieToList("www.google.com", "X=4; path=/", now, &initial_cookies); | |
| AddCookieToList("www.google.com", "Y=1; path=/", earlier, &initial_cookies); | |
| AddCookieToList("www.google.com", "Y=2; path=/", earlier, &initial_cookies); | |
| AddCookieToList("www.google.com", "Y=3; path=/", earlier, &initial_cookies); | |
| AddCookieToList("www.google.com", "Y=4; path=/", earlier, &initial_cookies); | |
| // Inject our initial cookies into the mock PersistentCookieStore. | |
| store->SetLoadExpectation(true, initial_cookies); | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL)); | |
| CookieList list(GetAllCookies(cm)); | |
| EXPECT_EQ(2U, list.size()); | |
| // Confirm that we have one of each. | |
| std::string name1(list[0].Name()); | |
| std::string name2(list[1].Name()); | |
| EXPECT_TRUE(name1 == "X" || name2 == "X"); | |
| EXPECT_TRUE(name1 == "Y" || name2 == "Y"); | |
| EXPECT_NE(name1, name2); | |
| } | |
| TEST_F(CookieMonsterTest, Delegate) { | |
| scoped_refptr<MockPersistentCookieStore> store( | |
| new MockPersistentCookieStore); | |
| scoped_refptr<MockCookieMonsterDelegate> delegate( | |
| new MockCookieMonsterDelegate); | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(store, delegate)); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=B")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "C=D")); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "E=F")); | |
| EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm, url_google_)); | |
| ASSERT_EQ(3u, delegate->changes().size()); | |
| EXPECT_FALSE(delegate->changes()[0].second); | |
| EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain()); | |
| EXPECT_EQ("A", delegate->changes()[0].first.Name()); | |
| EXPECT_EQ("B", delegate->changes()[0].first.Value()); | |
| EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain()); | |
| EXPECT_FALSE(delegate->changes()[1].second); | |
| EXPECT_EQ("C", delegate->changes()[1].first.Name()); | |
| EXPECT_EQ("D", delegate->changes()[1].first.Value()); | |
| EXPECT_EQ(url_google_.host(), delegate->changes()[2].first.Domain()); | |
| EXPECT_FALSE(delegate->changes()[2].second); | |
| EXPECT_EQ("E", delegate->changes()[2].first.Name()); | |
| EXPECT_EQ("F", delegate->changes()[2].first.Value()); | |
| delegate->reset(); | |
| EXPECT_TRUE(FindAndDeleteCookie(cm, url_google_.host(), "C")); | |
| EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_)); | |
| ASSERT_EQ(1u, delegate->changes().size()); | |
| EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain()); | |
| EXPECT_TRUE(delegate->changes()[0].second); | |
| EXPECT_EQ("C", delegate->changes()[0].first.Name()); | |
| EXPECT_EQ("D", delegate->changes()[0].first.Value()); | |
| delegate->reset(); | |
| EXPECT_FALSE(FindAndDeleteCookie(cm, "random.host", "E")); | |
| EXPECT_EQ("A=B; E=F", GetCookies(cm, url_google_)); | |
| EXPECT_EQ(0u, delegate->changes().size()); | |
| // Insert a cookie "a" for path "/path1" | |
| EXPECT_TRUE( | |
| SetCookie(cm, url_google_, "a=val1; path=/path1; " | |
| "expires=Mon, 18-Apr-22 22:50:13 GMT")); | |
| ASSERT_EQ(1u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type); | |
| ASSERT_EQ(1u, delegate->changes().size()); | |
| EXPECT_FALSE(delegate->changes()[0].second); | |
| EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain()); | |
| EXPECT_EQ("a", delegate->changes()[0].first.Name()); | |
| EXPECT_EQ("val1", delegate->changes()[0].first.Value()); | |
| delegate->reset(); | |
| // Insert a cookie "a" for path "/path1", that is httponly. This should | |
| // overwrite the non-http-only version. | |
| CookieOptions allow_httponly; | |
| allow_httponly.set_include_httponly(); | |
| EXPECT_TRUE( | |
| SetCookieWithOptions(cm, url_google_, | |
| "a=val2; path=/path1; httponly; " | |
| "expires=Mon, 18-Apr-22 22:50:14 GMT", | |
| allow_httponly)); | |
| ASSERT_EQ(3u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type); | |
| EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type); | |
| ASSERT_EQ(2u, delegate->changes().size()); | |
| EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain()); | |
| EXPECT_TRUE(delegate->changes()[0].second); | |
| EXPECT_EQ("a", delegate->changes()[0].first.Name()); | |
| EXPECT_EQ("val1", delegate->changes()[0].first.Value()); | |
| EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain()); | |
| EXPECT_FALSE(delegate->changes()[1].second); | |
| EXPECT_EQ("a", delegate->changes()[1].first.Name()); | |
| EXPECT_EQ("val2", delegate->changes()[1].first.Value()); | |
| delegate->reset(); | |
| } | |
| TEST_F(CookieMonsterTest, SetCookieWithDetails) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| EXPECT_TRUE(SetCookieWithDetails( | |
| cm, url_google_foo_, "A", "B", std::string(), "/foo", base::Time(), | |
| false, false)); | |
| EXPECT_TRUE(SetCookieWithDetails( | |
| cm, url_google_bar_, "C", "D", "google.izzle", "/bar", base::Time(), | |
| false, true)); | |
| EXPECT_TRUE(SetCookieWithDetails( | |
| cm, url_google_, "E", "F", std::string(), std::string(), base::Time(), | |
| true, false)); | |
| // Test that malformed attributes fail to set the cookie. | |
| EXPECT_FALSE(SetCookieWithDetails( | |
| cm, url_google_foo_, " A", "B", std::string(), "/foo", base::Time(), | |
| false, false)); | |
| EXPECT_FALSE(SetCookieWithDetails( | |
| cm, url_google_foo_, "A;", "B", std::string(), "/foo", base::Time(), | |
| false, false)); | |
| EXPECT_FALSE(SetCookieWithDetails( | |
| cm, url_google_foo_, "A=", "B", std::string(), "/foo", base::Time(), | |
| false, false)); | |
| EXPECT_FALSE(SetCookieWithDetails( | |
| cm, url_google_foo_, "A", "B", "google.ozzzzzzle", "foo", base::Time(), | |
| false, false)); | |
| EXPECT_FALSE(SetCookieWithDetails( | |
| cm, url_google_foo_, "A=", "B", std::string(), "foo", base::Time(), | |
| false, false)); | |
| CookieList cookies = GetAllCookiesForURL(cm, url_google_foo_); | |
| CookieList::iterator it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("A", it->Name()); | |
| EXPECT_EQ("B", it->Value()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("/foo", it->Path()); | |
| EXPECT_FALSE(it->IsPersistent()); | |
| EXPECT_FALSE(it->IsSecure()); | |
| EXPECT_FALSE(it->IsHttpOnly()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| cookies = GetAllCookiesForURL(cm, url_google_bar_); | |
| it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("C", it->Name()); | |
| EXPECT_EQ("D", it->Value()); | |
| EXPECT_EQ(".google.izzle", it->Domain()); | |
| EXPECT_EQ("/bar", it->Path()); | |
| EXPECT_FALSE(it->IsSecure()); | |
| EXPECT_TRUE(it->IsHttpOnly()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| cookies = GetAllCookiesForURL(cm, url_google_secure_); | |
| it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("E", it->Name()); | |
| EXPECT_EQ("F", it->Value()); | |
| EXPECT_EQ("/", it->Path()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_TRUE(it->IsSecure()); | |
| EXPECT_FALSE(it->IsHttpOnly()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| } | |
| TEST_F(CookieMonsterTest, DeleteAllForHost) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| // Test probes: | |
| // * Non-secure URL, mid-level (http://w.c.b.a) | |
| // * Secure URL, mid-level (https://w.c.b.a) | |
| // * URL with path, mid-level (https:/w.c.b.a/dir1/xx) | |
| // All three tests should nuke only the midlevel host cookie, | |
| // the http_only cookie, the host secure cookie, and the two host | |
| // path cookies. http_only, secure, and paths are ignored by | |
| // this call, and domain cookies arent touched. | |
| PopulateCmForDeleteAllForHost(cm); | |
| EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus3))); | |
| EXPECT_EQ("dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus2Secure))); | |
| EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1))); | |
| EXPECT_EQ("dom_path_2=X; host_path_2=X; dom_path_1=X; host_path_1=X; " | |
| "dom_1=X; dom_2=X; host_2=X; sec_dom=X; sec_host=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus2Secure + | |
| std::string("/dir1/dir2/xxx")))); | |
| EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2))); | |
| EXPECT_EQ(8U, GetAllCookies(cm).size()); | |
| EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus3))); | |
| EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus2Secure))); | |
| EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1))); | |
| EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus2Secure + | |
| std::string("/dir1/dir2/xxx")))); | |
| PopulateCmForDeleteAllForHost(cm); | |
| EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2Secure))); | |
| EXPECT_EQ(8U, GetAllCookies(cm).size()); | |
| EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus3))); | |
| EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus2Secure))); | |
| EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1))); | |
| EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus2Secure + | |
| std::string("/dir1/dir2/xxx")))); | |
| PopulateCmForDeleteAllForHost(cm); | |
| EXPECT_EQ(5, DeleteAllForHost(cm, GURL(kTopLevelDomainPlus2Secure + | |
| std::string("/dir1/xxx")))); | |
| EXPECT_EQ(8U, GetAllCookies(cm).size()); | |
| EXPECT_EQ("dom_1=X; dom_2=X; dom_3=X; host_3=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus3))); | |
| EXPECT_EQ("dom_1=X; dom_2=X; sec_dom=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus2Secure))); | |
| EXPECT_EQ("dom_1=X; host_1=X", GetCookies(cm, GURL(kTopLevelDomainPlus1))); | |
| EXPECT_EQ("dom_path_2=X; dom_path_1=X; dom_1=X; dom_2=X; sec_dom=X", | |
| GetCookies(cm, GURL(kTopLevelDomainPlus2Secure + | |
| std::string("/dir1/dir2/xxx")))); | |
| } | |
| TEST_F(CookieMonsterTest, UniqueCreationTime) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| CookieOptions options; | |
| // Add in three cookies through every public interface to the | |
| // CookieMonster and confirm that none of them have duplicate | |
| // creation times. | |
| // SetCookieWithCreationTime and SetCookieWithCreationTimeAndOptions | |
| // are not included as they aren't going to be public for very much | |
| // longer. | |
| // SetCookie, SetCookieWithOptions, SetCookieWithDetails | |
| SetCookie(cm, url_google_, "SetCookie1=A"); | |
| SetCookie(cm, url_google_, "SetCookie2=A"); | |
| SetCookie(cm, url_google_, "SetCookie3=A"); | |
| SetCookieWithOptions(cm, url_google_, "setCookieWithOptions1=A", options); | |
| SetCookieWithOptions(cm, url_google_, "setCookieWithOptions2=A", options); | |
| SetCookieWithOptions(cm, url_google_, "setCookieWithOptions3=A", options); | |
| SetCookieWithDetails(cm, url_google_, "setCookieWithDetails1", "A", | |
| ".google.com", "/", Time(), false, false); | |
| SetCookieWithDetails(cm, url_google_, "setCookieWithDetails2", "A", | |
| ".google.com", "/", Time(), false, false); | |
| SetCookieWithDetails(cm, url_google_, "setCookieWithDetails3", "A", | |
| ".google.com", "/", Time(), false, false); | |
| // Now we check | |
| CookieList cookie_list(GetAllCookies(cm)); | |
| typedef std::map<int64, CanonicalCookie> TimeCookieMap; | |
| TimeCookieMap check_map; | |
| for (CookieList::const_iterator it = cookie_list.begin(); | |
| it != cookie_list.end(); it++) { | |
| const int64 creation_date = it->CreationDate().ToInternalValue(); | |
| TimeCookieMap::const_iterator | |
| existing_cookie_it(check_map.find(creation_date)); | |
| EXPECT_TRUE(existing_cookie_it == check_map.end()) | |
| << "Cookie " << it->Name() << " has same creation date (" | |
| << it->CreationDate().ToInternalValue() | |
| << ") as previously entered cookie " | |
| << existing_cookie_it->second.Name(); | |
| if (existing_cookie_it == check_map.end()) { | |
| check_map.insert(TimeCookieMap::value_type( | |
| it->CreationDate().ToInternalValue(), *it)); | |
| } | |
| } | |
| } | |
| // Mainly a test of GetEffectiveDomain, or more specifically, of the | |
| // expected behavior of GetEffectiveDomain within the CookieMonster. | |
| TEST_F(CookieMonsterTest, GetKey) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| // This test is really only interesting if GetKey() actually does something. | |
| EXPECT_EQ("google.com", cm->GetKey("www.google.com")); | |
| EXPECT_EQ("google.izzie", cm->GetKey("www.google.izzie")); | |
| EXPECT_EQ("google.izzie", cm->GetKey(".google.izzie")); | |
| EXPECT_EQ("bbc.co.uk", cm->GetKey("bbc.co.uk")); | |
| EXPECT_EQ("bbc.co.uk", cm->GetKey("a.b.c.d.bbc.co.uk")); | |
| EXPECT_EQ("apple.com", cm->GetKey("a.b.c.d.apple.com")); | |
| EXPECT_EQ("apple.izzie", cm->GetKey("a.b.c.d.apple.izzie")); | |
| // Cases where the effective domain is null, so we use the host | |
| // as the key. | |
| EXPECT_EQ("co.uk", cm->GetKey("co.uk")); | |
| const std::string extension_name("iehocdgbbocmkdidlbnnfbmbinnahbae"); | |
| EXPECT_EQ(extension_name, cm->GetKey(extension_name)); | |
| EXPECT_EQ("com", cm->GetKey("com")); | |
| EXPECT_EQ("hostalias", cm->GetKey("hostalias")); | |
| EXPECT_EQ("localhost", cm->GetKey("localhost")); | |
| } | |
| // Test that cookies transfer from/to the backing store correctly. | |
| TEST_F(CookieMonsterTest, BackingStoreCommunication) { | |
| // Store details for cookies transforming through the backing store interface. | |
| base::Time current(base::Time::Now()); | |
| scoped_refptr<MockSimplePersistentCookieStore> store( | |
| new MockSimplePersistentCookieStore); | |
| base::Time new_access_time; | |
| base::Time expires(base::Time::Now() + base::TimeDelta::FromSeconds(100)); | |
| struct CookiesInputInfo { | |
| std::string gurl; | |
| std::string name; | |
| std::string value; | |
| std::string domain; | |
| std::string path; | |
| base::Time expires; | |
| bool secure; | |
| bool http_only; | |
| }; | |
| const CookiesInputInfo input_info[] = { | |
| {"http://a.b.google.com", "a", "1", "", "/path/to/cookie", expires, | |
| false, false}, | |
| {"https://www.google.com", "b", "2", ".google.com", "/path/from/cookie", | |
| expires + TimeDelta::FromSeconds(10), true, true}, | |
| {"https://google.com", "c", "3", "", "/another/path/to/cookie", | |
| base::Time::Now() + base::TimeDelta::FromSeconds(100), | |
| true, false} | |
| }; | |
| const int INPUT_DELETE = 1; | |
| // Create new cookies and flush them to the store. | |
| { | |
| scoped_refptr<CookieMonster> cmout(new CookieMonster(store, NULL)); | |
| for (const CookiesInputInfo* p = input_info; | |
| p < &input_info[ARRAYSIZE_UNSAFE(input_info)]; p++) { | |
| EXPECT_TRUE(SetCookieWithDetails(cmout, GURL(p->gurl), p->name, p->value, | |
| p->domain, p->path, p->expires, | |
| p->secure, p->http_only)); | |
| } | |
| DeleteCookie(cmout, GURL(std::string(input_info[INPUT_DELETE].gurl) + | |
| input_info[INPUT_DELETE].path), | |
| input_info[INPUT_DELETE].name); | |
| } | |
| // Create a new cookie monster and make sure that everything is correct | |
| { | |
| scoped_refptr<CookieMonster> cmin(new CookieMonster(store, NULL)); | |
| CookieList cookies(GetAllCookies(cmin)); | |
| ASSERT_EQ(2u, cookies.size()); | |
| // Ordering is path length, then creation time. So second cookie | |
| // will come first, and we need to swap them. | |
| std::swap(cookies[0], cookies[1]); | |
| for (int output_index = 0; output_index < 2; output_index++) { | |
| int input_index = output_index * 2; | |
| const CookiesInputInfo* input = &input_info[input_index]; | |
| const CanonicalCookie* output = &cookies[output_index]; | |
| EXPECT_EQ(input->name, output->Name()); | |
| EXPECT_EQ(input->value, output->Value()); | |
| EXPECT_EQ(GURL(input->gurl).host(), output->Domain()); | |
| EXPECT_EQ(input->path, output->Path()); | |
| EXPECT_LE(current.ToInternalValue(), | |
| output->CreationDate().ToInternalValue()); | |
| EXPECT_EQ(input->secure, output->IsSecure()); | |
| EXPECT_EQ(input->http_only, output->IsHttpOnly()); | |
| EXPECT_TRUE(output->IsPersistent()); | |
| EXPECT_EQ(input->expires.ToInternalValue(), | |
| output->ExpiryDate().ToInternalValue()); | |
| } | |
| } | |
| } | |
| TEST_F(CookieMonsterTest, CookieListOrdering) { | |
| // Put a random set of cookies into a monster and make sure | |
| // they're returned in the right order. | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| EXPECT_TRUE(SetCookie(cm, GURL("http://d.c.b.a.google.com/aa/x.html"), | |
| "c=1")); | |
| EXPECT_TRUE(SetCookie(cm, GURL("http://b.a.google.com/aa/bb/cc/x.html"), | |
| "d=1; domain=b.a.google.com")); | |
| EXPECT_TRUE(SetCookie(cm, GURL("http://b.a.google.com/aa/bb/cc/x.html"), | |
| "a=4; domain=b.a.google.com")); | |
| EXPECT_TRUE(SetCookie(cm, GURL("http://c.b.a.google.com/aa/bb/cc/x.html"), | |
| "e=1; domain=c.b.a.google.com")); | |
| EXPECT_TRUE(SetCookie(cm, GURL("http://d.c.b.a.google.com/aa/bb/x.html"), | |
| "b=1")); | |
| EXPECT_TRUE(SetCookie(cm, GURL("http://news.bbc.co.uk/midpath/x.html"), | |
| "g=10")); | |
| { | |
| unsigned int i = 0; | |
| CookieList cookies(GetAllCookiesForURL( | |
| cm, GURL("http://d.c.b.a.google.com/aa/bb/cc/dd"))); | |
| ASSERT_EQ(5u, cookies.size()); | |
| EXPECT_EQ("d", cookies[i++].Name()); | |
| EXPECT_EQ("a", cookies[i++].Name()); | |
| EXPECT_EQ("e", cookies[i++].Name()); | |
| EXPECT_EQ("b", cookies[i++].Name()); | |
| EXPECT_EQ("c", cookies[i++].Name()); | |
| } | |
| { | |
| unsigned int i = 0; | |
| CookieList cookies(GetAllCookies(cm)); | |
| ASSERT_EQ(6u, cookies.size()); | |
| EXPECT_EQ("d", cookies[i++].Name()); | |
| EXPECT_EQ("a", cookies[i++].Name()); | |
| EXPECT_EQ("e", cookies[i++].Name()); | |
| EXPECT_EQ("g", cookies[i++].Name()); | |
| EXPECT_EQ("b", cookies[i++].Name()); | |
| EXPECT_EQ("c", cookies[i++].Name()); | |
| } | |
| } | |
| // This test and CookieMonstertest.TestGCTimes (in cookie_monster_perftest.cc) | |
| // are somewhat complementary twins. This test is probing for whether | |
| // garbage collection always happens when it should (i.e. that we actually | |
| // get rid of cookies when we should). The perftest is probing for | |
| // whether garbage collection happens when it shouldn't. See comments | |
| // before that test for more details. | |
| // Disabled on Windows, see crbug.com/126095 | |
| #if defined(OS_WIN) | |
| #define MAYBE_GarbageCollectionTriggers DISABLED_GarbageCollectionTriggers | |
| #else | |
| #define MAYBE_GarbageCollectionTriggers GarbageCollectionTriggers | |
| #endif | |
| TEST_F(CookieMonsterTest, MAYBE_GarbageCollectionTriggers) { | |
| // First we check to make sure that a whole lot of recent cookies | |
| // doesn't get rid of anything after garbage collection is checked for. | |
| { | |
| scoped_refptr<CookieMonster> cm( | |
| CreateMonsterForGC(CookieMonster::kMaxCookies * 2)); | |
| EXPECT_EQ(CookieMonster::kMaxCookies * 2, GetAllCookies(cm).size()); | |
| SetCookie(cm, GURL("http://newdomain.com"), "b=2"); | |
| EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1, GetAllCookies(cm).size()); | |
| } | |
| // Now we explore a series of relationships between cookie last access | |
| // time and size of store to make sure we only get rid of cookies when | |
| // we really should. | |
| const struct TestCase { | |
| int num_cookies; | |
| int num_old_cookies; | |
| int expected_initial_cookies; | |
| // Indexed by ExpiryAndKeyScheme | |
| int expected_cookies_after_set; | |
| } test_cases[] = { | |
| { | |
| // A whole lot of recent cookies; gc shouldn't happen. | |
| CookieMonster::kMaxCookies * 2, | |
| 0, | |
| CookieMonster::kMaxCookies * 2, | |
| CookieMonster::kMaxCookies * 2 + 1 | |
| }, { | |
| // Some old cookies, but still overflowing max. | |
| CookieMonster::kMaxCookies * 2, | |
| CookieMonster::kMaxCookies / 2, | |
| CookieMonster::kMaxCookies * 2, | |
| CookieMonster::kMaxCookies * 2 - CookieMonster::kMaxCookies / 2 + 1 | |
| }, { | |
| // Old cookies enough to bring us right down to our purge line. | |
| CookieMonster::kMaxCookies * 2, | |
| CookieMonster::kMaxCookies + CookieMonster::kPurgeCookies + 1, | |
| CookieMonster::kMaxCookies * 2, | |
| CookieMonster::kMaxCookies - CookieMonster::kPurgeCookies | |
| }, { | |
| // Old cookies enough to bring below our purge line (which we | |
| // shouldn't do). | |
| CookieMonster::kMaxCookies * 2, | |
| CookieMonster::kMaxCookies * 3 / 2, | |
| CookieMonster::kMaxCookies * 2, | |
| CookieMonster::kMaxCookies - CookieMonster::kPurgeCookies | |
| } | |
| }; | |
| for (int ci = 0; ci < static_cast<int>(ARRAYSIZE_UNSAFE(test_cases)); ++ci) { | |
| const TestCase *test_case = &test_cases[ci]; | |
| scoped_refptr<CookieMonster> cm( | |
| CreateMonsterFromStoreForGC( | |
| test_case->num_cookies, test_case->num_old_cookies, | |
| CookieMonster::kSafeFromGlobalPurgeDays * 2)); | |
| EXPECT_EQ(test_case->expected_initial_cookies, | |
| static_cast<int>(GetAllCookies(cm).size())) | |
| << "For test case " << ci; | |
| // Will trigger GC | |
| SetCookie(cm, GURL("http://newdomain.com"), "b=2"); | |
| EXPECT_EQ(test_case->expected_cookies_after_set, | |
| static_cast<int>((GetAllCookies(cm).size()))) | |
| << "For test case " << ci; | |
| } | |
| } | |
| // This test checks that keep expired cookies flag is working. | |
| TEST_F(CookieMonsterTest, KeepExpiredCookies) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| cm->SetKeepExpiredCookies(); | |
| CookieOptions options; | |
| // Set a persistent cookie. | |
| ASSERT_TRUE(SetCookieWithOptions( | |
| cm, url_google_, | |
| std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT", | |
| options)); | |
| // Get the canonical cookie. | |
| CookieList cookie_list = GetAllCookies(cm); | |
| ASSERT_EQ(1U, cookie_list.size()); | |
| // Use a past expiry date to delete the cookie. | |
| ASSERT_TRUE(SetCookieWithOptions( | |
| cm, url_google_, | |
| std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT", | |
| options)); | |
| // Check that the cookie with the past expiry date is still there. | |
| // GetAllCookies() also triggers garbage collection. | |
| cookie_list = GetAllCookies(cm); | |
| ASSERT_EQ(1U, cookie_list.size()); | |
| ASSERT_TRUE(cookie_list[0].IsExpired(Time::Now())); | |
| } | |
| namespace { | |
| // Mock PersistentCookieStore that keeps track of the number of Flush() calls. | |
| class FlushablePersistentStore : public CookieMonster::PersistentCookieStore { | |
| public: | |
| FlushablePersistentStore() : flush_count_(0) {} | |
| void Load(const LoadedCallback& loaded_callback) { | |
| std::vector<CanonicalCookie*> out_cookies; | |
| MessageLoop::current()->PostTask(FROM_HERE, | |
| base::Bind(&net::LoadedCallbackTask::Run, | |
| new net::LoadedCallbackTask(loaded_callback, out_cookies))); | |
| } | |
| void LoadCookiesForKey(const std::string& key, | |
| const LoadedCallback& loaded_callback) { | |
| Load(loaded_callback); | |
| } | |
| void AddCookie(const CanonicalCookie&) {} | |
| void UpdateCookieAccessTime(const CanonicalCookie&) {} | |
| void DeleteCookie(const CanonicalCookie&) {} | |
| void SetForceKeepSessionState() {} | |
| void Flush(const base::Closure& callback) { | |
| ++flush_count_; | |
| if (!callback.is_null()) | |
| callback.Run(); | |
| } | |
| int flush_count() { | |
| return flush_count_; | |
| } | |
| private: | |
| virtual ~FlushablePersistentStore() {} | |
| volatile int flush_count_; | |
| }; | |
| // Counts the number of times Callback() has been run. | |
| class CallbackCounter : public base::RefCountedThreadSafe<CallbackCounter> { | |
| public: | |
| CallbackCounter() : callback_count_(0) {} | |
| void Callback() { | |
| ++callback_count_; | |
| } | |
| int callback_count() { | |
| return callback_count_; | |
| } | |
| private: | |
| friend class base::RefCountedThreadSafe<CallbackCounter>; | |
| ~CallbackCounter() {} | |
| volatile int callback_count_; | |
| }; | |
| } // namespace | |
| // Test that FlushStore() is forwarded to the store and callbacks are posted. | |
| TEST_F(CookieMonsterTest, FlushStore) { | |
| scoped_refptr<CallbackCounter> counter(new CallbackCounter()); | |
| scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore()); | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL)); | |
| ASSERT_EQ(0, store->flush_count()); | |
| ASSERT_EQ(0, counter->callback_count()); | |
| // Before initialization, FlushStore() should just run the callback. | |
| cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get())); | |
| MessageLoop::current()->RunAllPending(); | |
| ASSERT_EQ(0, store->flush_count()); | |
| ASSERT_EQ(1, counter->callback_count()); | |
| // NULL callback is safe. | |
| cm->FlushStore(base::Closure()); | |
| MessageLoop::current()->RunAllPending(); | |
| ASSERT_EQ(0, store->flush_count()); | |
| ASSERT_EQ(1, counter->callback_count()); | |
| // After initialization, FlushStore() should delegate to the store. | |
| GetAllCookies(cm); // Force init. | |
| cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get())); | |
| MessageLoop::current()->RunAllPending(); | |
| ASSERT_EQ(1, store->flush_count()); | |
| ASSERT_EQ(2, counter->callback_count()); | |
| // NULL callback is still safe. | |
| cm->FlushStore(base::Closure()); | |
| MessageLoop::current()->RunAllPending(); | |
| ASSERT_EQ(2, store->flush_count()); | |
| ASSERT_EQ(2, counter->callback_count()); | |
| // If there's no backing store, FlushStore() is always a safe no-op. | |
| cm = new CookieMonster(NULL, NULL); | |
| GetAllCookies(cm); // Force init. | |
| cm->FlushStore(base::Closure()); | |
| MessageLoop::current()->RunAllPending(); | |
| ASSERT_EQ(2, counter->callback_count()); | |
| cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get())); | |
| MessageLoop::current()->RunAllPending(); | |
| ASSERT_EQ(3, counter->callback_count()); | |
| } | |
| TEST_F(CookieMonsterTest, HistogramCheck) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| // Should match call in InitializeHistograms, but doesn't really matter | |
| // since the histogram should have been initialized by the CM construction | |
| // above. | |
| base::Histogram* expired_histogram = | |
| base::Histogram::FactoryGet( | |
| "Cookie.ExpirationDurationMinutes", 1, 10 * 365 * 24 * 60, 50, | |
| base::Histogram::kUmaTargetedHistogramFlag); | |
| scoped_ptr<base::HistogramSamples> samples1( | |
| expired_histogram->SnapshotSamples()); | |
| ASSERT_TRUE(SetCookieWithDetails( | |
| cm, GURL("http://fake.a.url"), "a", "b", "a.url", "/", | |
| base::Time::Now() + base::TimeDelta::FromMinutes(59), | |
| false, false)); | |
| scoped_ptr<base::HistogramSamples> samples2( | |
| expired_histogram->SnapshotSamples()); | |
| EXPECT_EQ(samples1->TotalCount() + 1, samples2->TotalCount()); | |
| // kValidCookieLine creates a session cookie. | |
| ASSERT_TRUE(SetCookie(cm, url_google_, kValidCookieLine)); | |
| scoped_ptr<base::HistogramSamples> samples3( | |
| expired_histogram->SnapshotSamples()); | |
| EXPECT_EQ(samples2->TotalCount(), samples3->TotalCount()); | |
| } | |
| namespace { | |
| class MultiThreadedCookieMonsterTest : public CookieMonsterTest { | |
| public: | |
| MultiThreadedCookieMonsterTest() : other_thread_("CMTthread") {} | |
| // Helper methods for calling the asynchronous CookieMonster methods | |
| // from a different thread. | |
| void GetAllCookiesTask(CookieMonster* cm, | |
| GetCookieListCallback* callback) { | |
| cm->GetAllCookiesAsync( | |
| base::Bind(&GetCookieListCallback::Run, base::Unretained(callback))); | |
| } | |
| void GetAllCookiesForURLTask(CookieMonster* cm, | |
| const GURL& url, | |
| GetCookieListCallback* callback) { | |
| cm->GetAllCookiesForURLAsync( | |
| url, | |
| base::Bind(&GetCookieListCallback::Run, base::Unretained(callback))); | |
| } | |
| void GetAllCookiesForURLWithOptionsTask(CookieMonster* cm, | |
| const GURL& url, | |
| const CookieOptions& options, | |
| GetCookieListCallback* callback) { | |
| cm->GetAllCookiesForURLWithOptionsAsync( | |
| url, options, | |
| base::Bind(&GetCookieListCallback::Run, base::Unretained(callback))); | |
| } | |
| void SetCookieWithDetailsTask(CookieMonster* cm, const GURL& url, | |
| SetCookieCallback* callback) { | |
| // Define the parameters here instead of in the calling fucntion. | |
| // The maximum number of parameters for Bind function is 6. | |
| std::string name = "A"; | |
| std::string value = "B"; | |
| std::string domain = std::string(); | |
| std::string path = "/foo"; | |
| base::Time expiration_time = base::Time(); | |
| bool secure = false; | |
| bool http_only = false; | |
| cm->SetCookieWithDetailsAsync( | |
| url, name, value, domain, path, expiration_time, secure, http_only, | |
| base::Bind(&SetCookieCallback::Run, base::Unretained(callback))); | |
| } | |
| void DeleteAllCreatedBetweenTask(CookieMonster* cm, | |
| const base::Time& delete_begin, | |
| const base::Time& delete_end, | |
| DeleteCallback* callback) { | |
| cm->DeleteAllCreatedBetweenAsync( | |
| delete_begin, delete_end, | |
| base::Bind(&DeleteCallback::Run, | |
| base::Unretained(callback))); | |
| } | |
| void DeleteAllForHostTask(CookieMonster* cm, | |
| const GURL& url, | |
| DeleteCallback* callback) { | |
| cm->DeleteAllForHostAsync( | |
| url, | |
| base::Bind(&DeleteCallback::Run, base::Unretained(callback))); | |
| } | |
| void DeleteCanonicalCookieTask(CookieMonster* cm, | |
| const CanonicalCookie& cookie, | |
| SetCookieCallback* callback) { | |
| cm->DeleteCanonicalCookieAsync( | |
| cookie, | |
| base::Bind(&SetCookieCallback::Run, base::Unretained(callback))); | |
| } | |
| protected: | |
| void RunOnOtherThread(const base::Closure& task) { | |
| other_thread_.Start(); | |
| other_thread_.message_loop()->PostTask(FROM_HERE, task); | |
| RunFor(kTimeout); | |
| other_thread_.Stop(); | |
| } | |
| Thread other_thread_; | |
| }; | |
| } // namespace | |
| TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=B")); | |
| CookieList cookies = GetAllCookies(cm); | |
| CookieList::const_iterator it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("A", it->Name()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| GetCookieListCallback callback(&other_thread_); | |
| base::Closure task = | |
| base::Bind(&net::MultiThreadedCookieMonsterTest::GetAllCookiesTask, | |
| base::Unretained(this), | |
| cm, &callback); | |
| RunOnOtherThread(task); | |
| EXPECT_TRUE(callback.did_run()); | |
| it = callback.cookies().begin(); | |
| ASSERT_TRUE(it != callback.cookies().end()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("A", it->Name()); | |
| ASSERT_TRUE(++it == callback.cookies().end()); | |
| } | |
| TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=B")); | |
| CookieList cookies = GetAllCookiesForURL(cm, url_google_); | |
| CookieList::const_iterator it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("A", it->Name()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| GetCookieListCallback callback(&other_thread_); | |
| base::Closure task = | |
| base::Bind(&net::MultiThreadedCookieMonsterTest::GetAllCookiesForURLTask, | |
| base::Unretained(this), | |
| cm, url_google_, &callback); | |
| RunOnOtherThread(task); | |
| EXPECT_TRUE(callback.did_run()); | |
| it = callback.cookies().begin(); | |
| ASSERT_TRUE(it != callback.cookies().end()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("A", it->Name()); | |
| ASSERT_TRUE(++it == callback.cookies().end()); | |
| } | |
| TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURLWithOpt) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=B")); | |
| CookieOptions options; | |
| CookieList cookies = | |
| GetAllCookiesForURLWithOptions(cm, url_google_, options); | |
| CookieList::const_iterator it = cookies.begin(); | |
| ASSERT_TRUE(it != cookies.end()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("A", it->Name()); | |
| ASSERT_TRUE(++it == cookies.end()); | |
| GetCookieListCallback callback(&other_thread_); | |
| base::Closure task = base::Bind( | |
| &net::MultiThreadedCookieMonsterTest::GetAllCookiesForURLWithOptionsTask, | |
| base::Unretained(this), | |
| cm, url_google_, options, &callback); | |
| RunOnOtherThread(task); | |
| EXPECT_TRUE(callback.did_run()); | |
| it = callback.cookies().begin(); | |
| ASSERT_TRUE(it != callback.cookies().end()); | |
| EXPECT_EQ("www.google.izzle", it->Domain()); | |
| EXPECT_EQ("A", it->Name()); | |
| ASSERT_TRUE(++it == callback.cookies().end()); | |
| } | |
| TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckSetCookieWithDetails) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| EXPECT_TRUE(SetCookieWithDetails( | |
| cm, url_google_foo_, | |
| "A", "B", std::string(), "/foo", base::Time(), | |
| false, false)); | |
| SetCookieCallback callback(&other_thread_); | |
| base::Closure task = base::Bind( | |
| &net::MultiThreadedCookieMonsterTest::SetCookieWithDetailsTask, | |
| base::Unretained(this), | |
| cm, url_google_foo_, &callback); | |
| RunOnOtherThread(task); | |
| EXPECT_TRUE(callback.did_run()); | |
| EXPECT_TRUE(callback.result()); | |
| } | |
| TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| CookieOptions options; | |
| Time now = Time::Now(); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options)); | |
| EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99), | |
| Time())); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options)); | |
| DeleteCallback callback(&other_thread_); | |
| base::Closure task = base::Bind( | |
| &net::MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask, | |
| base::Unretained(this), | |
| cm, now - TimeDelta::FromDays(99), | |
| Time(), &callback); | |
| RunOnOtherThread(task); | |
| EXPECT_TRUE(callback.did_run()); | |
| EXPECT_EQ(1, callback.num_deleted()); | |
| } | |
| TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| CookieOptions options; | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options)); | |
| EXPECT_EQ(1, DeleteAllForHost(cm, url_google_)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options)); | |
| DeleteCallback callback(&other_thread_); | |
| base::Closure task = base::Bind( | |
| &net::MultiThreadedCookieMonsterTest::DeleteAllForHostTask, | |
| base::Unretained(this), | |
| cm, url_google_, &callback); | |
| RunOnOtherThread(task); | |
| EXPECT_TRUE(callback.did_run()); | |
| EXPECT_EQ(1, callback.num_deleted()); | |
| } | |
| TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) { | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL)); | |
| CookieOptions options; | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options)); | |
| CookieList cookies = GetAllCookies(cm); | |
| CookieList::iterator it = cookies.begin(); | |
| EXPECT_TRUE(DeleteCanonicalCookie(cm, *it)); | |
| EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options)); | |
| SetCookieCallback callback(&other_thread_); | |
| cookies = GetAllCookies(cm); | |
| it = cookies.begin(); | |
| base::Closure task = base::Bind( | |
| &net::MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask, | |
| base::Unretained(this), | |
| cm, *it, &callback); | |
| RunOnOtherThread(task); | |
| EXPECT_TRUE(callback.did_run()); | |
| EXPECT_TRUE(callback.result()); | |
| } | |
| TEST_F(CookieMonsterTest, InvalidExpiryTime) { | |
| ParsedCookie pc(std::string(kValidCookieLine) + "; expires=Blarg arg arg"); | |
| scoped_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(url_google_, pc)); | |
| ASSERT_FALSE(cookie->IsPersistent()); | |
| } | |
| // Test that CookieMonster writes session cookies into the underlying | |
| // CookieStore if the "persist session cookies" option is on. | |
| TEST_F(CookieMonsterTest, PersistSessionCookies) { | |
| scoped_refptr<MockPersistentCookieStore> store( | |
| new MockPersistentCookieStore); | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL)); | |
| cm->SetPersistSessionCookies(true); | |
| // All cookies set with SetCookie are session cookies. | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=B")); | |
| EXPECT_EQ("A=B", GetCookies(cm, url_google_)); | |
| // The cookie was written to the backing store. | |
| EXPECT_EQ(1u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type); | |
| EXPECT_EQ("A", store->commands()[0].cookie.Name()); | |
| EXPECT_EQ("B", store->commands()[0].cookie.Value()); | |
| // Modify the cookie. | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "A=C")); | |
| EXPECT_EQ("A=C", GetCookies(cm, url_google_)); | |
| EXPECT_EQ(3u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type); | |
| EXPECT_EQ("A", store->commands()[1].cookie.Name()); | |
| EXPECT_EQ("B", store->commands()[1].cookie.Value()); | |
| EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type); | |
| EXPECT_EQ("A", store->commands()[2].cookie.Name()); | |
| EXPECT_EQ("C", store->commands()[2].cookie.Value()); | |
| // Delete the cookie. | |
| DeleteCookie(cm, url_google_, "A"); | |
| EXPECT_EQ("", GetCookies(cm, url_google_)); | |
| EXPECT_EQ(4u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type); | |
| EXPECT_EQ("A", store->commands()[3].cookie.Name()); | |
| EXPECT_EQ("C", store->commands()[3].cookie.Value()); | |
| } | |
| // Test the commands sent to the persistent cookie store. | |
| TEST_F(CookieMonsterTest, PersisentCookieStorageTest) { | |
| scoped_refptr<MockPersistentCookieStore> store( | |
| new MockPersistentCookieStore); | |
| scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL)); | |
| // Add a cookie. | |
| EXPECT_TRUE(SetCookie(cm, url_google_, | |
| "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT")); | |
| this->MatchCookieLines("A=B", GetCookies(cm, url_google_)); | |
| ASSERT_EQ(1u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type); | |
| // Remove it. | |
| EXPECT_TRUE(SetCookie(cm, url_google_,"A=B; max-age=0")); | |
| this->MatchCookieLines("", GetCookies(cm, url_google_)); | |
| ASSERT_EQ(2u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type); | |
| // Add a cookie. | |
| EXPECT_TRUE(SetCookie(cm, url_google_, | |
| "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT")); | |
| this->MatchCookieLines("A=B", GetCookies(cm, url_google_)); | |
| ASSERT_EQ(3u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type); | |
| // Overwrite it. | |
| EXPECT_TRUE(SetCookie(cm, url_google_, | |
| "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT")); | |
| this->MatchCookieLines("A=Foo", GetCookies(cm, url_google_)); | |
| ASSERT_EQ(5u, store->commands().size()); | |
| EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type); | |
| EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type); | |
| // Create some non-persistent cookies and check that they don't go to the | |
| // persistent storage. | |
| EXPECT_TRUE(SetCookie(cm, url_google_, "B=Bar")); | |
| this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm, url_google_)); | |
| EXPECT_EQ(5u, store->commands().size()); | |
| } | |
| } // namespace net |