1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_COOKIES_COOKIE_STORE_TEST_HELPERS_H_
#define NET_COOKIES_COOKIE_STORE_TEST_HELPERS_H_
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "base/functional/callback_forward.h"
#include "base/synchronization/lock.h"
#include "net/cookies/cookie_change_dispatcher.h"
#include "net/cookies/cookie_monster.h"
#include "net/log/net_log_with_source.h"
#include "testing/gtest/include/gtest/gtest.h"
class GURL;
namespace net {
class DelayedCookieMonsterChangeDispatcher : public CookieChangeDispatcher {
public:
DelayedCookieMonsterChangeDispatcher();
DelayedCookieMonsterChangeDispatcher(
const DelayedCookieMonsterChangeDispatcher&) = delete;
DelayedCookieMonsterChangeDispatcher& operator=(
const DelayedCookieMonsterChangeDispatcher&) = delete;
~DelayedCookieMonsterChangeDispatcher() override;
// net::CookieChangeDispatcher
[[nodiscard]] std::unique_ptr<CookieChangeSubscription> AddCallbackForCookie(
const GURL& url,
const std::string& name,
const std::optional<CookiePartitionKey>& cookie_partition_key,
CookieChangeCallback callback) override;
[[nodiscard]] std::unique_ptr<CookieChangeSubscription> AddCallbackForUrl(
const GURL& url,
const std::optional<CookiePartitionKey>& cookie_partition_key,
CookieChangeCallback callback) override;
[[nodiscard]] std::unique_ptr<CookieChangeSubscription>
AddCallbackForAllChanges(CookieChangeCallback callback) override;
};
class DelayedCookieMonster : public CookieStore {
public:
DelayedCookieMonster();
DelayedCookieMonster(const DelayedCookieMonster&) = delete;
DelayedCookieMonster& operator=(const DelayedCookieMonster&) = delete;
~DelayedCookieMonster() override;
// Call the asynchronous CookieMonster function, expect it to immediately
// invoke the internal callback.
// Post a delayed task to invoke the original callback with the results.
void SetCanonicalCookieAsync(
std::unique_ptr<CanonicalCookie> cookie,
const GURL& source_url,
const CookieOptions& options,
SetCookiesCallback callback,
const std::optional<CookieAccessResult> cookie_access_result =
std::nullopt) override;
// This function is for test purposes only.
// Call the asynchronous CookieMonster function, expect it to immediately
// invoke the internal callback.
// Post a delayed task to invoke the original callback with the results.
void SetUnsafeCanonicalCookieForTestAsync(
std::unique_ptr<CanonicalCookie> cookie,
SetCookiesCallback callback) override;
void GetCookieListWithOptionsAsync(
const GURL& url,
const CookieOptions& options,
const CookiePartitionKeyCollection& cookie_partition_key_collection,
GetCookieListCallback callback) override;
void GetAllCookiesAsync(GetAllCookiesCallback callback) override;
void DeleteCanonicalCookieAsync(const CanonicalCookie& cookie,
DeleteCallback callback) override;
void DeleteAllCreatedInTimeRangeAsync(
const CookieDeletionInfo::TimeRange& creation_range,
DeleteCallback callback) override;
void DeleteAllMatchingInfoAsync(net::CookieDeletionInfo delete_info,
DeleteCallback callback) override;
void DeleteSessionCookiesAsync(DeleteCallback) override;
void DeleteMatchingCookiesAsync(DeletePredicate, DeleteCallback) override;
void FlushStore(base::OnceClosure callback) override;
CookieChangeDispatcher& GetChangeDispatcher() override;
void SetCookieableSchemes(std::vector<std::string> schemes,
SetCookieableSchemesCallback callback) override;
private:
// Be called immediately from CookieMonster.
void SetCookiesInternalCallback(CookieAccessResult result);
void GetCookiesWithOptionsInternalCallback(const std::string& cookie);
void GetCookieListWithOptionsInternalCallback(
const CookieAccessResultList& cookie,
const CookieAccessResultList& excluded_cookies);
// Invoke the original callbacks.
void InvokeSetCookiesCallback(CookieMonster::SetCookiesCallback callback);
void InvokeGetCookieListCallback(
CookieMonster::GetCookieListCallback callback);
friend class base::RefCountedThreadSafe<DelayedCookieMonster>;
std::unique_ptr<CookieMonster> cookie_monster_;
DelayedCookieMonsterChangeDispatcher change_dispatcher_;
bool did_run_ = false;
CookieAccessResult result_;
std::string cookie_;
std::string cookie_line_;
CookieAccessResultList cookie_access_result_list_;
CookieList cookie_list_;
};
class CookieURLHelper {
public:
explicit CookieURLHelper(const std::string& url_string);
const std::string& domain() const { return domain_and_registry_; }
std::string host() const { return url_.host(); }
const GURL& url() const { return url_; }
const GURL AppendPath(const std::string& path) const;
// Return a new string with the following substitutions:
// 1. "%R" -> Domain registry (i.e. "com")
// 2. "%D" -> Domain + registry (i.e. "google.com")
std::string Format(const std::string& format_string) const;
private:
const GURL url_;
const std::string registry_;
const std::string domain_and_registry_;
};
// Mock PersistentCookieStore that keeps track of the number of Flush() calls.
class FlushablePersistentStore : public CookieMonster::PersistentCookieStore {
public:
FlushablePersistentStore();
// CookieMonster::PersistentCookieStore implementation:
void Load(LoadedCallback loaded_callback,
const NetLogWithSource& net_log) override;
void LoadCookiesForKey(const std::string& key,
LoadedCallback loaded_callback) override;
void AddCookie(const CanonicalCookie&) override;
void UpdateCookieAccessTime(const CanonicalCookie&) override;
void DeleteCookie(const CanonicalCookie&) override;
void SetForceKeepSessionState() override;
void SetBeforeCommitCallback(base::RepeatingClosure callback) override;
void Flush(base::OnceClosure callback) override;
int flush_count();
private:
~FlushablePersistentStore() override;
int flush_count_ = 0;
base::Lock flush_count_lock_; // Protects |flush_count_|.
};
// Counts the number of times Callback() has been run.
class CallbackCounter : public base::RefCountedThreadSafe<CallbackCounter> {
public:
CallbackCounter();
void Callback();
int callback_count();
private:
friend class base::RefCountedThreadSafe<CallbackCounter>;
~CallbackCounter();
int callback_count_ = 0;
base::Lock callback_count_lock_; // Protects |callback_count_|.
};
// Returns a cookie expiration string in the form of "; expires=<date>", where
// date is an RFC 7231 date a year in the future, which can be appended to
// cookie lines.
std::string FutureCookieExpirationString();
} // namespace net
#endif // NET_COOKIES_COOKIE_STORE_TEST_HELPERS_H_
|
