Google Git
Sign in
cobalt / cobalt / 19589f994026f63df553a83799ef841b566baff9 / . / src / net / cookies / cookie_monster_unittest.cc
blob: 38f73783a710b1c0359447ecb361b0ec471d1731 [file] [log] [blame]
// 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 {
size_t num_cookies;
size_t num_old_cookies;
size_t expected_initial_cookies;
// Indexed by ExpiryAndKeyScheme
size_t 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,
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,
(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()->RunUntilIdle();
ASSERT_EQ(0, store->flush_count());
ASSERT_EQ(1, counter->callback_count());
// NULL callback is safe.
cm->FlushStore(base::Closure());
MessageLoop::current()->RunUntilIdle();
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()->RunUntilIdle();
ASSERT_EQ(1, store->flush_count());
ASSERT_EQ(2, counter->callback_count());
// NULL callback is still safe.
cm->FlushStore(base::Closure());
MessageLoop::current()->RunUntilIdle();
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()->RunUntilIdle();
ASSERT_EQ(2, counter->callback_count());
cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
MessageLoop::current()->RunUntilIdle();
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) {
std::string cookie_line =
std::string(kValidCookieLine) + "; expires=Blarg arg arg";
scoped_ptr<CanonicalCookie> cookie(
CanonicalCookie::Create(url_google_, cookie_line, Time::Now(),
CookieOptions()));
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