1 // Copyright 2019 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/cookies/test_cookie_access_delegate.h"
6
7 #include <optional>
8 #include <set>
9 #include <utility>
10 #include <vector>
11
12 #include "base/containers/contains.h"
13 #include "base/containers/flat_map.h"
14 #include "base/containers/flat_set.h"
15 #include "base/functional/callback.h"
16 #include "base/ranges/algorithm.h"
17 #include "base/task/sequenced_task_runner.h"
18 #include "base/task/thread_pool.h"
19 #include "net/base/schemeful_site.h"
20 #include "net/cookies/cookie_constants.h"
21 #include "net/cookies/cookie_util.h"
22 #include "net/first_party_sets/first_party_set_entry.h"
23 #include "net/first_party_sets/first_party_set_metadata.h"
24 #include "net/first_party_sets/first_party_sets_cache_filter.h"
25
26 namespace net {
27
28 TestCookieAccessDelegate::TestCookieAccessDelegate() = default;
29
30 TestCookieAccessDelegate::~TestCookieAccessDelegate() = default;
31
GetAccessSemantics(const CanonicalCookie & cookie) const32 CookieAccessSemantics TestCookieAccessDelegate::GetAccessSemantics(
33 const CanonicalCookie& cookie) const {
34 auto it = expectations_.find(GetKeyForDomainValue(cookie.Domain()));
35 if (it != expectations_.end())
36 return it->second;
37 return CookieAccessSemantics::UNKNOWN;
38 }
39
GetAccessForLegacyCookieScope(const CanonicalCookie & cookie) const40 CookieLegacyScope TestCookieAccessDelegate::GetAccessForLegacyCookieScope(
41 const CanonicalCookie& cookie) const {
42 auto it = expectations_legacy_.find(GetKeyForDomainValue(cookie.Domain()));
43 if (it != expectations_legacy_.end()) {
44 return it->second;
45 }
46 return CookieLegacyScope::UNKNOWN;
47 }
48
ShouldIgnoreSameSiteRestrictions(const GURL & url,const SiteForCookies & site_for_cookies) const49 bool TestCookieAccessDelegate::ShouldIgnoreSameSiteRestrictions(
50 const GURL& url,
51 const SiteForCookies& site_for_cookies) const {
52 auto it =
53 ignore_samesite_restrictions_schemes_.find(site_for_cookies.scheme());
54 if (it == ignore_samesite_restrictions_schemes_.end())
55 return false;
56 if (it->second)
57 return url.SchemeIsCryptographic();
58 return true;
59 }
60
61 // Returns true if `url` has the same scheme://eTLD+1 as `trustworthy_site_`.
ShouldTreatUrlAsTrustworthy(const GURL & url) const62 bool TestCookieAccessDelegate::ShouldTreatUrlAsTrustworthy(
63 const GURL& url) const {
64 if (SchemefulSite(url) == trustworthy_site_) {
65 return true;
66 }
67
68 return false;
69 }
70
71 std::optional<
72 std::pair<FirstPartySetMetadata, FirstPartySetsCacheFilter::MatchInfo>>
ComputeFirstPartySetMetadataMaybeAsync(const SchemefulSite & site,const SchemefulSite * top_frame_site,base::OnceCallback<void (FirstPartySetMetadata,FirstPartySetsCacheFilter::MatchInfo)> callback) const73 TestCookieAccessDelegate::ComputeFirstPartySetMetadataMaybeAsync(
74 const SchemefulSite& site,
75 const SchemefulSite* top_frame_site,
76 base::OnceCallback<void(FirstPartySetMetadata,
77 FirstPartySetsCacheFilter::MatchInfo)> callback)
78 const {
79 FirstPartySetMetadata metadata(
80 FindFirstPartySetEntry(site),
81 top_frame_site ? FindFirstPartySetEntry(*top_frame_site) : std::nullopt);
82 FirstPartySetsCacheFilter::MatchInfo match_info(
83 first_party_sets_cache_filter_.GetMatchInfo(site));
84
85 if (invoke_callbacks_asynchronously_) {
86 base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
87 FROM_HERE,
88 base::BindOnce(std::move(callback), std::move(metadata), match_info));
89 return std::nullopt;
90 }
91 return std::pair(std::move(metadata), match_info);
92 }
93
94 std::optional<FirstPartySetEntry>
FindFirstPartySetEntry(const SchemefulSite & site) const95 TestCookieAccessDelegate::FindFirstPartySetEntry(
96 const SchemefulSite& site) const {
97 auto entry = first_party_sets_.find(site);
98
99 return entry != first_party_sets_.end() ? std::make_optional(entry->second)
100 : std::nullopt;
101 }
102
103 std::optional<base::flat_map<SchemefulSite, FirstPartySetEntry>>
FindFirstPartySetEntries(const base::flat_set<SchemefulSite> & sites,base::OnceCallback<void (base::flat_map<SchemefulSite,FirstPartySetEntry>)> callback) const104 TestCookieAccessDelegate::FindFirstPartySetEntries(
105 const base::flat_set<SchemefulSite>& sites,
106 base::OnceCallback<void(base::flat_map<SchemefulSite, FirstPartySetEntry>)>
107 callback) const {
108 std::vector<std::pair<SchemefulSite, FirstPartySetEntry>> mapping;
109 for (const SchemefulSite& site : sites) {
110 std::optional<FirstPartySetEntry> entry = FindFirstPartySetEntry(site);
111 if (entry)
112 mapping.emplace_back(site, *entry);
113 }
114
115 return RunMaybeAsync<base::flat_map<SchemefulSite, FirstPartySetEntry>>(
116 mapping, std::move(callback));
117 }
118
119 template <class T>
RunMaybeAsync(T result,base::OnceCallback<void (T)> callback) const120 std::optional<T> TestCookieAccessDelegate::RunMaybeAsync(
121 T result,
122 base::OnceCallback<void(T)> callback) const {
123 if (invoke_callbacks_asynchronously_) {
124 base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
125 FROM_HERE, base::BindOnce(std::move(callback), std::move(result)));
126 return std::nullopt;
127 }
128 return result;
129 }
130
SetExpectationForCookieDomain(const std::string & cookie_domain,CookieAccessSemantics access_semantics)131 void TestCookieAccessDelegate::SetExpectationForCookieDomain(
132 const std::string& cookie_domain,
133 CookieAccessSemantics access_semantics) {
134 expectations_[GetKeyForDomainValue(cookie_domain)] = access_semantics;
135 }
136
SetIgnoreSameSiteRestrictionsScheme(const std::string & site_for_cookies_scheme,bool require_secure_origin)137 void TestCookieAccessDelegate::SetIgnoreSameSiteRestrictionsScheme(
138 const std::string& site_for_cookies_scheme,
139 bool require_secure_origin) {
140 ignore_samesite_restrictions_schemes_[site_for_cookies_scheme] =
141 require_secure_origin;
142 }
143
GetKeyForDomainValue(const std::string & domain) const144 std::string TestCookieAccessDelegate::GetKeyForDomainValue(
145 const std::string& domain) const {
146 DCHECK(!domain.empty());
147 return cookie_util::CookieDomainAsHost(domain);
148 }
149
SetFirstPartySets(const base::flat_map<SchemefulSite,FirstPartySetEntry> & sets)150 void TestCookieAccessDelegate::SetFirstPartySets(
151 const base::flat_map<SchemefulSite, FirstPartySetEntry>& sets) {
152 first_party_sets_ = sets;
153 }
154
155 } // namespace net
156