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
|
// 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.
// Brought to you by number 42.
#ifndef NET_COOKIES_COOKIE_STORE_H_
#define NET_COOKIES_COOKIE_STORE_H_
#include <stdint.h>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "base/functional/callback_forward.h"
#include "net/base/net_export.h"
#include "net/cookies/canonical_cookie.h"
#include "net/cookies/cookie_access_delegate.h"
#include "net/cookies/cookie_access_result.h"
#include "net/cookies/cookie_deletion_info.h"
#include "net/cookies/cookie_options.h"
#include "net/cookies/cookie_partition_key_collection.h"
class GURL;
namespace net {
class CookieChangeDispatcher;
// An interface for storing and retrieving cookies. Implementations are not
// thread safe, as with most other net classes. All methods must be invoked on
// the network thread, and all callbacks will be called there.
//
// All async functions may either invoke the callback asynchronously, or they
// may be invoked immediately (prior to return of the asynchronous function).
// Destroying the CookieStore will cancel pending async callbacks.
class NET_EXPORT CookieStore {
public:
// Callback definitions.
using GetCookieListCallback =
base::OnceCallback<void(const CookieAccessResultList& included_cookies,
const CookieAccessResultList& excluded_list)>;
using GetAllCookiesCallback =
base::OnceCallback<void(const CookieList& cookies)>;
// |access_semantics_list| is guaranteed to the same length as |cookies|.
using GetAllCookiesWithAccessSemanticsCallback = base::OnceCallback<void(
const CookieList& cookies,
const std::vector<CookieAccessSemantics>& access_semantics_list)>;
using SetCookiesCallback =
base::OnceCallback<void(CookieAccessResult access_result)>;
using DeleteCallback = base::OnceCallback<void(uint32_t num_deleted)>;
using DeletePredicate =
base::RepeatingCallback<bool(const CanonicalCookie& cookie)>;
using SetCookieableSchemesCallback = base::OnceCallback<void(bool success)>;
CookieStore();
virtual ~CookieStore();
// Set the cookie on the cookie store. |cookie.IsCanonical()| must
// be true. |source_url| denotes the url of the resource setting this.
//
// |options| is used to determine the context the operation is run in, and
// which cookies it can alter (e.g. http only, or same site).
//
// The current time will be used in place of a null creation time.
//
// |cookie_access_result| is an optional input status, to allow for status
// chaining from callers. It helps callers provide the status of a
// canonical cookie that may have warnings associated with it.
virtual void SetCanonicalCookieAsync(
std::unique_ptr<CanonicalCookie> cookie,
const GURL& source_url,
const CookieOptions& options,
SetCookiesCallback callback,
std::optional<CookieAccessResult> cookie_access_result =
std::nullopt) = 0;
// Set the cookie on the cookie store. This is unsafe because it doesn't do
// any of the usual inclusion checks and will always insert the cookie, This
// should be used for testing only. Use this only if SetCanonicalCookieAsync
// does not fit your testing requirements.
virtual void SetUnsafeCanonicalCookieForTestAsync(
std::unique_ptr<CanonicalCookie> cookie,
SetCookiesCallback callback) = 0;
// Obtains a CookieList for the given |url| and |options|. The returned
// cookies are passed into |callback|, ordered by longest path, then earliest
// creation date.
// To get all the cookies for a URL, use this method with an all-inclusive
// |options|.
// If |cookie_partition_key_collection| is not empty, then this function will
// return the partitioned cookies for that URL whose partition keys are in the
// cookie_partition_key_collection *in addition to* the unpartitioned cookies
// for that URL.
virtual void GetCookieListWithOptionsAsync(
const GURL& url,
const CookieOptions& options,
const CookiePartitionKeyCollection& cookie_partition_key_collection,
GetCookieListCallback callback) = 0;
// Returns all the cookies, for use in management UI, etc. This does not mark
// the cookies as having been accessed. The returned cookies are ordered by
// longest path, then by earliest creation date.
virtual void GetAllCookiesAsync(GetAllCookiesCallback callback) = 0;
// Returns all the cookies, for use in management UI, etc. This does not mark
// the cookies as having been accessed. The returned cookies are ordered by
// longest path, then by earliest creation date.
// Additionally returns a vector of CookieAccessSemantics values for the
// returned cookies, which will be the same length as the vector of returned
// cookies. This vector will either contain all CookieAccessSemantics::UNKNOWN
// (if the default implementation is used), or each entry in the
// vector of CookieAccessSemantics will indicate the access semantics
// applicable to the cookie at the same index in the returned CookieList.
virtual void GetAllCookiesWithAccessSemanticsAsync(
GetAllCookiesWithAccessSemanticsCallback callback);
// Deletes one specific cookie. |cookie| must have been returned by a previous
// query on this CookieStore. Invokes |callback| with 1 if a cookie was
// deleted, 0 otherwise.
virtual void DeleteCanonicalCookieAsync(const CanonicalCookie& cookie,
DeleteCallback callback) = 0;
// Deletes all of the cookies that have a creation_date matching
// |creation_range|. See CookieDeletionInfo::TimeRange::Matches().
// Calls |callback| with the number of cookies deleted.
virtual void DeleteAllCreatedInTimeRangeAsync(
const CookieDeletionInfo::TimeRange& creation_range,
DeleteCallback callback) = 0;
// Deletes all of the cookies matching |delete_info|. This includes all
// http_only and secure cookies. Avoid deleting cookies that could leave
// websites with a partial set of visible cookies.
// Calls |callback| with the number of cookies deleted.
virtual void DeleteAllMatchingInfoAsync(CookieDeletionInfo delete_info,
DeleteCallback callback) = 0;
// Deletes all cookies without expiration data.
virtual void DeleteSessionCookiesAsync(DeleteCallback callback) = 0;
// Deletes all cookies where |predicate| returns true.
// Calls |callback| with the number of cookies deleted.
virtual void DeleteMatchingCookiesAsync(DeletePredicate predicate,
DeleteCallback callback) = 0;
// Deletes all cookies in the store.
void DeleteAllAsync(DeleteCallback callback);
// Flush the backing store (if any) to disk and post the given callback when
// done.
virtual void FlushStore(base::OnceClosure callback) = 0;
// Protects session cookies from deletion on shutdown, if the underlying
// CookieStore implemention is currently configured to store them to disk.
// Otherwise, does nothing.
virtual void SetForceKeepSessionState() {}
// The interface used to observe changes to this CookieStore's contents.
virtual CookieChangeDispatcher& GetChangeDispatcher() = 0;
// Resets the list of cookieable schemes to the supplied schemes. Does nothing
// (and returns false) if called after first use of the instance (i.e. after
// the instance initialization process). Otherwise, this returns true to
// indicate success. CookieStores which do not support modifying cookieable
// schemes will always return false.
virtual void SetCookieableSchemes(std::vector<std::string> schemes,
SetCookieableSchemesCallback callback) = 0;
// Transfer ownership of a CookieAccessDelegate.
void SetCookieAccessDelegate(std::unique_ptr<CookieAccessDelegate> delegate);
// This may be null if no delegate has been set yet, or the delegate has been
// reset to null.
const CookieAccessDelegate* cookie_access_delegate() const {
return cookie_access_delegate_.get();
}
// Returns a boolean indicating whether the cookie `site` has any cookie
// in another partition other than the `cookie_partition_key` supplied.
// Will return nullopt if cookies have not finished loading.
virtual std::optional<bool> SiteHasCookieInOtherPartition(
const net::SchemefulSite& site,
const CookiePartitionKey& cookie_partition_key) const;
private:
// Used to determine whether a particular cookie should be subject to legacy
// or non-legacy access semantics.
std::unique_ptr<CookieAccessDelegate> cookie_access_delegate_;
};
} // namespace net
#endif // NET_COOKIES_COOKIE_STORE_H_
|
