Google Git
Sign in
chromium / chromium / src / dd5dd98f5f59f4f53274308ec0a7dca74aba6525 / . / net / cookies / cookie_monster_unittest.cc
blob: cd7ab02c868f7dd634e899a735141d86ea8ab64f [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_monster.h"
#include <algorithm>
#include <memory>
#include <string>
#include <vector>
#include "base/bind.h"
#include "base/location.h"
#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted.h"
#include "base/metrics/histogram.h"
#include "base/metrics/histogram_samples.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_split.h"
#include "base/strings/string_tokenizer.h"
#include "base/strings/stringprintf.h"
#include "base/test/histogram_tester.h"
#include "base/threading/thread.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/time/time.h"
#include "net/cookies/canonical_cookie.h"
#include "net/cookies/cookie_constants.h"
#include "net/cookies/cookie_monster_store_test.h" // For CookieStore mock
#include "net/cookies/cookie_store_unittest.h"
#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"
#include "url/gurl.h"
namespace net {
using CookiePredicate = CookieStore::CookiePredicate;
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));
virtual void Flush(const base::Closure& callback) {
if (!callback.is_null())
base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
}
MOCK_METHOD0(SetForceKeepSessionState, void());
private:
virtual ~NewMockPersistentCookieStore() {}
};
// False means 'less than or equal', so we test both ways for full equal.
MATCHER_P(CookieEquals, expected, "") {
return !(arg.FullCompare(expected) || expected.FullCompare(arg));
}
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";
bool AlwaysTrueCookiePredicate(CanonicalCookie* to_save,
const CanonicalCookie& cookie) {
if (to_save)
*to_save = cookie;
return true;
}
bool AlwaysFalseCookiePredicate(CanonicalCookie* to_save,
const CanonicalCookie& cookie) {
if (to_save)
*to_save = cookie;
return false;
}
bool CookieValuePredicate(const std::string& true_value,
const CanonicalCookie& cookie) {
return cookie.Value() == true_value;
}
struct CookieMonsterTestTraits {
static std::unique_ptr<CookieStore> Create() {
return base::WrapUnique(new CookieMonster(nullptr, nullptr));
}
static const bool supports_http_only = true;
static const bool supports_non_dotted_domains = true;
static const bool preserves_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;
static const bool enforce_strict_secure = false;
};
struct CookieMonsterEnforcingStrictSecure {
static std::unique_ptr<CookieStore> Create() {
return base::WrapUnique(new CookieMonster(nullptr, nullptr));
}
static const bool supports_http_only = true;
static const bool supports_non_dotted_domains = true;
static const bool preserves_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;
static const bool enforce_strict_secure = true;
};
INSTANTIATE_TYPED_TEST_CASE_P(CookieMonster,
CookieStoreTest,
CookieMonsterTestTraits);
INSTANTIATE_TYPED_TEST_CASE_P(CookieMonsterStrictSecure,
CookieStoreTest,
CookieMonsterEnforcingStrictSecure);
template <typename T>
class CookieMonsterTestBase : public CookieStoreTest<T> {
public:
using CookieStoreTest<T>::SetCookie;
protected:
using CookieStoreTest<T>::http_www_google_;
using CookieStoreTest<T>::https_www_google_;
CookieList GetAllCookiesForURLWithOptions(CookieMonster* cm,
const GURL& url,
const CookieOptions& options) {
DCHECK(cm);
GetCookieListCallback callback;
cm->GetCookieListWithOptionsAsync(
url, options,
base::Bind(&GetCookieListCallback::Run, base::Unretained(&callback)));
callback.WaitUntilDone();
return callback.cookies();
}
bool SetAllCookies(CookieMonster* cm, const CookieList& list) {
DCHECK(cm);
ResultSavingCookieCallback<bool> callback;
cm->SetAllCookiesAsync(list,
base::Bind(&ResultSavingCookieCallback<bool>::Run,
base::Unretained(&callback)));
callback.WaitUntilDone();
return callback.result();
}
int DeleteAllCreatedBetween(CookieMonster* cm,
const base::Time& delete_begin,
const base::Time& delete_end) {
DCHECK(cm);
ResultSavingCookieCallback<int> callback;
cm->DeleteAllCreatedBetweenAsync(
delete_begin, delete_end,
base::Bind(&ResultSavingCookieCallback<int>::Run,
base::Unretained(&callback)));
callback.WaitUntilDone();
return callback.result();
}
int DeleteAllCreatedBetweenWithPredicate(CookieMonster* cm,
const base::Time delete_begin,
const base::Time delete_end,
const CookiePredicate& predicate) {
DCHECK(cm);
ResultSavingCookieCallback<int> callback;
cm->DeleteAllCreatedBetweenWithPredicateAsync(
delete_begin, delete_end, predicate,
base::Bind(&ResultSavingCookieCallback<int>::Run,
base::Unretained(&callback)));
callback.WaitUntilDone();
return callback.result();
}
// Helper for PredicateSeesAllCookies test; repopulates CM with same layout
// each time.
void PopulateCmForPredicateCheck(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);
this->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)
// * same_site 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", "A", ".harvard.edu", "/",
base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2, "dom_2", "B", ".math.harvard.edu", "/",
base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_3, "dom_3", "C",
".bourbaki.math.harvard.edu", "/", base::Time(), base::Time(),
base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
COOKIE_PRIORITY_DEFAULT));
// Host cookies
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_1, "host_1", "A", std::string(), "/",
base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2, "host_2", "B", std::string(), "/",
base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_3, "host_3", "C", std::string(), "/",
base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
// http_only cookie
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2, "httpo_check", "A", std::string(), "/",
base::Time(), base::Time(), base::Time(), false, true,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
// same-site cookie
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2, "firstp_check", "A", std::string(),
"/", base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::STRICT_MODE, COOKIE_PRIORITY_DEFAULT));
// Secure cookies
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2_secure, "sec_dom", "A",
".math.harvard.edu", "/", base::Time(), base::Time(), base::Time(),
true, false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2_secure, "sec_host", "B", std::string(),
"/", base::Time(), base::Time(), base::Time(), true, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
// Domain path cookies
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2, "dom_path_1", "A", ".math.harvard.edu",
"/dir1", base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2, "dom_path_2", "B", ".math.harvard.edu",
"/dir1/dir2", base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
// Host path cookies
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2, "host_path_1", "A", std::string(),
"/dir1", base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(this->SetCookieWithDetails(
cm, url_top_level_domain_plus_2, "host_path_2", "B", std::string(),
"/dir1/dir2", base::Time(), base::Time(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_EQ(14U, 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 = CookieMonster::kDomainMaxCookies;
int domain_purge_cookies = CookieMonster::kDomainPurgeCookies;
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.
{
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
for (int i = 0; i < more_than_enough_cookies; ++i) {
std::string cookie = base::StringPrintf("a%03d=b", i);
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), cookie));
std::string cookies =
this->GetCookies(cm.get(), http_www_google_.url());
// 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(http_www_google_.Format("http://www.gmail.%D"));
{
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
for (int i = 0; i < more_than_enough_cookies; ++i) {
std::string cookie_general = base::StringPrintf("a%03d=b", i);
EXPECT_TRUE(
SetCookie(cm.get(), http_www_google_.url(), cookie_general));
std::string cookie_specific = base::StringPrintf("c%03d=b", i);
EXPECT_TRUE(SetCookie(cm.get(), url_google_specific, cookie_specific));
std::string cookies_general =
this->GetCookies(cm.get(), http_www_google_.url());
EXPECT_NE(cookies_general.find(cookie_general), std::string::npos);
std::string cookies_specific =
this->GetCookies(cm.get(), 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.get(), http_www_google_.url());
std::string cookies_specific =
this->GetCookies(cm.get(), 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);
}
}
CookiePriority CharToPriority(char ch) {
switch (ch) {
case 'L':
return COOKIE_PRIORITY_LOW;
case 'M':
return COOKIE_PRIORITY_MEDIUM;
case 'H':
return COOKIE_PRIORITY_HIGH;
}
NOTREACHED();
return COOKIE_PRIORITY_DEFAULT;
}
// Instantiates a CookieMonster, adds multiple cookies (to http_www_google_)
// with priorities specified by |coded_priority_str|, and tests priority-aware
// domain cookie eviction.
//
// Example: |coded_priority_string| of "2MN 3LS MN 4HN" specifies sequential
// (i.e., from least- to most-recently accessed) insertion of 2
// medium-priority non-secure cookies, 3 low-priority secure cookies, 1
// medium-priority non-secure cookie, and 4 high-priority non-secure cookies.
//
// Within each priority, only the least-accessed cookies should be evicted.
// Thus, to describe expected suriving cookies, it suffices to specify the
// expected population of surviving cookies per priority, i.e.,
// |expected_low_count|, |expected_medium_count|, and |expected_high_count|.
void TestPriorityCookieCase(CookieMonster* cm,
const std::string& coded_priority_str,
size_t expected_low_count,
size_t expected_medium_count,
size_t expected_high_count,
size_t expected_nonsecure,
size_t expected_secure) {
SCOPED_TRACE(coded_priority_str);
this->DeleteAll(cm);
int next_cookie_id = 0;
// A list of cookie IDs, indexed by secure status, then by priority.
std::vector<int> id_list[2][3];
// A list of all the cookies stored, along with their properties.
std::vector<std::pair<bool, CookiePriority>> cookie_data;
// Parse |coded_priority_str| and add cookies.
for (const std::string& token :
base::SplitString(coded_priority_str, " ", base::TRIM_WHITESPACE,
base::SPLIT_WANT_ALL)) {
DCHECK(!token.empty());
bool is_secure = token[token.size() - 1] == 'S';
// The second-to-last character is the priority. Grab and discard it.
CookiePriority priority = CharToPriority(token[token.size() - 2]);
// Discard the security status and priority tokens. The rest of the string
// (possibly empty) specifies repetition.
int rep = 1;
if (!token.empty()) {
bool result = base::StringToInt(
base::StringPiece(token.begin(), token.end() - 2), &rep);
DCHECK(result);
}
for (; rep > 0; --rep, ++next_cookie_id) {
std::string cookie =
base::StringPrintf("a%d=b;priority=%s;%s", next_cookie_id,
CookiePriorityToString(priority).c_str(),
is_secure ? "secure" : "");
EXPECT_TRUE(SetCookie(cm, https_www_google_.url(), cookie));
cookie_data.push_back(std::make_pair(is_secure, priority));
id_list[is_secure][priority].push_back(next_cookie_id);
}
}
int num_cookies = static_cast<int>(cookie_data.size());
// A list of cookie IDs, indexed by secure status, then by priority.
std::vector<int> surviving_id_list[2][3];
// Parse the list of cookies
std::string cookie_str = this->GetCookies(cm, https_www_google_.url());
size_t num_nonsecure = 0;
size_t num_secure = 0;
for (const std::string& token : base::SplitString(
cookie_str, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
// Assuming *it is "a#=b", so extract and parse "#" portion.
int id = -1;
bool result = base::StringToInt(
base::StringPiece(token.begin() + 1, token.end() - 2), &id);
DCHECK(result);
DCHECK_GE(id, 0);
DCHECK_LT(id, num_cookies);
surviving_id_list[cookie_data[id].first][cookie_data[id].second]
.push_back(id);
if (cookie_data[id].first)
num_secure += 1;
else
num_nonsecure += 1;
}
EXPECT_EQ(expected_nonsecure, num_nonsecure);
EXPECT_EQ(expected_secure, num_secure);
// Validate each priority.
size_t expected_count[3] = {
expected_low_count, expected_medium_count, expected_high_count};
for (int i = 0; i < 3; ++i) {
size_t num_for_priority =
surviving_id_list[0][i].size() + surviving_id_list[1][i].size();
EXPECT_EQ(expected_count[i], num_for_priority);
// Verify that the remaining cookies are the most recent among those
// with the same priorities.
if (expected_count[i] == num_for_priority) {
// Non-secure:
std::sort(surviving_id_list[0][i].begin(),
surviving_id_list[0][i].end());
EXPECT_TRUE(std::equal(
surviving_id_list[0][i].begin(), surviving_id_list[0][i].end(),
id_list[0][i].end() - surviving_id_list[0][i].size()));
// Secure:
std::sort(surviving_id_list[1][i].begin(),
surviving_id_list[1][i].end());
EXPECT_TRUE(std::equal(
surviving_id_list[1][i].begin(), surviving_id_list[1][i].end(),
id_list[1][i].end() - surviving_id_list[1][i].size()));
}
}
}
// Represents a number of cookies to create, if they are Secure cookies, and
// a url to add them to.
struct CookiesEntry {
size_t num_cookies;
bool is_secure;
};
// A number of secure and a number of non-secure alternative hosts to create
// for testing.
typedef std::pair<size_t, size_t> AltHosts;
// Takes an array of CookieEntries which specify the number, type, and order
// of cookies to create. Cookies are created in the order they appear in
// cookie_entries. The value of cookie_entries[x].num_cookies specifies how
// many cookies of that type to create consecutively, while if
// cookie_entries[x].is_secure is |true|, those cookies will be marke as
// Secure.
void TestSecureCookieEviction(const CookiesEntry* cookie_entries,
size_t num_cookie_entries,
size_t expected_secure_cookies,
size_t expected_non_secure_cookies,
const AltHosts* alt_host_entries) {
std::unique_ptr<CookieMonster> cm;
if (alt_host_entries == nullptr) {
cm.reset(new CookieMonster(nullptr, nullptr));
} else {
// When generating all of these cookies on alternate hosts, they need to
// be all older than the max "safe" date for GC, which is currently 30
// days, so we set them to 60.
cm = CreateMonsterFromStoreForGC(
alt_host_entries->first, alt_host_entries->first,
alt_host_entries->second, alt_host_entries->second, 60);
}
int next_cookie_id = 0;
for (size_t i = 0; i < num_cookie_entries; i++) {
for (size_t j = 0; j < cookie_entries[i].num_cookies; j++) {
std::string cookie;
if (cookie_entries[i].is_secure)
cookie = base::StringPrintf("a%d=b; Secure", next_cookie_id);
else
cookie = base::StringPrintf("a%d=b", next_cookie_id);
EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.url(), cookie));
++next_cookie_id;
}
}
CookieList cookies = this->GetAllCookies(cm.get());
EXPECT_EQ(expected_secure_cookies + expected_non_secure_cookies,
cookies.size());
size_t total_secure_cookies = 0;
size_t total_non_secure_cookies = 0;
for (const auto& cookie : cookies) {
if (cookie.IsSecure())
++total_secure_cookies;
else
++total_non_secure_cookies;
}
EXPECT_EQ(expected_secure_cookies, total_secure_cookies);
EXPECT_EQ(expected_non_secure_cookies, total_non_secure_cookies);
}
void TestPriorityAwareGarbageCollectHelperNonSecure() {
// Hard-coding limits in the test, but use DCHECK_EQ to enforce constraint.
DCHECK_EQ(180U, CookieMonster::kDomainMaxCookies);
DCHECK_EQ(150U, CookieMonster::kDomainMaxCookies -
CookieMonster::kDomainPurgeCookies);
std::unique_ptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
// Each test case adds 181 cookies, so 31 cookies are evicted.
// Cookie same priority, repeated for each priority.
TestPriorityCookieCase(cm.get(), "181LN", 150U, 0U, 0U, 150U, 0U);
TestPriorityCookieCase(cm.get(), "181MN", 0U, 150U, 0U, 150U, 0U);
TestPriorityCookieCase(cm.get(), "181HN", 0U, 0U, 150U, 150U, 0U);
// Pairwise scenarios.
// Round 1 => none; round2 => 31M; round 3 => none.
TestPriorityCookieCase(cm.get(), "10HN 171MN", 0U, 140U, 10U, 150U, 0U);
// Round 1 => 10L; round2 => 21M; round 3 => none.
TestPriorityCookieCase(cm.get(), "141MN 40LN", 30U, 120U, 0U, 150U, 0U);
// Round 1 => none; round2 => 30M; round 3 => 1H.
TestPriorityCookieCase(cm.get(), "101HN 80MN", 0U, 50U, 100U, 150U, 0U);
// For {low, medium} priorities right on quota, different orders.
// Round 1 => 1L; round 2 => none, round3 => 30H.
TestPriorityCookieCase(cm.get(), "31LN 50MN 100HN", 30U, 50U, 70U, 150U,
0U);
// Round 1 => none; round 2 => 1M, round3 => 30H.
TestPriorityCookieCase(cm.get(), "51MN 100HN 30LN", 30U, 50U, 70U, 150U,
0U);
// Round 1 => none; round 2 => none; round3 => 31H.
TestPriorityCookieCase(cm.get(), "101HN 50MN 30LN", 30U, 50U, 70U, 150U,
0U);
// Round 1 => 10L; round 2 => 10M; round3 => 11H.
TestPriorityCookieCase(cm.get(), "81HN 60MN 40LN", 30U, 50U, 70U, 150U, 0U);
// More complex scenarios.
// Round 1 => 10L; round 2 => 10M; round 3 => 11H.
TestPriorityCookieCase(cm.get(), "21HN 60MN 40LN 60HN", 30U, 50U, 70U, 150U,
0U);
// Round 1 => 10L; round 2 => 21M; round 3 => 0H.
TestPriorityCookieCase(cm.get(), "11HN 10MN 20LN 110MN 20LN 10HN", 30U, 99U,
21U, 150U, 0U);
// Round 1 => none; round 2 => none; round 3 => 31H.
TestPriorityCookieCase(cm.get(), "11LN 10MN 140HN 10MN 10LN", 21U, 20U,
109U, 150U, 0U);
// Round 1 => none; round 2 => 21M; round 3 => 10H.
TestPriorityCookieCase(cm.get(), "11MN 10HN 10LN 60MN 90HN", 10U, 50U, 90U,
150U, 0U);
// Round 1 => none; round 2 => 31M; round 3 => none.
TestPriorityCookieCase(cm.get(), "11MN 10HN 10LN 90MN 60HN", 10U, 70U, 70U,
150U, 0U);
// Round 1 => 20L; round 2 => 0; round 3 => 11H
TestPriorityCookieCase(cm.get(), "50LN 131HN", 30U, 0U, 120U, 150U, 0U);
// Round 1 => 20L; round 2 => 0; round 3 => 11H
TestPriorityCookieCase(cm.get(), "131HN 50LN", 30U, 0U, 120U, 150U, 0U);
// Round 1 => 20L; round 2 => none; round 3 => 11H.
TestPriorityCookieCase(cm.get(), "50HN 50LN 81HN", 30U, 0U, 120U, 150U, 0U);
// Round 1 => 20L; round 2 => none; round 3 => 11H.
TestPriorityCookieCase(cm.get(), "81HN 50LN 50HN", 30U, 0U, 120U, 150U, 0U);
}
void TestPriorityAwareGarbageCollectHelperSecure() {
// Hard-coding limits in the test, but use DCHECK_EQ to enforce constraint.
DCHECK_EQ(180U, CookieMonster::kDomainMaxCookies);
DCHECK_EQ(150U, CookieMonster::kDomainMaxCookies -
CookieMonster::kDomainPurgeCookies);
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
// Each test case adds 181 cookies, so 31 cookies are evicted.
// Cookie same priority, repeated for each priority.
// Round 1 => 31L; round2 => none; round 3 => none.
TestPriorityCookieCase(cm.get(), "181LS", 150U, 0U, 0U, 0U, 150U);
// Round 1 => none; round2 => 31M; round 3 => none.
TestPriorityCookieCase(cm.get(), "181MS", 0U, 150U, 0U, 0U, 150U);
// Round 1 => none; round2 => none; round 3 => 31H.
TestPriorityCookieCase(cm.get(), "181HS", 0U, 0U, 150U, 0U, 150U);
// Pairwise scenarios.
// Round 1 => none; round2 => 31M; round 3 => none.
TestPriorityCookieCase(cm.get(), "10HS 171MS", 0U, 140U, 10U, 0U, 150U);
// Round 1 => 10L; round2 => 21M; round 3 => none.
TestPriorityCookieCase(cm.get(), "141MS 40LS", 30U, 120U, 0U, 0U, 150U);
// Round 1 => none; round2 => 30M; round 3 => 1H.
TestPriorityCookieCase(cm.get(), "101HS 80MS", 0U, 50U, 100U, 0U, 150U);
// For {low, medium} priorities right on quota, different orders.
// Round 1 => 1L; round 2 => none, round3 => 30H.
TestPriorityCookieCase(cm.get(), "31LS 50MS 100HS", 30U, 50U, 70U, 0U,
150U);
// Round 1 => none; round 2 => 1M, round3 => 30H.
TestPriorityCookieCase(cm.get(), "51MS 100HS 30LS", 30U, 50U, 70U, 0U,
150U);
// Round 1 => none; round 2 => none; round3 => 31H.
TestPriorityCookieCase(cm.get(), "101HS 50MS 30LS", 30U, 50U, 70U, 0U,
150U);
// Round 1 => 10L; round 2 => 10M; round3 => 11H.
TestPriorityCookieCase(cm.get(), "81HS 60MS 40LS", 30U, 50U, 70U, 0U, 150U);
// More complex scenarios.
// Round 1 => 10L; round 2 => 10M; round 3 => 11H.
TestPriorityCookieCase(cm.get(), "21HS 60MS 40LS 60HS", 30U, 50U, 70U, 0U,
150U);
// Round 1 => 10L; round 2 => 21M; round 3 => none.
TestPriorityCookieCase(cm.get(), "11HS 10MS 20LS 110MS 20LS 10HS", 30U, 99U,
21U, 0U, 150U);
// Round 1 => none; round 2 => none; round 3 => 31H.
TestPriorityCookieCase(cm.get(), "11LS 10MS 140HS 10MS 10LS", 21U, 20U,
109U, 0U, 150U);
// Round 1 => none; round 2 => 21M; round 3 => 10H.
TestPriorityCookieCase(cm.get(), "11MS 10HS 10LS 60MS 90HS", 10U, 50U, 90U,
0U, 150U);
// Round 1 => none; round 2 => 31M; round 3 => none.
TestPriorityCookieCase(cm.get(), "11MS 10HS 10LS 90MS 60HS", 10U, 70U, 70U,
0U, 150U);
}
void TestPriorityAwareGarbageCollectHelperMixed() {
// Hard-coding limits in the test, but use DCHECK_EQ to enforce constraint.
DCHECK_EQ(180U, CookieMonster::kDomainMaxCookies);
DCHECK_EQ(150U, CookieMonster::kDomainMaxCookies -
CookieMonster::kDomainPurgeCookies);
std::unique_ptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
// Each test case adds 180 secure cookies, and some non-secure cookie. The
// secure cookies take priority, so the non-secure cookie is removed, along
// with 30 secure cookies. Repeated for each priority, and with the
// non-secure cookie as older and newer.
// Round 1 => 1LN; round 2 => 30LS; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "1LN 180LS", 150U, 0U, 0U, 0U, 150U);
// Round 1 => none; round 2 => none; round 3 => 1MN.
// Round 4 => none; round 5 => 30MS; round 6 => none.
TestPriorityCookieCase(cm.get(), "1MN 180MS", 0U, 150U, 0U, 0U, 150U);
// Round 1 => none; round 2 => none; round 3 => none.
// Round 4 => 1HN; round 5 => none; round 6 => 30HS.
TestPriorityCookieCase(cm.get(), "1HN 180HS", 0U, 0U, 150U, 0U, 150U);
// Round 1 => 1LN; round 2 => 30LS; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "180LS 1LN", 150U, 0U, 0U, 0U, 150U);
// Round 1 => none; round 2 => none; round 3 => 1MN.
// Round 4 => none; round 5 => 30MS; round 6 => none.
TestPriorityCookieCase(cm.get(), "180MS 1MN", 0U, 150U, 0U, 0U, 150U);
// Round 1 => none; round 2 => none; round 3 => none.
// Round 4 => 1HN; round 5 => none; round 6 => 30HS.
TestPriorityCookieCase(cm.get(), "180HS 1HN", 0U, 0U, 150U, 0U, 150U);
// Low-priority secure cookies are removed before higher priority non-secure
// cookies.
// Round 1 => none; round 2 => 31LS; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "180LS 1MN", 149U, 1U, 0U, 1U, 149U);
// Round 1 => none; round 2 => 31LS; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "180LS 1HN", 149U, 0U, 1U, 1U, 149U);
// Round 1 => none; round 2 => 31LS; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "1MN 180LS", 149U, 1U, 0U, 1U, 149U);
// Round 1 => none; round 2 => 31LS; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "1HN 180LS", 149U, 0U, 1U, 1U, 149U);
// Higher-priority non-secure cookies are removed before any secure cookie
// with greater than low-priority. Is it true? How about the quota?
// Round 1 => none; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => 31MS; round 6 => none.
TestPriorityCookieCase(cm.get(), "180MS 1HN", 0U, 149U, 1U, 1U, 149U);
// Round 1 => none; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => 31MS; round 6 => none.
TestPriorityCookieCase(cm.get(), "1HN 180MS", 0U, 149U, 1U, 1U, 149U);
// Pairwise:
// Round 1 => 31LN; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "1LS 180LN", 150U, 0U, 0U, 149U, 1U);
// Round 1 => 31LN; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "100LS 81LN", 150U, 0U, 0U, 50U, 100U);
// Round 1 => 31LN; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "150LS 31LN", 150U, 0U, 0U, 0U, 150U);
// Round 1 => none; round 2 => none; round 3 => none.
// Round 4 => 31HN; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "1LS 180HN", 1U, 0U, 149U, 149U, 1U);
// Round 1 => none; round 2 => 31LS; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "100LS 81HN", 69U, 0U, 81U, 81U, 69U);
// Round 1 => none; round 2 => 31LS; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "150LS 31HN", 119U, 0U, 31U, 31U, 119U);
// Quota calculations inside non-secure/secure blocks remain in place:
// Round 1 => none; round 2 => 20LS; round 3 => none.
// Round 4 => 11HN; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "50HN 50LS 81HS", 30U, 0U, 120U, 39U,
111U);
// Round 1 => none; round 2 => none; round 3 => 31MN.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "11MS 10HN 10LS 90MN 60HN", 10U, 70U, 70U,
129U, 21U);
// Round 1 => 31LN; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
TestPriorityCookieCase(cm.get(), "40LS 40LN 101HS", 49U, 0U, 101U, 9U,
141U);
// Multiple GC rounds end up with consistent behavior:
// GC is started as soon as there are 181 cookies in the store.
// On each major round it tries to preserve the quota for each priority.
// It is not aware about more cookies going in.
// 1 GC notices there are 181 cookies - 100HS 81LN 0MN
// Round 1 => 31LN; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
// 2 GC notices there are 181 cookies - 100HS 69LN 12MN
// Round 1 => 31LN; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => none.
// 3 GC notices there are 181 cookies - 100HS 38LN 43MN
// Round 1 => 8LN; round 2 => none; round 3 => none.
// Round 4 => none; round 5 => none; round 6 => 23HS.
// 4 GC notcies there are 181 cookies - 77HS 30LN 74MN
// Round 1 => none; round 2 => none; round 3 => 24MN.
// Round 4 => none; round 5 => none; round 6 => 7HS.
TestPriorityCookieCase(cm.get(), "100HS 100LN 100MN", 30U, 76U, 70U, 106U,
70U);
}
// 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(base::StringPrintf("http://h%05d.izzle", i)), "a=1");
}
return cm;
}
bool IsCookieInList(const CanonicalCookie& cookie, const CookieList& list) {
for (CookieList::const_iterator it = list.begin(); it != list.end(); ++it) {
if (it->Source() == cookie.Source() && it->Name() == cookie.Name() &&
it->Value() == cookie.Value() && it->Domain() == cookie.Domain() &&
it->Path() == cookie.Path() &&
it->CreationDate() == cookie.CreationDate() &&
it->ExpiryDate() == cookie.ExpiryDate() &&
it->LastAccessDate() == cookie.LastAccessDate() &&
it->IsSecure() == cookie.IsSecure() &&
it->IsHttpOnly() == cookie.IsHttpOnly() &&
it->Priority() == cookie.Priority()) {
return true;
}
}
return false;
}
};
using CookieMonsterTest = CookieMonsterTestBase<CookieMonsterTestTraits>;
using CookieMonsterStrictSecureTest =
CookieMonsterTestBase<CookieMonsterEnforcingStrictSecure>;
// 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 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));
};
struct CookiesInputInfo {
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;
CookieSameSite same_site;
CookiePriority priority;
};
ACTION_P(QuitRunLoop, run_loop) {
run_loop->Quit();
}
// 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_P4(SetCookieAction, cookie_monster, url, cookie_line, callback) {
cookie_monster->SetCookieWithOptionsAsync(url, cookie_line, CookieOptions(),
callback->AsCallback());
}
ACTION_P3(SetAllCookiesAction, cookie_monster, list, callback) {
cookie_monster->SetAllCookiesAsync(list, callback->AsCallback());
}
ACTION_P4(DeleteAllCreatedBetweenAction,
cookie_monster,
delete_begin,
delete_end,
callback) {
cookie_monster->DeleteAllCreatedBetweenAsync(delete_begin, delete_end,
callback->AsCallback());
}
ACTION_P3(SetCookieWithDetailsAction, cookie_monster, cc, callback) {
cookie_monster->SetCookieWithDetailsAsync(
cc.url, cc.name, cc.value, cc.domain, cc.path, base::Time(),
cc.expiration_time, base::Time(), cc.secure, cc.http_only, cc.same_site,
false /* enforces strict secure cookies */, cc.priority,
callback->AsCallback());
}
ACTION_P2(GetAllCookiesAction, cookie_monster, callback) {
cookie_monster->GetAllCookiesAsync(callback->AsCallback());
}
ACTION_P5(DeleteAllCreatedBetweenWithPredicateAction,
cookie_monster,
delete_begin,
delete_end,
predicate,
callback) {
cookie_monster->DeleteAllCreatedBetweenWithPredicateAsync(
delete_begin, delete_end, predicate, 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(GetCookieListForUrlWithOptionsAction, cookie_monster, url, callback) {
cookie_monster->GetCookieListWithOptionsAsync(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() : expect_load_called_(false) {
persistent_store_ = new NewMockPersistentCookieStore();
cookie_monster_.reset(new CookieMonster(persistent_store_.get(), nullptr));
}
// Defines a cookie to be returned from PersistentCookieStore::Load
void DeclareLoadedCookie(const GURL& url,
const std::string& cookie_line,
const base::Time& creation_time) {
AddCookieToList(url, cookie_line, creation_time, &loaded_cookies_);
}
// Runs the message loop, waiting until PersistentCookieStore::Load is called.
// Call CompleteLoading to cause the load to complete.
void WaitForLoadCall() {
load_run_loop_.Run();
// Verify that PeristentStore::Load was called.
testing::Mock::VerifyAndClear(persistent_store_.get());
}
// Invokes the PersistentCookieStore::LoadCookiesForKey completion callbacks
// and PersistentCookieStore::Load completion callback.
void CompleteLoading() {
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_);
}
// 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);
Begin();
}
// Declares an expectation that PersistentCookieStore::Load will be called,
// saving the provided callback and sending a quit to |load_run_loop_|.
void ExpectLoadCall() {
// Make sure the |load_run_loop_| is not reused.
CHECK(!expect_load_called_);
expect_load_called_ = true;
EXPECT_CALL(*persistent_store_.get(), Load(testing::_))
.WillOnce(testing::DoAll(testing::SaveArg<0>(&loaded_callback_),
QuitRunLoop(&load_run_loop_)));
}
// Declares an expectation that PersistentCookieStore::LoadCookiesForKey
// will be called, saving the provided callback.
void ExpectLoadForKeyCall(const std::string& key) {
EXPECT_CALL(*persistent_store_.get(), 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_.get(); }
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_;
// base::RunLoop used to wait for PersistentCookieStore::Load to be called.
base::RunLoop load_run_loop_;
// Indicates whether ExpectLoadCall() has been called.
bool expect_load_called_;
// Stores the CookieMonster under test.
std::unique_ptr<CookieMonster> cookie_monster_;
// Stores the mock PersistentCookieStore.
scoped_refptr<NewMockPersistentCookieStore> persistent_store_;
};
TEST_F(DeferredCookieTaskTest, DeferredGetCookies) {
DeclareLoadedCookie(http_www_google_.url(),
"X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
Time::Now() + TimeDelta::FromDays(3));
MockGetCookiesCallback get_cookies_callback;
BeginWithForDomainKey(
http_www_google_.domain(),
GetCookiesAction(&cookie_monster(), http_www_google_.url(),
&get_cookies_callback));
WaitForLoadCall();
EXPECT_CALL(get_cookies_callback, Invoke("X=1"))
.WillOnce(GetCookiesAction(&cookie_monster(), http_www_google_.url(),
&get_cookies_callback));
base::RunLoop loop;
EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest, DeferredSetCookie) {
MockSetCookiesCallback set_cookies_callback;
BeginWithForDomainKey(
http_www_google_.domain(),
SetCookieAction(&cookie_monster(), http_www_google_.url(), "A=B",
&set_cookies_callback));
WaitForLoadCall();
EXPECT_CALL(set_cookies_callback, Invoke(true))
.WillOnce(SetCookieAction(&cookie_monster(), http_www_google_.url(),
"X=Y", &set_cookies_callback));
base::RunLoop loop;
EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest, DeferredSetAllCookies) {
MockSetCookiesCallback set_cookies_callback;
CookieList list;
list.push_back(*CanonicalCookie::Create(
http_www_google_.url(), "A", "B", http_www_google_.domain(), "/",
base::Time::Now(), base::Time(), false, true,
CookieSameSite::DEFAULT_MODE, false, COOKIE_PRIORITY_DEFAULT));
list.push_back(*CanonicalCookie::Create(
http_www_google_.url(), "C", "D", http_www_google_.domain(), "/",
base::Time::Now(), base::Time(), false, true,
CookieSameSite::DEFAULT_MODE, false, COOKIE_PRIORITY_DEFAULT));
BeginWith(
SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
WaitForLoadCall();
EXPECT_CALL(set_cookies_callback, Invoke(true))
.WillOnce(
SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
base::RunLoop loop;
EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest, DeferredDeleteCookie) {
MockClosure delete_cookie_callback;
BeginWithForDomainKey(
http_www_google_.domain(),
DeleteCookieAction(&cookie_monster(), http_www_google_.url(), "A",
&delete_cookie_callback));
WaitForLoadCall();
EXPECT_CALL(delete_cookie_callback, Invoke())
.WillOnce(DeleteCookieAction(&cookie_monster(), http_www_google_.url(),
"X", &delete_cookie_callback));
base::RunLoop loop;
EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest, DeferredSetCookieWithDetails) {
MockSetCookiesCallback set_cookies_callback;
CookiesInputInfo cookie_info = {www_google_foo_.url(),
"A",
"B",
std::string(),
"/foo",
base::Time(),
false,
false,
CookieSameSite::DEFAULT_MODE,
COOKIE_PRIORITY_DEFAULT};
BeginWithForDomainKey(
http_www_google_.domain(),
SetCookieWithDetailsAction(&cookie_monster(), cookie_info,
&set_cookies_callback));
WaitForLoadCall();
CookiesInputInfo cookie_info_exp = {www_google_foo_.url(),
"A",
"B",
std::string(),
"/foo",
base::Time(),
false,
false,
CookieSameSite::DEFAULT_MODE,
COOKIE_PRIORITY_DEFAULT};
EXPECT_CALL(set_cookies_callback, Invoke(true))
.WillOnce(SetCookieWithDetailsAction(&cookie_monster(), cookie_info_exp,
&set_cookies_callback));
base::RunLoop loop;
EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest, DeferredGetAllCookies) {
DeclareLoadedCookie(http_www_google_.url(),
"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));
base::RunLoop loop;
EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
.WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlCookies) {
DeclareLoadedCookie(http_www_google_.url(),
"X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
Time::Now() + TimeDelta::FromDays(3));
MockGetCookieListCallback get_cookie_list_callback;
BeginWithForDomainKey(
http_www_google_.domain(),
GetAllCookiesForUrlAction(&cookie_monster(), http_www_google_.url(),
&get_cookie_list_callback));
WaitForLoadCall();
EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
.WillOnce(GetAllCookiesForUrlAction(&cookie_monster(),
http_www_google_.url(),
&get_cookie_list_callback));
base::RunLoop loop;
EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
.WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlWithOptionsCookies) {
DeclareLoadedCookie(http_www_google_.url(),
"X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
Time::Now() + TimeDelta::FromDays(3));
MockGetCookieListCallback get_cookie_list_callback;
BeginWithForDomainKey(http_www_google_.domain(),
GetCookieListForUrlWithOptionsAction(
&cookie_monster(), http_www_google_.url(),
&get_cookie_list_callback));
WaitForLoadCall();
EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
.WillOnce(GetCookieListForUrlWithOptionsAction(
&cookie_monster(), http_www_google_.url(),
&get_cookie_list_callback));
base::RunLoop loop;
EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
.WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
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));
base::RunLoop loop;
EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
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));
base::RunLoop loop;
EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest,
DeferredDeleteAllWithPredicateCreatedBetweenCookies) {
MockDeleteCallback delete_callback;
CookiePredicate predicate = base::Bind(&AlwaysTrueCookiePredicate, nullptr);
BeginWith(DeleteAllCreatedBetweenWithPredicateAction(
&cookie_monster(), base::Time(), base::Time::Now(), predicate,
&delete_callback));
WaitForLoadCall();
EXPECT_CALL(delete_callback, Invoke(false))
.WillOnce(DeleteAllCreatedBetweenWithPredicateAction(
&cookie_monster(), base::Time(), base::Time::Now(), predicate,
&delete_callback));
base::RunLoop loop;
EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) {
std::vector<CanonicalCookie*> cookies;
std::unique_ptr<CanonicalCookie> cookie = BuildCanonicalCookie(
http_www_google_.url(), "X=1; path=/", base::Time::Now());
MockDeleteCallback delete_cookie_callback;
BeginWith(DeleteCanonicalCookieAction(&cookie_monster(), *cookie,
&delete_cookie_callback));
WaitForLoadCall();
EXPECT_CALL(delete_cookie_callback, Invoke(0))
.WillOnce(DeleteCanonicalCookieAction(&cookie_monster(), *cookie,
&delete_cookie_callback));
base::RunLoop loop;
EXPECT_CALL(delete_cookie_callback, Invoke(0)).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
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));
base::RunLoop loop;
EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
// 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(http_www_google_.url(),
"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;
MockGetCookiesCallback get_cookies_callback_deferred;
EXPECT_CALL(*this, Begin())
.WillOnce(testing::DoAll(
GetCookiesAction(&cookie_monster(), http_www_google_.url(),
&get_cookies_callback),
SetCookieAction(&cookie_monster(), http_www_google_.url(), "A=B",
&set_cookies_callback)));
ExpectLoadCall();
ExpectLoadForKeyCall(http_www_google_.domain());
Begin();
WaitForLoadCall();
EXPECT_CALL(get_cookies_callback, Invoke("X=1"))
.WillOnce(GetCookiesAction(&cookie_monster(), http_www_google_.url(),
&get_cookies_callback_deferred));
EXPECT_CALL(set_cookies_callback, Invoke(true));
base::RunLoop loop;
EXPECT_CALL(get_cookies_callback_deferred, Invoke("A=B; X=1"))
.WillOnce(QuitRunLoop(&loop));
CompleteLoading();
loop.Run();
}
TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
CookieOptions options;
options.set_include_httponly();
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), kValidCookieLine));
EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
"C=D; httponly", options));
EXPECT_EQ("A=B; C=D",
GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
EXPECT_EQ(2, DeleteAll(cm.get()));
EXPECT_EQ("",
GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
EXPECT_EQ(0u, store->commands().size());
// Create a persistent cookie.
EXPECT_TRUE(SetCookie(
cm.get(), http_www_google_.url(),
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.get())); // sync_to_store = true.
ASSERT_EQ(2u, store->commands().size());
EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
EXPECT_EQ("",
GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
}
TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
Time now = Time::Now();
// Nothing has been added so nothing should be deleted.
EXPECT_EQ(0, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99),
Time()));
// Create 5 cookies with different creation dates.
EXPECT_TRUE(
cm->SetCookieWithCreationTime(http_www_google_.url(), "T-0=Now", now));
EXPECT_TRUE(cm->SetCookieWithCreationTime(
http_www_google_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
EXPECT_TRUE(cm->SetCookieWithCreationTime(
http_www_google_.url(), "T-2=DayBefore", now - TimeDelta::FromDays(2)));
EXPECT_TRUE(cm->SetCookieWithCreationTime(
http_www_google_.url(), "T-3=ThreeDays", now - TimeDelta::FromDays(3)));
EXPECT_TRUE(cm->SetCookieWithCreationTime(
http_www_google_.url(), "T-7=LastWeek", now - TimeDelta::FromDays(7)));
// Try to delete threedays and the daybefore.
EXPECT_EQ(2, DeleteAllCreatedBetween(cm.get(), 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.get(), now - TimeDelta::FromDays(2), now));
// Make sure the delete_begin is inclusive.
EXPECT_EQ(
1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(7), now));
// Delete the last (now) item.
EXPECT_EQ(1, DeleteAllCreatedBetween(cm.get(), Time(), Time()));
// Really make sure everything is gone.
EXPECT_EQ(0, DeleteAll(cm.get()));
}
TEST_F(CookieMonsterTest,
TestCookieDeleteAllCreatedBetweenTimestampsWithPredicate) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
Time now = Time::Now();
CanonicalCookie test_cookie;
CookiePredicate true_predicate =
base::Bind(&AlwaysTrueCookiePredicate, &test_cookie);
CookiePredicate false_predicate =
base::Bind(&AlwaysFalseCookiePredicate, &test_cookie);
// Nothing has been added so nothing should be deleted.
EXPECT_EQ(
0, DeleteAllCreatedBetweenWithPredicate(
cm.get(), now - TimeDelta::FromDays(99), Time(), true_predicate));
// Create 5 cookies with different creation dates.
EXPECT_TRUE(
cm->SetCookieWithCreationTime(http_www_google_.url(), "T-0=Now", now));
EXPECT_TRUE(cm->SetCookieWithCreationTime(
http_www_google_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
EXPECT_TRUE(cm->SetCookieWithCreationTime(
http_www_google_.url(), "T-2=DayBefore", now - TimeDelta::FromDays(2)));
EXPECT_TRUE(cm->SetCookieWithCreationTime(
http_www_google_.url(), "T-3=ThreeDays", now - TimeDelta::FromDays(3)));
EXPECT_TRUE(cm->SetCookieWithCreationTime(
http_www_google_.url(), "T-7=LastWeek", now - TimeDelta::FromDays(7)));
// Try to delete threedays and the daybefore, but we should do nothing due
// to the predicate.
EXPECT_EQ(0, DeleteAllCreatedBetweenWithPredicate(
cm.get(), now - TimeDelta::FromDays(3),
now - TimeDelta::FromDays(1), false_predicate));
// Same as above with a null predicate, so it shouldn't delete anything.
EXPECT_EQ(0, DeleteAllCreatedBetweenWithPredicate(
cm.get(), now - TimeDelta::FromDays(3),
now - TimeDelta::FromDays(1), CookiePredicate()));
// Same as above, but we use the true_predicate, so it works.
EXPECT_EQ(2, DeleteAllCreatedBetweenWithPredicate(
cm.get(), now - TimeDelta::FromDays(3),
now - TimeDelta::FromDays(1), true_predicate));
// Try to delete yesterday, also make sure that delete_end is not
// inclusive.
EXPECT_EQ(0,
DeleteAllCreatedBetweenWithPredicate(
cm.get(), now - TimeDelta::FromDays(2), now, false_predicate));
EXPECT_EQ(1,
DeleteAllCreatedBetweenWithPredicate(
cm.get(), now - TimeDelta::FromDays(2), now, true_predicate));
// Check our cookie values.
std::unique_ptr<CanonicalCookie> expected_cookie =
CanonicalCookie::Create(http_www_google_.url(), "T-1=Yesterday",
now - TimeDelta::FromDays(1), CookieOptions());
EXPECT_THAT(test_cookie, CookieEquals(*expected_cookie))
<< "Actual:\n"
<< test_cookie.DebugString() << "\nExpected:\n"
<< expected_cookie->DebugString();
// Make sure the delete_begin is inclusive.
EXPECT_EQ(0,
DeleteAllCreatedBetweenWithPredicate(
cm.get(), now - TimeDelta::FromDays(7), now, false_predicate));
EXPECT_EQ(1,
DeleteAllCreatedBetweenWithPredicate(
cm.get(), now - TimeDelta::FromDays(7), now, true_predicate));
// Delete the last (now) item.
EXPECT_EQ(0, DeleteAllCreatedBetweenWithPredicate(cm.get(), Time(), Time(),
false_predicate));
EXPECT_EQ(1, DeleteAllCreatedBetweenWithPredicate(cm.get(), Time(), Time(),
true_predicate));
expected_cookie = CanonicalCookie::Create(http_www_google_.url(), "T-0=Now",
now, CookieOptions());
EXPECT_THAT(test_cookie, CookieEquals(*expected_cookie))
<< "Actual:\n"
<< test_cookie.DebugString() << "\nExpected:\n"
<< expected_cookie->DebugString();
// Really make sure everything is gone.
EXPECT_EQ(0, DeleteAll(cm.get()));
}
static const base::TimeDelta kLastAccessThreshold =
base::TimeDelta::FromMilliseconds(200);
static const base::TimeDelta kAccessDelay =
kLastAccessThreshold + base::TimeDelta::FromMilliseconds(20);
TEST_F(CookieMonsterTest, TestLastAccess) {
std::unique_ptr<CookieMonster> cm(
new CookieMonster(nullptr, nullptr, kLastAccessThreshold));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
// Reading the cookie again immediately shouldn't update the access date,
// since we're inside the threshold.
EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
EXPECT_EQ(last_access_date, GetFirstCookieAccessDate(cm.get()));
// Reading after a short wait will update the access date, if the cookie
// is requested with options that would update the access date. First, test
// that the flag's behavior is respected.
base::PlatformThread::Sleep(kAccessDelay);
CookieOptions options;
options.set_do_not_update_access_time();
EXPECT_EQ("A=B",
GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
EXPECT_EQ(last_access_date, GetFirstCookieAccessDate(cm.get()));
// Getting all cookies for a URL doesn't update the accessed time either.
CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_google_.url());
CookieList::iterator it = cookies.begin();
ASSERT_TRUE(it != cookies.end());
EXPECT_EQ(http_www_google_.host(), it->Domain());
EXPECT_EQ("A", it->Name());
EXPECT_EQ("B", it->Value());
EXPECT_EQ(last_access_date, GetFirstCookieAccessDate(cm.get()));
EXPECT_TRUE(++it == cookies.end());
// If the flag isn't set, the last accessed time should be updated.
options = CookieOptions();
EXPECT_EQ("A=B",
GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm.get()));
}
TEST_F(CookieMonsterTest, TestHostGarbageCollection) {
TestHostGarbageCollectHelper();
}
TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollectionNonSecure) {
TestPriorityAwareGarbageCollectHelperNonSecure();
}
TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollectionSecure) {
TestPriorityAwareGarbageCollectHelperSecure();
}
TEST_F(CookieMonsterStrictSecureTest, TestPriorityAwareGarbageCollectionMixed) {
TestPriorityAwareGarbageCollectHelperMixed();
}
TEST_F(CookieMonsterTest, SetCookieableSchemes) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
std::unique_ptr<CookieMonster> cm_foo(new CookieMonster(nullptr, nullptr));
// Only cm_foo should allow foo:// cookies.
std::vector<std::string> schemes;
schemes.push_back("foo");
cm_foo->SetCookieableSchemes(schemes);
GURL foo_url("foo://host/path");
GURL http_url("http://host/path");
EXPECT_TRUE(SetCookie(cm.get(), http_url, "x=1"));
EXPECT_FALSE(SetCookie(cm.get(), foo_url, "x=1"));
EXPECT_TRUE(SetCookie(cm_foo.get(), foo_url, "x=1"));
EXPECT_FALSE(SetCookie(cm_foo.get(), http_url, "x=1"));
}
TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
std::unique_ptr<CookieMonster> cm(
new CookieMonster(nullptr, nullptr, kLastAccessThreshold));
// Create an httponly cookie.
CookieOptions options;
options.set_include_httponly();
EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
"A=B; httponly", options));
EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
http_www_google_.Format("C=D; domain=.%D"),
options));
EXPECT_TRUE(SetCookieWithOptions(
cm.get(), https_www_google_.url(),
http_www_google_.Format("E=F; domain=.%D; secure"), options));
const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
base::PlatformThread::Sleep(kAccessDelay);
// Check cookies for url.
CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_google_.url());
CookieList::iterator it = cookies.begin();
ASSERT_TRUE(it != cookies.end());
EXPECT_EQ(http_www_google_.host(), it->Domain());
EXPECT_EQ("A", it->Name());
ASSERT_TRUE(++it != cookies.end());
EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
EXPECT_EQ("C", it->Name());
ASSERT_TRUE(++it == cookies.end());
// Check cookies for url excluding http-only cookies.
cookies = GetAllCookiesForURLWithOptions(cm.get(), http_www_google_.url(),
CookieOptions());
it = cookies.begin();
ASSERT_TRUE(it != cookies.end());
EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
EXPECT_EQ("C", it->Name());
ASSERT_TRUE(++it == cookies.end());
// Test secure cookies.
cookies = GetAllCookiesForURL(cm.get(), https_www_google_.url());
it = cookies.begin();
ASSERT_TRUE(it != cookies.end());
EXPECT_EQ(http_www_google_.host(), it->Domain());
EXPECT_EQ("A", it->Name());
ASSERT_TRUE(++it != cookies.end());
EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
EXPECT_EQ("C", it->Name());
ASSERT_TRUE(++it != cookies.end());
EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
EXPECT_EQ("E", it->Name());
ASSERT_TRUE(++it == cookies.end());
// Reading after a short wait should not update the access date.
EXPECT_EQ(last_access_date, GetFirstCookieAccessDate(cm.get()));
}
TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
CookieOptions options;
EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_google_foo_.url(),
"A=B; path=/foo;", options));
EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_google_bar_.url(),
"C=D; path=/bar;", options));
EXPECT_TRUE(
SetCookieWithOptions(cm.get(), http_www_google_.url(), "E=F;", options));
CookieList cookies = GetAllCookiesForURL(cm.get(), www_google_foo_.url());
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.get(), www_google_bar_.url());
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, CookieSorting) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B1; path=/"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B2; path=/foo"));
EXPECT_TRUE(
SetCookie(cm.get(), http_www_google_.url(), "B=B3; path=/foo/bar"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A1; path=/"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A2; path=/foo"));
EXPECT_TRUE(
SetCookie(cm.get(), http_www_google_.url(), "A=A3; path=/foo/bar"));
// Re-set cookie which should not change sort order.
EXPECT_TRUE(
SetCookie(cm.get(), http_www_google_.url(), "B=B3; path=/foo/bar"));
CookieList cookies = GetAllCookies(cm.get());
ASSERT_EQ(6u, cookies.size());
// According to RFC 6265 5.3 (11) re-setting this cookie should retain the
// initial creation-time from above, and the sort order should not change.
// Chrome's current implementation deviates from the spec so capturing this to
// avoid any inadvertent changes to this behavior.
EXPECT_EQ("A3", cookies[0].Value());
EXPECT_EQ("B3", cookies[1].Value());
EXPECT_EQ("B2", cookies[2].Value());
EXPECT_EQ("A2", cookies[3].Value());
EXPECT_EQ("B1", cookies[4].Value());
EXPECT_EQ("A1", cookies[5].Value());
}
TEST_F(CookieMonsterTest, DeleteCookieByName) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A1; path=/"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A2; path=/foo"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A3; path=/bar"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B1; path=/"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B2; path=/foo"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B3; path=/bar"));
DeleteCookie(cm.get(), http_www_google_.AppendPath("foo/bar"), "A");
CookieList cookies = GetAllCookies(cm.get());
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());
}
}
// 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(GURL("http://www.google.com"),
"X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
Time::Now() + TimeDelta::FromDays(3), &initial_cookies);
AddCookieToList(GURL("http://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(GURL("http://www.google.com"),
"X=3; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
Time::Now() + TimeDelta::FromDays(4), &initial_cookies);
AddCookieToList(GURL("http://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(GURL("http://www.google.com"),
"X=a1; path=/2; expires=Mon, 18-Apr-22 22:50:14 GMT",
Time::Now() + TimeDelta::FromDays(9), &initial_cookies);
AddCookieToList(GURL("http://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(GURL("http://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);
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
// 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.get(), 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.get(), 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(GURL("http://www.google.com"), "X=1; path=/", now,
&initial_cookies);
AddCookieToList(GURL("http://www.google.com"), "X=2; path=/", now,
&initial_cookies);
AddCookieToList(GURL("http://www.google.com"), "X=3; path=/", now,
&initial_cookies);
AddCookieToList(GURL("http://www.google.com"), "X=4; path=/", now,
&initial_cookies);
AddCookieToList(GURL("http://www.google.com"), "Y=1; path=/", earlier,
&initial_cookies);
AddCookieToList(GURL("http://www.google.com"), "Y=2; path=/", earlier,
&initial_cookies);
AddCookieToList(GURL("http://www.google.com"), "Y=3; path=/", earlier,
&initial_cookies);
AddCookieToList(GURL("http://www.google.com"), "Y=4; path=/", earlier,
&initial_cookies);
// Inject our initial cookies into the mock PersistentCookieStore.
store->SetLoadExpectation(true, initial_cookies);
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
CookieList list(GetAllCookies(cm.get()));
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, CookieMonsterDelegate) {
scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
scoped_refptr<MockCookieMonsterDelegate> delegate(
new MockCookieMonsterDelegate);
std::unique_ptr<CookieMonster> cm(
new CookieMonster(store.get(), delegate.get()));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "C=D"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "E=F"));
EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), http_www_google_.url()));
ASSERT_EQ(3u, delegate->changes().size());
EXPECT_FALSE(delegate->changes()[0].second);
EXPECT_EQ(http_www_google_.url().host(),
delegate->changes()[0].first.Domain());
EXPECT_EQ("A", delegate->changes()[0].first.Name());
EXPECT_EQ("B", delegate->changes()[0].first.Value());
EXPECT_EQ(http_www_google_.url().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(http_www_google_.url().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.get(), http_www_google_.url().host(), "C"));
EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
ASSERT_EQ(1u, delegate->changes().size());
EXPECT_EQ(http_www_google_.url().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.get(), "random.host", "E"));
EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
EXPECT_EQ(0u, delegate->changes().size());
// Insert a cookie "a" for path "/path1"
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
"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(http_www_google_.url().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.get(), http_www_google_.url(),
"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(http_www_google_.url().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(http_www_google_.url().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, PredicateSeesAllCookies) {
const std::string kTrueValue = "A";
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
// We test that we can see all cookies with our predicated. This includes
// host, http_only, host secure, and all domain cookies.
CookiePredicate value_matcher = base::Bind(&CookieValuePredicate, kTrueValue);
PopulateCmForPredicateCheck(cm.get());
EXPECT_EQ(7, DeleteAllCreatedBetweenWithPredicate(
cm.get(), base::Time(), base::Time::Now(), value_matcher));
EXPECT_EQ("dom_2=B; dom_3=C; host_3=C",
GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
EXPECT_EQ("dom_2=B; host_2=B; sec_host=B",
GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
EXPECT_EQ("", GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
EXPECT_EQ("dom_path_2=B; host_path_2=B; dom_2=B; host_2=B; sec_host=B",
GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure +
std::string("/dir1/dir2/xxx"))));
}
TEST_F(CookieMonsterTest, UniqueCreationTime) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
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
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "SetCookie1=A"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "SetCookie2=A"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "SetCookie3=A"));
EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
"setCookieWithOptions1=A", options));
EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
"setCookieWithOptions2=A", options));
EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
"setCookieWithOptions3=A", options));
EXPECT_TRUE(SetCookieWithDetails(
cm.get(), http_www_google_.url(), "setCookieWithDetails1", "A",
http_www_google_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(SetCookieWithDetails(
cm.get(), http_www_google_.url(), "setCookieWithDetails2", "A",
http_www_google_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
EXPECT_TRUE(SetCookieWithDetails(
cm.get(), http_www_google_.url(), "setCookieWithDetails3", "A",
http_www_google_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
// Now we check
CookieList cookie_list(GetAllCookies(cm.get()));
EXPECT_EQ(9u, cookie_list.size());
typedef std::map<int64_t, CanonicalCookie> TimeCookieMap;
TimeCookieMap check_map;
for (CookieList::const_iterator it = cookie_list.begin();
it != cookie_list.end(); it++) {
const int64_t 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) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
// 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));
const CookiesInputInfo input_info[] = {
{GURL("http://a.b.google.com"), "a", "1", "", "/path/to/cookie", expires,
false, false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT},
{GURL("https://www.google.com"), "b", "2", ".google.com",
"/path/from/cookie", expires + TimeDelta::FromSeconds(10), true, true,
CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT},
{GURL("https://google.com"), "c", "3", "", "/another/path/to/cookie",
base::Time::Now() + base::TimeDelta::FromSeconds(100), true, false,
CookieSameSite::STRICT_MODE, COOKIE_PRIORITY_DEFAULT}};
const int INPUT_DELETE = 1;
// Create new cookies and flush them to the store.
{
std::unique_ptr<CookieMonster> cmout(
new CookieMonster(store.get(), nullptr));
for (const CookiesInputInfo* p = input_info;
p < &input_info[arraysize(input_info)]; p++) {
EXPECT_TRUE(SetCookieWithDetails(
cmout.get(), p->url, p->name, p->value, p->domain, p->path,
base::Time(), p->expiration_time, base::Time(), p->secure,
p->http_only, p->same_site, p->priority));
}
GURL del_url(input_info[INPUT_DELETE]
.url.Resolve(input_info[INPUT_DELETE].path)
.spec());
DeleteCookie(cmout.get(), del_url, input_info[INPUT_DELETE].name);
}
// Create a new cookie monster and make sure that everything is correct
{
std::unique_ptr<CookieMonster> cmin(
new CookieMonster(store.get(), nullptr));
CookieList cookies(GetAllCookies(cmin.get()));
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(input->url.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_EQ(input->same_site, output->SameSite());
EXPECT_TRUE(output->IsPersistent());
EXPECT_EQ(input->expiration_time.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.
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
EXPECT_TRUE(
SetCookie(cm.get(), GURL("http://d.c.b.a.google.com/aa/x.html"), "c=1"));
EXPECT_TRUE(SetCookie(cm.get(), GURL("http://b.a.google.com/aa/bb/cc/x.html"),
"d=1; domain=b.a.google.com"));
EXPECT_TRUE(SetCookie(cm.get(), GURL("http://b.a.google.com/aa/bb/cc/x.html"),
"a=4; domain=b.a.google.com"));
EXPECT_TRUE(SetCookie(cm.get(),
GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
"e=1; domain=c.b.a.google.com"));
EXPECT_TRUE(SetCookie(cm.get(),
GURL("http://d.c.b.a.google.com/aa/bb/x.html"), "b=1"));
EXPECT_TRUE(SetCookie(cm.get(), GURL("http://news.bbc.co.uk/midpath/x.html"),
"g=10"));
{
unsigned int i = 0;
CookieList cookies(GetAllCookiesForURL(
cm.get(), 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.get()));
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.
{
std::unique_ptr<CookieMonster> cm(
CreateMonsterForGC(CookieMonster::kMaxCookies * 2));
EXPECT_EQ(CookieMonster::kMaxCookies * 2, GetAllCookies(cm.get()).size());
SetCookie(cm.get(), GURL("http://newdomain.com"), "b=2");
EXPECT_EQ(CookieMonster::kMaxCookies * 2 + 1,
GetAllCookies(cm.get()).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(test_cases)); ++ci) {
const TestCase* test_case = &test_cases[ci];
std::unique_ptr<CookieMonster> cm = CreateMonsterFromStoreForGC(
test_case->num_cookies, test_case->num_old_cookies, 0, 0,
CookieMonster::kSafeFromGlobalPurgeDays * 2);
EXPECT_EQ(test_case->expected_initial_cookies,
GetAllCookies(cm.get()).size())
<< "For test case " << ci;
// Will trigger GC
SetCookie(cm.get(), GURL("http://newdomain.com"), "b=2");
EXPECT_EQ(test_case->expected_cookies_after_set,
GetAllCookies(cm.get()).size())
<< "For test case " << ci;
}
}
// Tests that if the main load event happens before the loaded event for a
// particular key, the tasks for that key run first.
TEST_F(CookieMonsterTest, WhileLoadingLoadCompletesBeforeKeyLoadCompletes) {
const GURL kUrl = GURL(kTopLevelDomainPlus1);
scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
store->set_store_load_commands(true);
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
// Get all cookies task that queues a task to set a cookie when executed.
ResultSavingCookieCallback<bool> set_cookie_callback;
cm->SetCookieWithOptionsAsync(
kUrl, "a=b", CookieOptions(),
base::Bind(&ResultSavingCookieCallback<bool>::Run,
base::Unretained(&set_cookie_callback)));
GetCookieListCallback get_cookie_list_callback1;
cm->GetAllCookiesAsync(
base::Bind(&GetCookieListCallback::Run,
base::Unretained(&get_cookie_list_callback1)));
// Two load events should have been queued.
ASSERT_EQ(2u, store->commands().size());
ASSERT_EQ(CookieStoreCommand::LOAD, store->commands()[0].type);
ASSERT_EQ(CookieStoreCommand::LOAD_COOKIES_FOR_KEY,
store->commands()[1].type);
// The main load completes first (With no cookies).
store->commands()[0].loaded_callback.Run(std::vector<CanonicalCookie*>());
// The tasks should run in order, and the get should see the cookies.
set_cookie_callback.WaitUntilDone();
EXPECT_TRUE(set_cookie_callback.result());
get_cookie_list_callback1.WaitUntilDone();
EXPECT_EQ(1u, get_cookie_list_callback1.cookies().size());
// The loaded for key event completes late, with not cookies (Since they
// were already loaded).
store->commands()[1].loaded_callback.Run(std::vector<CanonicalCookie*>());
// The just set cookie should still be in the store.
GetCookieListCallback get_cookie_list_callback2;
cm->GetAllCookiesAsync(
base::Bind(&GetCookieListCallback::Run,
base::Unretained(&get_cookie_list_callback2)));
get_cookie_list_callback2.WaitUntilDone();
EXPECT_EQ(1u, get_cookie_list_callback2.cookies().size());
}
// Tests that case that DeleteAll is waiting for load to complete, and then a
// get is queued. The get should wait to run until after all the cookies are
// retrieved, and should return nothing, since all cookies were just deleted.
TEST_F(CookieMonsterTest, WhileLoadingDeleteAllGetForURL) {
const GURL kUrl = GURL(kTopLevelDomainPlus1);
scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
store->set_store_load_commands(true);
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
ResultSavingCookieCallback<int> delete_callback;
cm->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<int>::Run,
base::Unretained(&delete_callback)));
GetCookieListCallback get_cookie_list_callback;
cm->GetCookieListWithOptionsAsync(
kUrl, CookieOptions(),
base::Bind(&GetCookieListCallback::Run,
base::Unretained(&get_cookie_list_callback)));
// Only the main load should have been queued.
ASSERT_EQ(1u, store->commands().size());
ASSERT_EQ(CookieStoreCommand::LOAD, store->commands()[0].type);
std::vector<CanonicalCookie*> cookies;
// When passed to the CookieMonster, it takes ownership of the pointed to
// cookies.
cookies.push_back(
CanonicalCookie::Create(kUrl, "a=b", base::Time(), CookieOptions())
.release());
ASSERT_TRUE(cookies[0]);
store->commands()[0].loaded_callback.Run(cookies);
delete_callback.WaitUntilDone();
EXPECT_EQ(1, delete_callback.result());
get_cookie_list_callback.WaitUntilDone();
EXPECT_EQ(0u, get_cookie_list_callback.cookies().size());
}
// Tests that a set cookie call sandwiched between two get all cookies, all
// before load completes, affects the first but not the second. The set should
// also not trigger a LoadCookiesForKey (As that could complete only after the
// main load for the store).
TEST_F(CookieMonsterTest, WhileLoadingGetAllSetGetAll) {
const GURL kUrl = GURL(kTopLevelDomainPlus1);
scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
store->set_store_load_commands(true);
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
GetCookieListCallback get_cookie_list_callback1;
cm->GetAllCookiesAsync(
base::Bind(&GetCookieListCallback::Run,
base::Unretained(&get_cookie_list_callback1)));
ResultSavingCookieCallback<bool> set_cookie_callback;
cm->SetCookieWithOptionsAsync(
kUrl, "a=b", CookieOptions(),
base::Bind(&ResultSavingCookieCallback<bool>::Run,
base::Unretained(&set_cookie_callback)));
GetCookieListCallback get_cookie_list_callback2;
cm->GetAllCookiesAsync(
base::Bind(&GetCookieListCallback::Run,
base::Unretained(&get_cookie_list_callback2)));
// Only the main load should have been queued.
ASSERT_EQ(1u, store->commands().size());
ASSERT_EQ(CookieStoreCommand::LOAD, store->commands()[0].type);
// The load completes (With no cookies).
store->commands()[0].loaded_callback.Run(std::vector<CanonicalCookie*>());
get_cookie_list_callback1.WaitUntilDone();
EXPECT_EQ(0u, get_cookie_list_callback1.cookies().size());
set_cookie_callback.WaitUntilDone();
EXPECT_TRUE(set_cookie_callback.result());
get_cookie_list_callback2.WaitUntilDone();
EXPECT_EQ(1u, get_cookie_list_callback2.cookies().size());
}
namespace {
void RunClosureOnCookieListReceived(const base::Closure& closure,
const CookieList& cookie_list) {
closure.Run();
}
} // namespace
// Tests that if a single cookie task is queued as a result of a task performed
// on all cookies when loading completes, it will be run after any already
// queued tasks.
TEST_F(CookieMonsterTest, CheckOrderOfCookieTaskQueueWhenLoadingCompletes) {
const GURL kUrl = GURL(kTopLevelDomainPlus1);
scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
store->set_store_load_commands(true);
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
// Get all cookies task that queues a task to set a cookie when executed.
ResultSavingCookieCallback<bool> set_cookie_callback;
cm->GetAllCookiesAsync(base::Bind(
&RunClosureOnCookieListReceived,
base::Bind(&CookieStore::SetCookieWithOptionsAsync,
base::Unretained(cm.get()), kUrl, "a=b", CookieOptions(),
base::Bind(&ResultSavingCookieCallback<bool>::Run,
base::Unretained(&set_cookie_callback)))));
// Get cookie task. Queued before the delete task is executed, so should not
// see the set cookie.
GetCookieListCallback get_cookie_list_callback1;
cm->GetAllCookiesAsync(
base::Bind(&GetCookieListCallback::Run,
base::Unretained(&get_cookie_list_callback1)));
// Only the main load should have been queued.
ASSERT_EQ(1u, store->commands().size());
ASSERT_EQ(CookieStoreCommand::LOAD, store->commands()[0].type);
// The load completes.
store->commands()[0].loaded_callback.Run(std::vector<CanonicalCookie*>());
// The get cookies call should see no cookies set.
get_cookie_list_callback1.WaitUntilDone();
EXPECT_EQ(0u, get_cookie_list_callback1.cookies().size());
set_cookie_callback.WaitUntilDone();
EXPECT_TRUE(set_cookie_callback.result());
// A subsequent get cookies call should see the new cookie.
GetCookieListCallback get_cookie_list_callback2;
cm->GetAllCookiesAsync(
base::Bind(&GetCookieListCallback::Run,
base::Unretained(&get_cookie_list_callback2)));
get_cookie_list_callback2.WaitUntilDone();
EXPECT_EQ(1u, get_cookie_list_callback2.cookies().size());
}
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) override {
std::vector<CanonicalCookie*> out_cookies;
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::Bind(&LoadedCallbackTask::Run,
new LoadedCallbackTask(loaded_callback, out_cookies)));
}
void LoadCookiesForKey(const std::string& key,
const LoadedCallback& loaded_callback) override {
Load(loaded_callback);
}
void AddCookie(const CanonicalCookie&) override {}
void UpdateCookieAccessTime(const CanonicalCookie&) override {}
void DeleteCookie(const CanonicalCookie&) override {}
void SetForceKeepSessionState() override {}
void Flush(const base::Closure& callback) override {
++flush_count_;
if (!callback.is_null())
callback.Run();
}
int flush_count() { return flush_count_; }
private:
~FlushablePersistentStore() override {}
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());
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
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()));
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0, store->flush_count());
ASSERT_EQ(1, counter->callback_count());
// NULL callback is safe.
cm->FlushStore(base::Closure());
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0, store->flush_count());
ASSERT_EQ(1, counter->callback_count());
// After initialization, FlushStore() should delegate to the store.
GetAllCookies(cm.get()); // Force init.
cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
base::RunLoop().RunUntilIdle();
ASSERT_EQ(1, store->flush_count());
ASSERT_EQ(2, counter->callback_count());
// NULL callback is still safe.
cm->FlushStore(base::Closure());
base::RunLoop().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.reset(new CookieMonster(nullptr, nullptr));
GetAllCookies(cm.get()); // Force init.
cm->FlushStore(base::Closure());
base::RunLoop().RunUntilIdle();
ASSERT_EQ(2, counter->callback_count());
cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
base::RunLoop().RunUntilIdle();
ASSERT_EQ(3, counter->callback_count());
}
TEST_F(CookieMonsterTest, SetAllCookies) {
scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
cm->SetPersistSessionCookies(true);
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "U=V; path=/"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "W=X; path=/foo"));
EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "Y=Z; path=/"));
CookieList list;
list.push_back(*CanonicalCookie::Create(
http_www_google_.url(), "A", "B", http_www_google_.url().host(), "/",
base::Time::Now(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, false, COOKIE_PRIORITY_DEFAULT));
list.push_back(*CanonicalCookie::Create(
http_www_google_.url(), "W", "X", http_www_google_.url().host(), "/bar",
base::Time::Now(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, false, COOKIE_PRIORITY_DEFAULT));
list.push_back(*CanonicalCookie::Create(
http_www_google_.url(), "Y", "Z", http_www_google_.url().host(), "/",
base::Time::Now(), base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, false, COOKIE_PRIORITY_DEFAULT));
// SetAllCookies must not flush.
ASSERT_EQ(0, store->flush_count());
EXPECT_TRUE(SetAllCookies(cm.get(), list));
EXPECT_EQ(0, store->flush_count());
CookieList cookies = GetAllCookies(cm.get());
size_t expected_size = 3; // "A", "W" and "Y". "U" is gone.
EXPECT_EQ(expected_size, cookies.size());
CookieList::iterator it = cookies.begin();
ASSERT_TRUE(it != cookies.end());
EXPECT_EQ("W", it->Name());
EXPECT_EQ("X", it->Value());
EXPECT_EQ("/bar", it->Path()); // The path has been updated.
ASSERT_TRUE(++it != cookies.end());
EXPECT_EQ("A", it->Name());
EXPECT_EQ("B", it->Value());
ASSERT_TRUE(++it != cookies.end());
EXPECT_EQ("Y", it->Name());
EXPECT_EQ("Z", it->Value());
}
TEST_F(CookieMonsterTest, ComputeCookieDiff) {
std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
base::Time now = base::Time::Now();
base::Time creation_time = now - base::TimeDelta::FromSeconds(1);
std::unique_ptr<CanonicalCookie> cookie1(CanonicalCookie::Create(
http_www_google_.url(), "A", "B", http_www_google_.url().host(), "/",
creation_time, base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
false, COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie2(CanonicalCookie::Create(
http_www_google_.url(), "C", "D", http_www_google_.url().host(), "/",
creation_time, base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
false, COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie3(CanonicalCookie::Create(
http_www_google_.url(), "E", "F", http_www_google_.url().host(), "/",
creation_time, base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
false, COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie4(CanonicalCookie::Create(
http_www_google_.url(), "G", "H", http_www_google_.url().host(), "/",
creation_time, base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
false, COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie4_with_new_value(
CanonicalCookie::Create(
http_www_google_.url(), "G", "iamnew", http_www_google_.url().host(),
"/", creation_time, base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, false, COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie5(CanonicalCookie::Create(
http_www_google_.url(), "I", "J", http_www_google_.url().host(), "/",
creation_time, base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
false, COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie5_with_new_creation_time(
CanonicalCookie::Create(
http_www_google_.url(), "I", "J", http_www_google_.url().host(), "/",
now, base::Time(), false, false, CookieSameSite::DEFAULT_MODE, false,
COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie6(CanonicalCookie::Create(
http_www_google_.url(), "K", "L", http_www_google_.url().host(), "/foo",
creation_time, base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
false, COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie6_with_new_path(
CanonicalCookie::Create(
http_www_google_.url(), "K", "L", http_www_google_.url().host(),
"/bar", creation_time, base::Time(), false, false,
CookieSameSite::DEFAULT_MODE, false, COOKIE_PRIORITY_DEFAULT));
std::unique_ptr<CanonicalCookie> cookie7(CanonicalCookie::Create(
http_www