1 // Copyright 2024 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/http/http_stream_pool_test_util.h"
6
7 #include "net/base/completion_once_callback.h"
8 #include "net/base/connection_endpoint_metadata.h"
9 #include "net/base/net_errors.h"
10 #include "net/log/net_log_with_source.h"
11 #include "net/socket/socket_test_util.h"
12 #include "net/socket/stream_socket.h"
13 #include "net/ssl/ssl_connection_status_flags.h"
14 #include "net/test/cert_test_util.h"
15 #include "net/test/test_data_directory.h"
16 #include "net/traffic_annotation/network_traffic_annotation.h"
17
18 namespace net {
19
20 namespace {
21
MakeIPEndPoint(std::string_view addr,uint16_t port=80)22 IPEndPoint MakeIPEndPoint(std::string_view addr, uint16_t port = 80) {
23 return IPEndPoint(*IPAddress::FromIPLiteral(addr), port);
24 }
25
26 } // namespace
27
28 FakeServiceEndpointRequest::FakeServiceEndpointRequest() = default;
29
30 FakeServiceEndpointRequest::~FakeServiceEndpointRequest() = default;
31
32 FakeServiceEndpointRequest&
CompleteStartSynchronously(int rv)33 FakeServiceEndpointRequest::CompleteStartSynchronously(int rv) {
34 start_result_ = rv;
35 endpoints_crypto_ready_ = true;
36 return *this;
37 }
38
39 FakeServiceEndpointRequest&
CallOnServiceEndpointsUpdated()40 FakeServiceEndpointRequest::CallOnServiceEndpointsUpdated() {
41 CHECK(delegate_);
42 delegate_->OnServiceEndpointsUpdated();
43 return *this;
44 }
45
46 FakeServiceEndpointRequest&
CallOnServiceEndpointRequestFinished(int rv)47 FakeServiceEndpointRequest::CallOnServiceEndpointRequestFinished(int rv) {
48 CHECK(delegate_);
49 endpoints_crypto_ready_ = true;
50 delegate_->OnServiceEndpointRequestFinished(rv);
51 return *this;
52 }
53
Start(Delegate * delegate)54 int FakeServiceEndpointRequest::Start(Delegate* delegate) {
55 CHECK(!delegate_);
56 CHECK(delegate);
57 delegate_ = delegate;
58 return start_result_;
59 }
60
61 const std::vector<ServiceEndpoint>&
GetEndpointResults()62 FakeServiceEndpointRequest::GetEndpointResults() {
63 return endpoints_;
64 }
65
GetDnsAliasResults()66 const std::set<std::string>& FakeServiceEndpointRequest::GetDnsAliasResults() {
67 return aliases_;
68 }
69
EndpointsCryptoReady()70 bool FakeServiceEndpointRequest::EndpointsCryptoReady() {
71 return endpoints_crypto_ready_;
72 }
73
GetResolveErrorInfo()74 ResolveErrorInfo FakeServiceEndpointRequest::GetResolveErrorInfo() {
75 return resolve_error_info_;
76 }
77
ChangeRequestPriority(RequestPriority priority)78 void FakeServiceEndpointRequest::ChangeRequestPriority(
79 RequestPriority priority) {
80 priority_ = priority;
81 }
82
83 FakeServiceEndpointResolver::FakeServiceEndpointResolver() = default;
84
85 FakeServiceEndpointResolver::~FakeServiceEndpointResolver() = default;
86
AddFakeRequest()87 FakeServiceEndpointRequest* FakeServiceEndpointResolver::AddFakeRequest() {
88 std::unique_ptr<FakeServiceEndpointRequest> request =
89 std::make_unique<FakeServiceEndpointRequest>();
90 FakeServiceEndpointRequest* raw_request = request.get();
91 requests_.emplace_back(std::move(request));
92 return raw_request;
93 }
94
OnShutdown()95 void FakeServiceEndpointResolver::OnShutdown() {}
96
97 std::unique_ptr<HostResolver::ResolveHostRequest>
CreateRequest(url::SchemeHostPort host,NetworkAnonymizationKey network_anonymization_key,NetLogWithSource net_log,std::optional<ResolveHostParameters> optional_parameters)98 FakeServiceEndpointResolver::CreateRequest(
99 url::SchemeHostPort host,
100 NetworkAnonymizationKey network_anonymization_key,
101 NetLogWithSource net_log,
102 std::optional<ResolveHostParameters> optional_parameters) {
103 NOTREACHED();
104 }
105
106 std::unique_ptr<HostResolver::ResolveHostRequest>
CreateRequest(const HostPortPair & host,const NetworkAnonymizationKey & network_anonymization_key,const NetLogWithSource & net_log,const std::optional<ResolveHostParameters> & optional_parameters)107 FakeServiceEndpointResolver::CreateRequest(
108 const HostPortPair& host,
109 const NetworkAnonymizationKey& network_anonymization_key,
110 const NetLogWithSource& net_log,
111 const std::optional<ResolveHostParameters>& optional_parameters) {
112 NOTREACHED();
113 }
114
115 std::unique_ptr<HostResolver::ServiceEndpointRequest>
CreateServiceEndpointRequest(Host host,NetworkAnonymizationKey network_anonymization_key,NetLogWithSource net_log,ResolveHostParameters parameters)116 FakeServiceEndpointResolver::CreateServiceEndpointRequest(
117 Host host,
118 NetworkAnonymizationKey network_anonymization_key,
119 NetLogWithSource net_log,
120 ResolveHostParameters parameters) {
121 CHECK(!requests_.empty());
122 std::unique_ptr<FakeServiceEndpointRequest> request =
123 std::move(requests_.front());
124 requests_.pop_front();
125 request->set_priority(parameters.initial_priority);
126 return request;
127 }
128
129 ServiceEndpointBuilder::ServiceEndpointBuilder() = default;
130
131 ServiceEndpointBuilder::~ServiceEndpointBuilder() = default;
132
add_v4(std::string_view addr,uint16_t port)133 ServiceEndpointBuilder& ServiceEndpointBuilder::add_v4(std::string_view addr,
134 uint16_t port) {
135 endpoint_.ipv4_endpoints.emplace_back(MakeIPEndPoint(addr));
136 return *this;
137 }
138
add_v6(std::string_view addr,uint16_t port)139 ServiceEndpointBuilder& ServiceEndpointBuilder::add_v6(std::string_view addr,
140 uint16_t port) {
141 endpoint_.ipv6_endpoints.emplace_back(MakeIPEndPoint(addr));
142 return *this;
143 }
144
add_ip_endpoint(IPEndPoint ip_endpoint)145 ServiceEndpointBuilder& ServiceEndpointBuilder::add_ip_endpoint(
146 IPEndPoint ip_endpoint) {
147 if (ip_endpoint.address().IsIPv4()) {
148 endpoint_.ipv4_endpoints.emplace_back(ip_endpoint);
149 } else {
150 CHECK(ip_endpoint.address().IsIPv6());
151 endpoint_.ipv6_endpoints.emplace_back(ip_endpoint);
152 }
153 return *this;
154 }
155
set_alpns(std::vector<std::string> alpns)156 ServiceEndpointBuilder& ServiceEndpointBuilder::set_alpns(
157 std::vector<std::string> alpns) {
158 endpoint_.metadata.supported_protocol_alpns = std::move(alpns);
159 return *this;
160 }
161
set_ech_config_list(std::vector<uint8_t> ech_config_list)162 ServiceEndpointBuilder& ServiceEndpointBuilder::set_ech_config_list(
163 std::vector<uint8_t> ech_config_list) {
164 endpoint_.metadata.ech_config_list = std::move(ech_config_list);
165 return *this;
166 }
167
168 // static
CreateForSpdy()169 std::unique_ptr<FakeStreamSocket> FakeStreamSocket::CreateForSpdy() {
170 auto stream = std::make_unique<FakeStreamSocket>();
171 SSLInfo ssl_info;
172 SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_3,
173 &ssl_info.connection_status);
174 SSLConnectionStatusSetCipherSuite(0x1301 /* TLS_CHACHA20_POLY1305_SHA256 */,
175 &ssl_info.connection_status);
176 ssl_info.cert =
177 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
178 stream->set_ssl_info(std::move(ssl_info));
179 return stream;
180 }
181
FakeStreamSocket()182 FakeStreamSocket::FakeStreamSocket() : MockClientSocket(NetLogWithSource()) {
183 connected_ = true;
184 }
185
186 FakeStreamSocket::~FakeStreamSocket() = default;
187
Read(IOBuffer * buf,int buf_len,CompletionOnceCallback callback)188 int FakeStreamSocket::Read(IOBuffer* buf,
189 int buf_len,
190 CompletionOnceCallback callback) {
191 return ERR_IO_PENDING;
192 }
193
Write(IOBuffer * buf,int buf_len,CompletionOnceCallback callback,const NetworkTrafficAnnotationTag & traffic_annotation)194 int FakeStreamSocket::Write(
195 IOBuffer* buf,
196 int buf_len,
197 CompletionOnceCallback callback,
198 const NetworkTrafficAnnotationTag& traffic_annotation) {
199 return ERR_IO_PENDING;
200 }
201
Connect(CompletionOnceCallback callback)202 int FakeStreamSocket::Connect(CompletionOnceCallback callback) {
203 return OK;
204 }
205
IsConnected() const206 bool FakeStreamSocket::IsConnected() const {
207 return connected_;
208 }
209
IsConnectedAndIdle() const210 bool FakeStreamSocket::IsConnectedAndIdle() const {
211 return connected_ && is_idle_;
212 }
213
WasEverUsed() const214 bool FakeStreamSocket::WasEverUsed() const {
215 return was_ever_used_;
216 }
217
GetSSLInfo(SSLInfo * ssl_info)218 bool FakeStreamSocket::GetSSLInfo(SSLInfo* ssl_info) {
219 if (ssl_info_.has_value()) {
220 *ssl_info = *ssl_info_;
221 return true;
222 }
223
224 return false;
225 }
226
GroupIdToHttpStreamKey(const ClientSocketPool::GroupId & group_id)227 HttpStreamKey GroupIdToHttpStreamKey(
228 const ClientSocketPool::GroupId& group_id) {
229 return HttpStreamKey(group_id.destination(), group_id.privacy_mode(),
230 SocketTag(), group_id.network_anonymization_key(),
231 group_id.secure_dns_policy(),
232 group_id.disable_cert_network_fetches());
233 }
234
235 } // namespace net
236