1 // Copyright 2012 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/socket/transport_client_socket_pool.h"
6
7 #include <memory>
8 #include <utility>
9
10 #include "base/functional/bind.h"
11 #include "base/functional/callback.h"
12 #include "base/functional/callback_helpers.h"
13 #include "base/memory/raw_ptr.h"
14 #include "base/memory/ref_counted.h"
15 #include "base/run_loop.h"
16 #include "base/test/bind.h"
17 #include "base/test/scoped_feature_list.h"
18 #include "base/threading/platform_thread.h"
19 #include "build/build_config.h"
20 #include "net/base/completion_once_callback.h"
21 #include "net/base/features.h"
22 #include "net/base/ip_endpoint.h"
23 #include "net/base/load_timing_info.h"
24 #include "net/base/load_timing_info_test_util.h"
25 #include "net/base/net_errors.h"
26 #include "net/base/privacy_mode.h"
27 #include "net/base/proxy_chain.h"
28 #include "net/base/proxy_server.h"
29 #include "net/base/proxy_string_util.h"
30 #include "net/base/schemeful_site.h"
31 #include "net/base/test_completion_callback.h"
32 #include "net/cert/ct_policy_enforcer.h"
33 #include "net/cert/mock_cert_verifier.h"
34 #include "net/dns/mock_host_resolver.h"
35 #include "net/dns/public/secure_dns_policy.h"
36 #include "net/http/http_network_session.h"
37 #include "net/http/http_proxy_connect_job.h"
38 #include "net/http/transport_security_state.h"
39 #include "net/log/net_log.h"
40 #include "net/log/net_log_with_source.h"
41 #include "net/log/test_net_log.h"
42 #include "net/proxy_resolution/configured_proxy_resolution_service.h"
43 #include "net/socket/client_socket_handle.h"
44 #include "net/socket/connect_job.h"
45 #include "net/socket/socket_tag.h"
46 #include "net/socket/socket_test_util.h"
47 #include "net/socket/socks_connect_job.h"
48 #include "net/socket/ssl_connect_job.h"
49 #include "net/socket/stream_socket.h"
50 #include "net/socket/transport_client_socket_pool.h"
51 #include "net/socket/transport_client_socket_pool_test_util.h"
52 #include "net/socket/transport_connect_job.h"
53 #include "net/spdy/spdy_test_util_common.h"
54 #include "net/ssl/ssl_config_service.h"
55 #include "net/test/embedded_test_server/embedded_test_server.h"
56 #include "net/test/gtest_util.h"
57 #include "net/test/test_with_task_environment.h"
58 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
59 #include "testing/gmock/include/gmock/gmock.h"
60 #include "testing/gtest/include/gtest/gtest.h"
61 #include "third_party/abseil-cpp/absl/types/optional.h"
62 #include "url/gurl.h"
63 #include "url/scheme_host_port.h"
64 #include "url/url_constants.h"
65
66 using net::test::IsError;
67 using net::test::IsOk;
68
69 namespace net {
70
71 namespace {
72
73 const int kMaxSockets = 32;
74 const int kMaxSocketsPerGroup = 6;
75 constexpr base::TimeDelta kUnusedIdleSocketTimeout = base::Seconds(10);
76 const RequestPriority kDefaultPriority = LOW;
77
78 class SOCKS5MockData {
79 public:
SOCKS5MockData(IoMode mode)80 explicit SOCKS5MockData(IoMode mode) {
81 writes_ = std::make_unique<MockWrite[]>(2);
82 writes_[0] =
83 MockWrite(mode, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength);
84 writes_[1] = MockWrite(mode, kSOCKS5OkRequest, kSOCKS5OkRequestLength);
85
86 reads_ = std::make_unique<MockRead[]>(2);
87 reads_[0] =
88 MockRead(mode, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength);
89 reads_[1] = MockRead(mode, kSOCKS5OkResponse, kSOCKS5OkResponseLength);
90
91 data_ = std::make_unique<StaticSocketDataProvider>(
92 base::make_span(reads_.get(), 2u), base::make_span(writes_.get(), 2u));
93 }
94
data_provider()95 SocketDataProvider* data_provider() { return data_.get(); }
96
97 private:
98 std::unique_ptr<StaticSocketDataProvider> data_;
99 std::unique_ptr<MockWrite[]> writes_;
100 std::unique_ptr<MockRead[]> reads_;
101 };
102
103 class TransportClientSocketPoolTest : public ::testing::Test,
104 public WithTaskEnvironment {
105 public:
106 TransportClientSocketPoolTest(const TransportClientSocketPoolTest&) = delete;
107 TransportClientSocketPoolTest& operator=(
108 const TransportClientSocketPoolTest&) = delete;
109
110 protected:
111 // Constructor that allows mocking of the time.
TransportClientSocketPoolTest(base::test::TaskEnvironment::TimeSource time_source=base::test::TaskEnvironment::TimeSource::DEFAULT)112 explicit TransportClientSocketPoolTest(
113 base::test::TaskEnvironment::TimeSource time_source =
114 base::test::TaskEnvironment::TimeSource::DEFAULT)
115 : WithTaskEnvironment(time_source),
116 connect_backup_jobs_enabled_(
117 TransportClientSocketPool::set_connect_backup_jobs_enabled(true)),
118 group_id_(url::SchemeHostPort(url::kHttpScheme, "www.google.com", 80),
119 PrivacyMode::PRIVACY_MODE_DISABLED,
120 NetworkAnonymizationKey(),
121 SecureDnsPolicy::kAllow),
122 params_(ClientSocketPool::SocketParams::CreateForHttpForTesting()),
123 client_socket_factory_(NetLog::Get()) {
124 std::unique_ptr<MockCertVerifier> cert_verifier =
125 std::make_unique<MockCertVerifier>();
126 cert_verifier->set_default_result(OK);
127 session_deps_.cert_verifier = std::move(cert_verifier);
128
129 http_network_session_ =
130 SpdySessionDependencies::SpdyCreateSession(&session_deps_);
131
132 common_connect_job_params_ = std::make_unique<CommonConnectJobParams>(
133 http_network_session_->CreateCommonConnectJobParams());
134 common_connect_job_params_->client_socket_factory = &client_socket_factory_;
135 pool_ = std::make_unique<TransportClientSocketPool>(
136 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
137 ProxyChain::Direct(), /*is_for_websockets=*/false,
138 common_connect_job_params_.get());
139
140 tagging_common_connect_job_params_ =
141 std::make_unique<CommonConnectJobParams>(
142 http_network_session_->CreateCommonConnectJobParams());
143 tagging_common_connect_job_params_->client_socket_factory =
144 &tagging_client_socket_factory_;
145 tagging_pool_ = std::make_unique<TransportClientSocketPool>(
146 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
147 ProxyChain::Direct(), /*is_for_websockets=*/false,
148 tagging_common_connect_job_params_.get());
149
150 common_connect_job_params_for_real_sockets_ =
151 std::make_unique<CommonConnectJobParams>(
152 http_network_session_->CreateCommonConnectJobParams());
153 common_connect_job_params_for_real_sockets_->client_socket_factory =
154 ClientSocketFactory::GetDefaultFactory();
155 pool_for_real_sockets_ = std::make_unique<TransportClientSocketPool>(
156 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
157 ProxyChain::Direct(), /*is_for_websockets=*/false,
158 common_connect_job_params_for_real_sockets_.get());
159 }
160
~TransportClientSocketPoolTest()161 ~TransportClientSocketPoolTest() override {
162 TransportClientSocketPool::set_connect_backup_jobs_enabled(
163 connect_backup_jobs_enabled_);
164 }
165
StartRequest(const std::string & host_name,RequestPriority priority)166 int StartRequest(const std::string& host_name, RequestPriority priority) {
167 ClientSocketPool::GroupId group_id(
168 url::SchemeHostPort(url::kHttpScheme, host_name, 80),
169 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
170 SecureDnsPolicy::kAllow);
171 return test_base_.StartRequestUsingPool(
172 pool_.get(), group_id, priority,
173 ClientSocketPool::RespectLimits::ENABLED,
174 ClientSocketPool::SocketParams::CreateForHttpForTesting());
175 }
176
GetOrderOfRequest(size_t index)177 int GetOrderOfRequest(size_t index) {
178 return test_base_.GetOrderOfRequest(index);
179 }
180
ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive)181 bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
182 return test_base_.ReleaseOneConnection(keep_alive);
183 }
184
ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive)185 void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) {
186 test_base_.ReleaseAllConnections(keep_alive);
187 }
188
requests()189 std::vector<std::unique_ptr<TestSocketRequest>>* requests() {
190 return test_base_.requests();
191 }
completion_count() const192 size_t completion_count() const { return test_base_.completion_count(); }
193
194 bool connect_backup_jobs_enabled_;
195
196 // |group_id_| and |params_| correspond to the same group.
197 const ClientSocketPool::GroupId group_id_;
198 scoped_refptr<ClientSocketPool::SocketParams> params_;
199
200 MockTransportClientSocketFactory client_socket_factory_;
201 MockTaggingClientSocketFactory tagging_client_socket_factory_;
202
203 // None of these tests check SPDY behavior, but this is a convenient way to
204 // create most objects needed by the socket pools, as well as a SpdySession
205 // pool, which is required by HttpProxyConnectJobs when using an HTTPS proxy.
206 SpdySessionDependencies session_deps_;
207 // As with |session_deps_|, this is a convenient way to construct objects
208 // these tests depend on.
209 std::unique_ptr<HttpNetworkSession> http_network_session_;
210
211 std::unique_ptr<CommonConnectJobParams> common_connect_job_params_;
212 std::unique_ptr<TransportClientSocketPool> pool_;
213
214 // Just like |pool_|, except it uses a real MockTaggingClientSocketFactory
215 // instead of MockTransportClientSocketFactory.
216 std::unique_ptr<CommonConnectJobParams> tagging_common_connect_job_params_;
217 std::unique_ptr<TransportClientSocketPool> tagging_pool_;
218
219 // Just like |pool_|, except it uses a real ClientSocketFactory instead of
220 // |client_socket_factory_|.
221 std::unique_ptr<CommonConnectJobParams>
222 common_connect_job_params_for_real_sockets_;
223 std::unique_ptr<TransportClientSocketPool> pool_for_real_sockets_;
224
225 ClientSocketPoolTest test_base_;
226 };
227
TEST_F(TransportClientSocketPoolTest,Basic)228 TEST_F(TransportClientSocketPoolTest, Basic) {
229 TestCompletionCallback callback;
230 ClientSocketHandle handle;
231 int rv =
232 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
233 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
234 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
235 pool_.get(), NetLogWithSource());
236 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
237 EXPECT_FALSE(handle.is_initialized());
238 EXPECT_FALSE(handle.socket());
239
240 EXPECT_THAT(callback.WaitForResult(), IsOk());
241 EXPECT_TRUE(handle.is_initialized());
242 EXPECT_TRUE(handle.socket());
243 TestLoadTimingInfoConnectedNotReused(handle);
244 EXPECT_EQ(0u, handle.connection_attempts().size());
245 }
246
247 // Make sure that TransportConnectJob passes on its priority to its
248 // HostResolver request on Init.
TEST_F(TransportClientSocketPoolTest,SetResolvePriorityOnInit)249 TEST_F(TransportClientSocketPoolTest, SetResolvePriorityOnInit) {
250 for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
251 RequestPriority priority = static_cast<RequestPriority>(i);
252 TestCompletionCallback callback;
253 ClientSocketHandle handle;
254 EXPECT_EQ(
255 ERR_IO_PENDING,
256 handle.Init(group_id_, params_,
257 absl::nullopt /* proxy_annotation_tag */, priority,
258 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
259 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
260 pool_.get(), NetLogWithSource()));
261 EXPECT_EQ(priority, session_deps_.host_resolver->last_request_priority());
262 }
263 }
264
TEST_F(TransportClientSocketPoolTest,SetSecureDnsPolicy)265 TEST_F(TransportClientSocketPoolTest, SetSecureDnsPolicy) {
266 for (auto secure_dns_policy :
267 {SecureDnsPolicy::kAllow, SecureDnsPolicy::kDisable}) {
268 TestCompletionCallback callback;
269 ClientSocketHandle handle;
270 ClientSocketPool::GroupId group_id(
271 url::SchemeHostPort(url::kHttpScheme, "www.google.com", 80),
272 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
273 secure_dns_policy);
274 EXPECT_EQ(
275 ERR_IO_PENDING,
276 handle.Init(group_id, params_, absl::nullopt /* proxy_annotation_tag */,
277 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
278 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
279 pool_.get(), NetLogWithSource()));
280 EXPECT_EQ(secure_dns_policy,
281 session_deps_.host_resolver->last_secure_dns_policy());
282 }
283 }
284
TEST_F(TransportClientSocketPoolTest,ReprioritizeRequests)285 TEST_F(TransportClientSocketPoolTest, ReprioritizeRequests) {
286 session_deps_.host_resolver->set_ondemand_mode(true);
287
288 TestCompletionCallback callback1;
289 ClientSocketHandle handle1;
290 int rv1 =
291 handle1.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
292 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
293 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
294 pool_.get(), NetLogWithSource());
295 EXPECT_THAT(rv1, IsError(ERR_IO_PENDING));
296
297 TestCompletionCallback callback2;
298 ClientSocketHandle handle2;
299 int rv2 = handle2.Init(
300 group_id_, params_, absl::nullopt /* proxy_annotation_tag */, HIGHEST,
301 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
302 callback2.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
303 NetLogWithSource());
304 EXPECT_THAT(rv2, IsError(ERR_IO_PENDING));
305
306 TestCompletionCallback callback3;
307 ClientSocketHandle handle3;
308 int rv3 = handle3.Init(
309 group_id_, params_, absl::nullopt /* proxy_annotation_tag */, LOWEST,
310 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
311 callback3.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
312 NetLogWithSource());
313 EXPECT_THAT(rv3, IsError(ERR_IO_PENDING));
314
315 TestCompletionCallback callback4;
316 ClientSocketHandle handle4;
317 int rv4 = handle4.Init(
318 group_id_, params_, absl::nullopt /* proxy_annotation_tag */, MEDIUM,
319 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
320 callback4.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
321 NetLogWithSource());
322 EXPECT_THAT(rv4, IsError(ERR_IO_PENDING));
323
324 TestCompletionCallback callback5;
325 ClientSocketHandle handle5;
326 int rv5 = handle5.Init(
327 group_id_, params_, absl::nullopt /* proxy_annotation_tag */, HIGHEST,
328 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
329 callback5.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
330 NetLogWithSource());
331 EXPECT_THAT(rv5, IsError(ERR_IO_PENDING));
332
333 TestCompletionCallback callback6;
334 ClientSocketHandle handle6;
335 int rv6 =
336 handle6.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
337 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
338 callback6.callback(), ClientSocketPool::ProxyAuthCallback(),
339 pool_.get(), NetLogWithSource());
340 EXPECT_THAT(rv6, IsError(ERR_IO_PENDING));
341
342 // New jobs are created for each of the first 6 requests with the
343 // corresponding priority.
344 //
345 // Queue of pending requests:
346 // Request Job Priority
347 // ======= === ========
348 // 2 2 HIGHEST
349 // 5 5 HIGHEST
350 // 4 4 MEDIUM
351 // 1 1 LOW
352 // 6 6 LOW
353 // 3 3 LOWEST
354 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
355 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(2));
356 EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(3));
357 EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
358 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(5));
359 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(6));
360
361 // Inserting a highest-priority request steals the job from the lowest
362 // priority request and reprioritizes it to match the new request.
363 TestCompletionCallback callback7;
364 ClientSocketHandle handle7;
365 int rv7 = handle7.Init(
366 group_id_, params_, absl::nullopt /* proxy_annotation_tag */, HIGHEST,
367 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
368 callback7.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
369 NetLogWithSource());
370 EXPECT_THAT(rv7, IsError(ERR_IO_PENDING));
371 // Request Job Priority
372 // ======= === ========
373 // 2 2 HIGHEST
374 // 5 5 HIGHEST
375 // 7 3 HIGHEST
376 // 4 4 MEDIUM
377 // 1 1 LOW
378 // 6 6 LOW
379 // 3 LOWEST
380 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
381 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(2));
382 EXPECT_EQ(HIGHEST,
383 session_deps_.host_resolver->request_priority(3)); // reprioritized
384 EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
385 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(5));
386 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(6));
387
388 TestCompletionCallback callback8;
389 ClientSocketHandle handle8;
390 int rv8 = handle8.Init(
391 group_id_, params_, absl::nullopt /* proxy_annotation_tag */, HIGHEST,
392 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
393 callback8.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
394 NetLogWithSource());
395 EXPECT_THAT(rv8, IsError(ERR_IO_PENDING));
396 // Request Job Priority
397 // ======= === ========
398 // 2 2 HIGHEST
399 // 5 5 HIGHEST
400 // 7 3 HIGHEST
401 // 8 6 HIGHEST
402 // 4 4 MEDIUM
403 // 1 1 LOW
404 // 6 LOW
405 // 3 LOWEST
406 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
407 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(2));
408 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(3));
409 EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
410 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(5));
411 EXPECT_EQ(HIGHEST,
412 session_deps_.host_resolver->request_priority(6)); // reprioritized
413
414 // A request completes, then the socket is returned to the socket pool and
415 // goes to the highest remaining request. The job from the highest request
416 // should then be reassigned to the first request without a job.
417 session_deps_.host_resolver->ResolveNow(2);
418 EXPECT_THAT(callback2.WaitForResult(), IsOk());
419 EXPECT_TRUE(handle2.is_initialized());
420 EXPECT_TRUE(handle2.socket());
421 handle2.Reset();
422 EXPECT_THAT(callback5.WaitForResult(), IsOk());
423 EXPECT_TRUE(handle5.is_initialized());
424 EXPECT_TRUE(handle5.socket());
425 // Request Job Priority
426 // ======= === ========
427 // 7 3 HIGHEST
428 // 8 6 HIGHEST
429 // 4 4 MEDIUM
430 // 1 1 LOW
431 // 6 5 LOW
432 // 3 LOWEST
433 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
434 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(3));
435 EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
436 EXPECT_EQ(LOW,
437 session_deps_.host_resolver->request_priority(5)); // reprioritized
438 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(6));
439
440 // Cancelling a request with a job reassigns the job to a lower request.
441 handle7.Reset();
442 // Request Job Priority
443 // ======= === ========
444 // 8 6 HIGHEST
445 // 4 4 MEDIUM
446 // 1 1 LOW
447 // 6 5 LOW
448 // 3 3 LOWEST
449 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
450 EXPECT_EQ(LOWEST,
451 session_deps_.host_resolver->request_priority(3)); // reprioritized
452 EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(4));
453 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
454 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(6));
455
456 // Reprioritizing a request changes its job's priority.
457 pool_->SetPriority(group_id_, &handle4, LOWEST);
458 // Request Job Priority
459 // ======= === ========
460 // 8 6 HIGHEST
461 // 1 1 LOW
462 // 6 5 LOW
463 // 3 3 LOWEST
464 // 4 4 LOWEST
465 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
466 EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(3));
467 EXPECT_EQ(LOWEST,
468 session_deps_.host_resolver->request_priority(4)); // reprioritized
469 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
470 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(6));
471
472 pool_->SetPriority(group_id_, &handle3, MEDIUM);
473 // Request Job Priority
474 // ======= === ========
475 // 8 6 HIGHEST
476 // 3 3 MEDIUM
477 // 1 1 LOW
478 // 6 5 LOW
479 // 4 4 LOWEST
480 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
481 EXPECT_EQ(MEDIUM,
482 session_deps_.host_resolver->request_priority(3)); // reprioritized
483 EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(4));
484 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
485 EXPECT_EQ(HIGHEST, session_deps_.host_resolver->request_priority(6));
486
487 // Host resolution finishes for a lower-down request. The highest request
488 // should get the socket and its job should be reassigned to the lower
489 // request.
490 session_deps_.host_resolver->ResolveNow(1);
491 EXPECT_THAT(callback8.WaitForResult(), IsOk());
492 EXPECT_TRUE(handle8.is_initialized());
493 EXPECT_TRUE(handle8.socket());
494 // Request Job Priority
495 // ======= === ========
496 // 3 3 MEDIUM
497 // 1 6 LOW
498 // 6 5 LOW
499 // 4 4 LOWEST
500 EXPECT_EQ(MEDIUM, session_deps_.host_resolver->request_priority(3));
501 EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(4));
502 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
503 EXPECT_EQ(LOW,
504 session_deps_.host_resolver->request_priority(6)); // reprioritized
505
506 // Host resolution finishes for the highest request. Nothing gets
507 // reprioritized.
508 session_deps_.host_resolver->ResolveNow(3);
509 EXPECT_THAT(callback3.WaitForResult(), IsOk());
510 EXPECT_TRUE(handle3.is_initialized());
511 EXPECT_TRUE(handle3.socket());
512 // Request Job Priority
513 // ======= === ========
514 // 1 6 LOW
515 // 6 5 LOW
516 // 4 4 LOWEST
517 EXPECT_EQ(LOWEST, session_deps_.host_resolver->request_priority(4));
518 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(5));
519 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(6));
520
521 session_deps_.host_resolver->ResolveAllPending();
522 EXPECT_THAT(callback1.WaitForResult(), IsOk());
523 EXPECT_TRUE(handle1.is_initialized());
524 EXPECT_TRUE(handle1.socket());
525 EXPECT_THAT(callback4.WaitForResult(), IsOk());
526 EXPECT_TRUE(handle4.is_initialized());
527 EXPECT_TRUE(handle4.socket());
528 EXPECT_THAT(callback6.WaitForResult(), IsOk());
529 EXPECT_TRUE(handle6.is_initialized());
530 EXPECT_TRUE(handle6.socket());
531 }
532
TEST_F(TransportClientSocketPoolTest,RequestIgnoringLimitsIsReprioritized)533 TEST_F(TransportClientSocketPoolTest, RequestIgnoringLimitsIsReprioritized) {
534 TransportClientSocketPool pool(
535 kMaxSockets, 1, kUnusedIdleSocketTimeout, ProxyChain::Direct(),
536 /*is_for_websockets=*/false, common_connect_job_params_.get());
537
538 // Creates a job which ignores limits whose priority is MAXIMUM_PRIORITY.
539 TestCompletionCallback callback1;
540 ClientSocketHandle handle1;
541 int rv1 = handle1.Init(
542 group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
543 MAXIMUM_PRIORITY, SocketTag(), ClientSocketPool::RespectLimits::DISABLED,
544 callback1.callback(), ClientSocketPool::ProxyAuthCallback(), &pool,
545 NetLogWithSource());
546 EXPECT_THAT(rv1, IsError(ERR_IO_PENDING));
547
548 EXPECT_EQ(MAXIMUM_PRIORITY, session_deps_.host_resolver->request_priority(1));
549
550 TestCompletionCallback callback2;
551 ClientSocketHandle handle2;
552 int rv2 =
553 handle2.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
554 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
555 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
556 &pool, NetLogWithSource());
557 EXPECT_THAT(rv2, IsError(ERR_IO_PENDING));
558
559 // |handle2| gets assigned the job, which is reprioritized.
560 handle1.Reset();
561 EXPECT_EQ(LOW, session_deps_.host_resolver->request_priority(1));
562 }
563
TEST_F(TransportClientSocketPoolTest,InitHostResolutionFailure)564 TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) {
565 session_deps_.host_resolver->rules()->AddSimulatedTimeoutFailure(
566 group_id_.destination().host());
567 TestCompletionCallback callback;
568 ClientSocketHandle handle;
569 EXPECT_EQ(
570 ERR_IO_PENDING,
571 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
572 kDefaultPriority, SocketTag(),
573 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
574 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
575 NetLogWithSource()));
576 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
577 EXPECT_THAT(handle.resolve_error_info().error, IsError(ERR_DNS_TIMED_OUT));
578 ASSERT_EQ(1u, handle.connection_attempts().size());
579 EXPECT_TRUE(handle.connection_attempts()[0].endpoint.address().empty());
580 EXPECT_THAT(handle.connection_attempts()[0].result,
581 IsError(ERR_NAME_NOT_RESOLVED));
582 }
583
TEST_F(TransportClientSocketPoolTest,InitConnectionFailure)584 TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {
585 client_socket_factory_.set_default_client_socket_type(
586 MockTransportClientSocketFactory::Type::kFailing);
587 TestCompletionCallback callback;
588 ClientSocketHandle handle;
589 EXPECT_EQ(
590 ERR_IO_PENDING,
591 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
592 kDefaultPriority, SocketTag(),
593 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
594 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
595 NetLogWithSource()));
596 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
597 ASSERT_EQ(1u, handle.connection_attempts().size());
598 EXPECT_EQ("127.0.0.1:80",
599 handle.connection_attempts()[0].endpoint.ToString());
600 EXPECT_THAT(handle.connection_attempts()[0].result,
601 IsError(ERR_CONNECTION_FAILED));
602
603 // Make the host resolutions complete synchronously this time.
604 session_deps_.host_resolver->set_synchronous_mode(true);
605 EXPECT_EQ(
606 ERR_CONNECTION_FAILED,
607 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
608 kDefaultPriority, SocketTag(),
609 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
610 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
611 NetLogWithSource()));
612 ASSERT_EQ(1u, handle.connection_attempts().size());
613 EXPECT_EQ("127.0.0.1:80",
614 handle.connection_attempts()[0].endpoint.ToString());
615 EXPECT_THAT(handle.connection_attempts()[0].result,
616 IsError(ERR_CONNECTION_FAILED));
617 }
618
TEST_F(TransportClientSocketPoolTest,PendingRequests)619 TEST_F(TransportClientSocketPoolTest, PendingRequests) {
620 // First request finishes asynchronously.
621 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
622 EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());
623
624 // Make all subsequent host resolutions complete synchronously.
625 session_deps_.host_resolver->set_synchronous_mode(true);
626
627 // Rest of them finish synchronously, until we reach the per-group limit.
628 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
629 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
630 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
631 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
632 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
633
634 // The rest are pending since we've used all active sockets.
635 EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
636 EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
637 EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
638 EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
639 EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
640 EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
641 EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
642 EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
643 EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
644 EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
645
646 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
647
648 EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count());
649
650 // One initial asynchronous request and then 10 pending requests.
651 EXPECT_EQ(11U, completion_count());
652
653 // First part of requests, all with the same priority, finishes in FIFO order.
654 EXPECT_EQ(1, GetOrderOfRequest(1));
655 EXPECT_EQ(2, GetOrderOfRequest(2));
656 EXPECT_EQ(3, GetOrderOfRequest(3));
657 EXPECT_EQ(4, GetOrderOfRequest(4));
658 EXPECT_EQ(5, GetOrderOfRequest(5));
659 EXPECT_EQ(6, GetOrderOfRequest(6));
660
661 // Make sure that rest of the requests complete in the order of priority.
662 EXPECT_EQ(7, GetOrderOfRequest(7));
663 EXPECT_EQ(14, GetOrderOfRequest(8));
664 EXPECT_EQ(15, GetOrderOfRequest(9));
665 EXPECT_EQ(10, GetOrderOfRequest(10));
666 EXPECT_EQ(13, GetOrderOfRequest(11));
667 EXPECT_EQ(8, GetOrderOfRequest(12));
668 EXPECT_EQ(16, GetOrderOfRequest(13));
669 EXPECT_EQ(11, GetOrderOfRequest(14));
670 EXPECT_EQ(12, GetOrderOfRequest(15));
671 EXPECT_EQ(9, GetOrderOfRequest(16));
672
673 // Make sure we test order of all requests made.
674 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
675 }
676
TEST_F(TransportClientSocketPoolTest,PendingRequests_NoKeepAlive)677 TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) {
678 // First request finishes asynchronously.
679 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
680 EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());
681
682 // Make all subsequent host resolutions complete synchronously.
683 session_deps_.host_resolver->set_synchronous_mode(true);
684
685 // Rest of them finish synchronously, until we reach the per-group limit.
686 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
687 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
688 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
689 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
690 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
691
692 // The rest are pending since we've used all active sockets.
693 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
694 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
695 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
696 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
697 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
698
699 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
700
701 // The pending requests should finish successfully.
702 EXPECT_THAT((*requests())[6]->WaitForResult(), IsOk());
703 EXPECT_THAT((*requests())[7]->WaitForResult(), IsOk());
704 EXPECT_THAT((*requests())[8]->WaitForResult(), IsOk());
705 EXPECT_THAT((*requests())[9]->WaitForResult(), IsOk());
706 EXPECT_THAT((*requests())[10]->WaitForResult(), IsOk());
707
708 EXPECT_EQ(static_cast<int>(requests()->size()),
709 client_socket_factory_.allocation_count());
710
711 // First asynchronous request, and then last 5 pending requests.
712 EXPECT_EQ(6U, completion_count());
713 }
714
715 // This test will start up a RequestSocket() and then immediately Cancel() it.
716 // The pending host resolution will eventually complete, and destroy the
717 // ClientSocketPool which will crash if the group was not cleared properly.
TEST_F(TransportClientSocketPoolTest,CancelRequestClearGroup)718 TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) {
719 TestCompletionCallback callback;
720 ClientSocketHandle handle;
721 EXPECT_EQ(
722 ERR_IO_PENDING,
723 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
724 kDefaultPriority, SocketTag(),
725 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
726 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
727 NetLogWithSource()));
728 handle.Reset();
729 }
730
TEST_F(TransportClientSocketPoolTest,TwoRequestsCancelOne)731 TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) {
732 ClientSocketHandle handle;
733 TestCompletionCallback callback;
734 ClientSocketHandle handle2;
735 TestCompletionCallback callback2;
736
737 EXPECT_EQ(
738 ERR_IO_PENDING,
739 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
740 kDefaultPriority, SocketTag(),
741 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
742 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
743 NetLogWithSource()));
744 EXPECT_EQ(
745 ERR_IO_PENDING,
746 handle2.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
747 kDefaultPriority, SocketTag(),
748 ClientSocketPool::RespectLimits::ENABLED,
749 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
750 pool_.get(), NetLogWithSource()));
751
752 handle.Reset();
753
754 EXPECT_THAT(callback2.WaitForResult(), IsOk());
755 handle2.Reset();
756 }
757
TEST_F(TransportClientSocketPoolTest,ConnectCancelConnect)758 TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) {
759 client_socket_factory_.set_default_client_socket_type(
760 MockTransportClientSocketFactory::Type::kPending);
761 ClientSocketHandle handle;
762 TestCompletionCallback callback;
763 EXPECT_EQ(
764 ERR_IO_PENDING,
765 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
766 kDefaultPriority, SocketTag(),
767 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
768 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
769 NetLogWithSource()));
770
771 handle.Reset();
772
773 TestCompletionCallback callback2;
774 EXPECT_EQ(
775 ERR_IO_PENDING,
776 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
777 kDefaultPriority, SocketTag(),
778 ClientSocketPool::RespectLimits::ENABLED,
779 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
780 pool_.get(), NetLogWithSource()));
781
782 session_deps_.host_resolver->set_synchronous_mode(true);
783 // At this point, handle has two ConnectingSockets out for it. Due to the
784 // setting the mock resolver into synchronous mode, the host resolution for
785 // both will return in the same loop of the MessageLoop. The client socket
786 // is a pending socket, so the Connect() will asynchronously complete on the
787 // next loop of the MessageLoop. That means that the first
788 // ConnectingSocket will enter OnIOComplete, and then the second one will.
789 // If the first one is not cancelled, it will advance the load state, and
790 // then the second one will crash.
791
792 EXPECT_THAT(callback2.WaitForResult(), IsOk());
793 EXPECT_FALSE(callback.have_result());
794
795 handle.Reset();
796 }
797
TEST_F(TransportClientSocketPoolTest,CancelRequest)798 TEST_F(TransportClientSocketPoolTest, CancelRequest) {
799 // First request finishes asynchronously.
800 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
801 EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());
802
803 // Make all subsequent host resolutions complete synchronously.
804 session_deps_.host_resolver->set_synchronous_mode(true);
805
806 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
807 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
808 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
809 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
810 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());
811
812 // Reached per-group limit, queue up requests.
813 EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
814 EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
815 EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
816 EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
817 EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
818 EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
819 EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
820 EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
821 EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
822 EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
823
824 // Cancel a request.
825 size_t index_to_cancel = kMaxSocketsPerGroup + 2;
826 EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
827 (*requests())[index_to_cancel]->handle()->Reset();
828
829 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
830
831 EXPECT_EQ(kMaxSocketsPerGroup,
832 client_socket_factory_.allocation_count());
833 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count());
834
835 EXPECT_EQ(1, GetOrderOfRequest(1));
836 EXPECT_EQ(2, GetOrderOfRequest(2));
837 EXPECT_EQ(3, GetOrderOfRequest(3));
838 EXPECT_EQ(4, GetOrderOfRequest(4));
839 EXPECT_EQ(5, GetOrderOfRequest(5));
840 EXPECT_EQ(6, GetOrderOfRequest(6));
841 EXPECT_EQ(14, GetOrderOfRequest(7));
842 EXPECT_EQ(7, GetOrderOfRequest(8));
843 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound,
844 GetOrderOfRequest(9)); // Canceled request.
845 EXPECT_EQ(9, GetOrderOfRequest(10));
846 EXPECT_EQ(10, GetOrderOfRequest(11));
847 EXPECT_EQ(11, GetOrderOfRequest(12));
848 EXPECT_EQ(8, GetOrderOfRequest(13));
849 EXPECT_EQ(12, GetOrderOfRequest(14));
850 EXPECT_EQ(13, GetOrderOfRequest(15));
851 EXPECT_EQ(15, GetOrderOfRequest(16));
852
853 // Make sure we test order of all requests made.
854 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
855 }
856
857 class RequestSocketCallback : public TestCompletionCallbackBase {
858 public:
RequestSocketCallback(const ClientSocketPool::GroupId & group_id,scoped_refptr<ClientSocketPool::SocketParams> socket_params,ClientSocketHandle * handle,TransportClientSocketPool * pool)859 RequestSocketCallback(
860 const ClientSocketPool::GroupId& group_id,
861 scoped_refptr<ClientSocketPool::SocketParams> socket_params,
862 ClientSocketHandle* handle,
863 TransportClientSocketPool* pool)
864 : group_id_(group_id),
865 socket_params_(socket_params),
866 handle_(handle),
867 pool_(pool) {}
868
869 RequestSocketCallback(const RequestSocketCallback&) = delete;
870 RequestSocketCallback& operator=(const RequestSocketCallback&) = delete;
871
872 ~RequestSocketCallback() override = default;
873
callback()874 CompletionOnceCallback callback() {
875 return base::BindOnce(&RequestSocketCallback::OnComplete,
876 base::Unretained(this));
877 }
878
879 private:
OnComplete(int result)880 void OnComplete(int result) {
881 SetResult(result);
882 ASSERT_THAT(result, IsOk());
883
884 if (!within_callback_) {
885 // Don't allow reuse of the socket. Disconnect it and then release it and
886 // run through the MessageLoop once to get it completely released.
887 handle_->socket()->Disconnect();
888 handle_->Reset();
889 base::RunLoop(base::RunLoop::Type::kNestableTasksAllowed).RunUntilIdle();
890 within_callback_ = true;
891 int rv = handle_->Init(
892 group_id_, socket_params_, absl::nullopt /* proxy_annotation_tag */,
893 LOWEST, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
894 callback(), ClientSocketPool::ProxyAuthCallback(), pool_,
895 NetLogWithSource());
896 EXPECT_THAT(rv, IsOk());
897 }
898 }
899
900 const ClientSocketPool::GroupId group_id_;
901 scoped_refptr<ClientSocketPool::SocketParams> socket_params_;
902 const raw_ptr<ClientSocketHandle> handle_;
903 const raw_ptr<TransportClientSocketPool> pool_;
904 bool within_callback_ = false;
905 };
906
TEST_F(TransportClientSocketPoolTest,RequestTwice)907 TEST_F(TransportClientSocketPoolTest, RequestTwice) {
908 ClientSocketHandle handle;
909 RequestSocketCallback callback(group_id_, params_, &handle, pool_.get());
910 int rv =
911 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
912 LOWEST, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
913 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
914 pool_.get(), NetLogWithSource());
915 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
916
917 // The callback is going to request "www.google.com". We want it to complete
918 // synchronously this time.
919 session_deps_.host_resolver->set_synchronous_mode(true);
920
921 EXPECT_THAT(callback.WaitForResult(), IsOk());
922
923 handle.Reset();
924 }
925
926 // Make sure that pending requests get serviced after active requests get
927 // cancelled.
TEST_F(TransportClientSocketPoolTest,CancelActiveRequestWithPendingRequests)928 TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) {
929 client_socket_factory_.set_default_client_socket_type(
930 MockTransportClientSocketFactory::Type::kPending);
931
932 // Queue up all the requests
933 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
934 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
935 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
936 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
937 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
938 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
939 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
940 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
941 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
942
943 // Now, kMaxSocketsPerGroup requests should be active. Let's cancel them.
944 ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests()->size()));
945 for (int i = 0; i < kMaxSocketsPerGroup; i++)
946 (*requests())[i]->handle()->Reset();
947
948 // Let's wait for the rest to complete now.
949 for (size_t i = kMaxSocketsPerGroup; i < requests()->size(); ++i) {
950 EXPECT_THAT((*requests())[i]->WaitForResult(), IsOk());
951 (*requests())[i]->handle()->Reset();
952 }
953
954 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count());
955 }
956
957 // Make sure that pending requests get serviced after active requests fail.
TEST_F(TransportClientSocketPoolTest,FailingActiveRequestWithPendingRequests)958 TEST_F(TransportClientSocketPoolTest, FailingActiveRequestWithPendingRequests) {
959 client_socket_factory_.set_default_client_socket_type(
960 MockTransportClientSocketFactory::Type::kPendingFailing);
961
962 const int kNumRequests = 2 * kMaxSocketsPerGroup + 1;
963 ASSERT_LE(kNumRequests, kMaxSockets); // Otherwise the test will hang.
964
965 // Queue up all the requests
966 for (int i = 0; i < kNumRequests; i++)
967 EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
968
969 for (int i = 0; i < kNumRequests; i++)
970 EXPECT_THAT((*requests())[i]->WaitForResult(),
971 IsError(ERR_CONNECTION_FAILED));
972 }
973
TEST_F(TransportClientSocketPoolTest,IdleSocketLoadTiming)974 TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) {
975 TestCompletionCallback callback;
976 ClientSocketHandle handle;
977 int rv =
978 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
979 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
980 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
981 pool_.get(), NetLogWithSource());
982 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
983 EXPECT_FALSE(handle.is_initialized());
984 EXPECT_FALSE(handle.socket());
985
986 EXPECT_THAT(callback.WaitForResult(), IsOk());
987 EXPECT_TRUE(handle.is_initialized());
988 EXPECT_TRUE(handle.socket());
989 TestLoadTimingInfoConnectedNotReused(handle);
990
991 handle.Reset();
992 // Need to run all pending to release the socket back to the pool.
993 base::RunLoop().RunUntilIdle();
994
995 // Now we should have 1 idle socket.
996 EXPECT_EQ(1, pool_->IdleSocketCount());
997
998 rv = handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
999 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1000 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1001 pool_.get(), NetLogWithSource());
1002 EXPECT_THAT(rv, IsOk());
1003 EXPECT_EQ(0, pool_->IdleSocketCount());
1004 TestLoadTimingInfoConnectedReused(handle);
1005 }
1006
TEST_F(TransportClientSocketPoolTest,CloseIdleSocketsOnIPAddressChange)1007 TEST_F(TransportClientSocketPoolTest, CloseIdleSocketsOnIPAddressChange) {
1008 TestCompletionCallback callback;
1009 ClientSocketHandle handle;
1010 int rv =
1011 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
1012 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1013 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1014 pool_.get(), NetLogWithSource());
1015 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1016 EXPECT_FALSE(handle.is_initialized());
1017 EXPECT_FALSE(handle.socket());
1018
1019 EXPECT_THAT(callback.WaitForResult(), IsOk());
1020 EXPECT_TRUE(handle.is_initialized());
1021 EXPECT_TRUE(handle.socket());
1022
1023 handle.Reset();
1024
1025 // Need to run all pending to release the socket back to the pool.
1026 base::RunLoop().RunUntilIdle();
1027
1028 // Now we should have 1 idle socket.
1029 EXPECT_EQ(1, pool_->IdleSocketCount());
1030
1031 // After an IP address change, we should have 0 idle sockets.
1032 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
1033 base::RunLoop().RunUntilIdle(); // Notification happens async.
1034
1035 EXPECT_EQ(0, pool_->IdleSocketCount());
1036 }
1037
TEST(TransportClientSocketPoolStandaloneTest,DontCleanupOnIPAddressChange)1038 TEST(TransportClientSocketPoolStandaloneTest, DontCleanupOnIPAddressChange) {
1039 // This test manually sets things up in the same way
1040 // TransportClientSocketPoolTest does, but it creates a
1041 // TransportClientSocketPool with cleanup_on_ip_address_changed = false. Since
1042 // this is the only test doing this, it's not worth extending
1043 // TransportClientSocketPoolTest to support this scenario.
1044 base::test::SingleThreadTaskEnvironment task_environment;
1045 std::unique_ptr<MockCertVerifier> cert_verifier =
1046 std::make_unique<MockCertVerifier>();
1047 SpdySessionDependencies session_deps;
1048 session_deps.cert_verifier = std::move(cert_verifier);
1049 std::unique_ptr<HttpNetworkSession> http_network_session =
1050 SpdySessionDependencies::SpdyCreateSession(&session_deps);
1051 auto common_connect_job_params = std::make_unique<CommonConnectJobParams>(
1052 http_network_session->CreateCommonConnectJobParams());
1053 MockTransportClientSocketFactory client_socket_factory(NetLog::Get());
1054 common_connect_job_params->client_socket_factory = &client_socket_factory;
1055
1056 scoped_refptr<ClientSocketPool::SocketParams> params(
1057 ClientSocketPool::SocketParams::CreateForHttpForTesting());
1058 auto pool = std::make_unique<TransportClientSocketPool>(
1059 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
1060 ProxyChain::Direct(), /*is_for_websockets=*/false,
1061 common_connect_job_params.get(),
1062 /*cleanup_on_ip_address_change=*/false);
1063 const ClientSocketPool::GroupId group_id(
1064 url::SchemeHostPort(url::kHttpScheme, "www.google.com", 80),
1065 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
1066 SecureDnsPolicy::kAllow);
1067 TestCompletionCallback callback;
1068 ClientSocketHandle handle;
1069 int rv =
1070 handle.Init(group_id, params, absl::nullopt /* proxy_annotation_tag */,
1071 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1072 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1073 pool.get(), NetLogWithSource());
1074 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1075 EXPECT_FALSE(handle.is_initialized());
1076 EXPECT_FALSE(handle.socket());
1077
1078 EXPECT_THAT(callback.WaitForResult(), IsOk());
1079 EXPECT_TRUE(handle.is_initialized());
1080 EXPECT_TRUE(handle.socket());
1081
1082 handle.Reset();
1083 // Need to run all pending to release the socket back to the pool.
1084 base::RunLoop().RunUntilIdle();
1085 // Now we should have 1 idle socket.
1086 EXPECT_EQ(1, pool->IdleSocketCount());
1087
1088 // Since we set cleanup_on_ip_address_change = false, we should still have 1
1089 // idle socket after an IP address change.
1090 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
1091 base::RunLoop().RunUntilIdle(); // Notification happens async.
1092 EXPECT_EQ(1, pool->IdleSocketCount());
1093 }
1094
TEST_F(TransportClientSocketPoolTest,SSLCertError)1095 TEST_F(TransportClientSocketPoolTest, SSLCertError) {
1096 StaticSocketDataProvider data;
1097 tagging_client_socket_factory_.AddSocketDataProvider(&data);
1098 SSLSocketDataProvider ssl(ASYNC, ERR_CERT_COMMON_NAME_INVALID);
1099 tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl);
1100
1101 const url::SchemeHostPort kEndpoint(url::kHttpsScheme, "ssl.server.test",
1102 443);
1103 auto ssl_config_for_origin = std::make_unique<SSLConfig>();
1104 ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
1105
1106 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
1107 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1108 std::move(ssl_config_for_origin),
1109 /*base_ssl_config_for_proxies=*/nullptr);
1110
1111 ClientSocketHandle handle;
1112 TestCompletionCallback callback;
1113 int rv =
1114 handle.Init(ClientSocketPool::GroupId(
1115 kEndpoint, PrivacyMode::PRIVACY_MODE_DISABLED,
1116 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow),
1117 socket_params, absl::nullopt /* proxy_annotation_tag */,
1118 MEDIUM, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1119 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1120 tagging_pool_.get(), NetLogWithSource());
1121 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1122 EXPECT_FALSE(handle.is_initialized());
1123 EXPECT_FALSE(handle.socket());
1124
1125 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CERT_COMMON_NAME_INVALID));
1126 EXPECT_TRUE(handle.is_initialized());
1127 EXPECT_TRUE(handle.socket());
1128 }
1129
1130 namespace {
1131 class TransportClientSocketPoolSSLConfigChangeTest
1132 : public TransportClientSocketPoolTest,
1133 public ::testing::WithParamInterface<
1134 SSLClientContext::SSLConfigChangeType> {
1135 public:
SimulateChange()1136 void SimulateChange() {
1137 switch (GetParam()) {
1138 case SSLClientContext::SSLConfigChangeType::kSSLConfigChanged:
1139 session_deps_.ssl_config_service->NotifySSLContextConfigChange();
1140 break;
1141 case SSLClientContext::SSLConfigChangeType::kCertDatabaseChanged:
1142 // TODO(mattm): For more realistic testing this should call
1143 // `CertDatabase::GetInstance()->NotifyObserversCertDBChanged()`,
1144 // however that delivers notifications asynchronously, and running
1145 // the message loop to allow the notification to be delivered allows
1146 // other parts of the tested code to advance, breaking the test
1147 // expectations.
1148 pool_->OnSSLConfigChanged(GetParam());
1149 break;
1150 case SSLClientContext::SSLConfigChangeType::kCertVerifierChanged:
1151 session_deps_.cert_verifier->SimulateOnCertVerifierChanged();
1152 break;
1153 }
1154 }
1155
ExpectedMessage()1156 const char* ExpectedMessage() {
1157 switch (GetParam()) {
1158 case SSLClientContext::SSLConfigChangeType::kSSLConfigChanged:
1159 return TransportClientSocketPool::kNetworkChanged;
1160 case SSLClientContext::SSLConfigChangeType::kCertDatabaseChanged:
1161 return TransportClientSocketPool::kCertDatabaseChanged;
1162 case SSLClientContext::SSLConfigChangeType::kCertVerifierChanged:
1163 return TransportClientSocketPool::kCertVerifierChanged;
1164 }
1165 }
1166 };
1167 } // namespace
1168
TEST_P(TransportClientSocketPoolSSLConfigChangeTest,GracefulConfigChange)1169 TEST_P(TransportClientSocketPoolSSLConfigChangeTest, GracefulConfigChange) {
1170 // Create a request and finish connection of the socket, and release the
1171 // handle.
1172 {
1173 TestCompletionCallback callback;
1174 ClientSocketHandle handle1;
1175 int rv =
1176 handle1.Init(group_id_, params_, /*proxy_annotation_tag=*/absl::nullopt,
1177 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1178 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1179 pool_.get(), NetLogWithSource());
1180 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1181 EXPECT_FALSE(handle1.is_initialized());
1182 EXPECT_FALSE(handle1.socket());
1183
1184 EXPECT_THAT(callback.WaitForResult(), IsOk());
1185 EXPECT_TRUE(handle1.is_initialized());
1186 EXPECT_TRUE(handle1.socket());
1187 EXPECT_EQ(0, handle1.group_generation());
1188 EXPECT_EQ(0, pool_->IdleSocketCount());
1189
1190 handle1.Reset();
1191 }
1192
1193 // Need to run all pending to release the socket back to the pool.
1194 base::RunLoop().RunUntilIdle();
1195
1196 // Now we should have 1 idle socket.
1197 EXPECT_EQ(1, pool_->IdleSocketCount());
1198
1199 // Create another request and finish connection of the socket, but hold on to
1200 // the handle until later in the test.
1201 ClientSocketHandle handle2;
1202 {
1203 ClientSocketPool::GroupId group_id2(
1204 url::SchemeHostPort(url::kHttpScheme, "bar.example.com", 80),
1205 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
1206 SecureDnsPolicy::kAllow);
1207 TestCompletionCallback callback;
1208 int rv =
1209 handle2.Init(group_id2, params_, /*proxy_annotation_tag=*/absl::nullopt,
1210 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1211 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1212 pool_.get(), NetLogWithSource());
1213 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1214 EXPECT_FALSE(handle2.is_initialized());
1215 EXPECT_FALSE(handle2.socket());
1216
1217 EXPECT_THAT(callback.WaitForResult(), IsOk());
1218 EXPECT_TRUE(handle2.is_initialized());
1219 EXPECT_TRUE(handle2.socket());
1220 EXPECT_EQ(0, handle2.group_generation());
1221 }
1222
1223 // Still only have 1 idle socket since handle2 is still alive.
1224 base::RunLoop().RunUntilIdle();
1225 EXPECT_EQ(1, pool_->IdleSocketCount());
1226
1227 // Create a pending request but don't finish connection.
1228 ClientSocketPool::GroupId group_id3(
1229 url::SchemeHostPort(url::kHttpScheme, "foo.example.com", 80),
1230 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
1231 SecureDnsPolicy::kAllow);
1232 TestCompletionCallback callback3;
1233 ClientSocketHandle handle3;
1234 int rv =
1235 handle3.Init(group_id3, params_, /*proxy_annotation_tag=*/absl::nullopt,
1236 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1237 callback3.callback(), ClientSocketPool::ProxyAuthCallback(),
1238 pool_.get(), NetLogWithSource());
1239 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1240 EXPECT_FALSE(handle3.is_initialized());
1241 EXPECT_FALSE(handle3.socket());
1242
1243 // Do a configuration change.
1244 RecordingNetLogObserver net_log_observer;
1245 SimulateChange();
1246
1247 // Allow handle3 to advance.
1248 base::RunLoop().RunUntilIdle();
1249 // After a configuration change, we should have 0 idle sockets. The first
1250 // idle socket should have been closed, and handle2 and handle3 are still
1251 // alive.
1252 EXPECT_EQ(0, pool_->IdleSocketCount());
1253
1254 // Verify the netlog messages recorded the correct reason for closing the
1255 // idle sockets.
1256 auto events = net_log_observer.GetEntriesWithType(
1257 NetLogEventType::SOCKET_POOL_CLOSING_SOCKET);
1258 ASSERT_EQ(events.size(), 1u);
1259 std::string* reason = events[0].params.FindString("reason");
1260 ASSERT_TRUE(reason);
1261 EXPECT_EQ(*reason, ExpectedMessage());
1262
1263 // The pending request for handle3 should have succeeded under the new
1264 // generation since it didn't start until after the change.
1265 EXPECT_THAT(callback3.WaitForResult(), IsOk());
1266 EXPECT_TRUE(handle3.is_initialized());
1267 EXPECT_TRUE(handle3.socket());
1268 EXPECT_EQ(1, handle3.group_generation());
1269
1270 // After releasing handle2, it does not become an idle socket since it was
1271 // part of the first generation.
1272 handle2.Reset();
1273 base::RunLoop().RunUntilIdle();
1274 EXPECT_EQ(0, pool_->IdleSocketCount());
1275
1276 // After releasing handle3, there is now one idle socket, since that socket
1277 // was connected during the new generation.
1278 handle3.Reset();
1279 base::RunLoop().RunUntilIdle();
1280 EXPECT_EQ(1, pool_->IdleSocketCount());
1281 }
1282
1283 INSTANTIATE_TEST_SUITE_P(
1284 All,
1285 TransportClientSocketPoolSSLConfigChangeTest,
1286 testing::Values(
1287 SSLClientContext::SSLConfigChangeType::kSSLConfigChanged,
1288 SSLClientContext::SSLConfigChangeType::kCertDatabaseChanged,
1289 SSLClientContext::SSLConfigChangeType::kCertVerifierChanged));
1290
TEST_F(TransportClientSocketPoolTest,BackupSocketConnect)1291 TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) {
1292 // Case 1 tests the first socket stalling, and the backup connecting.
1293 MockTransportClientSocketFactory::Rule rules1[] = {
1294 // The first socket will not connect.
1295 MockTransportClientSocketFactory::Rule(
1296 MockTransportClientSocketFactory::Type::kStalled),
1297 // The second socket will connect more quickly.
1298 MockTransportClientSocketFactory::Rule(
1299 MockTransportClientSocketFactory::Type::kSynchronous),
1300 };
1301
1302 // Case 2 tests the first socket being slow, so that we start the
1303 // second connect, but the second connect stalls, and we still
1304 // complete the first.
1305 MockTransportClientSocketFactory::Rule rules2[] = {
1306 // The first socket will connect, although delayed.
1307 MockTransportClientSocketFactory::Rule(
1308 MockTransportClientSocketFactory::Type::kDelayed),
1309 // The second socket will not connect.
1310 MockTransportClientSocketFactory::Rule(
1311 MockTransportClientSocketFactory::Type::kStalled),
1312 };
1313
1314 base::span<const MockTransportClientSocketFactory::Rule> cases[2] = {rules1,
1315 rules2};
1316
1317 for (auto rules : cases) {
1318 client_socket_factory_.SetRules(rules);
1319
1320 EXPECT_EQ(0, pool_->IdleSocketCount());
1321
1322 TestCompletionCallback callback;
1323 ClientSocketHandle handle;
1324 int rv = handle.Init(
1325 group_id_, params_, absl::nullopt /* proxy_annotation_tag */, LOW,
1326 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1327 callback.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
1328 NetLogWithSource());
1329 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1330 EXPECT_FALSE(handle.is_initialized());
1331 EXPECT_FALSE(handle.socket());
1332
1333 // Create the first socket, set the timer.
1334 base::RunLoop().RunUntilIdle();
1335
1336 // Wait for the backup socket timer to fire.
1337 base::PlatformThread::Sleep(
1338 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs + 50));
1339
1340 // Let the appropriate socket connect.
1341 base::RunLoop().RunUntilIdle();
1342
1343 EXPECT_THAT(callback.WaitForResult(), IsOk());
1344 EXPECT_TRUE(handle.is_initialized());
1345 EXPECT_TRUE(handle.socket());
1346
1347 // One socket is stalled, the other is active.
1348 EXPECT_EQ(0, pool_->IdleSocketCount());
1349 handle.Reset();
1350
1351 // Close all pending connect jobs and existing sockets.
1352 pool_->FlushWithError(ERR_NETWORK_CHANGED, "Network changed");
1353 }
1354 }
1355
1356 // Test the case where a socket took long enough to start the creation
1357 // of the backup socket, but then we cancelled the request after that.
TEST_F(TransportClientSocketPoolTest,BackupSocketCancel)1358 TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) {
1359 client_socket_factory_.set_default_client_socket_type(
1360 MockTransportClientSocketFactory::Type::kStalled);
1361
1362 enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT };
1363
1364 for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) {
1365 EXPECT_EQ(0, pool_->IdleSocketCount());
1366
1367 TestCompletionCallback callback;
1368 ClientSocketHandle handle;
1369 int rv = handle.Init(
1370 group_id_, params_, absl::nullopt /* proxy_annotation_tag */, LOW,
1371 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1372 callback.callback(), ClientSocketPool::ProxyAuthCallback(), pool_.get(),
1373 NetLogWithSource());
1374 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1375 EXPECT_FALSE(handle.is_initialized());
1376 EXPECT_FALSE(handle.socket());
1377
1378 // Create the first socket, set the timer.
1379 base::RunLoop().RunUntilIdle();
1380
1381 if (index == CANCEL_AFTER_WAIT) {
1382 // Wait for the backup socket timer to fire.
1383 base::PlatformThread::Sleep(
1384 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
1385 }
1386
1387 // Let the appropriate socket connect.
1388 base::RunLoop().RunUntilIdle();
1389
1390 handle.Reset();
1391
1392 EXPECT_FALSE(callback.have_result());
1393 EXPECT_FALSE(handle.is_initialized());
1394 EXPECT_FALSE(handle.socket());
1395
1396 // One socket is stalled, the other is active.
1397 EXPECT_EQ(0, pool_->IdleSocketCount());
1398 }
1399 }
1400
1401 // Test the case where a socket took long enough to start the creation
1402 // of the backup socket and never completes, and then the backup
1403 // connection fails.
TEST_F(TransportClientSocketPoolTest,BackupSocketFailAfterStall)1404 TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) {
1405 MockTransportClientSocketFactory::Rule rules[] = {
1406 // The first socket will not connect.
1407 MockTransportClientSocketFactory::Rule(
1408 MockTransportClientSocketFactory::Type::kStalled),
1409 // The second socket will fail immediately.
1410 MockTransportClientSocketFactory::Rule(
1411 MockTransportClientSocketFactory::Type::kFailing),
1412 };
1413
1414 client_socket_factory_.SetRules(rules);
1415
1416 EXPECT_EQ(0, pool_->IdleSocketCount());
1417
1418 TestCompletionCallback callback;
1419 ClientSocketHandle handle;
1420 int rv =
1421 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
1422 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1423 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1424 pool_.get(), NetLogWithSource());
1425 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1426 EXPECT_FALSE(handle.is_initialized());
1427 EXPECT_FALSE(handle.socket());
1428
1429 // Create the first socket, set the timer.
1430 base::RunLoop().RunUntilIdle();
1431
1432 // Wait for the backup socket timer to fire.
1433 base::PlatformThread::Sleep(
1434 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
1435
1436 // Let the second connect be synchronous. Otherwise, the emulated
1437 // host resolution takes an extra trip through the message loop.
1438 session_deps_.host_resolver->set_synchronous_mode(true);
1439
1440 // Let the appropriate socket connect.
1441 base::RunLoop().RunUntilIdle();
1442
1443 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
1444 EXPECT_FALSE(handle.is_initialized());
1445 EXPECT_FALSE(handle.socket());
1446 ASSERT_EQ(1u, handle.connection_attempts().size());
1447 EXPECT_THAT(handle.connection_attempts()[0].result,
1448 IsError(ERR_CONNECTION_FAILED));
1449 EXPECT_EQ(0, pool_->IdleSocketCount());
1450 handle.Reset();
1451 }
1452
1453 // Test the case where a socket took long enough to start the creation
1454 // of the backup socket and eventually completes, but the backup socket
1455 // fails.
TEST_F(TransportClientSocketPoolTest,BackupSocketFailAfterDelay)1456 TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) {
1457 MockTransportClientSocketFactory::Rule rules[] = {
1458 // The first socket will connect, although delayed.
1459 MockTransportClientSocketFactory::Rule(
1460 MockTransportClientSocketFactory::Type::kDelayed),
1461 // The second socket will not connect.
1462 MockTransportClientSocketFactory::Rule(
1463 MockTransportClientSocketFactory::Type::kFailing),
1464 };
1465
1466 client_socket_factory_.SetRules(rules);
1467 client_socket_factory_.set_delay(base::Seconds(5));
1468
1469 EXPECT_EQ(0, pool_->IdleSocketCount());
1470
1471 TestCompletionCallback callback;
1472 ClientSocketHandle handle;
1473 int rv =
1474 handle.Init(group_id_, params_, absl::nullopt /* proxy_annotation_tag */,
1475 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1476 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1477 pool_.get(), NetLogWithSource());
1478 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1479 EXPECT_FALSE(handle.is_initialized());
1480 EXPECT_FALSE(handle.socket());
1481
1482 // Create the first socket, set the timer.
1483 base::RunLoop().RunUntilIdle();
1484
1485 // Wait for the backup socket timer to fire.
1486 base::PlatformThread::Sleep(
1487 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
1488
1489 // Let the second connect be synchronous. Otherwise, the emulated
1490 // host resolution takes an extra trip through the message loop.
1491 session_deps_.host_resolver->set_synchronous_mode(true);
1492
1493 // Let the appropriate socket connect.
1494 base::RunLoop().RunUntilIdle();
1495
1496 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
1497 EXPECT_FALSE(handle.is_initialized());
1498 EXPECT_FALSE(handle.socket());
1499 ASSERT_EQ(1u, handle.connection_attempts().size());
1500 EXPECT_THAT(handle.connection_attempts()[0].result,
1501 IsError(ERR_CONNECTION_FAILED));
1502 handle.Reset();
1503 }
1504
1505 // Test the case that SOCKSSocketParams are provided.
TEST_F(TransportClientSocketPoolTest,SOCKS)1506 TEST_F(TransportClientSocketPoolTest, SOCKS) {
1507 const url::SchemeHostPort kDestination(url::kHttpScheme, "host", 80);
1508
1509 TransportClientSocketPool proxy_pool(
1510 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
1511 ProxyUriToProxyChain("socks5://foopy",
1512 /*default_scheme=*/ProxyServer::SCHEME_HTTP),
1513 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
1514
1515 for (IoMode socket_io_mode : {SYNCHRONOUS, ASYNC}) {
1516 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
1517 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1518 /*ssl_config_for_origin=*/nullptr,
1519 /*base_ssl_config_for_proxies=*/nullptr);
1520
1521 SOCKS5MockData data(socket_io_mode);
1522 data.data_provider()->set_connect_data(MockConnect(socket_io_mode, OK));
1523 tagging_client_socket_factory_.AddSocketDataProvider(data.data_provider());
1524 ClientSocketHandle handle;
1525 TestCompletionCallback callback;
1526 int rv = handle.Init(
1527 ClientSocketPool::GroupId(
1528 kDestination, PrivacyMode::PRIVACY_MODE_DISABLED,
1529 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow),
1530 socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
1531 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
1532 ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
1533 EXPECT_THAT(callback.GetResult(rv), IsOk());
1534 EXPECT_TRUE(handle.is_initialized());
1535 EXPECT_TRUE(handle.socket());
1536 EXPECT_TRUE(data.data_provider()->AllReadDataConsumed());
1537 EXPECT_TRUE(data.data_provider()->AllWriteDataConsumed());
1538 }
1539 }
1540
1541 // Make sure there's no crash when an auth challenge is received over HTTP2
1542 // and there are two pending Requests to the socket pool, with a single
1543 // ConnectJob.
1544 //
1545 // See https://crbug.com/940848
TEST_F(TransportClientSocketPoolTest,SpdyOneConnectJobTwoRequestsError)1546 TEST_F(TransportClientSocketPoolTest, SpdyOneConnectJobTwoRequestsError) {
1547 const url::SchemeHostPort kEndpoint(url::kHttpsScheme,
1548 "unresolvable.host.name", 443);
1549
1550 session_deps_.host_resolver->set_synchronous_mode(true);
1551
1552 // Create a socket pool which only allows a single connection at a time.
1553 TransportClientSocketPool pool(
1554 1, 1, kUnusedIdleSocketTimeout,
1555 ProxyUriToProxyChain("https://unresolvable.proxy.name",
1556 /*default_scheme=*/ProxyServer::SCHEME_HTTP),
1557 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
1558
1559 // First connection attempt will get an error after creating the SpdyStream.
1560
1561 SpdyTestUtil spdy_util;
1562 spdy::SpdySerializedFrame connect(spdy_util.ConstructSpdyConnect(
1563 nullptr, 0, 1, HttpProxyConnectJob::kH2QuicTunnelPriority,
1564 HostPortPair::FromSchemeHostPort(kEndpoint)));
1565
1566 MockWrite writes[] = {
1567 CreateMockWrite(connect, 0, ASYNC),
1568 MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 2),
1569 };
1570
1571 MockRead reads[] = {
1572 MockRead(ASYNC, ERR_FAILED, 1),
1573 };
1574
1575 SequencedSocketData socket_data(MockConnect(SYNCHRONOUS, OK), reads, writes);
1576 tagging_client_socket_factory_.AddSocketDataProvider(&socket_data);
1577 SSLSocketDataProvider ssl_data(SYNCHRONOUS, OK);
1578 ssl_data.next_proto = kProtoHTTP2;
1579 tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data);
1580
1581 // Second connection also fails. Not a vital part of this test, but allows
1582 // waiting for the second request to complete without too much extra code.
1583 SequencedSocketData socket_data2(
1584 MockConnect(SYNCHRONOUS, ERR_CONNECTION_TIMED_OUT),
1585 base::span<const MockRead>(), base::span<const MockWrite>());
1586 tagging_client_socket_factory_.AddSocketDataProvider(&socket_data2);
1587 SSLSocketDataProvider ssl_data2(SYNCHRONOUS, OK);
1588 tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data2);
1589
1590 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
1591 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1592 /*ssl_config_for_origin=*/std::make_unique<SSLConfig>(),
1593 /*base_ssl_config_for_proxies=*/std::make_unique<SSLConfig>());
1594
1595 ClientSocketPool::GroupId group_id(
1596 kEndpoint, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
1597 SecureDnsPolicy::kAllow);
1598
1599 // Start the first connection attempt.
1600 TestCompletionCallback callback1;
1601 ClientSocketHandle handle1;
1602 int rv1 = handle1.Init(
1603 group_id, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, HIGHEST,
1604 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1605 callback1.callback(), ClientSocketPool::ProxyAuthCallback(), &pool,
1606 NetLogWithSource());
1607 ASSERT_THAT(rv1, IsError(ERR_IO_PENDING));
1608
1609 // Create a second request with a lower priority.
1610 TestCompletionCallback callback2;
1611 ClientSocketHandle handle2;
1612 int rv2 = handle2.Init(
1613 group_id, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOWEST,
1614 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1615 callback2.callback(), ClientSocketPool::ProxyAuthCallback(), &pool,
1616 NetLogWithSource());
1617 ASSERT_THAT(rv2, IsError(ERR_IO_PENDING));
1618
1619 // First connection fails after creating a SpdySession and a SpdyStream on
1620 // that session. The SpdyStream will be destroyed under the
1621 // SpdyProxyClientSocket. The failure will result in temporarily assigning the
1622 // failed ConnectJob to the second request, which results in an unneeded
1623 // reprioritization, which should not dereference the null SpdyStream.
1624 //
1625 // TODO(mmenke): Avoid that temporary reassignment.
1626 ASSERT_THAT(callback1.WaitForResult(), IsError(ERR_FAILED));
1627
1628 // Second connection fails, getting a connection error.
1629 ASSERT_THAT(callback2.WaitForResult(), IsError(ERR_PROXY_CONNECTION_FAILED));
1630 }
1631
1632 // Make sure there's no crash when an auth challenge is received over HTTP2
1633 // and there are two pending Requests to the socket pool, with a single
1634 // ConnectJob.
1635 //
1636 // See https://crbug.com/940848
TEST_F(TransportClientSocketPoolTest,SpdyAuthOneConnectJobTwoRequests)1637 TEST_F(TransportClientSocketPoolTest, SpdyAuthOneConnectJobTwoRequests) {
1638 const url::SchemeHostPort kEndpoint(url::kHttpsScheme,
1639 "unresolvable.host.name", 443);
1640 const HostPortPair kProxy("unresolvable.proxy.name", 443);
1641
1642 session_deps_.host_resolver->set_synchronous_mode(true);
1643
1644 // Create a socket pool which only allows a single connection at a time.
1645 TransportClientSocketPool pool(
1646 1, 1, kUnusedIdleSocketTimeout,
1647 ProxyUriToProxyChain("https://unresolvable.proxy.name",
1648 /*default_scheme=*/ProxyServer::SCHEME_HTTP),
1649 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
1650
1651 SpdyTestUtil spdy_util;
1652 spdy::SpdySerializedFrame connect(spdy_util.ConstructSpdyConnect(
1653 nullptr, 0, 1, HttpProxyConnectJob::kH2QuicTunnelPriority,
1654 HostPortPair::FromSchemeHostPort(kEndpoint)));
1655
1656 MockWrite writes[] = {
1657 CreateMockWrite(connect, 0, ASYNC),
1658 MockWrite(SYNCHRONOUS, ERR_IO_PENDING, 4),
1659 };
1660
1661 // The proxy responds to the connect with a 407, and them an
1662 // ERROR_CODE_HTTP_1_1_REQUIRED.
1663
1664 const char kAuthStatus[] = "407";
1665 const char* const kAuthChallenge[] = {
1666 "proxy-authenticate",
1667 "NTLM",
1668 };
1669 spdy::SpdySerializedFrame connect_auth_resp(spdy_util.ConstructSpdyReplyError(
1670 kAuthStatus, kAuthChallenge, std::size(kAuthChallenge) / 2, 1));
1671 spdy::SpdySerializedFrame reset(
1672 spdy_util.ConstructSpdyRstStream(1, spdy::ERROR_CODE_HTTP_1_1_REQUIRED));
1673 MockRead reads[] = {
1674 CreateMockRead(connect_auth_resp, 1, ASYNC),
1675 CreateMockRead(reset, 2, SYNCHRONOUS),
1676 MockRead(SYNCHRONOUS, ERR_IO_PENDING, 3),
1677 };
1678
1679 SequencedSocketData socket_data(MockConnect(SYNCHRONOUS, OK), reads, writes);
1680 tagging_client_socket_factory_.AddSocketDataProvider(&socket_data);
1681 SSLSocketDataProvider ssl_data(SYNCHRONOUS, OK);
1682 ssl_data.next_proto = kProtoHTTP2;
1683 tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data);
1684
1685 // Second connection fails, and gets a different error. Not a vital part of
1686 // this test, but allows waiting for the second request to complete without
1687 // too much extra code.
1688 SequencedSocketData socket_data2(
1689 MockConnect(SYNCHRONOUS, ERR_CONNECTION_TIMED_OUT),
1690 base::span<const MockRead>(), base::span<const MockWrite>());
1691 tagging_client_socket_factory_.AddSocketDataProvider(&socket_data2);
1692 SSLSocketDataProvider ssl_data2(SYNCHRONOUS, OK);
1693 tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data2);
1694
1695 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
1696 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1697 /*ssl_config_for_origin=*/std::make_unique<SSLConfig>(),
1698 /*base_ssl_config_for_proxies=*/std::make_unique<SSLConfig>());
1699
1700 ClientSocketPool::GroupId group_id(
1701 kEndpoint, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
1702 SecureDnsPolicy::kAllow);
1703
1704 // Start the first connection attempt.
1705 TestCompletionCallback callback1;
1706 ClientSocketHandle handle1;
1707 base::RunLoop run_loop;
1708 int rv1 = handle1.Init(group_id, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS,
1709 HIGHEST, SocketTag(),
1710 ClientSocketPool::RespectLimits::ENABLED,
1711 callback1.callback(),
1712 base::BindLambdaForTesting(
1713 [&](const HttpResponseInfo& response,
1714 HttpAuthController* auth_controller,
1715 base::OnceClosure restart_with_auth_callback) {
1716 run_loop.Quit();
1717 }),
1718 &pool, NetLogWithSource());
1719 ASSERT_THAT(rv1, IsError(ERR_IO_PENDING));
1720
1721 // Create a second request with a lower priority.
1722 TestCompletionCallback callback2;
1723 ClientSocketHandle handle2;
1724 int rv2 = handle2.Init(
1725 group_id, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOWEST,
1726 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1727 callback2.callback(), ClientSocketPool::ProxyAuthCallback(), &pool,
1728 NetLogWithSource());
1729 ASSERT_THAT(rv2, IsError(ERR_IO_PENDING));
1730
1731 // The ConnectJob connection sees the auth challenge and HTTP2 error, which
1732 // causes the SpdySession to be destroyed, as well as the SpdyStream. Then the
1733 // ConnectJob is bound to the first request. Binding the request will result
1734 // in temporarily assigning the ConnectJob to the second request, which
1735 // results in an unneeded reprioritization, which should not dereference the
1736 // null SpdyStream.
1737 //
1738 // TODO(mmenke): Avoid that temporary reassignment.
1739 run_loop.Run();
1740
1741 // Just tear down everything without continuing - there are other tests for
1742 // auth over HTTP2.
1743 }
1744
TEST_F(TransportClientSocketPoolTest,HttpTunnelSetupRedirect)1745 TEST_F(TransportClientSocketPoolTest, HttpTunnelSetupRedirect) {
1746 const url::SchemeHostPort kEndpoint(url::kHttpsScheme, "host.test", 443);
1747
1748 const std::string kRedirectTarget = "https://some.other.host.test/";
1749
1750 const std::string kResponseText =
1751 "HTTP/1.1 302 Found\r\n"
1752 "Location: " +
1753 kRedirectTarget +
1754 "\r\n"
1755 "Set-Cookie: foo=bar\r\n"
1756 "\r\n";
1757
1758 for (IoMode io_mode : {SYNCHRONOUS, ASYNC}) {
1759 SCOPED_TRACE(io_mode);
1760 session_deps_.host_resolver->set_synchronous_mode(io_mode == SYNCHRONOUS);
1761
1762 for (bool use_https_proxy : {false, true}) {
1763 SCOPED_TRACE(use_https_proxy);
1764
1765 TransportClientSocketPool proxy_pool(
1766 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
1767 ProxyUriToProxyChain(
1768 use_https_proxy ? "https://proxy.test" : "http://proxy.test",
1769 /*default_scheme=*/ProxyServer::SCHEME_HTTP),
1770 /*is_for_websockets=*/false,
1771 tagging_common_connect_job_params_.get());
1772
1773 MockWrite writes[] = {
1774 MockWrite(ASYNC, 0,
1775 "CONNECT host.test:443 HTTP/1.1\r\n"
1776 "Host: host.test:443\r\n"
1777 "Proxy-Connection: keep-alive\r\n\r\n"),
1778 };
1779 MockRead reads[] = {
1780 MockRead(ASYNC, 1, kResponseText.c_str()),
1781 };
1782
1783 SequencedSocketData data(reads, writes);
1784 tagging_client_socket_factory_.AddSocketDataProvider(&data);
1785 SSLSocketDataProvider ssl(ASYNC, OK);
1786 tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl);
1787
1788 ClientSocketHandle handle;
1789 TestCompletionCallback callback;
1790
1791 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
1792 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1793 /*ssl_config_for_origin=*/std::make_unique<SSLConfig>(),
1794 /*base_ssl_config_for_proxies=*/std::make_unique<SSLConfig>());
1795
1796 int rv = handle.Init(
1797 ClientSocketPool::GroupId(
1798 kEndpoint, PrivacyMode::PRIVACY_MODE_DISABLED,
1799 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow),
1800 socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
1801 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
1802 ClientSocketPool::ProxyAuthCallback(), &proxy_pool,
1803 NetLogWithSource());
1804 rv = callback.GetResult(rv);
1805
1806 // We don't trust 302 responses to CONNECT.
1807 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED));
1808 EXPECT_FALSE(handle.is_initialized());
1809 }
1810 }
1811 }
1812
TEST_F(TransportClientSocketPoolTest,NetworkAnonymizationKey)1813 TEST_F(TransportClientSocketPoolTest, NetworkAnonymizationKey) {
1814 const SchemefulSite kSite(GURL("https://foo.test/"));
1815 const auto kNetworkAnonymizationKey =
1816 NetworkAnonymizationKey::CreateSameSite(kSite);
1817 const char kHost[] = "bar.test";
1818
1819 base::test::ScopedFeatureList scoped_feature_list;
1820 scoped_feature_list.InitWithFeatures(
1821 // enabled_features
1822 {features::kPartitionConnectionsByNetworkIsolationKey,
1823 features::kSplitHostCacheByNetworkIsolationKey},
1824 // disabled_features
1825 {});
1826
1827 session_deps_.host_resolver->set_ondemand_mode(true);
1828
1829 TransportClientSocketPool::GroupId group_id(
1830 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
1831 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey,
1832 SecureDnsPolicy::kAllow);
1833 ClientSocketHandle handle;
1834 TestCompletionCallback callback;
1835 EXPECT_THAT(
1836 handle.Init(group_id,
1837 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1838 /*ssl_config_for_origin=*/nullptr,
1839 /*base_ssl_config_for_proxies=*/nullptr),
1840 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
1841 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
1842 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
1843 NetLogWithSource()),
1844 IsError(ERR_IO_PENDING));
1845
1846 ASSERT_EQ(1u, session_deps_.host_resolver->last_id());
1847 EXPECT_EQ(kHost, session_deps_.host_resolver->request_host(1));
1848 EXPECT_EQ(kNetworkAnonymizationKey,
1849 session_deps_.host_resolver->request_network_anonymization_key(1));
1850 }
1851
TEST_F(TransportClientSocketPoolTest,NetworkIsolationKeySsl)1852 TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeySsl) {
1853 const SchemefulSite kSite(GURL("https://foo.test/"));
1854 const auto kNetworkAnonymizationKey =
1855 NetworkAnonymizationKey::CreateSameSite(kSite);
1856 const char kHost[] = "bar.test";
1857
1858 base::test::ScopedFeatureList scoped_feature_list;
1859 scoped_feature_list.InitWithFeatures(
1860 // enabled_features
1861 {features::kPartitionConnectionsByNetworkIsolationKey,
1862 features::kSplitHostCacheByNetworkIsolationKey},
1863 // disabled_features
1864 {});
1865
1866 session_deps_.host_resolver->set_ondemand_mode(true);
1867
1868 TransportClientSocketPool::GroupId group_id(
1869 url::SchemeHostPort(url::kHttpsScheme, kHost, 443),
1870 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey,
1871 SecureDnsPolicy::kAllow);
1872 auto ssl_config_for_origin = std::make_unique<SSLConfig>();
1873 ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
1874 ClientSocketHandle handle;
1875 TestCompletionCallback callback;
1876 EXPECT_THAT(
1877 handle.Init(group_id,
1878 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1879 std::move(ssl_config_for_origin),
1880 /*base_ssl_config_for_proxies=*/nullptr),
1881 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
1882 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
1883 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
1884 NetLogWithSource()),
1885 IsError(ERR_IO_PENDING));
1886
1887 ASSERT_EQ(1u, session_deps_.host_resolver->last_id());
1888 EXPECT_EQ(kHost, session_deps_.host_resolver->request_host(1));
1889 EXPECT_EQ(kNetworkAnonymizationKey,
1890 session_deps_.host_resolver->request_network_anonymization_key(1));
1891 }
1892
1893 // Test that, in the case of an HTTP proxy, the same transient
1894 // NetworkAnonymizationKey is reused for resolving the proxy's host, regardless
1895 // of input NIK.
TEST_F(TransportClientSocketPoolTest,NetworkIsolationKeyHttpProxy)1896 TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeyHttpProxy) {
1897 const SchemefulSite kSite1(GURL("https://foo.test/"));
1898 const auto kNetworkAnonymizationKey1 =
1899 NetworkAnonymizationKey::CreateSameSite(kSite1);
1900 const SchemefulSite kSite2(GURL("https://bar.test/"));
1901 const auto kNetworkAnonymizationKey2 =
1902 NetworkAnonymizationKey::CreateSameSite(kSite2);
1903 const char kHost[] = "bar.test";
1904 const ProxyChain kProxyChain = ProxyUriToProxyChain(
1905 "http://proxy.test", /*default_scheme=*/ProxyServer::SCHEME_HTTP);
1906
1907 base::test::ScopedFeatureList scoped_feature_list;
1908 scoped_feature_list.InitWithFeatures(
1909 // enabled_features
1910 {features::kPartitionConnectionsByNetworkIsolationKey,
1911 features::kSplitHostCacheByNetworkIsolationKey},
1912 // disabled_features
1913 {});
1914
1915 session_deps_.host_resolver->set_ondemand_mode(true);
1916
1917 TransportClientSocketPool proxy_pool(
1918 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout, kProxyChain,
1919 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
1920
1921 TransportClientSocketPool::GroupId group_id1(
1922 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
1923 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey1,
1924 SecureDnsPolicy::kAllow);
1925 ClientSocketHandle handle1;
1926 TestCompletionCallback callback1;
1927 EXPECT_THAT(
1928 handle1.Init(group_id1,
1929 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1930 /*ssl_config_for_origin=*/nullptr,
1931 /*base_ssl_config_for_proxies=*/nullptr),
1932 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
1933 ClientSocketPool::RespectLimits::ENABLED,
1934 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
1935 &proxy_pool, NetLogWithSource()),
1936 IsError(ERR_IO_PENDING));
1937
1938 TransportClientSocketPool::GroupId group_id2(
1939 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
1940 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey2,
1941 SecureDnsPolicy::kAllow);
1942 ClientSocketHandle handle2;
1943 TestCompletionCallback callback2;
1944 EXPECT_THAT(
1945 handle2.Init(group_id2,
1946 base::MakeRefCounted<ClientSocketPool::SocketParams>(
1947 /*ssl_config_for_origin=*/nullptr,
1948 /*base_ssl_config_for_proxies=*/nullptr),
1949 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
1950 ClientSocketPool::RespectLimits::ENABLED,
1951 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
1952 &proxy_pool, NetLogWithSource()),
1953 IsError(ERR_IO_PENDING));
1954
1955 ASSERT_EQ(2u, session_deps_.host_resolver->last_id());
1956 EXPECT_EQ(kProxyChain.proxy_server().host_port_pair().host(),
1957 session_deps_.host_resolver->request_host(1));
1958 EXPECT_EQ(kProxyChain.proxy_server().host_port_pair().host(),
1959 session_deps_.host_resolver->request_host(2));
1960 EXPECT_TRUE(session_deps_.host_resolver->request_network_anonymization_key(1)
1961 .IsTransient());
1962 EXPECT_EQ(session_deps_.host_resolver->request_network_anonymization_key(1),
1963 session_deps_.host_resolver->request_network_anonymization_key(2));
1964 }
1965
1966 // Test that, in the case of an HTTPS proxy, the same transient
1967 // NetworkAnonymizationKey is reused for resolving the proxy's host, regardless
1968 // of input NIK.
TEST_F(TransportClientSocketPoolTest,NetworkIsolationKeyHttpsProxy)1969 TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeyHttpsProxy) {
1970 const SchemefulSite kSite1(GURL("https://foo.test/"));
1971 const auto kNetworkAnonymizationKey1 =
1972 NetworkAnonymizationKey::CreateSameSite(kSite1);
1973 const SchemefulSite kSite2(GURL("https://bar.test/"));
1974 const auto kNetworkAnonymizationKey2 =
1975 NetworkAnonymizationKey::CreateSameSite(kSite2);
1976 const char kHost[] = "bar.test";
1977 const ProxyChain kProxyChain = ProxyUriToProxyChain(
1978 "https://proxy.test", /*default_scheme=*/ProxyServer::SCHEME_HTTP);
1979
1980 base::test::ScopedFeatureList scoped_feature_list;
1981 scoped_feature_list.InitWithFeatures(
1982 // enabled_features
1983 {features::kPartitionConnectionsByNetworkIsolationKey,
1984 features::kSplitHostCacheByNetworkIsolationKey},
1985 // disabled_features
1986 {});
1987
1988 session_deps_.host_resolver->set_ondemand_mode(true);
1989
1990 TransportClientSocketPool proxy_pool(
1991 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout, kProxyChain,
1992 false /* is_for_websockets */, tagging_common_connect_job_params_.get());
1993
1994 TransportClientSocketPool::GroupId group_id1(
1995 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
1996 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey1,
1997 SecureDnsPolicy::kAllow);
1998 ClientSocketHandle handle1;
1999 TestCompletionCallback callback1;
2000 EXPECT_THAT(
2001 handle1.Init(
2002 group_id1,
2003 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2004 /*ssl_config_for_origin=*/nullptr,
2005 /*base_ssl_config_for_proxies=*/std::make_unique<SSLConfig>()),
2006 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
2007 ClientSocketPool::RespectLimits::ENABLED, callback1.callback(),
2008 ClientSocketPool::ProxyAuthCallback(), &proxy_pool,
2009 NetLogWithSource()),
2010 IsError(ERR_IO_PENDING));
2011
2012 TransportClientSocketPool::GroupId group_id2(
2013 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
2014 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey2,
2015 SecureDnsPolicy::kAllow);
2016 ClientSocketHandle handle2;
2017 TestCompletionCallback callback2;
2018 EXPECT_THAT(
2019 handle2.Init(
2020 group_id2,
2021 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2022 /*ssl_config_for_origin=*/nullptr,
2023 /*base_ssl_config_for_proxies=*/std::make_unique<SSLConfig>()),
2024 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
2025 ClientSocketPool::RespectLimits::ENABLED, callback2.callback(),
2026 ClientSocketPool::ProxyAuthCallback(), &proxy_pool,
2027 NetLogWithSource()),
2028 IsError(ERR_IO_PENDING));
2029
2030 ASSERT_EQ(2u, session_deps_.host_resolver->last_id());
2031 EXPECT_EQ(kProxyChain.proxy_server().host_port_pair().host(),
2032 session_deps_.host_resolver->request_host(1));
2033 EXPECT_EQ(kProxyChain.proxy_server().host_port_pair().host(),
2034 session_deps_.host_resolver->request_host(2));
2035 EXPECT_TRUE(session_deps_.host_resolver->request_network_anonymization_key(1)
2036 .IsTransient());
2037 EXPECT_EQ(session_deps_.host_resolver->request_network_anonymization_key(1),
2038 session_deps_.host_resolver->request_network_anonymization_key(2));
2039 }
2040
2041 // Test that, in the case of a SOCKS5 proxy, the passed in
2042 // NetworkAnonymizationKey is used for the destination DNS lookup, and the same
2043 // transient NetworkAnonymizationKey is reused for resolving the proxy's host,
2044 // regardless of input NIK.
TEST_F(TransportClientSocketPoolTest,NetworkIsolationKeySocks4Proxy)2045 TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeySocks4Proxy) {
2046 const SchemefulSite kSite1(GURL("https://foo.test/"));
2047 const auto kNetworkAnonymizationKey1 =
2048 NetworkAnonymizationKey::CreateSameSite(kSite1);
2049 const SchemefulSite kSite2(GURL("https://bar.test/"));
2050 const auto kNetworkAnonymizationKey2 =
2051 NetworkAnonymizationKey::CreateSameSite(kSite2);
2052 const char kHost[] = "bar.test";
2053 const ProxyChain kProxyChain = ProxyUriToProxyChain(
2054 "socks4://proxy.test", /*default_scheme=*/ProxyServer::SCHEME_HTTP);
2055
2056 base::test::ScopedFeatureList scoped_feature_list;
2057 scoped_feature_list.InitWithFeatures(
2058 // enabled_features
2059 {features::kPartitionConnectionsByNetworkIsolationKey,
2060 features::kSplitHostCacheByNetworkIsolationKey},
2061 // disabled_features
2062 {});
2063
2064 session_deps_.host_resolver->set_ondemand_mode(true);
2065
2066 // Test will establish two connections, but never use them to transfer data,
2067 // since thet stall on the followup DNS lookups.
2068 StaticSocketDataProvider data1;
2069 data1.set_connect_data(MockConnect(SYNCHRONOUS, OK));
2070 tagging_client_socket_factory_.AddSocketDataProvider(&data1);
2071 StaticSocketDataProvider data2;
2072 data2.set_connect_data(MockConnect(SYNCHRONOUS, OK));
2073 tagging_client_socket_factory_.AddSocketDataProvider(&data2);
2074
2075 TransportClientSocketPool proxy_pool(
2076 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout, kProxyChain,
2077 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
2078
2079 TransportClientSocketPool::GroupId group_id1(
2080 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
2081 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey1,
2082 SecureDnsPolicy::kAllow);
2083 ClientSocketHandle handle1;
2084 TestCompletionCallback callback1;
2085 EXPECT_THAT(
2086 handle1.Init(group_id1,
2087 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2088 /*ssl_config_for_origin=*/nullptr,
2089 /*base_ssl_config_for_proxies=*/nullptr),
2090 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
2091 ClientSocketPool::RespectLimits::ENABLED,
2092 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
2093 &proxy_pool, NetLogWithSource()),
2094 IsError(ERR_IO_PENDING));
2095
2096 TransportClientSocketPool::GroupId group_id2(
2097 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
2098 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey2,
2099 SecureDnsPolicy::kAllow);
2100 ClientSocketHandle handle2;
2101 TestCompletionCallback callback2;
2102 EXPECT_THAT(
2103 handle2.Init(group_id2,
2104 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2105 /*ssl_config_for_origin=*/nullptr,
2106 /*base_ssl_config_for_proxies=*/nullptr),
2107 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
2108 ClientSocketPool::RespectLimits::ENABLED,
2109 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2110 &proxy_pool, NetLogWithSource()),
2111 IsError(ERR_IO_PENDING));
2112
2113 // First two lookups are for the proxy's hostname, and should use the same
2114 // transient NIK.
2115 ASSERT_EQ(2u, session_deps_.host_resolver->last_id());
2116 EXPECT_EQ(kProxyChain.proxy_server().host_port_pair().host(),
2117 session_deps_.host_resolver->request_host(1));
2118 EXPECT_EQ(kProxyChain.proxy_server().host_port_pair().host(),
2119 session_deps_.host_resolver->request_host(2));
2120 EXPECT_TRUE(session_deps_.host_resolver->request_network_anonymization_key(1)
2121 .IsTransient());
2122 EXPECT_EQ(session_deps_.host_resolver->request_network_anonymization_key(1),
2123 session_deps_.host_resolver->request_network_anonymization_key(2));
2124
2125 // First two lookups completes, starting the next two, which should be for the
2126 // destination's hostname, and should use the passed in NIKs.
2127 session_deps_.host_resolver->ResolveNow(1);
2128 session_deps_.host_resolver->ResolveNow(2);
2129 ASSERT_EQ(4u, session_deps_.host_resolver->last_id());
2130 EXPECT_EQ(kHost, session_deps_.host_resolver->request_host(3));
2131 EXPECT_EQ(kNetworkAnonymizationKey1,
2132 session_deps_.host_resolver->request_network_anonymization_key(3));
2133 EXPECT_EQ(kHost, session_deps_.host_resolver->request_host(4));
2134 EXPECT_EQ(kNetworkAnonymizationKey2,
2135 session_deps_.host_resolver->request_network_anonymization_key(4));
2136 }
2137
2138 // Test that, in the case of a SOCKS5 proxy, the same transient
2139 // NetworkAnonymizationKey is reused for resolving the proxy's host, regardless
2140 // of input NIK.
TEST_F(TransportClientSocketPoolTest,NetworkIsolationKeySocks5Proxy)2141 TEST_F(TransportClientSocketPoolTest, NetworkIsolationKeySocks5Proxy) {
2142 const SchemefulSite kSite1(GURL("https://foo.test/"));
2143 const auto kNetworkAnonymizationKey1 =
2144 NetworkAnonymizationKey::CreateSameSite(kSite1);
2145 const SchemefulSite kSite2(GURL("https://bar.test/"));
2146 const auto kNetworkAnonymizationKey2 =
2147 NetworkAnonymizationKey::CreateSameSite(kSite2);
2148 const char kHost[] = "bar.test";
2149 const ProxyChain kProxyChain = ProxyUriToProxyChain(
2150 "socks5://proxy.test", /*default_scheme=*/ProxyServer::SCHEME_HTTP);
2151
2152 base::test::ScopedFeatureList scoped_feature_list;
2153 scoped_feature_list.InitWithFeatures(
2154 // enabled_features
2155 {features::kPartitionConnectionsByNetworkIsolationKey,
2156 features::kSplitHostCacheByNetworkIsolationKey},
2157 // disabled_features
2158 {});
2159
2160 session_deps_.host_resolver->set_ondemand_mode(true);
2161
2162 TransportClientSocketPool proxy_pool(
2163 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout, kProxyChain,
2164 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
2165
2166 TransportClientSocketPool::GroupId group_id1(
2167 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
2168 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey1,
2169 SecureDnsPolicy::kAllow);
2170 ClientSocketHandle handle1;
2171 TestCompletionCallback callback1;
2172 EXPECT_THAT(
2173 handle1.Init(group_id1,
2174 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2175 /*ssl_config_for_origin=*/nullptr,
2176 /*base_ssl_config_for_proxies=*/nullptr),
2177 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
2178 ClientSocketPool::RespectLimits::ENABLED,
2179 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
2180 &proxy_pool, NetLogWithSource()),
2181 IsError(ERR_IO_PENDING));
2182
2183 TransportClientSocketPool::GroupId group_id2(
2184 url::SchemeHostPort(url::kHttpScheme, kHost, 80),
2185 PrivacyMode::PRIVACY_MODE_DISABLED, kNetworkAnonymizationKey2,
2186 SecureDnsPolicy::kAllow);
2187 ClientSocketHandle handle2;
2188 TestCompletionCallback callback2;
2189 EXPECT_THAT(
2190 handle2.Init(group_id2,
2191 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2192 /*ssl_config_for_origin=*/nullptr,
2193 /*base_ssl_config_for_proxies=*/nullptr),
2194 TRAFFIC_ANNOTATION_FOR_TESTS, LOW, SocketTag(),
2195 ClientSocketPool::RespectLimits::ENABLED,
2196 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2197 &proxy_pool, NetLogWithSource()),
2198 IsError(ERR_IO_PENDING));
2199
2200 ASSERT_EQ(2u, session_deps_.host_resolver->last_id());
2201 EXPECT_EQ(kProxyChain.proxy_server().host_port_pair().host(),
2202 session_deps_.host_resolver->request_host(1));
2203 EXPECT_EQ(kProxyChain.proxy_server().host_port_pair().host(),
2204 session_deps_.host_resolver->request_host(2));
2205 EXPECT_TRUE(session_deps_.host_resolver->request_network_anonymization_key(1)
2206 .IsTransient());
2207 EXPECT_EQ(session_deps_.host_resolver->request_network_anonymization_key(1),
2208 session_deps_.host_resolver->request_network_anonymization_key(2));
2209 }
2210
TEST_F(TransportClientSocketPoolTest,HasActiveSocket)2211 TEST_F(TransportClientSocketPoolTest, HasActiveSocket) {
2212 const url::SchemeHostPort kEndpoint1(url::kHttpScheme, "host1.test", 80);
2213 const url::SchemeHostPort kEndpoint2(url::kHttpScheme, "host2.test", 80);
2214
2215 ClientSocketHandle handle;
2216 ClientSocketPool::GroupId group_id1(
2217 kEndpoint1, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
2218 SecureDnsPolicy::kAllow);
2219 ClientSocketPool::GroupId group_id2(
2220 kEndpoint2, PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
2221 SecureDnsPolicy::kAllow);
2222
2223 // HasActiveSocket() must return false before creating a socket.
2224 EXPECT_FALSE(pool_->HasActiveSocket(group_id1));
2225
2226 TestCompletionCallback callback1;
2227 int rv1 =
2228 handle.Init(group_id1, params_, absl::nullopt /* proxy_annotation_tag */,
2229 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2230 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
2231 pool_.get(), NetLogWithSource());
2232 EXPECT_THAT(rv1, IsError(ERR_IO_PENDING));
2233
2234 // HasActiveSocket() must return true while connecting.
2235 EXPECT_TRUE(pool_->HasActiveSocket(group_id1));
2236 EXPECT_FALSE(handle.is_initialized());
2237 EXPECT_FALSE(handle.socket());
2238
2239 EXPECT_THAT(callback1.WaitForResult(), IsOk());
2240
2241 // HasActiveSocket() must return true after handed out.
2242 EXPECT_TRUE(pool_->HasActiveSocket(group_id1));
2243 EXPECT_TRUE(handle.is_initialized());
2244 EXPECT_TRUE(handle.socket());
2245
2246 handle.Reset();
2247
2248 // HasActiveSocket returns true for the idle socket.
2249 EXPECT_TRUE(pool_->HasActiveSocket(group_id1));
2250 // Now we should have 1 idle socket.
2251 EXPECT_EQ(1, pool_->IdleSocketCount());
2252
2253 // HasActiveSocket() for group_id2 must still return false.
2254 EXPECT_FALSE(pool_->HasActiveSocket(group_id2));
2255
2256 TestCompletionCallback callback2;
2257 int rv2 =
2258 handle.Init(group_id2, params_, absl::nullopt /* proxy_annotation_tag */,
2259 LOW, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2260 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2261 pool_.get(), NetLogWithSource());
2262 EXPECT_THAT(rv2, IsError(ERR_IO_PENDING));
2263
2264 // HasActiveSocket(group_id2) must return true while connecting.
2265 EXPECT_TRUE(pool_->HasActiveSocket(group_id2));
2266
2267 // HasActiveSocket(group_id1) must still return true.
2268 EXPECT_TRUE(pool_->HasActiveSocket(group_id2));
2269
2270 // Close the sockets.
2271 pool_->FlushWithError(ERR_NETWORK_CHANGED, "Network changed");
2272
2273 // HasActiveSocket() must return false after closing the socket.
2274 EXPECT_FALSE(pool_->HasActiveSocket(group_id1));
2275 EXPECT_FALSE(pool_->HasActiveSocket(group_id2));
2276 }
2277
2278 // Test that SocketTag passed into TransportClientSocketPool is applied to
2279 // returned sockets.
2280 #if BUILDFLAG(IS_ANDROID)
TEST_F(TransportClientSocketPoolTest,Tag)2281 TEST_F(TransportClientSocketPoolTest, Tag) {
2282 if (!CanGetTaggedBytes()) {
2283 DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
2284 return;
2285 }
2286
2287 // Start test server.
2288 EmbeddedTestServer test_server;
2289 test_server.AddDefaultHandlers(base::FilePath());
2290 ASSERT_TRUE(test_server.Start());
2291
2292 ClientSocketHandle handle;
2293 int32_t tag_val1 = 0x12345678;
2294 SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
2295 int32_t tag_val2 = 0x87654321;
2296 SocketTag tag2(getuid(), tag_val2);
2297
2298 // Test socket is tagged before connected.
2299 uint64_t old_traffic = GetTaggedBytes(tag_val1);
2300 const ClientSocketPool::GroupId kGroupId(
2301 url::SchemeHostPort(test_server.base_url()),
2302 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
2303 SecureDnsPolicy::kAllow);
2304 scoped_refptr<ClientSocketPool::SocketParams> params =
2305 ClientSocketPool::SocketParams::CreateForHttpForTesting();
2306 TestCompletionCallback callback;
2307 int rv =
2308 handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
2309 LOW, tag1, ClientSocketPool::RespectLimits::ENABLED,
2310 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2311 pool_for_real_sockets_.get(), NetLogWithSource());
2312 EXPECT_THAT(callback.GetResult(rv), IsOk());
2313 EXPECT_TRUE(handle.socket());
2314 EXPECT_TRUE(handle.socket()->IsConnected());
2315 EXPECT_GT(GetTaggedBytes(tag_val1), old_traffic);
2316
2317 // Test reused socket is retagged.
2318 StreamSocket* socket = handle.socket();
2319 handle.Reset();
2320 old_traffic = GetTaggedBytes(tag_val2);
2321 rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
2322 LOW, tag2, ClientSocketPool::RespectLimits::ENABLED,
2323 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2324 pool_for_real_sockets_.get(), NetLogWithSource());
2325 EXPECT_THAT(rv, IsOk());
2326 EXPECT_TRUE(handle.socket());
2327 EXPECT_TRUE(handle.socket()->IsConnected());
2328 EXPECT_EQ(handle.socket(), socket);
2329 const char kRequest[] = "GET / HTTP/1.0\n\n";
2330 scoped_refptr<IOBuffer> write_buffer =
2331 base::MakeRefCounted<StringIOBuffer>(kRequest);
2332 rv =
2333 handle.socket()->Write(write_buffer.get(), strlen(kRequest),
2334 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
2335 EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
2336 EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
2337 // Disconnect socket to prevent reuse.
2338 handle.socket()->Disconnect();
2339 handle.Reset();
2340
2341 // Test connect jobs that are orphaned and then adopted, appropriately apply
2342 // new tag. Request socket with |tag1|.
2343 TestCompletionCallback callback2;
2344 rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
2345 LOW, tag1, ClientSocketPool::RespectLimits::ENABLED,
2346 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2347 pool_for_real_sockets_.get(), NetLogWithSource());
2348 EXPECT_TRUE(rv == OK || rv == ERR_IO_PENDING) << "Result: " << rv;
2349 // Abort and request socket with |tag2|.
2350 handle.Reset();
2351 rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
2352 LOW, tag2, ClientSocketPool::RespectLimits::ENABLED,
2353 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2354 pool_for_real_sockets_.get(), NetLogWithSource());
2355 EXPECT_THAT(callback.GetResult(rv), IsOk());
2356 EXPECT_TRUE(handle.socket());
2357 EXPECT_TRUE(handle.socket()->IsConnected());
2358 // Verify socket has |tag2| applied.
2359 old_traffic = GetTaggedBytes(tag_val2);
2360 rv =
2361 handle.socket()->Write(write_buffer.get(), strlen(kRequest),
2362 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
2363 EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
2364 EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
2365 // Disconnect socket to prevent reuse.
2366 handle.socket()->Disconnect();
2367 handle.Reset();
2368 // Eat the left over connect job from the second request.
2369 // TODO(pauljensen): remove when crbug.com/800731 fixed.
2370 rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
2371 LOW, tag1, ClientSocketPool::RespectLimits::ENABLED,
2372 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2373 pool_for_real_sockets_.get(), NetLogWithSource());
2374 EXPECT_THAT(rv, IsOk());
2375 // Disconnect socket to prevent reuse.
2376 handle.socket()->Disconnect();
2377 handle.Reset();
2378
2379 // Test two connect jobs of differing priorities. Start the lower priority one
2380 // first but expect its socket to get vended to the higher priority request.
2381 ClientSocketHandle handle_high_pri;
2382 TestCompletionCallback callback_high_pri;
2383 rv = handle.Init(kGroupId, params, absl::nullopt /* proxy_annotation_tag */,
2384 LOW, tag1, ClientSocketPool::RespectLimits::ENABLED,
2385 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2386 pool_for_real_sockets_.get(), NetLogWithSource());
2387 EXPECT_TRUE(rv == OK || rv == ERR_IO_PENDING) << "Result: " << rv;
2388 int rv_high_pri = handle_high_pri.Init(
2389 kGroupId, params, absl::nullopt /* proxy_annotation_tag */, HIGHEST, tag2,
2390 ClientSocketPool::RespectLimits::ENABLED, callback_high_pri.callback(),
2391 ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
2392 NetLogWithSource());
2393 EXPECT_THAT(callback_high_pri.GetResult(rv_high_pri), IsOk());
2394 EXPECT_TRUE(handle_high_pri.socket());
2395 EXPECT_TRUE(handle_high_pri.socket()->IsConnected());
2396 EXPECT_THAT(callback.GetResult(rv), IsOk());
2397 EXPECT_TRUE(handle.socket());
2398 EXPECT_TRUE(handle.socket()->IsConnected());
2399 // Verify |handle_high_pri| has |tag2| applied.
2400 old_traffic = GetTaggedBytes(tag_val2);
2401 rv = handle_high_pri.socket()->Write(write_buffer.get(), strlen(kRequest),
2402 callback.callback(),
2403 TRAFFIC_ANNOTATION_FOR_TESTS);
2404 EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
2405 EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
2406 // Verify |handle| has |tag1| applied.
2407 old_traffic = GetTaggedBytes(tag_val1);
2408 rv =
2409 handle.socket()->Write(write_buffer.get(), strlen(kRequest),
2410 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
2411 EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
2412 EXPECT_GT(GetTaggedBytes(tag_val1), old_traffic);
2413 }
2414
TEST_F(TransportClientSocketPoolTest,TagSOCKSProxy)2415 TEST_F(TransportClientSocketPoolTest, TagSOCKSProxy) {
2416 session_deps_.host_resolver->set_synchronous_mode(true);
2417
2418 TransportClientSocketPool proxy_pool(
2419 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
2420 ProxyUriToProxyChain("socks5://proxy",
2421 /*default_scheme=*/ProxyServer::SCHEME_HTTP),
2422 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
2423
2424 SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
2425 SocketTag tag2(getuid(), 0x87654321);
2426 const url::SchemeHostPort kDestination(url::kHttpScheme, "host", 80);
2427 const ClientSocketPool::GroupId kGroupId(
2428 kDestination, PrivacyMode::PRIVACY_MODE_DISABLED,
2429 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow);
2430 scoped_refptr<ClientSocketPool::SocketParams> socks_params =
2431 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2432 /*ssl_config_for_origin=*/nullptr,
2433 /*base_ssl_config_for_proxies=*/nullptr);
2434
2435 // Test socket is tagged when created synchronously.
2436 SOCKS5MockData data_sync(SYNCHRONOUS);
2437 data_sync.data_provider()->set_connect_data(MockConnect(SYNCHRONOUS, OK));
2438 tagging_client_socket_factory_.AddSocketDataProvider(
2439 data_sync.data_provider());
2440 ClientSocketHandle handle;
2441 int rv = handle.Init(
2442 kGroupId, socks_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag1,
2443 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
2444 ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
2445 EXPECT_THAT(rv, IsOk());
2446 EXPECT_TRUE(handle.is_initialized());
2447 EXPECT_TRUE(handle.socket());
2448 EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
2449 tag1);
2450 EXPECT_TRUE(tagging_client_socket_factory_.GetLastProducedTCPSocket()
2451 ->tagged_before_connected());
2452
2453 // Test socket is tagged when reused synchronously.
2454 StreamSocket* socket = handle.socket();
2455 handle.Reset();
2456 rv = handle.Init(
2457 kGroupId, socks_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag2,
2458 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
2459 ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
2460 EXPECT_THAT(rv, IsOk());
2461 EXPECT_TRUE(handle.socket());
2462 EXPECT_TRUE(handle.socket()->IsConnected());
2463 EXPECT_EQ(handle.socket(), socket);
2464 EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
2465 tag2);
2466 handle.socket()->Disconnect();
2467 handle.Reset();
2468
2469 // Test socket is tagged when created asynchronously.
2470 SOCKS5MockData data_async(ASYNC);
2471 tagging_client_socket_factory_.AddSocketDataProvider(
2472 data_async.data_provider());
2473 TestCompletionCallback callback;
2474 rv = handle.Init(kGroupId, socks_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW,
2475 tag1, ClientSocketPool::RespectLimits::ENABLED,
2476 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2477 &proxy_pool, NetLogWithSource());
2478 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2479 EXPECT_THAT(callback.WaitForResult(), IsOk());
2480 EXPECT_TRUE(handle.is_initialized());
2481 EXPECT_TRUE(handle.socket());
2482 EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
2483 tag1);
2484 EXPECT_TRUE(tagging_client_socket_factory_.GetLastProducedTCPSocket()
2485 ->tagged_before_connected());
2486
2487 // Test socket is tagged when reused after being created asynchronously.
2488 socket = handle.socket();
2489 handle.Reset();
2490 rv = handle.Init(
2491 kGroupId, socks_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag2,
2492 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
2493 ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
2494 EXPECT_THAT(rv, IsOk());
2495 EXPECT_TRUE(handle.socket());
2496 EXPECT_TRUE(handle.socket()->IsConnected());
2497 EXPECT_EQ(handle.socket(), socket);
2498 EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
2499 tag2);
2500 }
2501
TEST_F(TransportClientSocketPoolTest,TagSSLDirect)2502 TEST_F(TransportClientSocketPoolTest, TagSSLDirect) {
2503 if (!CanGetTaggedBytes()) {
2504 DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
2505 return;
2506 }
2507
2508 // Start test server.
2509 EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
2510 test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, SSLServerConfig());
2511 test_server.AddDefaultHandlers(base::FilePath());
2512 ASSERT_TRUE(test_server.Start());
2513
2514 TestCompletionCallback callback;
2515 ClientSocketHandle handle;
2516 int32_t tag_val1 = 0x12345678;
2517 SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
2518 int32_t tag_val2 = 0x87654321;
2519 SocketTag tag2(getuid(), tag_val2);
2520 const ClientSocketPool::GroupId kGroupId(
2521 url::SchemeHostPort(test_server.base_url()),
2522 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
2523 SecureDnsPolicy::kAllow);
2524
2525 auto ssl_config_for_origin = std::make_unique<SSLConfig>();
2526 ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
2527 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
2528 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2529 std::move(ssl_config_for_origin),
2530 /*base_ssl_config_for_proxies=*/nullptr);
2531
2532 // Test socket is tagged before connected.
2533 uint64_t old_traffic = GetTaggedBytes(tag_val1);
2534 int rv = handle.Init(
2535 kGroupId, socket_params, absl::nullopt /* proxy_annotation_tag */, LOW,
2536 tag1, ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2537 ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
2538 NetLogWithSource());
2539 EXPECT_THAT(callback.GetResult(rv), IsOk());
2540 EXPECT_TRUE(handle.socket());
2541 EXPECT_TRUE(handle.socket()->IsConnected());
2542 EXPECT_GT(GetTaggedBytes(tag_val1), old_traffic);
2543
2544 // Test reused socket is retagged.
2545 StreamSocket* socket = handle.socket();
2546 handle.Reset();
2547 old_traffic = GetTaggedBytes(tag_val2);
2548 TestCompletionCallback callback2;
2549 rv = handle.Init(kGroupId, socket_params,
2550 absl::nullopt /* proxy_annotation_tag */, LOW, tag2,
2551 ClientSocketPool::RespectLimits::ENABLED,
2552 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2553 pool_for_real_sockets_.get(), NetLogWithSource());
2554 EXPECT_THAT(rv, IsOk());
2555 EXPECT_TRUE(handle.socket());
2556 EXPECT_TRUE(handle.socket()->IsConnected());
2557 EXPECT_EQ(handle.socket(), socket);
2558 const char kRequest[] = "GET / HTTP/1.1\r\n\r\n";
2559 scoped_refptr<IOBuffer> write_buffer =
2560 base::MakeRefCounted<StringIOBuffer>(kRequest);
2561 rv =
2562 handle.socket()->Write(write_buffer.get(), strlen(kRequest),
2563 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
2564 EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
2565 scoped_refptr<IOBufferWithSize> read_buffer =
2566 base::MakeRefCounted<IOBufferWithSize>(1);
2567 rv = handle.socket()->Read(read_buffer.get(), read_buffer->size(),
2568 callback.callback());
2569 EXPECT_EQ(read_buffer->size(), callback.GetResult(rv));
2570 EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
2571 // Disconnect socket to prevent reuse.
2572 handle.socket()->Disconnect();
2573 handle.Reset();
2574 }
2575
TEST_F(TransportClientSocketPoolTest,TagSSLDirectTwoSockets)2576 TEST_F(TransportClientSocketPoolTest, TagSSLDirectTwoSockets) {
2577 if (!CanGetTaggedBytes()) {
2578 DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
2579 return;
2580 }
2581
2582 // Start test server.
2583 EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
2584 test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, SSLServerConfig());
2585 test_server.AddDefaultHandlers(base::FilePath());
2586 ASSERT_TRUE(test_server.Start());
2587
2588 ClientSocketHandle handle;
2589 int32_t tag_val1 = 0x12345678;
2590 SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
2591 int32_t tag_val2 = 0x87654321;
2592 SocketTag tag2(getuid(), tag_val2);
2593 const ClientSocketPool::GroupId kGroupId(
2594 url::SchemeHostPort(test_server.base_url()),
2595 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
2596 SecureDnsPolicy::kAllow);
2597 auto ssl_config_for_origin = std::make_unique<SSLConfig>();
2598 ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
2599 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
2600 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2601 std::move(ssl_config_for_origin),
2602 /*base_ssl_config_for_proxies=*/nullptr);
2603
2604 // Test connect jobs that are orphaned and then adopted, appropriately apply
2605 // new tag. Request socket with |tag1|.
2606 TestCompletionCallback callback;
2607 int rv = handle.Init(
2608 kGroupId, socket_params, absl::nullopt /* proxy_annotation_tag */, LOW,
2609 tag1, ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2610 ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
2611 NetLogWithSource());
2612 EXPECT_TRUE(rv == OK || rv == ERR_IO_PENDING) << "Result: " << rv;
2613 // Abort and request socket with |tag2|.
2614 handle.Reset();
2615 TestCompletionCallback callback2;
2616 rv = handle.Init(kGroupId, socket_params,
2617 absl::nullopt /* proxy_annotation_tag */, LOW, tag2,
2618 ClientSocketPool::RespectLimits::ENABLED,
2619 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2620 pool_for_real_sockets_.get(), NetLogWithSource());
2621 EXPECT_THAT(callback2.GetResult(rv), IsOk());
2622 EXPECT_TRUE(handle.socket());
2623 EXPECT_TRUE(handle.socket()->IsConnected());
2624 // Verify socket has |tag2| applied.
2625 uint64_t old_traffic = GetTaggedBytes(tag_val2);
2626 const char kRequest[] = "GET / HTTP/1.1\r\n\r\n";
2627 scoped_refptr<IOBuffer> write_buffer =
2628 base::MakeRefCounted<StringIOBuffer>(kRequest);
2629 rv = handle.socket()->Write(write_buffer.get(), strlen(kRequest),
2630 callback2.callback(),
2631 TRAFFIC_ANNOTATION_FOR_TESTS);
2632 EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback2.GetResult(rv));
2633 scoped_refptr<IOBufferWithSize> read_buffer =
2634 base::MakeRefCounted<IOBufferWithSize>(1);
2635 rv = handle.socket()->Read(read_buffer.get(), read_buffer->size(),
2636 callback2.callback());
2637 EXPECT_EQ(read_buffer->size(), callback2.GetResult(rv));
2638 EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
2639 }
2640
TEST_F(TransportClientSocketPoolTest,TagSSLDirectTwoSocketsFullPool)2641 TEST_F(TransportClientSocketPoolTest, TagSSLDirectTwoSocketsFullPool) {
2642 if (!CanGetTaggedBytes()) {
2643 DVLOG(0) << "Skipping test - GetTaggedBytes unsupported.";
2644 return;
2645 }
2646
2647 // Start test server.
2648 EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
2649 test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, SSLServerConfig());
2650 test_server.AddDefaultHandlers(base::FilePath());
2651 ASSERT_TRUE(test_server.Start());
2652
2653 TestCompletionCallback callback;
2654 ClientSocketHandle handle;
2655 int32_t tag_val1 = 0x12345678;
2656 SocketTag tag1(SocketTag::UNSET_UID, tag_val1);
2657 int32_t tag_val2 = 0x87654321;
2658 SocketTag tag2(getuid(), tag_val2);
2659 const ClientSocketPool::GroupId kGroupId(
2660 url::SchemeHostPort(test_server.base_url()),
2661 PrivacyMode::PRIVACY_MODE_DISABLED, NetworkAnonymizationKey(),
2662 SecureDnsPolicy::kAllow);
2663 auto ssl_config_for_origin = std::make_unique<SSLConfig>();
2664 ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
2665 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
2666 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2667 std::move(ssl_config_for_origin),
2668 /*base_ssl_config_for_proxies=*/nullptr);
2669
2670 // Test that sockets paused by a full underlying socket pool are properly
2671 // connected and tagged when underlying pool is freed up.
2672 // Fill up all slots in TCP pool.
2673 ClientSocketHandle tcp_handles[kMaxSocketsPerGroup];
2674 int rv;
2675 for (auto& tcp_handle : tcp_handles) {
2676 rv = tcp_handle.Init(
2677 kGroupId, socket_params, absl::nullopt /* proxy_annotation_tag */, LOW,
2678 tag1, ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2679 ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
2680 NetLogWithSource());
2681 EXPECT_THAT(callback.GetResult(rv), IsOk());
2682 EXPECT_TRUE(tcp_handle.socket());
2683 EXPECT_TRUE(tcp_handle.socket()->IsConnected());
2684 }
2685 // Request two SSL sockets.
2686 ClientSocketHandle handle_to_be_canceled;
2687 rv = handle_to_be_canceled.Init(
2688 kGroupId, socket_params, absl::nullopt /* proxy_annotation_tag */, LOW,
2689 tag1, ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2690 ClientSocketPool::ProxyAuthCallback(), pool_for_real_sockets_.get(),
2691 NetLogWithSource());
2692 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2693 rv = handle.Init(kGroupId, socket_params,
2694 absl::nullopt /* proxy_annotation_tag */, LOW, tag2,
2695 ClientSocketPool::RespectLimits::ENABLED,
2696 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2697 pool_for_real_sockets_.get(), NetLogWithSource());
2698 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2699 // Cancel first request.
2700 handle_to_be_canceled.Reset();
2701 // Disconnect a TCP socket to free up a slot.
2702 tcp_handles[0].socket()->Disconnect();
2703 tcp_handles[0].Reset();
2704 // Verify |handle| gets a valid tagged socket.
2705 EXPECT_THAT(callback.WaitForResult(), IsOk());
2706 EXPECT_TRUE(handle.socket());
2707 EXPECT_TRUE(handle.socket()->IsConnected());
2708 uint64_t old_traffic = GetTaggedBytes(tag_val2);
2709 const char kRequest[] = "GET / HTTP/1.1\r\n\r\n";
2710 scoped_refptr<IOBuffer> write_buffer =
2711 base::MakeRefCounted<StringIOBuffer>(kRequest);
2712 rv =
2713 handle.socket()->Write(write_buffer.get(), strlen(kRequest),
2714 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
2715 EXPECT_EQ(static_cast<int>(strlen(kRequest)), callback.GetResult(rv));
2716 scoped_refptr<IOBufferWithSize> read_buffer =
2717 base::MakeRefCounted<IOBufferWithSize>(1);
2718 EXPECT_EQ(handle.socket()->Read(read_buffer.get(), read_buffer->size(),
2719 callback.callback()),
2720 ERR_IO_PENDING);
2721 EXPECT_THAT(callback.WaitForResult(), read_buffer->size());
2722 EXPECT_GT(GetTaggedBytes(tag_val2), old_traffic);
2723 }
2724
TEST_F(TransportClientSocketPoolTest,TagHttpProxyNoTunnel)2725 TEST_F(TransportClientSocketPoolTest, TagHttpProxyNoTunnel) {
2726 SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
2727 SocketTag tag2(getuid(), 0x87654321);
2728
2729 TransportClientSocketPool proxy_pool(
2730 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
2731 ProxyUriToProxyChain("http://proxy",
2732 /*default_scheme=*/ProxyServer::SCHEME_HTTP),
2733 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
2734
2735 session_deps_.host_resolver->set_synchronous_mode(true);
2736 SequencedSocketData socket_data;
2737 socket_data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
2738 tagging_client_socket_factory_.AddSocketDataProvider(&socket_data);
2739
2740 const url::SchemeHostPort kDestination(url::kHttpScheme, "www.google.com",
2741 80);
2742 const ClientSocketPool::GroupId kGroupId(
2743 kDestination, PrivacyMode::PRIVACY_MODE_DISABLED,
2744 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow);
2745 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
2746 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2747 /*ssl_config_for_origin=*/nullptr,
2748 /*base_ssl_config_for_proxies=*/nullptr);
2749
2750 // Verify requested socket is tagged properly.
2751 ClientSocketHandle handle;
2752 int rv = handle.Init(
2753 kGroupId, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag1,
2754 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
2755 ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
2756 EXPECT_THAT(rv, IsOk());
2757 EXPECT_TRUE(handle.is_initialized());
2758 ASSERT_TRUE(handle.socket());
2759 EXPECT_TRUE(handle.socket()->IsConnected());
2760 EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
2761 tag1);
2762 EXPECT_TRUE(tagging_client_socket_factory_.GetLastProducedTCPSocket()
2763 ->tagged_before_connected());
2764
2765 // Verify reused socket is retagged properly.
2766 StreamSocket* socket = handle.socket();
2767 handle.Reset();
2768 rv = handle.Init(
2769 kGroupId, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag2,
2770 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
2771 ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
2772 EXPECT_THAT(rv, IsOk());
2773 EXPECT_TRUE(handle.socket());
2774 EXPECT_TRUE(handle.socket()->IsConnected());
2775 EXPECT_EQ(handle.socket(), socket);
2776 EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
2777 tag2);
2778 handle.socket()->Disconnect();
2779 handle.Reset();
2780 }
2781
2782 // This creates a tunnel without SSL on top of it - something not normally done,
2783 // though some non-HTTP consumers use this path to create tunnels for other
2784 // uses.
TEST_F(TransportClientSocketPoolTest,TagHttpProxyTunnel)2785 TEST_F(TransportClientSocketPoolTest, TagHttpProxyTunnel) {
2786 SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
2787 SocketTag tag2(getuid(), 0x87654321);
2788
2789 TransportClientSocketPool proxy_pool(
2790 kMaxSockets, kMaxSocketsPerGroup, kUnusedIdleSocketTimeout,
2791 ProxyUriToProxyChain("http://proxy",
2792 /*default_scheme=*/ProxyServer::SCHEME_HTTP),
2793 /*is_for_websockets=*/false, tagging_common_connect_job_params_.get());
2794
2795 session_deps_.host_resolver->set_synchronous_mode(true);
2796
2797 std::string request =
2798 "CONNECT www.google.com:443 HTTP/1.1\r\n"
2799 "Host: www.google.com:443\r\n"
2800 "Proxy-Connection: keep-alive\r\n\r\n";
2801 MockWrite writes[] = {
2802 MockWrite(SYNCHRONOUS, 0, request.c_str()),
2803 };
2804 MockRead reads[] = {
2805 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
2806 };
2807
2808 SequencedSocketData socket_data(MockConnect(SYNCHRONOUS, OK), reads, writes);
2809 tagging_client_socket_factory_.AddSocketDataProvider(&socket_data);
2810 SSLSocketDataProvider ssl_data(SYNCHRONOUS, OK);
2811 tagging_client_socket_factory_.AddSSLSocketDataProvider(&ssl_data);
2812
2813 const url::SchemeHostPort kDestination(url::kHttpsScheme, "www.google.com",
2814 443);
2815 const ClientSocketPool::GroupId kGroupId(
2816 kDestination, PrivacyMode::PRIVACY_MODE_DISABLED,
2817 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow);
2818
2819 auto ssl_config_for_origin = std::make_unique<SSLConfig>();
2820 ssl_config_for_origin->alpn_protos = {kProtoHTTP2, kProtoHTTP11};
2821 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
2822 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2823 std::move(ssl_config_for_origin),
2824 /*base_ssl_config_for_proxies=*/nullptr);
2825
2826 // Verify requested socket is tagged properly.
2827 ClientSocketHandle handle;
2828 int rv = handle.Init(
2829 kGroupId, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag1,
2830 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
2831 ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
2832 EXPECT_THAT(rv, IsOk());
2833 EXPECT_TRUE(handle.is_initialized());
2834 ASSERT_TRUE(handle.socket());
2835 EXPECT_TRUE(handle.socket()->IsConnected());
2836 EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
2837 tag1);
2838 EXPECT_TRUE(tagging_client_socket_factory_.GetLastProducedTCPSocket()
2839 ->tagged_before_connected());
2840
2841 // Verify reused socket is retagged properly.
2842 StreamSocket* socket = handle.socket();
2843 handle.Reset();
2844 rv = handle.Init(
2845 kGroupId, socket_params, TRAFFIC_ANNOTATION_FOR_TESTS, LOW, tag2,
2846 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
2847 ClientSocketPool::ProxyAuthCallback(), &proxy_pool, NetLogWithSource());
2848 EXPECT_THAT(rv, IsOk());
2849 EXPECT_TRUE(handle.socket());
2850 EXPECT_TRUE(handle.socket()->IsConnected());
2851 EXPECT_EQ(handle.socket(), socket);
2852 EXPECT_EQ(tagging_client_socket_factory_.GetLastProducedTCPSocket()->tag(),
2853 tag2);
2854 handle.socket()->Disconnect();
2855 handle.Reset();
2856 }
2857
2858 #endif // BUILDFLAG(IS_ANDROID)
2859
2860 // Class that enables tests to set mock time.
2861 class TransportClientSocketPoolMockNowSourceTest
2862 : public TransportClientSocketPoolTest {
2863 public:
2864 TransportClientSocketPoolMockNowSourceTest(
2865 const TransportClientSocketPoolMockNowSourceTest&) = delete;
2866 TransportClientSocketPoolMockNowSourceTest& operator=(
2867 const TransportClientSocketPoolMockNowSourceTest&) = delete;
2868
2869 protected:
TransportClientSocketPoolMockNowSourceTest()2870 TransportClientSocketPoolMockNowSourceTest()
2871 : TransportClientSocketPoolTest(
2872 base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
2873 };
2874
2875 // Tests that changing the idle unused socket timeout using the experiment
2876 // works. The test first sets the value of timeout duration for idle sockets.
2877 // Next, it opens |kNumIdleSockets| sockets. To trigger the cleanup of idle
2878 // sockets that may have timedout, it then opens one more socket. This is
2879 // required since requesting a new socket triggers cleanup of idle timedout
2880 // sockets. Next, the test verifies the count of idle timed-out sockets.
TEST_F(TransportClientSocketPoolMockNowSourceTest,IdleUnusedSocketTimeout)2881 TEST_F(TransportClientSocketPoolMockNowSourceTest, IdleUnusedSocketTimeout) {
2882 const url::SchemeHostPort kSchemeHostPort1(url::kHttpScheme, "www.foo.com",
2883 80);
2884 const url::SchemeHostPort kSchemeHostPort2(url::kHttpScheme, "www.bar.com",
2885 80);
2886
2887 const struct {
2888 bool use_first_socket;
2889 int fast_forward_seconds;
2890 int unused_idle_socket_timeout_seconds;
2891 bool expect_idle_socket;
2892 } kTests[] = {
2893 // When the clock is fast forwarded by a duration longer than
2894 // |unused_idle_socket_timeout_seconds|, the first unused idle socket is
2895 // expected to be timedout, and cleared.
2896 {false, 0, 0, false},
2897 {false, 9, 10, true},
2898 {false, 11, 10, false},
2899 {false, 19, 20, true},
2900 {false, 21, 20, false},
2901 // If |use_first_socket| is true, then the test would write some data to
2902 // the socket, thereby marking it as "used". Thereafter, this idle socket
2903 // should be timedout based on used idle socket timeout, and changing
2904 // |unused_idle_socket_timeout_seconds| should not affect the
2905 // |expected_idle_sockets|.
2906 {true, 0, 0, true},
2907 {true, 9, 10, true},
2908 {true, 11, 10, true},
2909 {true, 19, 20, true},
2910 {true, 21, 20, true},
2911 };
2912
2913 for (const auto& test : kTests) {
2914 SpdySessionDependencies session_deps(
2915 ConfiguredProxyResolutionService::CreateDirect());
2916 std::unique_ptr<HttpNetworkSession> session(
2917 SpdySessionDependencies::SpdyCreateSession(&session_deps));
2918
2919 base::test::ScopedFeatureList scoped_feature_list_;
2920 std::map<std::string, std::string> parameters;
2921 parameters["unused_idle_socket_timeout_seconds"] =
2922 base::NumberToString(test.unused_idle_socket_timeout_seconds);
2923 scoped_feature_list_.InitAndEnableFeatureWithParameters(
2924 net::features::kNetUnusedIdleSocketTimeout, parameters);
2925
2926 const char kWriteData[] = "1";
2927 const MockWrite kWrites[] = {MockWrite(SYNCHRONOUS, kWriteData)};
2928
2929 SequencedSocketData provider_socket_1(MockConnect(ASYNC, OK),
2930 base::span<MockRead>(), kWrites);
2931 {
2932 // Create 1 socket.
2933 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
2934 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2935 /*ssl_config_for_origin=*/nullptr,
2936 /*base_ssl_config_for_proxies=*/nullptr);
2937 session_deps.socket_factory->AddSocketDataProvider(&provider_socket_1);
2938 ClientSocketHandle connection;
2939 TestCompletionCallback callback;
2940 int rv = connection.Init(
2941 ClientSocketPool::GroupId(
2942 kSchemeHostPort1, PrivacyMode::PRIVACY_MODE_DISABLED,
2943 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow),
2944 ClientSocketPool::SocketParams::CreateForHttpForTesting(),
2945 /*proxy_annotation_tag=*/absl::nullopt, MEDIUM, SocketTag(),
2946 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2947 ClientSocketPool::ProxyAuthCallback(),
2948 session->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
2949 ProxyChain::Direct()),
2950 NetLogWithSource());
2951 EXPECT_THAT(callback.GetResult(rv), IsOk());
2952 EXPECT_FALSE(connection.socket()->WasEverUsed());
2953
2954 // Writing some data to the socket should set WasEverUsed.
2955 if (test.use_first_socket) {
2956 // Generate |socket_write_data| from kMockWriteData by appending null
2957 // character to the latter.
2958 auto write_buffer = base::MakeRefCounted<StringIOBuffer>(kWriteData);
2959 TestCompletionCallback write_callback;
2960 rv = connection.socket()->Write(
2961 write_buffer.get(), write_buffer->size(), write_callback.callback(),
2962 TRAFFIC_ANNOTATION_FOR_TESTS);
2963 EXPECT_EQ(rv, 1);
2964 EXPECT_TRUE(connection.socket()->WasEverUsed());
2965 }
2966 }
2967
2968 EXPECT_EQ(1, session
2969 ->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
2970 ProxyChain::Direct())
2971 ->IdleSocketCount());
2972
2973 // Moving the clock forward may cause the idle socket to be timedout.
2974 FastForwardBy(base::Seconds(test.fast_forward_seconds));
2975
2976 {
2977 // Request a new socket to trigger cleanup of idle timedout sockets.
2978 scoped_refptr<ClientSocketPool::SocketParams> socket_params =
2979 base::MakeRefCounted<ClientSocketPool::SocketParams>(
2980 /*ssl_config_for_origin=*/nullptr,
2981 /*base_ssl_config_for_proxies=*/nullptr);
2982 SequencedSocketData provider_socket_2(MockConnect(ASYNC, OK),
2983 base::span<MockRead>(),
2984 base::span<MockWrite>());
2985 session_deps.socket_factory->AddSocketDataProvider(&provider_socket_2);
2986 ClientSocketHandle connection;
2987 TestCompletionCallback callback;
2988 int rv = connection.Init(
2989 ClientSocketPool::GroupId(
2990 kSchemeHostPort2, PrivacyMode::PRIVACY_MODE_DISABLED,
2991 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow),
2992 socket_params, /*proxy_annotation_tag=*/absl::nullopt, MEDIUM,
2993 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2994 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2995 session->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
2996 ProxyChain::Direct()),
2997 NetLogWithSource());
2998 EXPECT_THAT(callback.GetResult(rv), IsOk());
2999 connection.socket()->Disconnect();
3000 }
3001
3002 EXPECT_EQ(test.expect_idle_socket ? 1 : 0,
3003 session
3004 ->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
3005 ProxyChain::Direct())
3006 ->IdleSocketCount());
3007 }
3008 }
3009
3010 } // namespace
3011
3012 } // namespace net
3013