blob: 83d4df82651c5e32b00bffe138298c0524d7653a [file] [log] [blame]
[email protected]e34400c32012-01-24 02:49:331// Copyright (c) 2012 The Chromium Authors. All rights reserved.
[email protected]f6d1d6eb2009-06-24 20:16:092// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
tbansalf82cc8e2015-10-14 20:05:495#include <stdint.h>
Daniel Cheng5feb16f2022-02-28 06:52:076
dchengc7eeda422015-12-26 03:56:487#include <utility>
[email protected]51fdc7c2012-04-10 19:19:488#include <vector>
9
[email protected]6ecf2b92011-12-15 01:14:5210#include "base/bind.h"
[email protected]2041cf342010-02-19 03:15:5911#include "base/callback.h"
danakjdb9ae7942020-11-11 16:01:3512#include "base/callback_helpers.h"
Hans Wennborg0924470b2020-04-27 21:08:0513#include "base/check_op.h"
skyostil4891b25b2015-06-11 11:43:4514#include "base/location.h"
Daniel Cheng5feb16f2022-02-28 06:52:0715#include "base/memory/raw_ptr.h"
[email protected]3b63f8f42011-03-28 01:54:1516#include "base/memory/ref_counted.h"
[email protected]6ea7b152011-12-21 21:21:1317#include "base/memory/weak_ptr.h"
Hans Wennborg0924470b2020-04-27 21:08:0518#include "base/notreached.h"
[email protected]034df0f32013-01-07 23:17:4819#include "base/run_loop.h"
[email protected]fc9be5802013-06-11 10:56:5120#include "base/strings/string_number_conversions.h"
[email protected]18b577412013-07-18 04:19:1521#include "base/strings/stringprintf.h"
Patrick Monette643cdf62021-10-15 19:13:4222#include "base/task/single_thread_task_runner.h"
Matt Menke166443c2019-05-24 18:45:5923#include "base/test/scoped_feature_list.h"
[email protected]f214f8792011-01-01 02:17:0824#include "base/threading/platform_thread.h"
gabf767595f2016-05-11 18:50:3525#include "base/threading/thread_task_runner_handle.h"
[email protected]f3a1c642011-07-12 19:15:0326#include "base/values.h"
Matt Menke166443c2019-05-24 18:45:5927#include "net/base/features.h"
Eric Ortha2e7773212021-06-22 21:49:5528#include "net/base/host_port_pair.h"
[email protected]034df0f32013-01-07 23:17:4829#include "net/base/load_timing_info.h"
[email protected]b258e0792013-01-12 07:11:5930#include "net/base/load_timing_info_test_util.h"
[email protected]d8eb84242010-09-25 02:25:0631#include "net/base/net_errors.h"
Matt Menke166443c2019-05-24 18:45:5932#include "net/base/network_isolation_key.h"
Matt Menkebdf777802019-04-22 19:38:5933#include "net/base/privacy_mode.h"
Matt Menkeaafff542019-04-22 22:09:3634#include "net/base/proxy_server.h"
Eric Orth5ccc3f02021-09-23 00:01:5735#include "net/base/proxy_string_util.h"
[email protected]ac790b42009-12-02 04:31:3136#include "net/base/request_priority.h"
Matt Menke4807a9a2020-11-21 00:14:4137#include "net/base/schemeful_site.h"
[email protected]f6d1d6eb2009-06-24 20:16:0938#include "net/base/test_completion_callback.h"
dalykedd30d982019-12-16 15:31:1039#include "net/dns/public/resolve_error_info.h"
Ben Schwartz3ff4dc1e62021-04-27 21:15:2340#include "net/dns/public/secure_dns_policy.h"
[email protected]277d5942010-08-11 21:02:3541#include "net/http/http_response_headers.h"
Matt Menke39b7c5a2019-04-10 19:47:5142#include "net/http/http_response_info.h"
eroman87c53d62015-04-02 06:51:0743#include "net/log/net_log.h"
mikecirone8b85c432016-09-08 19:11:0044#include "net/log/net_log_event_type.h"
mikecironef22f9812016-10-04 03:40:1945#include "net/log/net_log_source.h"
mikecirone8b85c432016-09-08 19:11:0046#include "net/log/net_log_source_type.h"
mmenke16a7cbdd2015-04-24 23:00:5647#include "net/log/test_net_log.h"
mmenke43758e62015-05-04 21:09:4648#include "net/log/test_net_log_util.h"
[email protected]f6d1d6eb2009-06-24 20:16:0949#include "net/socket/client_socket_factory.h"
50#include "net/socket/client_socket_handle.h"
Eric Ortha9b8be02021-06-29 23:09:0851#include "net/socket/connect_job_factory.h"
tfarina5dd13c22016-11-16 12:08:2652#include "net/socket/datagram_client_socket.h"
tbansalca83c002016-04-28 20:56:2853#include "net/socket/socket_performance_watcher.h"
Paul Jensen8d6f87ec2018-01-13 00:46:5454#include "net/socket/socket_tag.h"
[email protected]75439d3b2009-07-23 22:11:1755#include "net/socket/socket_test_util.h"
[email protected]18ccfdb2013-08-15 00:13:4456#include "net/socket/ssl_client_socket.h"
[email protected]3268023f2011-05-05 00:08:1057#include "net/socket/stream_socket.h"
Daniel Cheng5feb16f2022-02-28 06:52:0758#include "net/socket/transport_client_socket_pool.h"
Matt Menke9fa17d52019-03-25 19:12:2659#include "net/socket/transport_connect_job.h"
Matt Menke39b7c5a2019-04-10 19:47:5160#include "net/ssl/ssl_cert_request_info.h"
robpercival214763f2016-07-01 23:27:0161#include "net/test/gtest_util.h"
Gabriel Charettec7108742019-08-23 03:31:4062#include "net/test/test_with_task_environment.h"
Matt Menkef09e64c2019-04-23 22:16:2863#include "net/traffic_annotation/network_traffic_annotation.h"
Ramin Halavati0a08cc82018-02-06 07:46:3864#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
[email protected]51fdc7c2012-04-10 19:19:4865#include "testing/gmock/include/gmock/gmock.h"
[email protected]f6d1d6eb2009-06-24 20:16:0966#include "testing/gtest/include/gtest/gtest.h"
Anton Bikineev068d2912021-05-15 20:43:5267#include "third_party/abseil-cpp/absl/types/optional.h"
Eric Ortha2e7773212021-06-22 21:49:5568#include "url/scheme_host_port.h"
69#include "url/url_constants.h"
[email protected]f6d1d6eb2009-06-24 20:16:0970
robpercival214763f2016-07-01 23:27:0171using net::test::IsError;
72using net::test::IsOk;
73
[email protected]51fdc7c2012-04-10 19:19:4874using ::testing::Invoke;
75using ::testing::Return;
76
[email protected]f6d1d6eb2009-06-24 20:16:0977namespace net {
78
79namespace {
80
[email protected]211d21722009-07-22 15:48:5381const int kDefaultMaxSockets = 4;
[email protected]c9d6a1d2009-07-14 16:15:2082const int kDefaultMaxSocketsPerGroup = 2;
Peter Kastinge5a38ed2021-10-02 03:06:3583constexpr base::TimeDelta kUnusedIdleSocketTimeout = base::Seconds(10);
[email protected]0b7648c2009-07-06 20:14:0184
Matt Menkebdf777802019-04-22 19:38:5985ClientSocketPool::GroupId TestGroupId(
Eric Ortha2e7773212021-06-22 21:49:5586 base::StringPiece host,
Matt Menkebdf777802019-04-22 19:38:5987 int port = 80,
Eric Ortha2e7773212021-06-22 21:49:5588 base::StringPiece scheme = url::kHttpScheme,
Matt Menke166443c2019-05-24 18:45:5989 PrivacyMode privacy_mode = PrivacyMode::PRIVACY_MODE_DISABLED,
90 NetworkIsolationKey network_isolation_key = NetworkIsolationKey()) {
Eric Ortha2e7773212021-06-22 21:49:5591 return ClientSocketPool::GroupId(url::SchemeHostPort(scheme, host, port),
dalyk5f48a132019-10-14 15:20:1992 privacy_mode, network_isolation_key,
Ben Schwartz3ff4dc1e62021-04-27 21:15:2393 SecureDnsPolicy::kAllow);
Matt Menkec6b3edf72019-03-19 17:00:3994}
95
[email protected]034df0f32013-01-07 23:17:4896// Make sure |handle| sets load times correctly when it has been assigned a
97// reused socket.
98void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
99 LoadTimingInfo load_timing_info;
100 // Only pass true in as |is_reused|, as in general, HttpStream types should
101 // have stricter concepts of reuse than socket pools.
102 EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info));
103
104 EXPECT_EQ(true, load_timing_info.socket_reused);
mikecironef22f9812016-10-04 03:40:19105 EXPECT_NE(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
[email protected]034df0f32013-01-07 23:17:48106
[email protected]b258e0792013-01-12 07:11:59107 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
108 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
[email protected]034df0f32013-01-07 23:17:48109}
110
111// Make sure |handle| sets load times correctly when it has been assigned a
[email protected]b021ece62013-06-11 11:06:33112// fresh socket. Also runs TestLoadTimingInfoConnectedReused, since the owner
[email protected]034df0f32013-01-07 23:17:48113// of a connection where |is_reused| is false may consider the connection
114// reused.
115void TestLoadTimingInfoConnectedNotReused(const ClientSocketHandle& handle) {
116 EXPECT_FALSE(handle.is_reused());
117
118 LoadTimingInfo load_timing_info;
119 EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info));
120
121 EXPECT_FALSE(load_timing_info.socket_reused);
mikecironef22f9812016-10-04 03:40:19122 EXPECT_NE(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
[email protected]034df0f32013-01-07 23:17:48123
[email protected]b258e0792013-01-12 07:11:59124 ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
125 CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
126 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
[email protected]034df0f32013-01-07 23:17:48127
128 TestLoadTimingInfoConnectedReused(handle);
129}
130
131// Make sure |handle| sets load times correctly, in the case that it does not
132// currently have a socket.
133void TestLoadTimingInfoNotConnected(const ClientSocketHandle& handle) {
134 // Should only be set to true once a socket is assigned, if at all.
135 EXPECT_FALSE(handle.is_reused());
136
137 LoadTimingInfo load_timing_info;
138 EXPECT_FALSE(handle.GetLoadTimingInfo(false, &load_timing_info));
139
140 EXPECT_FALSE(load_timing_info.socket_reused);
mikecironef22f9812016-10-04 03:40:19141 EXPECT_EQ(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
[email protected]034df0f32013-01-07 23:17:48142
[email protected]b258e0792013-01-12 07:11:59143 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
144 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
[email protected]034df0f32013-01-07 23:17:48145}
146
[email protected]3268023f2011-05-05 00:08:10147class MockClientSocket : public StreamSocket {
[email protected]f6d1d6eb2009-06-24 20:16:09148 public:
[email protected]034df0f32013-01-07 23:17:48149 explicit MockClientSocket(net::NetLog* net_log)
150 : connected_(false),
[email protected]0dc88b32014-03-26 20:12:28151 has_unread_data_(false),
tfarina428341112016-09-22 13:38:20152 net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)),
Charlie Harrison3e4c0622018-05-13 15:44:30153 was_used_to_convey_data_(false) {}
[email protected]f6d1d6eb2009-06-24 20:16:09154
Peter Boström407869b2021-10-07 04:42:48155 MockClientSocket(const MockClientSocket&) = delete;
156 MockClientSocket& operator=(const MockClientSocket&) = delete;
157
[email protected]0dc88b32014-03-26 20:12:28158 // Sets whether the socket has unread data. If true, the next call to Read()
159 // will return 1 byte and IsConnectedAndIdle() will return false.
160 void set_has_unread_data(bool has_unread_data) {
161 has_unread_data_ = has_unread_data;
162 }
163
[email protected]3f55aa12011-12-07 02:03:33164 // Socket implementation.
dchengb03027d2014-10-21 12:00:20165 int Read(IOBuffer* /* buf */,
166 int len,
Brad Lassey3a814172018-04-26 03:30:21167 CompletionOnceCallback /* callback */) override {
[email protected]0dc88b32014-03-26 20:12:28168 if (has_unread_data_ && len > 0) {
169 has_unread_data_ = false;
170 was_used_to_convey_data_ = true;
171 return 1;
172 }
[email protected]e86df8dc2013-03-30 13:18:28173 return ERR_UNEXPECTED;
[email protected]3f55aa12011-12-07 02:03:33174 }
[email protected]ab838892009-06-30 18:49:05175
[email protected]a2b2cfc2017-12-06 09:06:08176 int Write(
177 IOBuffer* /* buf */,
178 int len,
Brad Lassey3a814172018-04-26 03:30:21179 CompletionOnceCallback /* callback */,
[email protected]a2b2cfc2017-12-06 09:06:08180 const NetworkTrafficAnnotationTag& /*traffic_annotation*/) override {
[email protected]0f873e82010-09-02 16:09:01181 was_used_to_convey_data_ = true;
182 return len;
[email protected]ab838892009-06-30 18:49:05183 }
Avi Drissman13fc8932015-12-20 04:40:46184 int SetReceiveBufferSize(int32_t size) override { return OK; }
185 int SetSendBufferSize(int32_t size) override { return OK; }
[email protected]ab838892009-06-30 18:49:05186
[email protected]dbf036f2011-12-06 23:33:24187 // StreamSocket implementation.
Brad Lassey3a814172018-04-26 03:30:21188 int Connect(CompletionOnceCallback callback) override {
[email protected]dbf036f2011-12-06 23:33:24189 connected_ = true;
190 return OK;
191 }
[email protected]f6d1d6eb2009-06-24 20:16:09192
dchengb03027d2014-10-21 12:00:20193 void Disconnect() override { connected_ = false; }
194 bool IsConnected() const override { return connected_; }
195 bool IsConnectedAndIdle() const override {
[email protected]0dc88b32014-03-26 20:12:28196 return connected_ && !has_unread_data_;
197 }
[email protected]0b7648c2009-07-06 20:14:01198
dchengb03027d2014-10-21 12:00:20199 int GetPeerAddress(IPEndPoint* /* address */) const override {
[email protected]9f864b32010-01-20 15:01:16200 return ERR_UNEXPECTED;
[email protected]f6d1d6eb2009-06-24 20:16:09201 }
[email protected]f6d1d6eb2009-06-24 20:16:09202
dchengb03027d2014-10-21 12:00:20203 int GetLocalAddress(IPEndPoint* /* address */) const override {
[email protected]e7f74da2011-04-19 23:49:35204 return ERR_UNEXPECTED;
205 }
206
tfarina428341112016-09-22 13:38:20207 const NetLogWithSource& NetLog() const override { return net_log_; }
[email protected]a2006ece2010-04-23 16:44:02208
dchengb03027d2014-10-21 12:00:20209 bool WasEverUsed() const override { return was_used_to_convey_data_; }
tfarina2846404c2016-12-25 14:31:37210 bool WasAlpnNegotiated() const override { return false; }
dchengb03027d2014-10-21 12:00:20211 NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
212 bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
ttuttle23fdb7b2015-05-15 01:28:03213 void GetConnectionAttempts(ConnectionAttempts* out) const override {
214 out->clear();
215 }
216 void ClearConnectionAttempts() override {}
217 void AddConnectionAttempts(const ConnectionAttempts& attempts) override {}
tbansalf82cc8e2015-10-14 20:05:49218 int64_t GetTotalReceivedBytes() const override {
219 NOTIMPLEMENTED();
220 return 0;
221 }
Paul Jensen0f49dec2017-12-12 23:39:58222 void ApplySocketTag(const SocketTag& tag) override {}
[email protected]9b5614a2010-08-25 20:29:45223
[email protected]f6d1d6eb2009-06-24 20:16:09224 private:
225 bool connected_;
[email protected]0dc88b32014-03-26 20:12:28226 bool has_unread_data_;
tfarina428341112016-09-22 13:38:20227 NetLogWithSource net_log_;
[email protected]0f873e82010-09-02 16:09:01228 bool was_used_to_convey_data_;
[email protected]f6d1d6eb2009-06-24 20:16:09229};
230
[email protected]5fc08e32009-07-15 17:09:57231class TestConnectJob;
232
[email protected]f6d1d6eb2009-06-24 20:16:09233class MockClientSocketFactory : public ClientSocketFactory {
234 public:
[email protected]ab838892009-06-30 18:49:05235 MockClientSocketFactory() : allocation_count_(0) {}
[email protected]f6d1d6eb2009-06-24 20:16:09236
danakj655b66c2016-04-16 00:51:38237 std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
[email protected]5370c012011-06-29 03:47:04238 DatagramSocket::BindType bind_type,
[email protected]98b0e582011-06-22 14:31:41239 NetLog* net_log,
mikecironef22f9812016-10-04 03:40:19240 const NetLogSource& source) override {
[email protected]98b0e582011-06-22 14:31:41241 NOTREACHED();
David Benjamin24725be2019-07-24 20:57:18242 return nullptr;
[email protected]98b0e582011-06-22 14:31:41243 }
244
Helen Lid5bb9222018-04-12 15:33:09245 std::unique_ptr<TransportClientSocket> CreateTransportClientSocket(
[email protected]0a0b7682010-08-25 17:08:07246 const AddressList& addresses,
danakj655b66c2016-04-16 00:51:38247 std::unique_ptr<
248 SocketPerformanceWatcher> /* socket_performance_watcher */,
Eric Roman2bc77162020-09-16 18:30:45249 NetworkQualityEstimator* /* network_quality_estimator */,
[email protected]0a0b7682010-08-25 17:08:07250 NetLog* /* net_log */,
mikecironef22f9812016-10-04 03:40:19251 const NetLogSource& /*source*/) override {
[email protected]f6d1d6eb2009-06-24 20:16:09252 allocation_count_++;
Helen Lid5bb9222018-04-12 15:33:09253 return nullptr;
[email protected]f6d1d6eb2009-06-24 20:16:09254 }
255
danakj655b66c2016-04-16 00:51:38256 std::unique_ptr<SSLClientSocket> CreateSSLClientSocket(
David Benjamin24725be2019-07-24 20:57:18257 SSLClientContext* context,
Matt Menke841fc412019-03-05 23:20:12258 std::unique_ptr<StreamSocket> stream_socket,
[email protected]4f4de7e62010-11-12 19:55:27259 const HostPortPair& host_and_port,
David Benjamin24725be2019-07-24 20:57:18260 const SSLConfig& ssl_config) override {
[email protected]f6d1d6eb2009-06-24 20:16:09261 NOTIMPLEMENTED();
David Benjamin24725be2019-07-24 20:57:18262 return nullptr;
[email protected]f6d1d6eb2009-06-24 20:16:09263 }
Matt Menkefd956922019-02-04 23:44:03264
[email protected]5fc08e32009-07-15 17:09:57265 void WaitForSignal(TestConnectJob* job) { waiting_jobs_.push_back(job); }
[email protected]03b7c8c2013-07-20 04:38:55266
[email protected]5fc08e32009-07-15 17:09:57267 void SignalJobs();
268
[email protected]03b7c8c2013-07-20 04:38:55269 void SignalJob(size_t job);
270
271 void SetJobLoadState(size_t job, LoadState load_state);
272
Matt Menke141b87f22019-01-30 02:43:03273 // Sets the HasConnectionEstablished value of the specified job to true,
274 // without invoking the callback.
275 void SetJobHasEstablishedConnection(size_t job);
276
[email protected]f6d1d6eb2009-06-24 20:16:09277 int allocation_count() const { return allocation_count_; }
278
[email protected]f6d1d6eb2009-06-24 20:16:09279 private:
280 int allocation_count_;
[email protected]5fc08e32009-07-15 17:09:57281 std::vector<TestConnectJob*> waiting_jobs_;
[email protected]f6d1d6eb2009-06-24 20:16:09282};
283
[email protected]ab838892009-06-30 18:49:05284class TestConnectJob : public ConnectJob {
285 public:
286 enum JobType {
287 kMockJob,
288 kMockFailingJob,
289 kMockPendingJob,
290 kMockPendingFailingJob,
[email protected]5fc08e32009-07-15 17:09:57291 kMockWaitingJob,
Matt Menkeb57663b32019-03-01 17:17:10292
293 // Certificate errors return a socket in addition to an error code.
294 kMockCertErrorJob,
295 kMockPendingCertErrorJob,
296
[email protected]e60e47a2010-07-14 03:37:18297 kMockAdditionalErrorStateJob,
298 kMockPendingAdditionalErrorStateJob,
[email protected]0dc88b32014-03-26 20:12:28299 kMockUnreadDataJob,
Matt Menkeb57663b32019-03-01 17:17:10300
301 kMockAuthChallengeOnceJob,
302 kMockAuthChallengeTwiceJob,
303 kMockAuthChallengeOnceFailingJob,
304 kMockAuthChallengeTwiceFailingJob,
[email protected]ab838892009-06-30 18:49:05305 };
306
[email protected]994d4932010-07-12 17:55:13307 // The kMockPendingJob uses a slight delay before allowing the connect
308 // to complete.
309 static const int kPendingConnectDelay = 2;
310
[email protected]ab838892009-06-30 18:49:05311 TestConnectJob(JobType job_type,
Matt Menke16f5c2e52019-03-25 21:50:40312 RequestPriority request_priority,
313 SocketTag socket_tag,
[email protected]974ebd62009-08-03 23:14:34314 base::TimeDelta timeout_duration,
Matt Menkea6f99ad2019-03-08 02:26:43315 const CommonConnectJobParams* common_connect_job_params,
[email protected]ab838892009-06-30 18:49:05316 ConnectJob::Delegate* delegate,
Matt Menkea6f99ad2019-03-08 02:26:43317 MockClientSocketFactory* client_socket_factory)
Matt Menke16f5c2e52019-03-25 21:50:40318 : ConnectJob(request_priority,
319 socket_tag,
Matt Menke1a6c92d2019-02-23 00:25:38320 timeout_duration,
Matt Menkea6f99ad2019-03-08 02:26:43321 common_connect_job_params,
Matt Menke1a6c92d2019-02-23 00:25:38322 delegate,
323 nullptr /* net_log */,
324 NetLogSourceType::TRANSPORT_CONNECT_JOB,
325 NetLogEventType::TRANSPORT_CONNECT_JOB_CONNECT),
[email protected]2ab05b52009-07-01 23:57:58326 job_type_(job_type),
[email protected]ab838892009-06-30 18:49:05327 client_socket_factory_(client_socket_factory),
[email protected]e60e47a2010-07-14 03:37:18328 load_state_(LOAD_STATE_IDLE),
Matt Menke141b87f22019-01-30 02:43:03329 has_established_connection_(false),
Jeremy Romand54000b22019-07-08 18:40:16330 store_additional_error_state_(false) {}
[email protected]ab838892009-06-30 18:49:05331
Peter Boström407869b2021-10-07 04:42:48332 TestConnectJob(const TestConnectJob&) = delete;
333 TestConnectJob& operator=(const TestConnectJob&) = delete;
334
[email protected]974ebd62009-08-03 23:14:34335 void Signal() {
[email protected]e772db3f2010-07-12 18:11:13336 DoConnect(waiting_success_, true /* async */, false /* recoverable */);
[email protected]974ebd62009-08-03 23:14:34337 }
338
[email protected]03b7c8c2013-07-20 04:38:55339 void set_load_state(LoadState load_state) { load_state_ = load_state; }
340
Matt Menke141b87f22019-01-30 02:43:03341 void set_has_established_connection() {
342 DCHECK(!has_established_connection_);
343 has_established_connection_ = true;
344 }
345
[email protected]03b7c8c2013-07-20 04:38:55346 // From ConnectJob:
347
dchengb03027d2014-10-21 12:00:20348 LoadState GetLoadState() const override { return load_state_; }
[email protected]46451352009-09-01 14:54:21349
Matt Menke141b87f22019-01-30 02:43:03350 bool HasEstablishedConnection() const override {
351 return has_established_connection_;
352 }
353
dalykedd30d982019-12-16 15:31:10354 ResolveErrorInfo GetResolveErrorInfo() const override {
355 return ResolveErrorInfo(OK);
356 }
357
Matt Menke6f84d1f12019-04-11 19:26:47358 bool IsSSLError() const override { return store_additional_error_state_; }
359
360 scoped_refptr<SSLCertRequestInfo> GetCertRequestInfo() override {
361 if (store_additional_error_state_)
362 return base::MakeRefCounted<SSLCertRequestInfo>();
363 return nullptr;
[email protected]e60e47a2010-07-14 03:37:18364 }
365
[email protected]974ebd62009-08-03 23:14:34366 private:
[email protected]03b7c8c2013-07-20 04:38:55367 // From ConnectJob:
[email protected]ab838892009-06-30 18:49:05368
dchengb03027d2014-10-21 12:00:20369 int ConnectInternal() override {
[email protected]ab838892009-06-30 18:49:05370 AddressList ignored;
Raul Tambre94493c652019-03-11 17:18:35371 client_socket_factory_->CreateTransportClientSocket(
Eric Roman2bc77162020-09-16 18:30:45372 ignored, nullptr, nullptr, nullptr, NetLogSource());
[email protected]ab838892009-06-30 18:49:05373 switch (job_type_) {
374 case kMockJob:
[email protected]e772db3f2010-07-12 18:11:13375 return DoConnect(true /* successful */, false /* sync */,
Matt Menkeb57663b32019-03-01 17:17:10376 false /* cert_error */);
[email protected]ab838892009-06-30 18:49:05377 case kMockFailingJob:
[email protected]e772db3f2010-07-12 18:11:13378 return DoConnect(false /* error */, false /* sync */,
Matt Menkeb57663b32019-03-01 17:17:10379 false /* cert_error */);
[email protected]ab838892009-06-30 18:49:05380 case kMockPendingJob:
[email protected]5fc08e32009-07-15 17:09:57381 set_load_state(LOAD_STATE_CONNECTING);
[email protected]6b175382009-10-13 06:47:47382
383 // Depending on execution timings, posting a delayed task can result
384 // in the task getting executed the at the earliest possible
385 // opportunity or only after returning once from the message loop and
386 // then a second call into the message loop. In order to make behavior
387 // more deterministic, we change the default delay to 2ms. This should
388 // always require us to wait for the second call into the message loop.
389 //
390 // N.B. The correct fix for this and similar timing problems is to
391 // abstract time for the purpose of unittests. Unfortunately, we have
392 // a lot of third-party components that directly call the various
393 // time functions, so this change would be rather invasive.
skyostil4891b25b2015-06-11 11:43:45394 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
[email protected]ab838892009-06-30 18:49:05395 FROM_HERE,
kylecharf4fe5172019-02-15 18:53:49396 base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
397 weak_factory_.GetWeakPtr(), true /* successful */,
Matt Menkeb57663b32019-03-01 17:17:10398 true /* async */, false /* cert_error */),
Peter Kastinge5a38ed2021-10-02 03:06:35399 base::Milliseconds(kPendingConnectDelay));
[email protected]ab838892009-06-30 18:49:05400 return ERR_IO_PENDING;
401 case kMockPendingFailingJob:
[email protected]5fc08e32009-07-15 17:09:57402 set_load_state(LOAD_STATE_CONNECTING);
skyostil4891b25b2015-06-11 11:43:45403 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
[email protected]ab838892009-06-30 18:49:05404 FROM_HERE,
kylecharf4fe5172019-02-15 18:53:49405 base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
406 weak_factory_.GetWeakPtr(), false /* error */,
Matt Menkeb57663b32019-03-01 17:17:10407 true /* async */, false /* cert_error */),
Peter Kastinge5a38ed2021-10-02 03:06:35408 base::Milliseconds(2));
[email protected]ab838892009-06-30 18:49:05409 return ERR_IO_PENDING;
[email protected]5fc08e32009-07-15 17:09:57410 case kMockWaitingJob:
[email protected]03b7c8c2013-07-20 04:38:55411 set_load_state(LOAD_STATE_CONNECTING);
[email protected]5fc08e32009-07-15 17:09:57412 client_socket_factory_->WaitForSignal(this);
413 waiting_success_ = true;
414 return ERR_IO_PENDING;
Matt Menkeb57663b32019-03-01 17:17:10415 case kMockCertErrorJob:
[email protected]e772db3f2010-07-12 18:11:13416 return DoConnect(false /* error */, false /* sync */,
Matt Menkeb57663b32019-03-01 17:17:10417 true /* cert_error */);
418 case kMockPendingCertErrorJob:
[email protected]e772db3f2010-07-12 18:11:13419 set_load_state(LOAD_STATE_CONNECTING);
skyostil4891b25b2015-06-11 11:43:45420 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
[email protected]e772db3f2010-07-12 18:11:13421 FROM_HERE,
kylecharf4fe5172019-02-15 18:53:49422 base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
423 weak_factory_.GetWeakPtr(), false /* error */,
Matt Menkeb57663b32019-03-01 17:17:10424 true /* async */, true /* cert_error */),
Peter Kastinge5a38ed2021-10-02 03:06:35425 base::Milliseconds(2));
[email protected]e772db3f2010-07-12 18:11:13426 return ERR_IO_PENDING;
[email protected]e60e47a2010-07-14 03:37:18427 case kMockAdditionalErrorStateJob:
428 store_additional_error_state_ = true;
429 return DoConnect(false /* error */, false /* sync */,
Matt Menkeb57663b32019-03-01 17:17:10430 false /* cert_error */);
[email protected]e60e47a2010-07-14 03:37:18431 case kMockPendingAdditionalErrorStateJob:
432 set_load_state(LOAD_STATE_CONNECTING);
433 store_additional_error_state_ = true;
skyostil4891b25b2015-06-11 11:43:45434 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
[email protected]e60e47a2010-07-14 03:37:18435 FROM_HERE,
kylecharf4fe5172019-02-15 18:53:49436 base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
437 weak_factory_.GetWeakPtr(), false /* error */,
Matt Menkeb57663b32019-03-01 17:17:10438 true /* async */, false /* cert_error */),
Peter Kastinge5a38ed2021-10-02 03:06:35439 base::Milliseconds(2));
[email protected]e60e47a2010-07-14 03:37:18440 return ERR_IO_PENDING;
[email protected]0dc88b32014-03-26 20:12:28441 case kMockUnreadDataJob: {
442 int ret = DoConnect(true /* successful */, false /* sync */,
Matt Menkeb57663b32019-03-01 17:17:10443 false /* cert_error */);
[email protected]0dc88b32014-03-26 20:12:28444 static_cast<MockClientSocket*>(socket())->set_has_unread_data(true);
445 return ret;
446 }
Matt Menkeb57663b32019-03-01 17:17:10447 case kMockAuthChallengeOnceJob:
Matt Menke4b69f932019-03-04 16:20:01448 set_load_state(LOAD_STATE_CONNECTING);
Matt Menkeb57663b32019-03-01 17:17:10449 DoAdvanceAuthChallenge(1, true /* succeed_after_last_challenge */);
450 return ERR_IO_PENDING;
451 case kMockAuthChallengeTwiceJob:
Matt Menke4b69f932019-03-04 16:20:01452 set_load_state(LOAD_STATE_CONNECTING);
Matt Menkeb57663b32019-03-01 17:17:10453 DoAdvanceAuthChallenge(2, true /* succeed_after_last_challenge */);
454 return ERR_IO_PENDING;
455 case kMockAuthChallengeOnceFailingJob:
Matt Menke4b69f932019-03-04 16:20:01456 set_load_state(LOAD_STATE_CONNECTING);
Matt Menkeb57663b32019-03-01 17:17:10457 DoAdvanceAuthChallenge(1, false /* succeed_after_last_challenge */);
458 return ERR_IO_PENDING;
459 case kMockAuthChallengeTwiceFailingJob:
Matt Menke4b69f932019-03-04 16:20:01460 set_load_state(LOAD_STATE_CONNECTING);
Matt Menkeb57663b32019-03-01 17:17:10461 DoAdvanceAuthChallenge(2, false /* succeed_after_last_challenge */);
462 return ERR_IO_PENDING;
[email protected]ab838892009-06-30 18:49:05463 default:
464 NOTREACHED();
Anton Bikineev068d2912021-05-15 20:43:52465 SetSocket(std::unique_ptr<StreamSocket>(), absl::nullopt);
[email protected]ab838892009-06-30 18:49:05466 return ERR_FAILED;
467 }
468 }
469
Lily Chen02ef29a2018-11-30 16:31:43470 void ChangePriorityInternal(RequestPriority priority) override {}
471
Matt Menkeb57663b32019-03-01 17:17:10472 int DoConnect(bool succeed, bool was_async, bool cert_error) {
[email protected]e772db3f2010-07-12 18:11:13473 int result = OK;
Matt Menke141b87f22019-01-30 02:43:03474 has_established_connection_ = true;
[email protected]ab838892009-06-30 18:49:05475 if (succeed) {
Cammie Smith Barnesaa2a8b52020-12-17 19:33:19476 SetSocket(std::make_unique<MockClientSocket>(net_log().net_log()),
Anton Bikineev068d2912021-05-15 20:43:52477 absl::nullopt);
Bence Békybdbb0e72018-08-07 21:42:59478 socket()->Connect(CompletionOnceCallback());
Matt Menkeb57663b32019-03-01 17:17:10479 } else if (cert_error) {
Cammie Smith Barnesaa2a8b52020-12-17 19:33:19480 SetSocket(std::make_unique<MockClientSocket>(net_log().net_log()),
Anton Bikineev068d2912021-05-15 20:43:52481 absl::nullopt);
Matt Menkeb57663b32019-03-01 17:17:10482 result = ERR_CERT_COMMON_NAME_INVALID;
[email protected]6e713f02009-08-06 02:56:40483 } else {
[email protected]e772db3f2010-07-12 18:11:13484 result = ERR_CONNECTION_FAILED;
Anton Bikineev068d2912021-05-15 20:43:52485 SetSocket(std::unique_ptr<StreamSocket>(), absl::nullopt);
[email protected]ab838892009-06-30 18:49:05486 }
[email protected]2ab05b52009-07-01 23:57:58487
488 if (was_async)
[email protected]fd7b7c92009-08-20 19:38:30489 NotifyDelegateOfCompletion(result);
[email protected]ab838892009-06-30 18:49:05490 return result;
491 }
492
Matt Menkeb57663b32019-03-01 17:17:10493 void DoAdvanceAuthChallenge(int remaining_challenges,
494 bool succeed_after_last_challenge) {
495 base::ThreadTaskRunnerHandle::Get()->PostTask(
496 FROM_HERE,
497 base::BindOnce(&TestConnectJob::InvokeNextProxyAuthCallback,
498 weak_factory_.GetWeakPtr(), remaining_challenges,
499 succeed_after_last_challenge));
500 }
501
502 void InvokeNextProxyAuthCallback(int remaining_challenges,
503 bool succeed_after_last_challenge) {
Matt Menke4b69f932019-03-04 16:20:01504 set_load_state(LOAD_STATE_ESTABLISHING_PROXY_TUNNEL);
Matt Menkeb57663b32019-03-01 17:17:10505 if (remaining_challenges == 0) {
506 DoConnect(succeed_after_last_challenge, true /* was_async */,
507 false /* cert_error */);
508 return;
509 }
510
511 // Integration tests make sure HttpResponseInfo and HttpAuthController work.
512 // The auth tests here are just focused on ConnectJob bookkeeping.
513 HttpResponseInfo info;
514 NotifyDelegateOfProxyAuth(
515 info, nullptr /* http_auth_controller */,
516 base::BindOnce(&TestConnectJob::DoAdvanceAuthChallenge,
517 weak_factory_.GetWeakPtr(), remaining_challenges - 1,
518 succeed_after_last_challenge));
519 }
520
[email protected]5fc08e32009-07-15 17:09:57521 bool waiting_success_;
[email protected]ab838892009-06-30 18:49:05522 const JobType job_type_;
Keishi Hattori0e45c022021-11-27 09:25:52523 const raw_ptr<MockClientSocketFactory> client_socket_factory_;
[email protected]46451352009-09-01 14:54:21524 LoadState load_state_;
Matt Menke141b87f22019-01-30 02:43:03525 bool has_established_connection_;
[email protected]e60e47a2010-07-14 03:37:18526 bool store_additional_error_state_;
[email protected]ab838892009-06-30 18:49:05527
Jeremy Romand54000b22019-07-08 18:40:16528 base::WeakPtrFactory<TestConnectJob> weak_factory_{this};
[email protected]ab838892009-06-30 18:49:05529};
530
Eric Ortha9b8be02021-06-29 23:09:08531class TestConnectJobFactory : public ConnectJobFactory {
[email protected]ab838892009-06-30 18:49:05532 public:
Eric Ortha9b8be02021-06-29 23:09:08533 explicit TestConnectJobFactory(MockClientSocketFactory* client_socket_factory)
534 : client_socket_factory_(client_socket_factory) {}
[email protected]ab838892009-06-30 18:49:05535
Peter Boström293b1342021-09-22 17:31:43536 TestConnectJobFactory(const TestConnectJobFactory&) = delete;
537 TestConnectJobFactory& operator=(const TestConnectJobFactory&) = delete;
538
Chris Watkins7a41d3552017-12-01 02:13:27539 ~TestConnectJobFactory() override = default;
[email protected]ab838892009-06-30 18:49:05540
541 void set_job_type(TestConnectJob::JobType job_type) { job_type_ = job_type; }
542
[email protected]51fdc7c2012-04-10 19:19:48543 void set_job_types(std::list<TestConnectJob::JobType>* job_types) {
544 job_types_ = job_types;
545 CHECK(!job_types_->empty());
546 }
547
[email protected]974ebd62009-08-03 23:14:34548 void set_timeout_duration(base::TimeDelta timeout_duration) {
549 timeout_duration_ = timeout_duration;
550 }
551
[email protected]3f55aa12011-12-07 02:03:33552 // ConnectJobFactory implementation.
[email protected]83039bb2011-12-09 18:43:55553
Eric Ortha9b8be02021-06-29 23:09:08554 std::unique_ptr<ConnectJob> CreateConnectJob(
Eric Orthc98a3e62021-07-02 17:46:37555 Endpoint endpoint,
Eric Ortha9b8be02021-06-29 23:09:08556 const ProxyServer& proxy_server,
Anton Bikineev068d2912021-05-15 20:43:52557 const absl::optional<NetworkTrafficAnnotationTag>& proxy_annotation_tag,
Eric Ortha9b8be02021-06-29 23:09:08558 const SSLConfig* ssl_config_for_origin,
559 const SSLConfig* ssl_config_for_proxy,
560 bool force_tunnel,
561 PrivacyMode privacy_mode,
562 const OnHostResolutionCallback& resolution_callback,
Matt Menke16f5c2e52019-03-25 21:50:40563 RequestPriority request_priority,
564 SocketTag socket_tag,
Eric Ortha9b8be02021-06-29 23:09:08565 const NetworkIsolationKey& network_isolation_key,
566 SecureDnsPolicy secure_dns_policy,
567 const CommonConnectJobParams* common_connect_job_params,
mostynbba063d6032014-10-09 11:01:13568 ConnectJob::Delegate* delegate) const override {
[email protected]51fdc7c2012-04-10 19:19:48569 EXPECT_TRUE(!job_types_ || !job_types_->empty());
570 TestConnectJob::JobType job_type = job_type_;
571 if (job_types_ && !job_types_->empty()) {
572 job_type = job_types_->front();
573 job_types_->pop_front();
574 }
Matt Menkea6f99ad2019-03-08 02:26:43575 return std::make_unique<TestConnectJob>(
Matt Menke16f5c2e52019-03-25 21:50:40576 job_type, request_priority, socket_tag, timeout_duration_,
Eric Ortha9b8be02021-06-29 23:09:08577 common_connect_job_params, delegate, client_socket_factory_);
[email protected]ab838892009-06-30 18:49:05578 }
579
580 private:
Eric Ortha9b8be02021-06-29 23:09:08581 TestConnectJob::JobType job_type_ = TestConnectJob::kMockJob;
Keishi Hattori0e45c022021-11-27 09:25:52582 raw_ptr<std::list<TestConnectJob::JobType>> job_types_ = nullptr;
[email protected]974ebd62009-08-03 23:14:34583 base::TimeDelta timeout_duration_;
Keishi Hattori0e45c022021-11-27 09:25:52584 const raw_ptr<MockClientSocketFactory> client_socket_factory_;
[email protected]ab838892009-06-30 18:49:05585};
586
[email protected]a937a06d2009-08-19 21:19:24587} // namespace
588
[email protected]a937a06d2009-08-19 21:19:24589namespace {
590
[email protected]5fc08e32009-07-15 17:09:57591void MockClientSocketFactory::SignalJobs() {
jdoerrie22a91d8b92018-10-05 08:43:26592 for (auto it = waiting_jobs_.begin(); it != waiting_jobs_.end(); ++it) {
[email protected]5fc08e32009-07-15 17:09:57593 (*it)->Signal();
594 }
595 waiting_jobs_.clear();
596}
597
[email protected]03b7c8c2013-07-20 04:38:55598void MockClientSocketFactory::SignalJob(size_t job) {
599 ASSERT_LT(job, waiting_jobs_.size());
600 waiting_jobs_[job]->Signal();
601 waiting_jobs_.erase(waiting_jobs_.begin() + job);
602}
603
604void MockClientSocketFactory::SetJobLoadState(size_t job,
605 LoadState load_state) {
606 ASSERT_LT(job, waiting_jobs_.size());
607 waiting_jobs_[job]->set_load_state(load_state);
608}
609
Matt Menke141b87f22019-01-30 02:43:03610void MockClientSocketFactory::SetJobHasEstablishedConnection(size_t job) {
611 ASSERT_LT(job, waiting_jobs_.size());
612 waiting_jobs_[job]->set_has_established_connection();
613}
614
Gabriel Charette694c3c332019-08-19 14:53:05615class ClientSocketPoolBaseTest : public TestWithTaskEnvironment {
[email protected]f6d1d6eb2009-06-24 20:16:09616 protected:
Alex Clarke0def2092018-12-10 12:01:45617 ClientSocketPoolBaseTest()
Gabriel Charette694c3c332019-08-19 14:53:05618 : TestWithTaskEnvironment(
619 base::test::TaskEnvironment::TimeSource::MOCK_TIME),
Matt Menke870e19ab2019-04-23 16:23:03620 params_(ClientSocketPool::SocketParams::CreateForHttpForTesting()) {
[email protected]636b8252011-04-08 19:56:54621 connect_backup_jobs_enabled_ =
Matt Menke16f5c2e52019-03-25 21:50:40622 TransportClientSocketPool::connect_backup_jobs_enabled();
623 TransportClientSocketPool::set_connect_backup_jobs_enabled(true);
[email protected]636b8252011-04-08 19:56:54624 }
[email protected]2431756e2010-09-29 20:26:13625
dcheng67be2b1f2014-10-27 21:47:29626 ~ClientSocketPoolBaseTest() override {
Matt Menke16f5c2e52019-03-25 21:50:40627 TransportClientSocketPool::set_connect_backup_jobs_enabled(
[email protected]636b8252011-04-08 19:56:54628 connect_backup_jobs_enabled_);
629 }
[email protected]c9d6a1d2009-07-14 16:15:20630
Matt Menke9fa17d52019-03-25 19:12:26631 void CreatePool(int max_sockets,
632 int max_sockets_per_group,
633 bool enable_backup_connect_jobs = false) {
Tarun Bansala7635092019-02-20 10:00:59634 CreatePoolWithIdleTimeouts(max_sockets, max_sockets_per_group,
635 kUnusedIdleSocketTimeout,
Matt Menke9fa17d52019-03-25 19:12:26636 ClientSocketPool::used_idle_socket_timeout(),
637 enable_backup_connect_jobs);
[email protected]9bf28db2009-08-29 01:35:16638 }
639
David Benjaminbac8dff2019-08-07 01:30:41640 void CreatePoolWithIdleTimeouts(
641 int max_sockets,
642 int max_sockets_per_group,
643 base::TimeDelta unused_idle_socket_timeout,
644 base::TimeDelta used_idle_socket_timeout,
645 bool enable_backup_connect_jobs = false,
646 ProxyServer proxy_server = ProxyServer::Direct()) {
[email protected]c9d6a1d2009-07-14 16:15:20647 DCHECK(!pool_.get());
Matt Menke9fa17d52019-03-25 19:12:26648 std::unique_ptr<TestConnectJobFactory> connect_job_factory =
Eric Ortha9b8be02021-06-29 23:09:08649 std::make_unique<TestConnectJobFactory>(&client_socket_factory_);
Matt Menke9fa17d52019-03-25 19:12:26650 connect_job_factory_ = connect_job_factory.get();
651 pool_ = TransportClientSocketPool::CreateForTesting(
652 max_sockets, max_sockets_per_group, unused_idle_socket_timeout,
Eric Ortha9b8be02021-06-29 23:09:08653 used_idle_socket_timeout, proxy_server, /*is_for_websockets=*/false,
654 &common_connect_job_params_, std::move(connect_job_factory),
Matt Menke9fa17d52019-03-25 19:12:26655 nullptr /* ssl_config_service */, enable_backup_connect_jobs);
[email protected]c9d6a1d2009-07-14 16:15:20656 }
[email protected]f6d1d6eb2009-06-24 20:16:09657
mmenked3641e12016-01-28 16:06:15658 int StartRequestWithIgnoreLimits(
Matt Menkec6b3edf72019-03-19 17:00:39659 const ClientSocketPool::GroupId& group_id,
[email protected]b021ece62013-06-11 11:06:33660 RequestPriority priority,
mmenked3641e12016-01-28 16:06:15661 ClientSocketPool::RespectLimits respect_limits) {
Matt Menkec6b3edf72019-03-19 17:00:39662 return test_base_.StartRequestUsingPool(pool_.get(), group_id, priority,
mmenked3641e12016-01-28 16:06:15663 respect_limits, params_);
[email protected]b021ece62013-06-11 11:06:33664 }
665
Matt Menkec6b3edf72019-03-19 17:00:39666 int StartRequest(const ClientSocketPool::GroupId& group_id,
667 RequestPriority priority) {
mmenked3641e12016-01-28 16:06:15668 return StartRequestWithIgnoreLimits(
Matt Menkec6b3edf72019-03-19 17:00:39669 group_id, priority, ClientSocketPool::RespectLimits::ENABLED);
[email protected]f6d1d6eb2009-06-24 20:16:09670 }
671
[email protected]2431756e2010-09-29 20:26:13672 int GetOrderOfRequest(size_t index) const {
673 return test_base_.GetOrderOfRequest(index);
[email protected]f6d1d6eb2009-06-24 20:16:09674 }
675
[email protected]2431756e2010-09-29 20:26:13676 bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
677 return test_base_.ReleaseOneConnection(keep_alive);
678 }
679
680 void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) {
681 test_base_.ReleaseAllConnections(keep_alive);
682 }
683
Matt Menke433de6d2020-03-04 00:24:11684 // Expects a single NetLogEventType::SOCKET_POOL_CLOSING_SOCKET in |net_log_|.
685 // It should be logged for the provided source and have the indicated reason.
686 void ExpectSocketClosedWithReason(NetLogSource expected_source,
687 const char* expected_reason) {
Matt Reichhoff0049a0b72021-10-20 20:44:26688 auto entries = net_log_observer_.GetEntriesForSourceWithType(
Matt Menke433de6d2020-03-04 00:24:11689 expected_source, NetLogEventType::SOCKET_POOL_CLOSING_SOCKET,
690 NetLogEventPhase::NONE);
691 ASSERT_EQ(1u, entries.size());
692 ASSERT_TRUE(entries[0].HasParams());
693 ASSERT_TRUE(entries[0].params.is_dict());
694 const std::string* reason = entries[0].params.FindStringKey("reason");
695 ASSERT_TRUE(reason);
696 EXPECT_EQ(expected_reason, *reason);
697 }
698
[email protected]2431756e2010-09-29 20:26:13699 TestSocketRequest* request(int i) { return test_base_.request(i); }
700 size_t requests_size() const { return test_base_.requests_size(); }
danakj655b66c2016-04-16 00:51:38701 std::vector<std::unique_ptr<TestSocketRequest>>* requests() {
olli.raula9d66b7d2015-11-23 08:30:42702 return test_base_.requests();
703 }
rdsmith29dbad12017-02-17 02:22:18704 // Only counts the requests that get sockets asynchronously;
705 // synchronous completions are not registered by this count.
[email protected]2431756e2010-09-29 20:26:13706 size_t completion_count() const { return test_base_.completion_count(); }
707
Eric Ortha9b8be02021-06-29 23:09:08708 const CommonConnectJobParams common_connect_job_params_{
709 nullptr /* client_socket_factory */,
710 nullptr /* host_resolver */,
711 nullptr /* http_auth_cache */,
712 nullptr /* http_auth_handler_factory */,
713 nullptr /* spdy_session_pool */,
714 nullptr /* quic_supported_versions */,
715 nullptr /* quic_stream_factory */,
716 nullptr /* proxy_delegate */,
717 nullptr /* http_user_agent_settings */,
718 nullptr /* ssl_client_context */,
719 nullptr /* socket_performance_watcher_factory */,
720 nullptr /* network_quality_estimator */,
Matt Reichhoff36a1fd62021-10-12 22:52:20721 NetLog::Get(),
Eric Ortha9b8be02021-06-29 23:09:08722 nullptr /* websocket_endpoint_lock_manager */};
[email protected]636b8252011-04-08 19:56:54723 bool connect_backup_jobs_enabled_;
[email protected]f6d1d6eb2009-06-24 20:16:09724 MockClientSocketFactory client_socket_factory_;
Keishi Hattori0e45c022021-11-27 09:25:52725 raw_ptr<TestConnectJobFactory> connect_job_factory_;
Matt Reichhoff0049a0b72021-10-20 20:44:26726 RecordingNetLogObserver net_log_observer_;
Matt Menke9fa17d52019-03-25 19:12:26727 // These parameters are never actually used to create a TransportConnectJob.
Matt Menke84d11e562019-03-27 00:11:19728 scoped_refptr<ClientSocketPool::SocketParams> params_;
Matt Menke9fa17d52019-03-25 19:12:26729 std::unique_ptr<TransportClientSocketPool> pool_;
[email protected]2431756e2010-09-29 20:26:13730 ClientSocketPoolTest test_base_;
[email protected]f6d1d6eb2009-06-24 20:16:09731};
732
[email protected]5fc08e32009-07-15 17:09:57733TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
[email protected]211d21722009-07-22 15:48:53734 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]c9d6a1d2009-07-14 16:15:20735
[email protected]6ecf2b92011-12-15 01:14:52736 TestCompletionCallback callback;
[email protected]a512f5982009-08-18 16:01:06737 ClientSocketHandle handle;
Matt Reichhoff0049a0b72021-10-20 20:44:26738 NetLogWithSource net_log_with_source =
739 NetLogWithSource::Make(NetLogSourceType::NONE);
740
[email protected]034df0f32013-01-07 23:17:48741 TestLoadTimingInfoNotConnected(handle);
[email protected]9e743cd2010-03-16 07:03:53742
Matt Menkef09e64c2019-04-23 22:16:28743 EXPECT_EQ(OK, handle.Init(
Anton Bikineev068d2912021-05-15 20:43:52744 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:28745 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
746 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
Matt Reichhoff0049a0b72021-10-20 20:44:26747 pool_.get(), net_log_with_source));
[email protected]f6d1d6eb2009-06-24 20:16:09748 EXPECT_TRUE(handle.is_initialized());
749 EXPECT_TRUE(handle.socket());
[email protected]034df0f32013-01-07 23:17:48750 TestLoadTimingInfoConnectedNotReused(handle);
751
[email protected]f6d1d6eb2009-06-24 20:16:09752 handle.Reset();
[email protected]034df0f32013-01-07 23:17:48753 TestLoadTimingInfoNotConnected(handle);
[email protected]fd7b7c92009-08-20 19:38:30754
Matt Reichhoff0049a0b72021-10-20 20:44:26755 auto entries =
756 net_log_observer_.GetEntriesForSource(net_log_with_source.source());
[email protected]b2fcd0e2010-12-01 15:19:40757
Matt Menke9fa17d52019-03-25 19:12:26758 EXPECT_EQ(5u, entries.size());
[email protected]9e743cd2010-03-16 07:03:53759 EXPECT_TRUE(LogContainsEvent(
Matt Menke9fa17d52019-03-25 19:12:26760 entries, 0, NetLogEventType::TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKET,
mikecirone8b85c432016-09-08 19:11:00761 NetLogEventPhase::NONE));
Matt Menke9fa17d52019-03-25 19:12:26762 EXPECT_TRUE(LogContainsBeginEvent(entries, 1, NetLogEventType::SOCKET_POOL));
763 EXPECT_TRUE(LogContainsEvent(
764 entries, 2, NetLogEventType::SOCKET_POOL_BOUND_TO_CONNECT_JOB,
765 NetLogEventPhase::NONE));
766 EXPECT_TRUE(LogContainsEvent(entries, 3,
mikecirone8b85c432016-09-08 19:11:00767 NetLogEventType::SOCKET_POOL_BOUND_TO_SOCKET,
768 NetLogEventPhase::NONE));
Matt Menke9fa17d52019-03-25 19:12:26769 EXPECT_TRUE(LogContainsEndEvent(entries, 4, NetLogEventType::SOCKET_POOL));
[email protected]f6d1d6eb2009-06-24 20:16:09770}
771
[email protected]ab838892009-06-30 18:49:05772TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
[email protected]211d21722009-07-22 15:48:53773 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]c9d6a1d2009-07-14 16:15:20774
[email protected]ab838892009-06-30 18:49:05775 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
Matt Reichhoff0049a0b72021-10-20 20:44:26776 NetLogWithSource net_log_with_source =
777 NetLogWithSource::Make(NetLogSourceType::NONE);
[email protected]9e743cd2010-03-16 07:03:53778
[email protected]2431756e2010-09-29 20:26:13779 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:52780 TestCompletionCallback callback;
[email protected]e60e47a2010-07-14 03:37:18781 // Set the additional error state members to ensure that they get cleared.
[email protected]2431756e2010-09-29 20:26:13782 handle.set_is_ssl_error(true);
Matt Menke39b7c5a2019-04-10 19:47:51783 handle.set_ssl_cert_request_info(base::MakeRefCounted<SSLCertRequestInfo>());
Matt Menke28ac03e2019-02-25 22:25:50784 EXPECT_EQ(
785 ERR_CONNECTION_FAILED,
Anton Bikineev068d2912021-05-15 20:43:52786 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:28787 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
788 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
Matt Reichhoff0049a0b72021-10-20 20:44:26789 pool_.get(), net_log_with_source));
[email protected]2431756e2010-09-29 20:26:13790 EXPECT_FALSE(handle.socket());
791 EXPECT_FALSE(handle.is_ssl_error());
Matt Menke39b7c5a2019-04-10 19:47:51792 EXPECT_FALSE(handle.ssl_cert_request_info());
[email protected]034df0f32013-01-07 23:17:48793 TestLoadTimingInfoNotConnected(handle);
[email protected]fd7b7c92009-08-20 19:38:30794
Matt Reichhoff0049a0b72021-10-20 20:44:26795 auto entries =
796 net_log_observer_.GetEntriesForSource(net_log_with_source.source());
[email protected]b2fcd0e2010-12-01 15:19:40797
Matt Menke9fa17d52019-03-25 19:12:26798 EXPECT_EQ(4u, entries.size());
[email protected]06650c52010-06-03 00:49:17799 EXPECT_TRUE(LogContainsEvent(
Matt Menke9fa17d52019-03-25 19:12:26800 entries, 0, NetLogEventType::TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKET,
mikecirone8b85c432016-09-08 19:11:00801 NetLogEventPhase::NONE));
Matt Menke9fa17d52019-03-25 19:12:26802 EXPECT_TRUE(LogContainsBeginEvent(entries, 1, NetLogEventType::SOCKET_POOL));
803 EXPECT_TRUE(LogContainsEvent(
804 entries, 2, NetLogEventType::SOCKET_POOL_BOUND_TO_CONNECT_JOB,
805 NetLogEventPhase::NONE));
806 EXPECT_TRUE(LogContainsEndEvent(entries, 3, NetLogEventType::SOCKET_POOL));
[email protected]f6d1d6eb2009-06-24 20:16:09807}
808
Matt Menke433de6d2020-03-04 00:24:11809// Test releasing an open socket into the socket pool, telling the socket pool
810// to close the socket.
811TEST_F(ClientSocketPoolBaseTest, ReleaseAndCloseConnection) {
812 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
813
814 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(OK));
815 ASSERT_TRUE(request(0)->handle()->socket());
816 net::NetLogSource source = request(0)->handle()->socket()->NetLog().source();
817 ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE);
818
819 EXPECT_EQ(0, pool_->IdleSocketCount());
820 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
821
822 ExpectSocketClosedWithReason(
823 source, TransportClientSocketPool::kClosedConnectionReturnedToPool);
824}
825
826TEST_F(ClientSocketPoolBaseTest, SocketWithUnreadDataReturnedToPool) {
827 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
828 connect_job_factory_->set_job_type(TestConnectJob::kMockUnreadDataJob);
829
830 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(OK));
831 ASSERT_TRUE(request(0)->handle()->socket());
832 net::NetLogSource source = request(0)->handle()->socket()->NetLog().source();
833 EXPECT_TRUE(request(0)->handle()->socket()->IsConnected());
834 EXPECT_FALSE(request(0)->handle()->socket()->IsConnectedAndIdle());
835 ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE);
836
837 EXPECT_EQ(0, pool_->IdleSocketCount());
838 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
839
840 ExpectSocketClosedWithReason(
841 source, TransportClientSocketPool::kDataReceivedUnexpectedly);
842}
843
Matt Menkef6edce752019-03-19 17:21:56844// Make sure different groups do not share sockets.
845TEST_F(ClientSocketPoolBaseTest, GroupSeparation) {
Matt Menke166443c2019-05-24 18:45:59846 base::test::ScopedFeatureList feature_list;
847 feature_list.InitAndEnableFeature(
848 features::kPartitionConnectionsByNetworkIsolationKey);
849
Matt Menkef6edce752019-03-19 17:21:56850 CreatePool(1000 /* max_sockets */, 2 /* max_sockets_per_group */);
851
852 const HostPortPair kHostPortPairs[] = {
853 {"a", 80},
854 {"a", 443},
855 {"b", 80},
856 };
857
Eric Ortha2e7773212021-06-22 21:49:55858 const char* const kSchemes[] = {
859 url::kHttpScheme,
860 url::kHttpsScheme,
Matt Menkef6edce752019-03-19 17:21:56861 };
862
Matt Menkebdf777802019-04-22 19:38:59863 const PrivacyMode kPrivacyModes[] = {PrivacyMode::PRIVACY_MODE_DISABLED,
864 PrivacyMode::PRIVACY_MODE_ENABLED};
Matt Menkef6edce752019-03-19 17:21:56865
Matt Menke4807a9a2020-11-21 00:14:41866 const SchemefulSite kSiteA(GURL("http://a.test/"));
867 const SchemefulSite kSiteB(GURL("http://b.test/"));
Matt Menke166443c2019-05-24 18:45:59868 const NetworkIsolationKey kNetworkIsolationKeys[] = {
Matt Menke4807a9a2020-11-21 00:14:41869 NetworkIsolationKey(kSiteA, kSiteA),
870 NetworkIsolationKey(kSiteB, kSiteB),
Matt Menke166443c2019-05-24 18:45:59871 };
872
Ben Schwartz3ff4dc1e62021-04-27 21:15:23873 const SecureDnsPolicy kSecureDnsPolicys[] = {SecureDnsPolicy::kAllow,
874 SecureDnsPolicy::kDisable};
dalyk5f48a132019-10-14 15:20:19875
Matt Menkef6edce752019-03-19 17:21:56876 int total_idle_sockets = 0;
877
878 // Walk through each GroupId, making sure that requesting a socket for one
879 // group does not return a previously connected socket for another group.
880 for (const auto& host_port_pair : kHostPortPairs) {
881 SCOPED_TRACE(host_port_pair.ToString());
Eric Ortha2e7773212021-06-22 21:49:55882 for (const char* scheme : kSchemes) {
883 SCOPED_TRACE(scheme);
Matt Menkef6edce752019-03-19 17:21:56884 for (const auto& privacy_mode : kPrivacyModes) {
885 SCOPED_TRACE(privacy_mode);
Matt Menke166443c2019-05-24 18:45:59886 for (const auto& network_isolation_key : kNetworkIsolationKeys) {
887 SCOPED_TRACE(network_isolation_key.ToString());
Ben Schwartz3ff4dc1e62021-04-27 21:15:23888 for (const auto& secure_dns_policy : kSecureDnsPolicys) {
889 SCOPED_TRACE(static_cast<int>(secure_dns_policy));
Matt Menkef6edce752019-03-19 17:21:56890
dalyk5f48a132019-10-14 15:20:19891 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
Matt Menkef6edce752019-03-19 17:21:56892
dalyk5f48a132019-10-14 15:20:19893 ClientSocketPool::GroupId group_id(
Eric Ortha2e7773212021-06-22 21:49:55894 url::SchemeHostPort(scheme, host_port_pair.host(),
895 host_port_pair.port()),
896 privacy_mode, network_isolation_key, secure_dns_policy);
Matt Menkef6edce752019-03-19 17:21:56897
dalyk5f48a132019-10-14 15:20:19898 EXPECT_FALSE(pool_->HasGroupForTesting(group_id));
Matt Menkef6edce752019-03-19 17:21:56899
dalyk5f48a132019-10-14 15:20:19900 TestCompletionCallback callback;
901 ClientSocketHandle handle;
Matt Menkef6edce752019-03-19 17:21:56902
dalyk5f48a132019-10-14 15:20:19903 // Since the group is empty, requesting a socket should not complete
904 // synchronously.
Anton Bikineev068d2912021-05-15 20:43:52905 EXPECT_THAT(handle.Init(group_id, params_, absl::nullopt,
dalyk5f48a132019-10-14 15:20:19906 DEFAULT_PRIORITY, SocketTag(),
907 ClientSocketPool::RespectLimits::ENABLED,
908 callback.callback(),
909 ClientSocketPool::ProxyAuthCallback(),
910 pool_.get(), NetLogWithSource()),
911 IsError(ERR_IO_PENDING));
912 EXPECT_TRUE(pool_->HasGroupForTesting(group_id));
913 EXPECT_EQ(total_idle_sockets, pool_->IdleSocketCount());
Matt Menkef6edce752019-03-19 17:21:56914
dalyk5f48a132019-10-14 15:20:19915 EXPECT_THAT(callback.WaitForResult(), IsOk());
916 EXPECT_TRUE(handle.socket());
917 EXPECT_TRUE(pool_->HasGroupForTesting(group_id));
918 EXPECT_EQ(total_idle_sockets, pool_->IdleSocketCount());
Matt Menkef6edce752019-03-19 17:21:56919
dalyk5f48a132019-10-14 15:20:19920 // Return socket to pool.
921 handle.Reset();
922 EXPECT_EQ(total_idle_sockets + 1, pool_->IdleSocketCount());
Matt Menkef6edce752019-03-19 17:21:56923
dalyk5f48a132019-10-14 15:20:19924 // Requesting a socket again should return the same socket as
925 // before, so should complete synchronously.
Anton Bikineev068d2912021-05-15 20:43:52926 EXPECT_THAT(handle.Init(group_id, params_, absl::nullopt,
dalyk5f48a132019-10-14 15:20:19927 DEFAULT_PRIORITY, SocketTag(),
928 ClientSocketPool::RespectLimits::ENABLED,
929 callback.callback(),
930 ClientSocketPool::ProxyAuthCallback(),
931 pool_.get(), NetLogWithSource()),
932 IsOk());
933 EXPECT_TRUE(handle.socket());
934 EXPECT_EQ(total_idle_sockets, pool_->IdleSocketCount());
Matt Menkef6edce752019-03-19 17:21:56935
dalyk5f48a132019-10-14 15:20:19936 // Return socket to pool again.
937 handle.Reset();
938 EXPECT_EQ(total_idle_sockets + 1, pool_->IdleSocketCount());
Matt Menkef6edce752019-03-19 17:21:56939
dalyk5f48a132019-10-14 15:20:19940 ++total_idle_sockets;
941 }
Matt Menke166443c2019-05-24 18:45:59942 }
Matt Menkef6edce752019-03-19 17:21:56943 }
944 }
945 }
946}
947
[email protected]211d21722009-07-22 15:48:53948TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
949 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
950
[email protected]9e743cd2010-03-16 07:03:53951 // TODO(eroman): Check that the NetLog contains this event.
[email protected]fd7b7c92009-08-20 19:38:30952
Matt Menkec6b3edf72019-03-19 17:00:39953 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
954 EXPECT_THAT(StartRequest(TestGroupId("b"), DEFAULT_PRIORITY), IsOk());
955 EXPECT_THAT(StartRequest(TestGroupId("c"), DEFAULT_PRIORITY), IsOk());
956 EXPECT_THAT(StartRequest(TestGroupId("d"), DEFAULT_PRIORITY), IsOk());
[email protected]211d21722009-07-22 15:48:53957
[email protected]2431756e2010-09-29 20:26:13958 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]211d21722009-07-22 15:48:53959 client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:13960 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
[email protected]211d21722009-07-22 15:48:53961
Matt Menkec6b3edf72019-03-19 17:00:39962 EXPECT_THAT(StartRequest(TestGroupId("e"), DEFAULT_PRIORITY),
963 IsError(ERR_IO_PENDING));
964 EXPECT_THAT(StartRequest(TestGroupId("f"), DEFAULT_PRIORITY),
965 IsError(ERR_IO_PENDING));
966 EXPECT_THAT(StartRequest(TestGroupId("g"), DEFAULT_PRIORITY),
967 IsError(ERR_IO_PENDING));
[email protected]211d21722009-07-22 15:48:53968
[email protected]2431756e2010-09-29 20:26:13969 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
[email protected]211d21722009-07-22 15:48:53970
[email protected]2431756e2010-09-29 20:26:13971 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]211d21722009-07-22 15:48:53972 client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:13973 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
[email protected]211d21722009-07-22 15:48:53974
975 EXPECT_EQ(1, GetOrderOfRequest(1));
976 EXPECT_EQ(2, GetOrderOfRequest(2));
977 EXPECT_EQ(3, GetOrderOfRequest(3));
978 EXPECT_EQ(4, GetOrderOfRequest(4));
979 EXPECT_EQ(5, GetOrderOfRequest(5));
980 EXPECT_EQ(6, GetOrderOfRequest(6));
981 EXPECT_EQ(7, GetOrderOfRequest(7));
[email protected]75439d3b2009-07-23 22:11:17982
983 // Make sure we test order of all requests made.
[email protected]2431756e2010-09-29 20:26:13984 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
[email protected]211d21722009-07-22 15:48:53985}
986
987TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) {
988 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
989
[email protected]9e743cd2010-03-16 07:03:53990 // TODO(eroman): Check that the NetLog contains this event.
[email protected]fd7b7c92009-08-20 19:38:30991
[email protected]211d21722009-07-22 15:48:53992 // Reach all limits: max total sockets, and max sockets per group.
Matt Menkec6b3edf72019-03-19 17:00:39993 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
994 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
995 EXPECT_THAT(StartRequest(TestGroupId("b"), DEFAULT_PRIORITY), IsOk());
996 EXPECT_THAT(StartRequest(TestGroupId("b"), DEFAULT_PRIORITY), IsOk());
[email protected]211d21722009-07-22 15:48:53997
[email protected]2431756e2010-09-29 20:26:13998 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]211d21722009-07-22 15:48:53999 client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:131000 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
[email protected]211d21722009-07-22 15:48:531001
1002 // Now create a new group and verify that we don't starve it.
Matt Menkec6b3edf72019-03-19 17:00:391003 EXPECT_THAT(StartRequest(TestGroupId("c"), DEFAULT_PRIORITY),
1004 IsError(ERR_IO_PENDING));
[email protected]211d21722009-07-22 15:48:531005
[email protected]2431756e2010-09-29 20:26:131006 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
[email protected]211d21722009-07-22 15:48:531007
[email protected]2431756e2010-09-29 20:26:131008 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]211d21722009-07-22 15:48:531009 client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:131010 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
[email protected]211d21722009-07-22 15:48:531011
1012 EXPECT_EQ(1, GetOrderOfRequest(1));
1013 EXPECT_EQ(2, GetOrderOfRequest(2));
1014 EXPECT_EQ(3, GetOrderOfRequest(3));
1015 EXPECT_EQ(4, GetOrderOfRequest(4));
1016 EXPECT_EQ(5, GetOrderOfRequest(5));
[email protected]75439d3b2009-07-23 22:11:171017
1018 // Make sure we test order of all requests made.
[email protected]2431756e2010-09-29 20:26:131019 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6));
[email protected]211d21722009-07-22 15:48:531020}
1021
1022TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsPriority) {
1023 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1024
Matt Menkec6b3edf72019-03-19 17:00:391025 EXPECT_THAT(StartRequest(TestGroupId("b"), LOWEST), IsOk());
1026 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsOk());
1027 EXPECT_THAT(StartRequest(TestGroupId("b"), HIGHEST), IsOk());
1028 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsOk());
[email protected]211d21722009-07-22 15:48:531029
[email protected]2431756e2010-09-29 20:26:131030 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]211d21722009-07-22 15:48:531031 client_socket_factory_.allocation_count());
1032
Matt Menkec6b3edf72019-03-19 17:00:391033 EXPECT_THAT(StartRequest(TestGroupId("c"), LOWEST), IsError(ERR_IO_PENDING));
1034 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
1035 EXPECT_THAT(StartRequest(TestGroupId("b"), HIGHEST), IsError(ERR_IO_PENDING));
[email protected]211d21722009-07-22 15:48:531036
[email protected]2431756e2010-09-29 20:26:131037 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
[email protected]211d21722009-07-22 15:48:531038
[email protected]2431756e2010-09-29 20:26:131039 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
[email protected]211d21722009-07-22 15:48:531040
1041 // First 4 requests don't have to wait, and finish in order.
1042 EXPECT_EQ(1, GetOrderOfRequest(1));
1043 EXPECT_EQ(2, GetOrderOfRequest(2));
1044 EXPECT_EQ(3, GetOrderOfRequest(3));
1045 EXPECT_EQ(4, GetOrderOfRequest(4));
1046
Matt Menkec6b3edf72019-03-19 17:00:391047 // Request ("b", HIGHEST) has the highest priority, then (TestGroupId("a"),
1048 // MEDIUM), and then ("c", LOWEST).
[email protected]211d21722009-07-22 15:48:531049 EXPECT_EQ(7, GetOrderOfRequest(5));
1050 EXPECT_EQ(6, GetOrderOfRequest(6));
1051 EXPECT_EQ(5, GetOrderOfRequest(7));
[email protected]75439d3b2009-07-23 22:11:171052
1053 // Make sure we test order of all requests made.
[email protected]2431756e2010-09-29 20:26:131054 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9));
[email protected]211d21722009-07-22 15:48:531055}
1056
rdsmith29dbad12017-02-17 02:22:181057// Test reprioritizing a request before completion doesn't interfere with
1058// its completion.
1059TEST_F(ClientSocketPoolBaseTest, ReprioritizeOne) {
1060 CreatePool(kDefaultMaxSockets, 1);
1061
Matt Menkec6b3edf72019-03-19 17:00:391062 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(OK));
1063 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
rdsmith29dbad12017-02-17 02:22:181064 EXPECT_TRUE(request(0)->handle()->socket());
1065 EXPECT_FALSE(request(1)->handle()->socket());
1066
Lily Chenecebf932018-11-02 17:15:431067 request(1)->handle()->SetPriority(HIGHEST);
rdsmith29dbad12017-02-17 02:22:181068
1069 ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE);
1070
1071 EXPECT_TRUE(request(1)->handle()->socket());
1072}
1073
1074// Reprioritize a request up past another one and make sure that changes the
1075// completion order.
1076TEST_F(ClientSocketPoolBaseTest, ReprioritizeUpReorder) {
1077 CreatePool(kDefaultMaxSockets, 1);
1078
Matt Menkec6b3edf72019-03-19 17:00:391079 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(OK));
1080 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
1081 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(ERR_IO_PENDING));
rdsmith29dbad12017-02-17 02:22:181082 EXPECT_TRUE(request(0)->handle()->socket());
1083 EXPECT_FALSE(request(1)->handle()->socket());
1084 EXPECT_FALSE(request(2)->handle()->socket());
1085
1086 request(2)->handle()->SetPriority(HIGHEST);
1087
1088 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1089
1090 EXPECT_EQ(1, GetOrderOfRequest(1));
1091 EXPECT_EQ(3, GetOrderOfRequest(2));
1092 EXPECT_EQ(2, GetOrderOfRequest(3));
1093}
1094
1095// Reprioritize a request without changing relative priorities and check
1096// that the order doesn't change.
1097TEST_F(ClientSocketPoolBaseTest, ReprioritizeUpNoReorder) {
1098 CreatePool(kDefaultMaxSockets, 1);
1099
Matt Menkec6b3edf72019-03-19 17:00:391100 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(OK));
1101 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
1102 EXPECT_THAT(StartRequest(TestGroupId("a"), LOW), IsError(ERR_IO_PENDING));
rdsmith29dbad12017-02-17 02:22:181103 EXPECT_TRUE(request(0)->handle()->socket());
1104 EXPECT_FALSE(request(1)->handle()->socket());
1105 EXPECT_FALSE(request(2)->handle()->socket());
1106
1107 request(2)->handle()->SetPriority(MEDIUM);
1108
1109 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1110
1111 EXPECT_EQ(1, GetOrderOfRequest(1));
1112 EXPECT_EQ(2, GetOrderOfRequest(2));
1113 EXPECT_EQ(3, GetOrderOfRequest(3));
1114}
1115
1116// Reprioritize a request past down another one and make sure that changes the
1117// completion order.
1118TEST_F(ClientSocketPoolBaseTest, ReprioritizeDownReorder) {
1119 CreatePool(kDefaultMaxSockets, 1);
1120
Matt Menkec6b3edf72019-03-19 17:00:391121 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(OK));
1122 EXPECT_THAT(StartRequest(TestGroupId("a"), HIGHEST), IsError(ERR_IO_PENDING));
1123 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
rdsmith29dbad12017-02-17 02:22:181124 EXPECT_TRUE(request(0)->handle()->socket());
1125 EXPECT_FALSE(request(1)->handle()->socket());
1126 EXPECT_FALSE(request(2)->handle()->socket());
1127
1128 request(1)->handle()->SetPriority(LOW);
1129
1130 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1131
1132 EXPECT_EQ(1, GetOrderOfRequest(1));
1133 EXPECT_EQ(3, GetOrderOfRequest(2));
1134 EXPECT_EQ(2, GetOrderOfRequest(3));
1135}
1136
1137// Reprioritize a request to the same level as another and confirm it is
1138// put after the old request.
1139TEST_F(ClientSocketPoolBaseTest, ReprioritizeResetFIFO) {
1140 CreatePool(kDefaultMaxSockets, 1);
1141
Matt Menkec6b3edf72019-03-19 17:00:391142 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(OK));
1143 EXPECT_THAT(StartRequest(TestGroupId("a"), HIGHEST), IsError(ERR_IO_PENDING));
1144 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
rdsmith29dbad12017-02-17 02:22:181145 EXPECT_TRUE(request(0)->handle()->socket());
1146 EXPECT_FALSE(request(1)->handle()->socket());
1147 EXPECT_FALSE(request(2)->handle()->socket());
1148
1149 request(1)->handle()->SetPriority(MEDIUM);
1150
1151 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1152
1153 EXPECT_EQ(1, GetOrderOfRequest(1));
1154 EXPECT_EQ(3, GetOrderOfRequest(2));
1155 EXPECT_EQ(2, GetOrderOfRequest(3));
1156}
1157
[email protected]211d21722009-07-22 15:48:531158TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsGroupLimit) {
1159 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1160
Matt Menkec6b3edf72019-03-19 17:00:391161 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsOk());
1162 EXPECT_THAT(StartRequest(TestGroupId("a"), LOW), IsOk());
1163 EXPECT_THAT(StartRequest(TestGroupId("b"), HIGHEST), IsOk());
1164 EXPECT_THAT(StartRequest(TestGroupId("b"), MEDIUM), IsOk());
[email protected]211d21722009-07-22 15:48:531165
[email protected]2431756e2010-09-29 20:26:131166 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]211d21722009-07-22 15:48:531167 client_socket_factory_.allocation_count());
1168
Matt Menkec6b3edf72019-03-19 17:00:391169 EXPECT_THAT(StartRequest(TestGroupId("c"), MEDIUM), IsError(ERR_IO_PENDING));
1170 EXPECT_THAT(StartRequest(TestGroupId("a"), LOW), IsError(ERR_IO_PENDING));
1171 EXPECT_THAT(StartRequest(TestGroupId("b"), HIGHEST), IsError(ERR_IO_PENDING));
[email protected]211d21722009-07-22 15:48:531172
[email protected]2431756e2010-09-29 20:26:131173 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
[email protected]211d21722009-07-22 15:48:531174
[email protected]2431756e2010-09-29 20:26:131175 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]211d21722009-07-22 15:48:531176 client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:131177 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
[email protected]211d21722009-07-22 15:48:531178
1179 // First 4 requests don't have to wait, and finish in order.
1180 EXPECT_EQ(1, GetOrderOfRequest(1));
1181 EXPECT_EQ(2, GetOrderOfRequest(2));
1182 EXPECT_EQ(3, GetOrderOfRequest(3));
1183 EXPECT_EQ(4, GetOrderOfRequest(4));
1184
1185 // Request ("b", 7) has the highest priority, but we can't make new socket for
1186 // group "b", because it has reached the per-group limit. Then we make
1187 // socket for ("c", 6), because it has higher priority than ("a", 4),
1188 // and we still can't make a socket for group "b".
1189 EXPECT_EQ(5, GetOrderOfRequest(5));
1190 EXPECT_EQ(6, GetOrderOfRequest(6));
1191 EXPECT_EQ(7, GetOrderOfRequest(7));
[email protected]75439d3b2009-07-23 22:11:171192
1193 // Make sure we test order of all requests made.
[email protected]2431756e2010-09-29 20:26:131194 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
[email protected]211d21722009-07-22 15:48:531195}
1196
1197// Make sure that we count connecting sockets against the total limit.
1198TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
1199 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1200
Matt Menkec6b3edf72019-03-19 17:00:391201 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1202 EXPECT_THAT(StartRequest(TestGroupId("b"), DEFAULT_PRIORITY), IsOk());
1203 EXPECT_THAT(StartRequest(TestGroupId("c"), DEFAULT_PRIORITY), IsOk());
[email protected]211d21722009-07-22 15:48:531204
1205 // Create one asynchronous request.
1206 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
Matt Menkec6b3edf72019-03-19 17:00:391207 EXPECT_THAT(StartRequest(TestGroupId("d"), DEFAULT_PRIORITY),
1208 IsError(ERR_IO_PENDING));
[email protected]211d21722009-07-22 15:48:531209
[email protected]6b175382009-10-13 06:47:471210 // We post all of our delayed tasks with a 2ms delay. I.e. they don't
1211 // actually become pending until 2ms after they have been created. In order
1212 // to flush all tasks, we need to wait so that we know there are no
1213 // soon-to-be-pending tasks waiting.
Peter Kastinge5a38ed2021-10-02 03:06:351214 FastForwardBy(base::Milliseconds(10));
[email protected]6b175382009-10-13 06:47:471215
[email protected]211d21722009-07-22 15:48:531216 // The next synchronous request should wait for its turn.
1217 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
Matt Menkec6b3edf72019-03-19 17:00:391218 EXPECT_THAT(StartRequest(TestGroupId("e"), DEFAULT_PRIORITY),
1219 IsError(ERR_IO_PENDING));
[email protected]211d21722009-07-22 15:48:531220
[email protected]2431756e2010-09-29 20:26:131221 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
[email protected]211d21722009-07-22 15:48:531222
[email protected]2431756e2010-09-29 20:26:131223 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]211d21722009-07-22 15:48:531224 client_socket_factory_.allocation_count());
1225
1226 EXPECT_EQ(1, GetOrderOfRequest(1));
1227 EXPECT_EQ(2, GetOrderOfRequest(2));
1228 EXPECT_EQ(3, GetOrderOfRequest(3));
1229 EXPECT_EQ(4, GetOrderOfRequest(4));
[email protected]75439d3b2009-07-23 22:11:171230 EXPECT_EQ(5, GetOrderOfRequest(5));
1231
1232 // Make sure we test order of all requests made.
[email protected]2431756e2010-09-29 20:26:131233 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6));
[email protected]211d21722009-07-22 15:48:531234}
1235
[email protected]6427fe22010-04-16 22:27:411236TEST_F(ClientSocketPoolBaseTest, CorrectlyCountStalledGroups) {
1237 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
1238 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1239
Matt Menkec6b3edf72019-03-19 17:00:391240 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1241 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1242 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1243 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
[email protected]6427fe22010-04-16 22:27:411244
1245 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1246
1247 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1248
Matt Menkec6b3edf72019-03-19 17:00:391249 EXPECT_THAT(StartRequest(TestGroupId("b"), DEFAULT_PRIORITY),
1250 IsError(ERR_IO_PENDING));
1251 EXPECT_THAT(StartRequest(TestGroupId("c"), DEFAULT_PRIORITY),
1252 IsError(ERR_IO_PENDING));
[email protected]6427fe22010-04-16 22:27:411253
1254 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1255
[email protected]2431756e2010-09-29 20:26:131256 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
[email protected]6427fe22010-04-16 22:27:411257 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:131258 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
[email protected]6427fe22010-04-16 22:27:411259 EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:131260 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1261 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
[email protected]6427fe22010-04-16 22:27:411262 EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
1263}
1264
[email protected]d7027bb2010-05-10 18:58:541265TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
1266 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
1267 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1268
1269 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:521270 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:501271 EXPECT_EQ(
1272 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:521273 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281274 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1275 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1276 pool_.get(), NetLogWithSource()));
[email protected]d7027bb2010-05-10 18:58:541277
1278 ClientSocketHandle handles[4];
Daniel Cheng5feb16f2022-02-28 06:52:071279 for (size_t i = 0; i < std::size(handles); ++i) {
Matt Menke28ac03e2019-02-25 22:25:501280 EXPECT_EQ(ERR_IO_PENDING,
Matt Menkec6b3edf72019-03-19 17:00:391281 handles[i].Init(
Anton Bikineev068d2912021-05-15 20:43:521282 TestGroupId("b"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281283 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1284 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1285 pool_.get(), NetLogWithSource()));
[email protected]d7027bb2010-05-10 18:58:541286 }
1287
1288 // One will be stalled, cancel all the handles now.
1289 // This should hit the OnAvailableSocketSlot() code where we previously had
1290 // stalled groups, but no longer have any.
Daniel Cheng5feb16f2022-02-28 06:52:071291 for (size_t i = 0; i < std::size(handles); ++i)
[email protected]d7027bb2010-05-10 18:58:541292 handles[i].Reset();
1293}
1294
[email protected]eb5a99382010-07-11 03:18:261295TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
[email protected]43a21b82010-06-10 21:30:541296 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1297 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1298
[email protected]eb5a99382010-07-11 03:18:261299 {
1300 ClientSocketHandle handles[kDefaultMaxSockets];
[email protected]6ecf2b92011-12-15 01:14:521301 TestCompletionCallback callbacks[kDefaultMaxSockets];
[email protected]eb5a99382010-07-11 03:18:261302 for (int i = 0; i < kDefaultMaxSockets; ++i) {
Eric Ortha2e7773212021-06-22 21:49:551303 EXPECT_EQ(OK, handles[i].Init(TestGroupId("a" + base::NumberToString(i)),
1304 params_, absl::nullopt, DEFAULT_PRIORITY,
1305 SocketTag(),
1306 ClientSocketPool::RespectLimits::ENABLED,
1307 callbacks[i].callback(),
1308 ClientSocketPool::ProxyAuthCallback(),
1309 pool_.get(), NetLogWithSource()));
[email protected]eb5a99382010-07-11 03:18:261310 }
1311
1312 // Force a stalled group.
1313 ClientSocketHandle stalled_handle;
[email protected]6ecf2b92011-12-15 01:14:521314 TestCompletionCallback callback;
tfarina428341112016-09-22 13:38:201315 EXPECT_EQ(ERR_IO_PENDING,
Matt Menkec6b3edf72019-03-19 17:00:391316 stalled_handle.Init(
Anton Bikineev068d2912021-05-15 20:43:521317 TestGroupId("foo"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281318 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1319 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1320 pool_.get(), NetLogWithSource()));
[email protected]eb5a99382010-07-11 03:18:261321
1322 // Cancel the stalled request.
1323 stalled_handle.Reset();
1324
1325 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1326 EXPECT_EQ(0, pool_->IdleSocketCount());
1327
1328 // Dropping out of scope will close all handles and return them to idle.
[email protected]43a21b82010-06-10 21:30:541329 }
1330
[email protected]43a21b82010-06-10 21:30:541331 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1332 EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount());
[email protected]eb5a99382010-07-11 03:18:261333}
[email protected]43a21b82010-06-10 21:30:541334
[email protected]eb5a99382010-07-11 03:18:261335TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
1336 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1337 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1338
1339 {
1340 ClientSocketHandle handles[kDefaultMaxSockets];
1341 for (int i = 0; i < kDefaultMaxSockets; ++i) {
[email protected]6ecf2b92011-12-15 01:14:521342 TestCompletionCallback callback;
tfarina428341112016-09-22 13:38:201343 EXPECT_EQ(ERR_IO_PENDING,
Eric Ortha2e7773212021-06-22 21:49:551344 handles[i].Init(
1345 TestGroupId("a" + base::NumberToString(i)), params_,
1346 absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
1347 ClientSocketPool::RespectLimits::ENABLED,
1348 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1349 pool_.get(), NetLogWithSource()));
[email protected]eb5a99382010-07-11 03:18:261350 }
1351
1352 // Force a stalled group.
1353 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1354 ClientSocketHandle stalled_handle;
[email protected]6ecf2b92011-12-15 01:14:521355 TestCompletionCallback callback;
tfarina428341112016-09-22 13:38:201356 EXPECT_EQ(ERR_IO_PENDING,
Matt Menkec6b3edf72019-03-19 17:00:391357 stalled_handle.Init(
Anton Bikineev068d2912021-05-15 20:43:521358 TestGroupId("foo"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281359 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1360 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1361 pool_.get(), NetLogWithSource()));
[email protected]eb5a99382010-07-11 03:18:261362
1363 // Since it is stalled, it should have no connect jobs.
Matt Menke9fa17d52019-03-25 19:12:261364 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("foo")));
1365 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
1366 TestGroupId("foo")));
1367 EXPECT_EQ(0u, pool_->NumUnassignedConnectJobsInGroupForTesting(
1368 TestGroupId("foo")));
[email protected]eb5a99382010-07-11 03:18:261369
1370 // Cancel the stalled request.
1371 handles[0].Reset();
1372
[email protected]eb5a99382010-07-11 03:18:261373 // Now we should have a connect job.
Matt Menke9fa17d52019-03-25 19:12:261374 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("foo")));
1375 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
1376 TestGroupId("foo")));
1377 EXPECT_EQ(0u, pool_->NumUnassignedConnectJobsInGroupForTesting(
1378 TestGroupId("foo")));
[email protected]eb5a99382010-07-11 03:18:261379
1380 // The stalled socket should connect.
robpercival214763f2016-07-01 23:27:011381 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]eb5a99382010-07-11 03:18:261382
1383 EXPECT_EQ(kDefaultMaxSockets + 1,
1384 client_socket_factory_.allocation_count());
1385 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:261386 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("foo")));
1387 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
1388 TestGroupId("foo")));
1389 EXPECT_EQ(0u, pool_->NumUnassignedConnectJobsInGroupForTesting(
1390 TestGroupId("foo")));
[email protected]eb5a99382010-07-11 03:18:261391
1392 // Dropping out of scope will close all handles and return them to idle.
[email protected]43a21b82010-06-10 21:30:541393 }
1394
[email protected]eb5a99382010-07-11 03:18:261395 EXPECT_EQ(1, pool_->IdleSocketCount());
1396}
[email protected]43a21b82010-06-10 21:30:541397
[email protected]eb5a99382010-07-11 03:18:261398TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
1399 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1400 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
[email protected]43a21b82010-06-10 21:30:541401
[email protected]eb5a99382010-07-11 03:18:261402 ClientSocketHandle stalled_handle;
[email protected]6ecf2b92011-12-15 01:14:521403 TestCompletionCallback callback;
[email protected]eb5a99382010-07-11 03:18:261404 {
[email protected]51fdc7c2012-04-10 19:19:481405 EXPECT_FALSE(pool_->IsStalled());
[email protected]eb5a99382010-07-11 03:18:261406 ClientSocketHandle handles[kDefaultMaxSockets];
1407 for (int i = 0; i < kDefaultMaxSockets; ++i) {
Matt Menkec6b3edf72019-03-19 17:00:391408 EXPECT_EQ(
Matt Menkef09e64c2019-04-23 22:16:281409 OK, handles[i].Init(
Eric Ortha2e7773212021-06-22 21:49:551410 TestGroupId(base::StringPrintf("take-2-%d", i)), params_,
Anton Bikineev068d2912021-05-15 20:43:521411 absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menkef09e64c2019-04-23 22:16:281412 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
1413 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
1414 NetLogWithSource()));
[email protected]eb5a99382010-07-11 03:18:261415 }
1416
1417 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1418 EXPECT_EQ(0, pool_->IdleSocketCount());
[email protected]51fdc7c2012-04-10 19:19:481419 EXPECT_FALSE(pool_->IsStalled());
[email protected]eb5a99382010-07-11 03:18:261420
1421 // Now we will hit the socket limit.
tfarina428341112016-09-22 13:38:201422 EXPECT_EQ(ERR_IO_PENDING,
Matt Menkec6b3edf72019-03-19 17:00:391423 stalled_handle.Init(
Anton Bikineev068d2912021-05-15 20:43:521424 TestGroupId("foo"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281425 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1426 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1427 pool_.get(), NetLogWithSource()));
[email protected]51fdc7c2012-04-10 19:19:481428 EXPECT_TRUE(pool_->IsStalled());
[email protected]eb5a99382010-07-11 03:18:261429
1430 // Dropping out of scope will close all handles and return them to idle.
1431 }
[email protected]43a21b82010-06-10 21:30:541432
1433 // But if we wait for it, the released idle sockets will be closed in
1434 // preference of the waiting request.
robpercival214763f2016-07-01 23:27:011435 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]eb5a99382010-07-11 03:18:261436
1437 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
1438 EXPECT_EQ(3, pool_->IdleSocketCount());
[email protected]43a21b82010-06-10 21:30:541439}
1440
1441// Regression test for http://crbug.com/40952.
1442TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
Matt Menke9fa17d52019-03-25 19:12:261443 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
1444 true /* enable_backup_connect_jobs */);
[email protected]43a21b82010-06-10 21:30:541445 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1446
1447 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1448 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:521449 TestCompletionCallback callback;
Eric Ortha2e7773212021-06-22 21:49:551450 EXPECT_EQ(
1451 OK,
1452 handle.Init(TestGroupId("a" + base::NumberToString(i)), params_,
1453 absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
1454 ClientSocketPool::RespectLimits::ENABLED,
1455 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1456 pool_.get(), NetLogWithSource()));
[email protected]43a21b82010-06-10 21:30:541457 }
1458
1459 // Flush all the DoReleaseSocket tasks.
fdoray5eeb7642016-06-22 16:11:281460 base::RunLoop().RunUntilIdle();
[email protected]43a21b82010-06-10 21:30:541461
1462 // Stall a group. Set a pending job so it'll trigger a backup job if we don't
1463 // reuse a socket.
1464 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1465 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:521466 TestCompletionCallback callback;
[email protected]43a21b82010-06-10 21:30:541467
Eric Ortha2e7773212021-06-22 21:49:551468 // "a0" is special here, since it should be the first entry in the sorted map,
[email protected]43a21b82010-06-10 21:30:541469 // which is the one which we would close an idle socket for. We shouldn't
1470 // close an idle socket though, since we should reuse the idle socket.
Matt Menkec6b3edf72019-03-19 17:00:391471 EXPECT_EQ(OK, handle.Init(
Eric Ortha2e7773212021-06-22 21:49:551472 TestGroupId("a0"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281473 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menkec6b3edf72019-03-19 17:00:391474 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1475 pool_.get(), NetLogWithSource()));
[email protected]43a21b82010-06-10 21:30:541476
1477 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1478 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
1479}
1480
[email protected]ab838892009-06-30 18:49:051481TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
[email protected]211d21722009-07-22 15:48:531482 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]f6d1d6eb2009-06-24 20:16:091483
Matt Menkec6b3edf72019-03-19 17:00:391484 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1485 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1486 EXPECT_THAT(StartRequest(TestGroupId("a"), IDLE), IsError(ERR_IO_PENDING));
1487 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(ERR_IO_PENDING));
1488 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
1489 EXPECT_THAT(StartRequest(TestGroupId("a"), HIGHEST), IsError(ERR_IO_PENDING));
1490 EXPECT_THAT(StartRequest(TestGroupId("a"), LOW), IsError(ERR_IO_PENDING));
1491 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(ERR_IO_PENDING));
[email protected]f6d1d6eb2009-06-24 20:16:091492
[email protected]2431756e2010-09-29 20:26:131493 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
[email protected]c9d6a1d2009-07-14 16:15:201494 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
1495 client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:131496 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1497 completion_count());
[email protected]f6d1d6eb2009-06-24 20:16:091498
[email protected]c9d6a1d2009-07-14 16:15:201499 EXPECT_EQ(1, GetOrderOfRequest(1));
1500 EXPECT_EQ(2, GetOrderOfRequest(2));
[email protected]c9c6f5c2010-07-31 01:30:031501 EXPECT_EQ(8, GetOrderOfRequest(3));
1502 EXPECT_EQ(6, GetOrderOfRequest(4));
1503 EXPECT_EQ(4, GetOrderOfRequest(5));
1504 EXPECT_EQ(3, GetOrderOfRequest(6));
1505 EXPECT_EQ(5, GetOrderOfRequest(7));
1506 EXPECT_EQ(7, GetOrderOfRequest(8));
[email protected]75439d3b2009-07-23 22:11:171507
1508 // Make sure we test order of all requests made.
[email protected]2431756e2010-09-29 20:26:131509 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9));
[email protected]f6d1d6eb2009-06-24 20:16:091510}
1511
[email protected]ab838892009-06-30 18:49:051512TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) {
[email protected]211d21722009-07-22 15:48:531513 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]f6d1d6eb2009-06-24 20:16:091514
Matt Menkec6b3edf72019-03-19 17:00:391515 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1516 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1517 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(ERR_IO_PENDING));
1518 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
1519 EXPECT_THAT(StartRequest(TestGroupId("a"), HIGHEST), IsError(ERR_IO_PENDING));
1520 EXPECT_THAT(StartRequest(TestGroupId("a"), LOW), IsError(ERR_IO_PENDING));
1521 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(ERR_IO_PENDING));
[email protected]f6d1d6eb2009-06-24 20:16:091522
[email protected]2431756e2010-09-29 20:26:131523 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
[email protected]f6d1d6eb2009-06-24 20:16:091524
[email protected]2431756e2010-09-29 20:26:131525 for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i)
robpercival214763f2016-07-01 23:27:011526 EXPECT_THAT(request(i)->WaitForResult(), IsOk());
[email protected]c9d6a1d2009-07-14 16:15:201527
[email protected]2431756e2010-09-29 20:26:131528 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]c9d6a1d2009-07-14 16:15:201529 client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:131530 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1531 completion_count());
[email protected]f6d1d6eb2009-06-24 20:16:091532}
1533
Matt Menke7eb405e2019-04-25 20:48:211534TEST_F(ClientSocketPoolBaseTest, ResetAndCloseSocket) {
1535 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1536
1537 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1538 ClientSocketHandle handle;
1539 TestCompletionCallback callback;
1540 EXPECT_EQ(
1541 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:521542 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menke7eb405e2019-04-25 20:48:211543 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1544 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1545 pool_.get(), NetLogWithSource()));
1546
1547 EXPECT_THAT(callback.WaitForResult(), IsOk());
1548 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1549 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
1550 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
1551 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
1552
1553 handle.ResetAndCloseSocket();
1554 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
1555}
1556
Matt Menke99251ea42019-04-25 22:59:021557// This test will start up a socket request and then call Reset() on the handle.
1558// The pending ConnectJob should not be destroyed.
Matt Menke7eb405e2019-04-25 20:48:211559TEST_F(ClientSocketPoolBaseTest, CancelRequestKeepsConnectJob) {
[email protected]211d21722009-07-22 15:48:531560 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]c9d6a1d2009-07-14 16:15:201561
[email protected]ab838892009-06-30 18:49:051562 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
[email protected]2431756e2010-09-29 20:26:131563 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:521564 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:501565 EXPECT_EQ(
1566 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:521567 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281568 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1569 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1570 pool_.get(), NetLogWithSource()));
[email protected]2431756e2010-09-29 20:26:131571 handle.Reset();
Matt Menke7eb405e2019-04-25 20:48:211572 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1573 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
1574}
1575
Matt Menke99251ea42019-04-25 22:59:021576// This test will start up a socket request and then call ResetAndCloseSocket()
1577// on the handle. The pending ConnectJob or connected socket should be
1578// destroyed.
Matt Menke7eb405e2019-04-25 20:48:211579TEST_F(ClientSocketPoolBaseTest, CancelRequestAndCloseSocket) {
1580 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1581
Matt Menke99251ea42019-04-25 22:59:021582 // When true, the socket connects before it's canceled.
1583 for (bool cancel_when_callback_pending : {false, true}) {
1584 if (cancel_when_callback_pending) {
1585 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1586 } else {
1587 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1588 }
1589 ClientSocketHandle handle;
1590 TestCompletionCallback callback;
1591 EXPECT_EQ(
1592 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:521593 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menke99251ea42019-04-25 22:59:021594 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1595 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1596 pool_.get(), NetLogWithSource()));
1597 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1598 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
1599
1600 if (cancel_when_callback_pending) {
1601 client_socket_factory_.SignalJobs();
1602 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1603 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
1604 }
1605
1606 handle.ResetAndCloseSocket();
1607 ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
1608 }
Matt Menke7eb405e2019-04-25 20:48:211609}
1610
1611TEST_F(ClientSocketPoolBaseTest,
1612 CancelRequestAndCloseSocketWhenMoreRequestsThanConnectJobs) {
1613 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1614
Matt Menke99251ea42019-04-25 22:59:021615 // When true, the sockets connect before they're canceled.
1616 for (bool cancel_when_callback_pending : {false, true}) {
1617 if (cancel_when_callback_pending) {
1618 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1619 } else {
1620 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1621 }
Matt Menke7eb405e2019-04-25 20:48:211622
Matt Menke99251ea42019-04-25 22:59:021623 std::vector<std::unique_ptr<ClientSocketHandle>> handles;
1624 TestCompletionCallback callback;
1625 // Make |kDefaultMaxSockets + 1| socket requests.
1626 for (int i = 0; i < kDefaultMaxSocketsPerGroup + 1; ++i) {
1627 std::unique_ptr<ClientSocketHandle> handle =
1628 std::make_unique<ClientSocketHandle>();
1629 EXPECT_EQ(ERR_IO_PENDING,
1630 handle->Init(
Anton Bikineev068d2912021-05-15 20:43:521631 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menke99251ea42019-04-25 22:59:021632 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1633 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1634 pool_.get(), NetLogWithSource()));
1635 handles.push_back(std::move(handle));
Matt Menke7eb405e2019-04-25 20:48:211636 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menke99251ea42019-04-25 22:59:021637 EXPECT_EQ(
1638 static_cast<size_t>(std::min(i + 1, kDefaultMaxSocketsPerGroup)),
1639 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
1640 }
1641
1642 if (cancel_when_callback_pending) {
1643 client_socket_factory_.SignalJobs();
1644 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1645 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
1646 pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
1647 }
1648
1649 // Calling ResetAndCloseSocket() on a handle should not cancel a ConnectJob
1650 // or close a socket, since there are more requests than ConnectJobs or
1651 // sockets.
1652 handles[kDefaultMaxSocketsPerGroup]->ResetAndCloseSocket();
1653 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1654 if (cancel_when_callback_pending) {
1655 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
1656 pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
1657 } else {
1658 EXPECT_EQ(static_cast<size_t>(kDefaultMaxSocketsPerGroup),
Matt Menke7eb405e2019-04-25 20:48:211659 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
1660 }
Matt Menke99251ea42019-04-25 22:59:021661
1662 // Calling ResetAndCloseSocket() on other handles should cancel a ConnectJob
1663 // or close a socket.
1664 for (int i = kDefaultMaxSocketsPerGroup - 1; i >= 0; --i) {
1665 handles[i]->ResetAndCloseSocket();
1666 if (i > 0) {
1667 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1668 if (cancel_when_callback_pending) {
1669 EXPECT_EQ(i,
1670 pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
1671 } else {
1672 EXPECT_EQ(static_cast<size_t>(i),
1673 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
1674 }
1675 } else {
1676 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
1677 }
1678 }
Matt Menke7eb405e2019-04-25 20:48:211679 }
[email protected]f6d1d6eb2009-06-24 20:16:091680}
1681
[email protected]ab838892009-06-30 18:49:051682TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
[email protected]211d21722009-07-22 15:48:531683 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]c9d6a1d2009-07-14 16:15:201684
[email protected]ab838892009-06-30 18:49:051685 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
[email protected]a512f5982009-08-18 16:01:061686 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:521687 TestCompletionCallback callback;
[email protected]f6d1d6eb2009-06-24 20:16:091688
Matt Menke28ac03e2019-02-25 22:25:501689 EXPECT_EQ(
1690 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:521691 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281692 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
1693 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1694 pool_.get(), NetLogWithSource()));
[email protected]f6d1d6eb2009-06-24 20:16:091695
1696 handle.Reset();
Matt Menke7eb405e2019-04-25 20:48:211697 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1698 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]f6d1d6eb2009-06-24 20:16:091699
Matt Menke7eb405e2019-04-25 20:48:211700 // This will create a second ConnectJob, since the other ConnectJob was
1701 // previously assigned to a request.
[email protected]6ecf2b92011-12-15 01:14:521702 TestCompletionCallback callback2;
Matt Menke28ac03e2019-02-25 22:25:501703 EXPECT_EQ(
1704 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:521705 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281706 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:501707 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
1708 pool_.get(), NetLogWithSource()));
[email protected]f6d1d6eb2009-06-24 20:16:091709
Matt Menke7eb405e2019-04-25 20:48:211710 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1711 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
1712
robpercival214763f2016-07-01 23:27:011713 EXPECT_THAT(callback2.WaitForResult(), IsOk());
[email protected]f6d1d6eb2009-06-24 20:16:091714 EXPECT_FALSE(callback.have_result());
Matt Menke7eb405e2019-04-25 20:48:211715 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1716 // One ConnectJob completed, and its socket is now assigned to |handle|.
1717 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
1718 // The other ConnectJob should have either completed, or still be connecting.
1719 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")) +
1720 pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]f6d1d6eb2009-06-24 20:16:091721
1722 handle.Reset();
Matt Menke7eb405e2019-04-25 20:48:211723 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
1724 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")) +
1725 pool_->IdleSocketCountInGroup(TestGroupId("a")));
1726 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
[email protected]f6d1d6eb2009-06-24 20:16:091727}
1728
[email protected]ab838892009-06-30 18:49:051729TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
[email protected]211d21722009-07-22 15:48:531730 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]f6d1d6eb2009-06-24 20:16:091731
Matt Menkec6b3edf72019-03-19 17:00:391732 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1733 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
1734 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(ERR_IO_PENDING));
1735 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
1736 EXPECT_THAT(StartRequest(TestGroupId("a"), HIGHEST), IsError(ERR_IO_PENDING));
1737 EXPECT_THAT(StartRequest(TestGroupId("a"), LOW), IsError(ERR_IO_PENDING));
1738 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(ERR_IO_PENDING));
[email protected]f6d1d6eb2009-06-24 20:16:091739
1740 // Cancel a request.
[email protected]c9d6a1d2009-07-14 16:15:201741 size_t index_to_cancel = kDefaultMaxSocketsPerGroup + 2;
[email protected]2431756e2010-09-29 20:26:131742 EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
1743 (*requests())[index_to_cancel]->handle()->Reset();
[email protected]f6d1d6eb2009-06-24 20:16:091744
[email protected]2431756e2010-09-29 20:26:131745 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
[email protected]f6d1d6eb2009-06-24 20:16:091746
[email protected]c9d6a1d2009-07-14 16:15:201747 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
1748 client_socket_factory_.allocation_count());
[email protected]2431756e2010-09-29 20:26:131749 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup - 1,
1750 completion_count());
[email protected]f6d1d6eb2009-06-24 20:16:091751
[email protected]c9d6a1d2009-07-14 16:15:201752 EXPECT_EQ(1, GetOrderOfRequest(1));
1753 EXPECT_EQ(2, GetOrderOfRequest(2));
1754 EXPECT_EQ(5, GetOrderOfRequest(3));
1755 EXPECT_EQ(3, GetOrderOfRequest(4));
[email protected]2431756e2010-09-29 20:26:131756 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound,
1757 GetOrderOfRequest(5)); // Canceled request.
[email protected]c9d6a1d2009-07-14 16:15:201758 EXPECT_EQ(4, GetOrderOfRequest(6));
1759 EXPECT_EQ(6, GetOrderOfRequest(7));
[email protected]75439d3b2009-07-23 22:11:171760
1761 // Make sure we test order of all requests made.
[email protected]2431756e2010-09-29 20:26:131762 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
[email protected]f6d1d6eb2009-06-24 20:16:091763}
1764
mmenke33d24423d2015-05-19 19:41:091765// Function to be used as a callback on socket request completion. It first
1766// disconnects the successfully connected socket from the first request, and
1767// then reuses the ClientSocketHandle to request another socket.
1768//
1769// |nested_callback| is called with the result of the second socket request.
1770void RequestSocketOnComplete(ClientSocketHandle* handle,
Matt Menke9fa17d52019-03-25 19:12:261771 TransportClientSocketPool* pool,
mmenke33d24423d2015-05-19 19:41:091772 TestConnectJobFactory* test_connect_job_factory,
1773 TestConnectJob::JobType next_job_type,
Bence Békya4a50932018-08-10 13:39:411774 TestCompletionCallback* nested_callback,
mmenke33d24423d2015-05-19 19:41:091775 int first_request_result) {
robpercival214763f2016-07-01 23:27:011776 EXPECT_THAT(first_request_result, IsOk());
mmenke33d24423d2015-05-19 19:41:091777
1778 test_connect_job_factory->set_job_type(next_job_type);
1779
1780 // Don't allow reuse of the socket. Disconnect it and then release it.
1781 if (handle->socket())
1782 handle->socket()->Disconnect();
1783 handle->Reset();
1784
mmenke33d24423d2015-05-19 19:41:091785 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:501786 int rv = handle->Init(
Matt Menke870e19ab2019-04-23 16:23:031787 TestGroupId("a"),
Anton Bikineev068d2912021-05-15 20:43:521788 ClientSocketPool::SocketParams::CreateForHttpForTesting(), absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:281789 LOWEST, SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke870e19ab2019-04-23 16:23:031790 nested_callback->callback(), ClientSocketPool::ProxyAuthCallback(), pool,
1791 NetLogWithSource());
mmenke33d24423d2015-05-19 19:41:091792 if (rv != ERR_IO_PENDING) {
1793 DCHECK_EQ(TestConnectJob::kMockJob, next_job_type);
Bence Békya4a50932018-08-10 13:39:411794 nested_callback->callback().Run(rv);
mmenke33d24423d2015-05-19 19:41:091795 } else {
1796 DCHECK_EQ(TestConnectJob::kMockPendingJob, next_job_type);
[email protected]6ecf2b92011-12-15 01:14:521797 }
mmenke33d24423d2015-05-19 19:41:091798}
[email protected]f6d1d6eb2009-06-24 20:16:091799
mmenke33d24423d2015-05-19 19:41:091800// Tests the case where a second socket is requested in a completion callback,
1801// and the second socket connects asynchronously. Reuses the same
1802// ClientSocketHandle for the second socket, after disconnecting the first.
[email protected]2ab05b52009-07-01 23:57:581803TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
[email protected]211d21722009-07-22 15:48:531804 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]c9d6a1d2009-07-14 16:15:201805
[email protected]0b7648c2009-07-06 20:14:011806 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
[email protected]a512f5982009-08-18 16:01:061807 ClientSocketHandle handle;
mmenke33d24423d2015-05-19 19:41:091808 TestCompletionCallback second_result_callback;
1809 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:521810 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Paul Jensen8d6f87ec2018-01-13 00:46:541811 ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:501812 base::BindOnce(&RequestSocketOnComplete, &handle, pool_.get(),
1813 connect_job_factory_, TestConnectJob::kMockPendingJob,
1814 &second_result_callback),
1815 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:011816 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]f6d1d6eb2009-06-24 20:16:091817
robpercival214763f2016-07-01 23:27:011818 EXPECT_THAT(second_result_callback.WaitForResult(), IsOk());
[email protected]2ab05b52009-07-01 23:57:581819}
[email protected]f6d1d6eb2009-06-24 20:16:091820
mmenke33d24423d2015-05-19 19:41:091821// Tests the case where a second socket is requested in a completion callback,
1822// and the second socket connects synchronously. Reuses the same
1823// ClientSocketHandle for the second socket, after disconnecting the first.
[email protected]2ab05b52009-07-01 23:57:581824TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
[email protected]211d21722009-07-22 15:48:531825 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]c9d6a1d2009-07-14 16:15:201826
[email protected]0b7648c2009-07-06 20:14:011827 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
[email protected]a512f5982009-08-18 16:01:061828 ClientSocketHandle handle;
mmenke33d24423d2015-05-19 19:41:091829 TestCompletionCallback second_result_callback;
1830 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:521831 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Paul Jensen8d6f87ec2018-01-13 00:46:541832 ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:501833 base::BindOnce(&RequestSocketOnComplete, &handle, pool_.get(),
1834 connect_job_factory_, TestConnectJob::kMockPendingJob,
1835 &second_result_callback),
1836 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:011837 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]2ab05b52009-07-01 23:57:581838
robpercival214763f2016-07-01 23:27:011839 EXPECT_THAT(second_result_callback.WaitForResult(), IsOk());
[email protected]f6d1d6eb2009-06-24 20:16:091840}
1841
1842// Make sure that pending requests get serviced after active requests get
1843// cancelled.
[email protected]ab838892009-06-30 18:49:051844TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
[email protected]211d21722009-07-22 15:48:531845 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]c9d6a1d2009-07-14 16:15:201846
[email protected]0b7648c2009-07-06 20:14:011847 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
[email protected]f6d1d6eb2009-06-24 20:16:091848
Matt Menkec6b3edf72019-03-19 17:00:391849 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1850 IsError(ERR_IO_PENDING));
1851 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1852 IsError(ERR_IO_PENDING));
1853 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1854 IsError(ERR_IO_PENDING));
1855 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1856 IsError(ERR_IO_PENDING));
1857 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1858 IsError(ERR_IO_PENDING));
1859 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1860 IsError(ERR_IO_PENDING));
1861 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1862 IsError(ERR_IO_PENDING));
[email protected]f6d1d6eb2009-06-24 20:16:091863
[email protected]c9d6a1d2009-07-14 16:15:201864 // Now, kDefaultMaxSocketsPerGroup requests should be active.
1865 // Let's cancel them.
1866 for (int i = 0; i < kDefaultMaxSocketsPerGroup; ++i) {
[email protected]2431756e2010-09-29 20:26:131867 ASSERT_FALSE(request(i)->handle()->is_initialized());
1868 request(i)->handle()->Reset();
[email protected]f6d1d6eb2009-06-24 20:16:091869 }
1870
[email protected]f6d1d6eb2009-06-24 20:16:091871 // Let's wait for the rest to complete now.
[email protected]2431756e2010-09-29 20:26:131872 for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i) {
robpercival214763f2016-07-01 23:27:011873 EXPECT_THAT(request(i)->WaitForResult(), IsOk());
[email protected]2431756e2010-09-29 20:26:131874 request(i)->handle()->Reset();
[email protected]f6d1d6eb2009-06-24 20:16:091875 }
1876
[email protected]2431756e2010-09-29 20:26:131877 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1878 completion_count());
[email protected]f6d1d6eb2009-06-24 20:16:091879}
1880
1881// Make sure that pending requests get serviced after active requests fail.
[email protected]ab838892009-06-30 18:49:051882TEST_F(ClientSocketPoolBaseTest, FailingActiveRequestWithPendingRequests) {
[email protected]211d21722009-07-22 15:48:531883 const size_t kMaxSockets = 5;
1884 CreatePool(kMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]c9d6a1d2009-07-14 16:15:201885
[email protected]0b7648c2009-07-06 20:14:011886 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
[email protected]f6d1d6eb2009-06-24 20:16:091887
[email protected]211d21722009-07-22 15:48:531888 const size_t kNumberOfRequests = 2 * kDefaultMaxSocketsPerGroup + 1;
1889 ASSERT_LE(kNumberOfRequests, kMaxSockets); // Otherwise the test will hang.
[email protected]f6d1d6eb2009-06-24 20:16:091890
1891 // Queue up all the requests
[email protected]211d21722009-07-22 15:48:531892 for (size_t i = 0; i < kNumberOfRequests; ++i)
Matt Menkec6b3edf72019-03-19 17:00:391893 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1894 IsError(ERR_IO_PENDING));
[email protected]f6d1d6eb2009-06-24 20:16:091895
[email protected]211d21722009-07-22 15:48:531896 for (size_t i = 0; i < kNumberOfRequests; ++i)
robpercival214763f2016-07-01 23:27:011897 EXPECT_THAT(request(i)->WaitForResult(), IsError(ERR_CONNECTION_FAILED));
[email protected]f6d1d6eb2009-06-24 20:16:091898}
1899
mmenke9d72fe42017-05-18 22:36:071900// Make sure that pending requests that complete synchronously get serviced
1901// after active requests fail. See https://crbug.com/723748
1902TEST_F(ClientSocketPoolBaseTest, HandleMultipleSyncFailuresAfterAsyncFailure) {
1903 const size_t kNumberOfRequests = 10;
1904 const size_t kMaxSockets = 1;
1905 CreatePool(kMaxSockets, kMaxSockets);
1906
1907 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
1908
Matt Menkec6b3edf72019-03-19 17:00:391909 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1910 IsError(ERR_IO_PENDING));
mmenke9d72fe42017-05-18 22:36:071911
1912 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
1913
1914 // Queue up all the other requests
1915 for (size_t i = 1; i < kNumberOfRequests; ++i)
Matt Menkec6b3edf72019-03-19 17:00:391916 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
1917 IsError(ERR_IO_PENDING));
mmenke9d72fe42017-05-18 22:36:071918
1919 // Make sure all requests fail, instead of hanging.
1920 for (size_t i = 0; i < kNumberOfRequests; ++i)
1921 EXPECT_THAT(request(i)->WaitForResult(), IsError(ERR_CONNECTION_FAILED));
1922}
1923
[email protected]5fc08e32009-07-15 17:09:571924TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
[email protected]211d21722009-07-22 15:48:531925 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]5fc08e32009-07-15 17:09:571926
1927 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1928
[email protected]2431756e2010-09-29 20:26:131929 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:521930 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:501931 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:521932 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:501933 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
1934 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:011935 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]5fc08e32009-07-15 17:09:571936
1937 // Cancel the active request.
[email protected]2431756e2010-09-29 20:26:131938 handle.Reset();
[email protected]5fc08e32009-07-15 17:09:571939
Anton Bikineev068d2912021-05-15 20:43:521940 rv = handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:281941 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:501942 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
1943 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:011944 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1945 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]5fc08e32009-07-15 17:09:571946
[email protected]2431756e2010-09-29 20:26:131947 EXPECT_FALSE(handle.is_reused());
[email protected]034df0f32013-01-07 23:17:481948 TestLoadTimingInfoConnectedNotReused(handle);
[email protected]5fc08e32009-07-15 17:09:571949 EXPECT_EQ(2, client_socket_factory_.allocation_count());
1950}
1951
xunjieli26619e72016-11-23 19:39:551952TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsForced) {
Matt Menke433de6d2020-03-04 00:24:111953 const char kReason[] = "Really nifty reason";
1954
xunjieli26619e72016-11-23 19:39:551955 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1956 ClientSocketHandle handle;
1957 TestCompletionCallback callback;
Matt Reichhoff0049a0b72021-10-20 20:44:261958 int rv =
1959 handle.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST, SocketTag(),
1960 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
1961 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
1962 NetLogWithSource::Make(NetLogSourceType::NONE));
xunjieli26619e72016-11-23 19:39:551963 EXPECT_THAT(rv, IsOk());
Matt Menke433de6d2020-03-04 00:24:111964 ASSERT_TRUE(handle.socket());
1965 NetLogSource source = handle.socket()->NetLog().source();
xunjieli26619e72016-11-23 19:39:551966 handle.Reset();
1967 EXPECT_EQ(1, pool_->IdleSocketCount());
Matt Menke433de6d2020-03-04 00:24:111968 pool_->CloseIdleSockets(kReason);
1969 ExpectSocketClosedWithReason(source, kReason);
xunjieli26619e72016-11-23 19:39:551970}
1971
xunjieli92feb332017-03-03 17:19:231972TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsInGroupForced) {
xunjieli92feb332017-03-03 17:19:231973 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1974 TestCompletionCallback callback;
Matt Reichhoff0049a0b72021-10-20 20:44:261975 NetLogWithSource net_log_with_source =
1976 NetLogWithSource::Make(NetLogSourceType::NONE);
xunjieli92feb332017-03-03 17:19:231977 ClientSocketHandle handle1;
Matt Menke28ac03e2019-02-25 22:25:501978 int rv = handle1.Init(
Anton Bikineev068d2912021-05-15 20:43:521979 TestGroupId("a"), params_, absl::nullopt, LOWEST, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:501980 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
Matt Reichhoff0049a0b72021-10-20 20:44:261981 ClientSocketPool::ProxyAuthCallback(), pool_.get(), net_log_with_source);
xunjieli92feb332017-03-03 17:19:231982 EXPECT_THAT(rv, IsOk());
1983 ClientSocketHandle handle2;
Anton Bikineev068d2912021-05-15 20:43:521984 rv = handle2.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:281985 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:501986 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
Matt Reichhoff0049a0b72021-10-20 20:44:261987 pool_.get(), net_log_with_source);
xunjieli92feb332017-03-03 17:19:231988 ClientSocketHandle handle3;
Anton Bikineev068d2912021-05-15 20:43:521989 rv = handle3.Init(TestGroupId("b"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:281990 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:501991 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
Matt Reichhoff0049a0b72021-10-20 20:44:261992 pool_.get(), net_log_with_source);
xunjieli92feb332017-03-03 17:19:231993 EXPECT_THAT(rv, IsOk());
1994 handle1.Reset();
1995 handle2.Reset();
1996 handle3.Reset();
1997 EXPECT_EQ(3, pool_->IdleSocketCount());
Matt Menke433de6d2020-03-04 00:24:111998 pool_->CloseIdleSocketsInGroup(TestGroupId("a"), "Very good reason");
xunjieli92feb332017-03-03 17:19:231999 EXPECT_EQ(1, pool_->IdleSocketCount());
xunjieli92feb332017-03-03 17:19:232000}
2001
xunjieli26619e72016-11-23 19:39:552002TEST_F(ClientSocketPoolBaseTest, CleanUpUnusableIdleSockets) {
xunjieli26619e72016-11-23 19:39:552003 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2004 ClientSocketHandle handle;
2005 TestCompletionCallback callback;
Matt Reichhoff0049a0b72021-10-20 20:44:262006 NetLogWithSource net_log_with_source =
2007 NetLogWithSource::Make(NetLogSourceType::NONE);
Matt Menke28ac03e2019-02-25 22:25:502008 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522009 TestGroupId("a"), params_, absl::nullopt, LOWEST, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502010 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
Matt Reichhoff0049a0b72021-10-20 20:44:262011 ClientSocketPool::ProxyAuthCallback(), pool_.get(), net_log_with_source);
xunjieli26619e72016-11-23 19:39:552012 EXPECT_THAT(rv, IsOk());
2013 StreamSocket* socket = handle.socket();
Matt Menke433de6d2020-03-04 00:24:112014 ASSERT_TRUE(socket);
xunjieli26619e72016-11-23 19:39:552015 handle.Reset();
2016 EXPECT_EQ(1, pool_->IdleSocketCount());
2017
2018 // Disconnect socket now to make the socket unusable.
Matt Menke433de6d2020-03-04 00:24:112019 NetLogSource source = socket->NetLog().source();
xunjieli26619e72016-11-23 19:39:552020 socket->Disconnect();
2021 ClientSocketHandle handle2;
Anton Bikineev068d2912021-05-15 20:43:522022 rv = handle2.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:282023 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502024 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
Matt Reichhoff0049a0b72021-10-20 20:44:262025 pool_.get(), net_log_with_source);
xunjieli26619e72016-11-23 19:39:552026 EXPECT_THAT(rv, IsOk());
2027 EXPECT_FALSE(handle2.is_reused());
Matt Menke433de6d2020-03-04 00:24:112028
2029 // This is admittedly not an accurate error in this case, but normally code
2030 // doesn't secretly keep a raw pointers to sockets returned to the socket pool
2031 // and close them out of band, so discovering an idle socket was closed when
2032 // trying to reuse it normally means it was closed by the remote side.
2033 ExpectSocketClosedWithReason(
2034 source, TransportClientSocketPool::kRemoteSideClosedConnection);
xunjieli26619e72016-11-23 19:39:552035}
2036
[email protected]2b7523d2009-07-29 20:29:232037// Regression test for http://crbug.com/17985.
2038TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) {
2039 const int kMaxSockets = 3;
2040 const int kMaxSocketsPerGroup = 2;
2041 CreatePool(kMaxSockets, kMaxSocketsPerGroup);
2042
[email protected]ac790b42009-12-02 04:31:312043 const RequestPriority kHighPriority = HIGHEST;
[email protected]2b7523d2009-07-29 20:29:232044
Matt Menkec6b3edf72019-03-19 17:00:392045 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
2046 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
[email protected]2b7523d2009-07-29 20:29:232047
2048 // This is going to be a pending request in an otherwise empty group.
Matt Menkec6b3edf72019-03-19 17:00:392049 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
2050 IsError(ERR_IO_PENDING));
[email protected]2b7523d2009-07-29 20:29:232051
2052 // Reach the maximum socket limit.
Matt Menkec6b3edf72019-03-19 17:00:392053 EXPECT_THAT(StartRequest(TestGroupId("b"), DEFAULT_PRIORITY), IsOk());
[email protected]2b7523d2009-07-29 20:29:232054
2055 // Create a stalled group with high priorities.
Matt Menkec6b3edf72019-03-19 17:00:392056 EXPECT_THAT(StartRequest(TestGroupId("c"), kHighPriority),
2057 IsError(ERR_IO_PENDING));
2058 EXPECT_THAT(StartRequest(TestGroupId("c"), kHighPriority),
2059 IsError(ERR_IO_PENDING));
[email protected]2b7523d2009-07-29 20:29:232060
Matt Menkec6b3edf72019-03-19 17:00:392061 // Release the first two sockets from TestGroupId("a"). Because this is a
2062 // keepalive, the first release will unblock the pending request for
2063 // TestGroupId("a"). The second release will unblock a request for "c",
2064 // because it is the next high priority socket.
[email protected]2431756e2010-09-29 20:26:132065 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
2066 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
[email protected]2b7523d2009-07-29 20:29:232067
2068 // Closing idle sockets should not get us into trouble, but in the bug
2069 // we were hitting a CHECK here.
Matt Menkec6b3edf72019-03-19 17:00:392070 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke433de6d2020-03-04 00:24:112071 pool_->CloseIdleSockets("Very good reason");
[email protected]eb5a99382010-07-11 03:18:262072
[email protected]2da659e2013-05-23 20:51:342073 // Run the released socket wakeups.
fdoray5eeb7642016-06-22 16:11:282074 base::RunLoop().RunUntilIdle();
[email protected]2b7523d2009-07-29 20:29:232075}
2076
[email protected]4d3b05d2010-01-27 21:27:292077TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
[email protected]211d21722009-07-22 15:48:532078 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]5fc08e32009-07-15 17:09:572079
2080 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
[email protected]2431756e2010-09-29 20:26:132081 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522082 TestCompletionCallback callback;
Matt Reichhoff0049a0b72021-10-20 20:44:262083 NetLogWithSource net_log_with_source =
2084 NetLogWithSource::Make(NetLogSourceType::NONE);
Matt Menke28ac03e2019-02-25 22:25:502085 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522086 TestGroupId("a"), params_, absl::nullopt, LOWEST, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502087 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
Matt Reichhoff0049a0b72021-10-20 20:44:262088 ClientSocketPool::ProxyAuthCallback(), pool_.get(), net_log_with_source);
robpercival214763f2016-07-01 23:27:012089 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
Matt Menkec6b3edf72019-03-19 17:00:392090 EXPECT_EQ(LOAD_STATE_CONNECTING,
2091 pool_->GetLoadState(TestGroupId("a"), &handle));
[email protected]034df0f32013-01-07 23:17:482092 TestLoadTimingInfoNotConnected(handle);
2093
robpercival214763f2016-07-01 23:27:012094 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]2431756e2010-09-29 20:26:132095 EXPECT_TRUE(handle.is_initialized());
2096 EXPECT_TRUE(handle.socket());
[email protected]034df0f32013-01-07 23:17:482097 TestLoadTimingInfoConnectedNotReused(handle);
2098
[email protected]2431756e2010-09-29 20:26:132099 handle.Reset();
[email protected]034df0f32013-01-07 23:17:482100 TestLoadTimingInfoNotConnected(handle);
[email protected]fd7b7c92009-08-20 19:38:302101
Matt Reichhoff0049a0b72021-10-20 20:44:262102 auto entries =
2103 net_log_observer_.GetEntriesForSource(net_log_with_source.source());
[email protected]b2fcd0e2010-12-01 15:19:402104
Matt Menke9fa17d52019-03-25 19:12:262105 EXPECT_EQ(5u, entries.size());
[email protected]06650c52010-06-03 00:49:172106 EXPECT_TRUE(LogContainsEvent(
Matt Menke9fa17d52019-03-25 19:12:262107 entries, 0, NetLogEventType::TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKET,
mikecirone8b85c432016-09-08 19:11:002108 NetLogEventPhase::NONE));
Matt Menke9fa17d52019-03-25 19:12:262109 EXPECT_TRUE(LogContainsBeginEvent(entries, 1, NetLogEventType::SOCKET_POOL));
2110 EXPECT_TRUE(LogContainsEvent(
2111 entries, 2, NetLogEventType::SOCKET_POOL_BOUND_TO_CONNECT_JOB,
2112 NetLogEventPhase::NONE));
2113 EXPECT_TRUE(LogContainsEvent(entries, 3,
mikecirone8b85c432016-09-08 19:11:002114 NetLogEventType::SOCKET_POOL_BOUND_TO_SOCKET,
2115 NetLogEventPhase::NONE));
Matt Menke9fa17d52019-03-25 19:12:262116 EXPECT_TRUE(LogContainsEndEvent(entries, 4, NetLogEventType::SOCKET_POOL));
[email protected]5fc08e32009-07-15 17:09:572117}
2118
[email protected]4d3b05d2010-01-27 21:27:292119TEST_F(ClientSocketPoolBaseTest,
[email protected]5fc08e32009-07-15 17:09:572120 InitConnectionAsynchronousFailure) {
[email protected]211d21722009-07-22 15:48:532121 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]5fc08e32009-07-15 17:09:572122
2123 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
[email protected]2431756e2010-09-29 20:26:132124 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522125 TestCompletionCallback callback;
Matt Reichhoff0049a0b72021-10-20 20:44:262126 NetLogWithSource net_log_with_source =
2127 NetLogWithSource::Make(NetLogSourceType::NONE);
[email protected]e60e47a2010-07-14 03:37:182128 // Set the additional error state members to ensure that they get cleared.
[email protected]2431756e2010-09-29 20:26:132129 handle.set_is_ssl_error(true);
Matt Menke39b7c5a2019-04-10 19:47:512130 handle.set_ssl_cert_request_info(base::MakeRefCounted<SSLCertRequestInfo>());
Matt Menke28ac03e2019-02-25 22:25:502131 EXPECT_EQ(
2132 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522133 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282134 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2135 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
Matt Reichhoff0049a0b72021-10-20 20:44:262136 pool_.get(), net_log_with_source));
Matt Menkec6b3edf72019-03-19 17:00:392137 EXPECT_EQ(LOAD_STATE_CONNECTING,
2138 pool_->GetLoadState(TestGroupId("a"), &handle));
robpercival214763f2016-07-01 23:27:012139 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
[email protected]2431756e2010-09-29 20:26:132140 EXPECT_FALSE(handle.is_ssl_error());
Matt Menke39b7c5a2019-04-10 19:47:512141 EXPECT_FALSE(handle.ssl_cert_request_info());
[email protected]fd7b7c92009-08-20 19:38:302142
Matt Reichhoff0049a0b72021-10-20 20:44:262143 auto entries =
2144 net_log_observer_.GetEntriesForSource(net_log_with_source.source());
[email protected]b2fcd0e2010-12-01 15:19:402145
Matt Menke9fa17d52019-03-25 19:12:262146 EXPECT_EQ(4u, entries.size());
[email protected]06650c52010-06-03 00:49:172147 EXPECT_TRUE(LogContainsEvent(
Matt Menke9fa17d52019-03-25 19:12:262148 entries, 0, NetLogEventType::TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKET,
mikecirone8b85c432016-09-08 19:11:002149 NetLogEventPhase::NONE));
Matt Menke9fa17d52019-03-25 19:12:262150 EXPECT_TRUE(LogContainsBeginEvent(entries, 1, NetLogEventType::SOCKET_POOL));
2151 EXPECT_TRUE(LogContainsEvent(
2152 entries, 2, NetLogEventType::SOCKET_POOL_BOUND_TO_CONNECT_JOB,
2153 NetLogEventPhase::NONE));
2154 EXPECT_TRUE(LogContainsEndEvent(entries, 3, NetLogEventType::SOCKET_POOL));
[email protected]5fc08e32009-07-15 17:09:572155}
2156
mmenke6be122f2015-03-09 22:22:472157// Check that an async ConnectJob failure does not result in creation of a new
2158// ConnectJob when there's another pending request also waiting on its own
2159// ConnectJob. See http://crbug.com/463960.
2160TEST_F(ClientSocketPoolBaseTest, AsyncFailureWithPendingRequestWithJob) {
2161 CreatePool(2, 2);
2162 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
2163
Matt Menkec6b3edf72019-03-19 17:00:392164 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
2165 IsError(ERR_IO_PENDING));
2166 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
2167 IsError(ERR_IO_PENDING));
mmenke6be122f2015-03-09 22:22:472168
robpercival214763f2016-07-01 23:27:012169 EXPECT_THAT(request(0)->WaitForResult(), IsError(ERR_CONNECTION_FAILED));
2170 EXPECT_THAT(request(1)->WaitForResult(), IsError(ERR_CONNECTION_FAILED));
mmenke6be122f2015-03-09 22:22:472171
2172 EXPECT_EQ(2, client_socket_factory_.allocation_count());
2173}
2174
[email protected]4d3b05d2010-01-27 21:27:292175TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
[email protected]b22b5162010-03-16 07:53:102176 // TODO(eroman): Add back the log expectations! Removed them because the
2177 // ordering is difficult, and some may fire during destructor.
[email protected]211d21722009-07-22 15:48:532178 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]5fc08e32009-07-15 17:09:572179
2180 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
[email protected]2431756e2010-09-29 20:26:132181 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522182 TestCompletionCallback callback;
[email protected]2431756e2010-09-29 20:26:132183 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:522184 TestCompletionCallback callback2;
[email protected]5fc08e32009-07-15 17:09:572185
Matt Menke28ac03e2019-02-25 22:25:502186 EXPECT_EQ(
2187 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522188 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282189 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2190 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2191 pool_.get(), NetLogWithSource()));
Matt Reichhoff0049a0b72021-10-20 20:44:262192 RecordingNetLogObserver log2;
tfarina428341112016-09-22 13:38:202193 EXPECT_EQ(
2194 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522195 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282196 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502197 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2198 pool_.get(), NetLogWithSource()));
[email protected]5fc08e32009-07-15 17:09:572199
[email protected]2431756e2010-09-29 20:26:132200 handle.Reset();
[email protected]5fc08e32009-07-15 17:09:572201
[email protected]fd7b7c92009-08-20 19:38:302202
2203 // At this point, request 2 is just waiting for the connect job to finish.
[email protected]fd7b7c92009-08-20 19:38:302204
robpercival214763f2016-07-01 23:27:012205 EXPECT_THAT(callback2.WaitForResult(), IsOk());
[email protected]2431756e2010-09-29 20:26:132206 handle2.Reset();
[email protected]fd7b7c92009-08-20 19:38:302207
2208 // Now request 2 has actually finished.
[email protected]9e743cd2010-03-16 07:03:532209 // TODO(eroman): Add back log expectations.
[email protected]5fc08e32009-07-15 17:09:572210}
2211
[email protected]4d3b05d2010-01-27 21:27:292212TEST_F(ClientSocketPoolBaseTest, CancelRequestLimitsJobs) {
[email protected]974ebd62009-08-03 23:14:342213 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2214
[email protected]17a0c6c2009-08-04 00:07:042215 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2216
Matt Menkec6b3edf72019-03-19 17:00:392217 EXPECT_THAT(StartRequest(TestGroupId("a"), LOWEST), IsError(ERR_IO_PENDING));
2218 EXPECT_THAT(StartRequest(TestGroupId("a"), LOW), IsError(ERR_IO_PENDING));
2219 EXPECT_THAT(StartRequest(TestGroupId("a"), MEDIUM), IsError(ERR_IO_PENDING));
2220 EXPECT_THAT(StartRequest(TestGroupId("a"), HIGHEST), IsError(ERR_IO_PENDING));
[email protected]974ebd62009-08-03 23:14:342221
Raul Tambre8335a6d2019-02-21 16:57:432222 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
Matt Menke9fa17d52019-03-25 19:12:262223 static_cast<int>(
2224 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a"))));
[email protected]2431756e2010-09-29 20:26:132225 (*requests())[2]->handle()->Reset();
2226 (*requests())[3]->handle()->Reset();
Raul Tambre8335a6d2019-02-21 16:57:432227 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
Matt Menke9fa17d52019-03-25 19:12:262228 static_cast<int>(
2229 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a"))));
[email protected]974ebd62009-08-03 23:14:342230
[email protected]2431756e2010-09-29 20:26:132231 (*requests())[1]->handle()->Reset();
Raul Tambre8335a6d2019-02-21 16:57:432232 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
Matt Menke9fa17d52019-03-25 19:12:262233 static_cast<int>(
2234 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a"))));
[email protected]974ebd62009-08-03 23:14:342235
[email protected]2431756e2010-09-29 20:26:132236 (*requests())[0]->handle()->Reset();
Raul Tambre8335a6d2019-02-21 16:57:432237 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
Matt Menke9fa17d52019-03-25 19:12:262238 static_cast<int>(
2239 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a"))));
[email protected]974ebd62009-08-03 23:14:342240}
2241
[email protected]5fc08e32009-07-15 17:09:572242// When requests and ConnectJobs are not coupled, the request will get serviced
2243// by whatever comes first.
[email protected]4d3b05d2010-01-27 21:27:292244TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
[email protected]211d21722009-07-22 15:48:532245 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]5fc08e32009-07-15 17:09:572246
2247 // Start job 1 (async OK)
[email protected]b59ff372009-07-15 22:04:322248 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
[email protected]5fc08e32009-07-15 17:09:572249
[email protected]2431756e2010-09-29 20:26:132250 std::vector<TestSocketRequest*> request_order;
2251 size_t completion_count; // unused
2252 TestSocketRequest req1(&request_order, &completion_count);
Matt Menke28ac03e2019-02-25 22:25:502253 int rv = req1.handle()->Init(
Anton Bikineev068d2912021-05-15 20:43:522254 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502255 ClientSocketPool::RespectLimits::ENABLED, req1.callback(),
2256 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012257 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2258 EXPECT_THAT(req1.WaitForResult(), IsOk());
[email protected]5fc08e32009-07-15 17:09:572259
2260 // Job 1 finished OK. Start job 2 (also async OK). Request 3 is pending
2261 // without a job.
2262 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2263
[email protected]2431756e2010-09-29 20:26:132264 TestSocketRequest req2(&request_order, &completion_count);
Matt Menke28ac03e2019-02-25 22:25:502265 rv = req2.handle()->Init(
Anton Bikineev068d2912021-05-15 20:43:522266 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502267 ClientSocketPool::RespectLimits::ENABLED, req2.callback(),
2268 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012269 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]2431756e2010-09-29 20:26:132270 TestSocketRequest req3(&request_order, &completion_count);
Matt Menke28ac03e2019-02-25 22:25:502271 rv = req3.handle()->Init(
Anton Bikineev068d2912021-05-15 20:43:522272 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502273 ClientSocketPool::RespectLimits::ENABLED, req3.callback(),
2274 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012275 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]5fc08e32009-07-15 17:09:572276
2277 // Both Requests 2 and 3 are pending. We release socket 1 which should
2278 // service request 2. Request 3 should still be waiting.
[email protected]a6c59f62009-07-29 16:33:332279 req1.handle()->Reset();
[email protected]2da659e2013-05-23 20:51:342280 // Run the released socket wakeups.
fdoray5eeb7642016-06-22 16:11:282281 base::RunLoop().RunUntilIdle();
[email protected]a6c59f62009-07-29 16:33:332282 ASSERT_TRUE(req2.handle()->socket());
robpercival214763f2016-07-01 23:27:012283 EXPECT_THAT(req2.WaitForResult(), IsOk());
[email protected]a6c59f62009-07-29 16:33:332284 EXPECT_FALSE(req3.handle()->socket());
[email protected]5fc08e32009-07-15 17:09:572285
2286 // Signal job 2, which should service request 3.
2287
2288 client_socket_factory_.SignalJobs();
robpercival214763f2016-07-01 23:27:012289 EXPECT_THAT(req3.WaitForResult(), IsOk());
[email protected]5fc08e32009-07-15 17:09:572290
Raul Tambre8335a6d2019-02-21 16:57:432291 ASSERT_EQ(3u, request_order.size());
[email protected]2431756e2010-09-29 20:26:132292 EXPECT_EQ(&req1, request_order[0]);
2293 EXPECT_EQ(&req2, request_order[1]);
2294 EXPECT_EQ(&req3, request_order[2]);
Matt Menkec6b3edf72019-03-19 17:00:392295 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]5fc08e32009-07-15 17:09:572296}
2297
2298// The requests are not coupled to the jobs. So, the requests should finish in
2299// their priority / insertion order.
[email protected]4d3b05d2010-01-27 21:27:292300TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
[email protected]211d21722009-07-22 15:48:532301 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]5fc08e32009-07-15 17:09:572302 // First two jobs are async.
[email protected]b59ff372009-07-15 22:04:322303 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
[email protected]5fc08e32009-07-15 17:09:572304
[email protected]2431756e2010-09-29 20:26:132305 std::vector<TestSocketRequest*> request_order;
2306 size_t completion_count; // unused
2307 TestSocketRequest req1(&request_order, &completion_count);
Matt Menke28ac03e2019-02-25 22:25:502308 int rv = req1.handle()->Init(
Anton Bikineev068d2912021-05-15 20:43:522309 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502310 ClientSocketPool::RespectLimits::ENABLED, req1.callback(),
2311 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012312 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]5fc08e32009-07-15 17:09:572313
[email protected]2431756e2010-09-29 20:26:132314 TestSocketRequest req2(&request_order, &completion_count);
Matt Menke28ac03e2019-02-25 22:25:502315 rv = req2.handle()->Init(
Anton Bikineev068d2912021-05-15 20:43:522316 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502317 ClientSocketPool::RespectLimits::ENABLED, req2.callback(),
2318 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012319 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]5fc08e32009-07-15 17:09:572320
2321 // The pending job is sync.
[email protected]b59ff372009-07-15 22:04:322322 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
[email protected]5fc08e32009-07-15 17:09:572323
[email protected]2431756e2010-09-29 20:26:132324 TestSocketRequest req3(&request_order, &completion_count);
Matt Menke28ac03e2019-02-25 22:25:502325 rv = req3.handle()->Init(
Anton Bikineev068d2912021-05-15 20:43:522326 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502327 ClientSocketPool::RespectLimits::ENABLED, req3.callback(),
2328 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012329 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]5fc08e32009-07-15 17:09:572330
robpercival214763f2016-07-01 23:27:012331 EXPECT_THAT(req1.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
2332 EXPECT_THAT(req2.WaitForResult(), IsOk());
2333 EXPECT_THAT(req3.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
[email protected]5fc08e32009-07-15 17:09:572334
Raul Tambre8335a6d2019-02-21 16:57:432335 ASSERT_EQ(3u, request_order.size());
[email protected]2431756e2010-09-29 20:26:132336 EXPECT_EQ(&req1, request_order[0]);
2337 EXPECT_EQ(&req2, request_order[1]);
2338 EXPECT_EQ(&req3, request_order[2]);
[email protected]5fc08e32009-07-15 17:09:572339}
2340
[email protected]03b7c8c2013-07-20 04:38:552341// Test GetLoadState in the case there's only one socket request.
2342TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) {
[email protected]211d21722009-07-22 15:48:532343 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
[email protected]03b7c8c2013-07-20 04:38:552344 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
[email protected]5fc08e32009-07-15 17:09:572345
[email protected]2431756e2010-09-29 20:26:132346 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522347 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502348 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522349 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502350 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2351 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012352 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]03b7c8c2013-07-20 04:38:552353 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
[email protected]5fc08e32009-07-15 17:09:572354
[email protected]03b7c8c2013-07-20 04:38:552355 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
2356 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
2357
2358 // No point in completing the connection, since ClientSocketHandles only
2359 // expect the LoadState to be checked while connecting.
2360}
2361
2362// Test GetLoadState in the case there are two socket requests.
2363TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
2364 CreatePool(2, 2);
2365 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2366
2367 ClientSocketHandle handle;
2368 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502369 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522370 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502371 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2372 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012373 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
haavardm835c1d62015-04-22 08:18:002374 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
2375
2376 ClientSocketHandle handle2;
2377 TestCompletionCallback callback2;
Anton Bikineev068d2912021-05-15 20:43:522378 rv = handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282379 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502380 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2381 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012382 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
haavardm835c1d62015-04-22 08:18:002383 client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
2384
Matt Menke4b69f932019-03-04 16:20:012385 // Each handle should reflect the state of its own job.
haavardm835c1d62015-04-22 08:18:002386 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle.GetLoadState());
2387 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle2.GetLoadState());
2388
Matt Menke4b69f932019-03-04 16:20:012389 // Update the state of the first job.
haavardm835c1d62015-04-22 08:18:002390 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_CONNECTING);
2391
Matt Menke4b69f932019-03-04 16:20:012392 // Only the state of the first request should have changed.
haavardm835c1d62015-04-22 08:18:002393 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
haavardm835c1d62015-04-22 08:18:002394 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle2.GetLoadState());
Matt Menke4b69f932019-03-04 16:20:012395
2396 // Update the state of the second job.
2397 client_socket_factory_.SetJobLoadState(1, LOAD_STATE_SSL_HANDSHAKE);
2398
2399 // Only the state of the second request should have changed.
2400 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2401 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState());
2402
2403 // Second job connects and the first request gets the socket. The
2404 // second handle switches to the state of the remaining ConnectJob.
2405 client_socket_factory_.SignalJob(1);
2406 EXPECT_THAT(callback.WaitForResult(), IsOk());
2407 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
[email protected]03b7c8c2013-07-20 04:38:552408}
2409
2410// Test GetLoadState in the case the per-group limit is reached.
2411TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
2412 CreatePool(2, 1);
2413 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2414
2415 ClientSocketHandle handle;
2416 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502417 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522418 TestGroupId("a"), params_, absl::nullopt, MEDIUM, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502419 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2420 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012421 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]03b7c8c2013-07-20 04:38:552422 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2423
2424 // Request another socket from the same pool, buth with a higher priority.
2425 // The first request should now be stalled at the socket group limit.
2426 ClientSocketHandle handle2;
2427 TestCompletionCallback callback2;
Anton Bikineev068d2912021-05-15 20:43:522428 rv = handle2.Init(TestGroupId("a"), params_, absl::nullopt, HIGHEST,
Matt Menkef09e64c2019-04-23 22:16:282429 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502430 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2431 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012432 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]03b7c8c2013-07-20 04:38:552433 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2434 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
2435
2436 // The first handle should remain stalled as the other socket goes through
2437 // the connect process.
2438
2439 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
2440 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2441 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState());
2442
2443 client_socket_factory_.SignalJob(0);
robpercival214763f2016-07-01 23:27:012444 EXPECT_THAT(callback2.WaitForResult(), IsOk());
[email protected]03b7c8c2013-07-20 04:38:552445 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2446
2447 // Closing the second socket should cause the stalled handle to finally get a
2448 // ConnectJob.
2449 handle2.socket()->Disconnect();
2450 handle2.Reset();
2451 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2452}
2453
2454// Test GetLoadState in the case the per-pool limit is reached.
2455TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
2456 CreatePool(2, 2);
2457 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2458
2459 ClientSocketHandle handle;
2460 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502461 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522462 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502463 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2464 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012465 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]03b7c8c2013-07-20 04:38:552466
2467 // Request for socket from another pool.
2468 ClientSocketHandle handle2;
2469 TestCompletionCallback callback2;
Anton Bikineev068d2912021-05-15 20:43:522470 rv = handle2.Init(TestGroupId("b"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282471 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502472 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2473 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012474 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]03b7c8c2013-07-20 04:38:552475
2476 // Request another socket from the first pool. Request should stall at the
2477 // socket pool limit.
2478 ClientSocketHandle handle3;
2479 TestCompletionCallback callback3;
Anton Bikineev068d2912021-05-15 20:43:522480 rv = handle3.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282481 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502482 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2483 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012484 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]03b7c8c2013-07-20 04:38:552485
2486 // The third handle should remain stalled as the other sockets in its group
2487 // goes through the connect process.
2488
2489 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2490 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2491
2492 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
2493 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
2494 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2495
2496 client_socket_factory_.SignalJob(0);
robpercival214763f2016-07-01 23:27:012497 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]03b7c8c2013-07-20 04:38:552498 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2499
2500 // Closing a socket should allow the stalled handle to finally get a new
2501 // ConnectJob.
2502 handle.socket()->Disconnect();
2503 handle.Reset();
2504 EXPECT_EQ(LOAD_STATE_CONNECTING, handle3.GetLoadState());
[email protected]5fc08e32009-07-15 17:09:572505}
2506
Matt Menkeb57663b32019-03-01 17:17:102507TEST_F(ClientSocketPoolBaseTest, CertError) {
[email protected]e772db3f2010-07-12 18:11:132508 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
Matt Menkeb57663b32019-03-01 17:17:102509 connect_job_factory_->set_job_type(TestConnectJob::kMockCertErrorJob);
[email protected]e772db3f2010-07-12 18:11:132510
[email protected]2431756e2010-09-29 20:26:132511 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522512 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502513 EXPECT_EQ(
Matt Menkeb57663b32019-03-01 17:17:102514 ERR_CERT_COMMON_NAME_INVALID,
Anton Bikineev068d2912021-05-15 20:43:522515 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282516 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2517 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2518 pool_.get(), NetLogWithSource()));
[email protected]2431756e2010-09-29 20:26:132519 EXPECT_TRUE(handle.is_initialized());
2520 EXPECT_TRUE(handle.socket());
[email protected]e772db3f2010-07-12 18:11:132521}
2522
Matt Menkeb57663b32019-03-01 17:17:102523TEST_F(ClientSocketPoolBaseTest, AsyncCertError) {
[email protected]e772db3f2010-07-12 18:11:132524 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2525
Matt Menkeb57663b32019-03-01 17:17:102526 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingCertErrorJob);
[email protected]2431756e2010-09-29 20:26:132527 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522528 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502529 EXPECT_EQ(
2530 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522531 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282532 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2533 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2534 pool_.get(), NetLogWithSource()));
Matt Menkec6b3edf72019-03-19 17:00:392535 EXPECT_EQ(LOAD_STATE_CONNECTING,
2536 pool_->GetLoadState(TestGroupId("a"), &handle));
Matt Menkeb57663b32019-03-01 17:17:102537 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CERT_COMMON_NAME_INVALID));
[email protected]2431756e2010-09-29 20:26:132538 EXPECT_TRUE(handle.is_initialized());
2539 EXPECT_TRUE(handle.socket());
[email protected]e772db3f2010-07-12 18:11:132540}
2541
[email protected]e60e47a2010-07-14 03:37:182542TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
2543 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2544 connect_job_factory_->set_job_type(
2545 TestConnectJob::kMockAdditionalErrorStateJob);
2546
[email protected]2431756e2010-09-29 20:26:132547 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522548 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502549 EXPECT_EQ(
2550 ERR_CONNECTION_FAILED,
Anton Bikineev068d2912021-05-15 20:43:522551 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282552 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2553 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2554 pool_.get(), NetLogWithSource()));
[email protected]2431756e2010-09-29 20:26:132555 EXPECT_FALSE(handle.is_initialized());
2556 EXPECT_FALSE(handle.socket());
2557 EXPECT_TRUE(handle.is_ssl_error());
Matt Menke39b7c5a2019-04-10 19:47:512558 EXPECT_TRUE(handle.ssl_cert_request_info());
[email protected]e60e47a2010-07-14 03:37:182559}
2560
2561TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
2562 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2563
2564 connect_job_factory_->set_job_type(
2565 TestConnectJob::kMockPendingAdditionalErrorStateJob);
[email protected]2431756e2010-09-29 20:26:132566 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522567 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502568 EXPECT_EQ(
2569 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522570 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282571 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2572 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2573 pool_.get(), NetLogWithSource()));
Matt Menkec6b3edf72019-03-19 17:00:392574 EXPECT_EQ(LOAD_STATE_CONNECTING,
2575 pool_->GetLoadState(TestGroupId("a"), &handle));
robpercival214763f2016-07-01 23:27:012576 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
[email protected]2431756e2010-09-29 20:26:132577 EXPECT_FALSE(handle.is_initialized());
2578 EXPECT_FALSE(handle.socket());
2579 EXPECT_TRUE(handle.is_ssl_error());
Matt Menke39b7c5a2019-04-10 19:47:512580 EXPECT_TRUE(handle.ssl_cert_request_info());
[email protected]e60e47a2010-07-14 03:37:182581}
2582
martijn003cd612016-05-19 22:24:382583// Make sure we can reuse sockets.
2584TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSocketsReuse) {
[email protected]64770b7d2011-11-16 04:30:412585 CreatePoolWithIdleTimeouts(
2586 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
[email protected]e7b1c6d2c2012-05-05 00:54:032587 base::TimeDelta(), // Time out unused sockets immediately.
Peter Kastinge5a38ed2021-10-02 03:06:352588 base::Days(1)); // Don't time out used sockets.
[email protected]e7b1c6d2c2012-05-05 00:54:032589
2590 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2591
2592 ClientSocketHandle handle;
2593 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502594 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522595 TestGroupId("a"), params_, absl::nullopt, LOWEST, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502596 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2597 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012598 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
Matt Menkec6b3edf72019-03-19 17:00:392599 EXPECT_EQ(LOAD_STATE_CONNECTING,
2600 pool_->GetLoadState(TestGroupId("a"), &handle));
robpercival214763f2016-07-01 23:27:012601 ASSERT_THAT(callback.WaitForResult(), IsOk());
[email protected]e7b1c6d2c2012-05-05 00:54:032602
2603 // Use and release the socket.
Raul Tambre94493c652019-03-11 17:18:352604 EXPECT_EQ(1, handle.socket()->Write(nullptr, 1, CompletionOnceCallback(),
Ramin Halavati0a08cc82018-02-06 07:46:382605 TRAFFIC_ANNOTATION_FOR_TESTS));
[email protected]034df0f32013-01-07 23:17:482606 TestLoadTimingInfoConnectedNotReused(handle);
[email protected]e7b1c6d2c2012-05-05 00:54:032607 handle.Reset();
2608
2609 // Should now have one idle socket.
2610 ASSERT_EQ(1, pool_->IdleSocketCount());
2611
2612 // Request a new socket. This should reuse the old socket and complete
2613 // synchronously.
Matt Reichhoff0049a0b72021-10-20 20:44:262614 NetLogWithSource net_log_with_source =
2615 NetLogWithSource::Make(NetLogSourceType::NONE);
Matt Menke28ac03e2019-02-25 22:25:502616 rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522617 TestGroupId("a"), params_, absl::nullopt, LOWEST, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502618 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
Matt Reichhoff0049a0b72021-10-20 20:44:262619 ClientSocketPool::ProxyAuthCallback(), pool_.get(), net_log_with_source);
robpercival214763f2016-07-01 23:27:012620 ASSERT_THAT(rv, IsOk());
[email protected]e7b1c6d2c2012-05-05 00:54:032621 EXPECT_TRUE(handle.is_reused());
[email protected]034df0f32013-01-07 23:17:482622 TestLoadTimingInfoConnectedReused(handle);
[email protected]e7b1c6d2c2012-05-05 00:54:032623
Matt Menke9fa17d52019-03-25 19:12:262624 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:392625 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:262626 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
[email protected]e7b1c6d2c2012-05-05 00:54:032627
Matt Reichhoff0049a0b72021-10-20 20:44:262628 auto entries =
2629 net_log_observer_.GetEntriesForSource(net_log_with_source.source());
Matt Menke9fa17d52019-03-25 19:12:262630 EXPECT_TRUE(LogContainsEvent(
2631 entries, 0, NetLogEventType::TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKET,
2632 NetLogEventPhase::NONE));
2633 EXPECT_TRUE(LogContainsBeginEvent(entries, 1, NetLogEventType::SOCKET_POOL));
[email protected]e7b1c6d2c2012-05-05 00:54:032634 EXPECT_TRUE(LogContainsEntryWithType(
Matt Menke9fa17d52019-03-25 19:12:262635 entries, 2, NetLogEventType::SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
[email protected]e7b1c6d2c2012-05-05 00:54:032636}
2637
martijn003cd612016-05-19 22:24:382638// Make sure we cleanup old unused sockets.
Eric Romanb49715e2018-04-24 22:41:172639TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSocketsNoReuse) {
[email protected]e7b1c6d2c2012-05-05 00:54:032640 CreatePoolWithIdleTimeouts(
2641 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2642 base::TimeDelta(), // Time out unused sockets immediately
2643 base::TimeDelta()); // Time out used sockets immediately
[email protected]64770b7d2011-11-16 04:30:412644
2645 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2646
2647 // Startup two mock pending connect jobs, which will sit in the MessageLoop.
2648
2649 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522650 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502651 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522652 TestGroupId("a"), params_, absl::nullopt, LOWEST, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502653 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2654 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012655 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
Matt Menkec6b3edf72019-03-19 17:00:392656 EXPECT_EQ(LOAD_STATE_CONNECTING,
2657 pool_->GetLoadState(TestGroupId("a"), &handle));
[email protected]64770b7d2011-11-16 04:30:412658
2659 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:522660 TestCompletionCallback callback2;
Anton Bikineev068d2912021-05-15 20:43:522661 rv = handle2.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:282662 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502663 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2664 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012665 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
Matt Menkec6b3edf72019-03-19 17:00:392666 EXPECT_EQ(LOAD_STATE_CONNECTING,
2667 pool_->GetLoadState(TestGroupId("a"), &handle2));
[email protected]64770b7d2011-11-16 04:30:412668
2669 // Cancel one of the requests. Wait for the other, which will get the first
2670 // job. Release the socket. Run the loop again to make sure the second
2671 // socket is sitting idle and the first one is released (since ReleaseSocket()
2672 // just posts a DoReleaseSocket() task).
2673
2674 handle.Reset();
robpercival214763f2016-07-01 23:27:012675 ASSERT_THAT(callback2.WaitForResult(), IsOk());
Matt Menke433de6d2020-03-04 00:24:112676 // Get the NetLogSource for the socket, so the time out reason can be checked
2677 // at the end of the test.
2678 NetLogSource net_log_source2 = handle2.socket()->NetLog().source();
[email protected]64770b7d2011-11-16 04:30:412679 // Use the socket.
Raul Tambre94493c652019-03-11 17:18:352680 EXPECT_EQ(1, handle2.socket()->Write(nullptr, 1, CompletionOnceCallback(),
Ramin Halavati0a08cc82018-02-06 07:46:382681 TRAFFIC_ANNOTATION_FOR_TESTS));
[email protected]64770b7d2011-11-16 04:30:412682 handle2.Reset();
2683
[email protected]e7b1c6d2c2012-05-05 00:54:032684 // We post all of our delayed tasks with a 2ms delay. I.e. they don't
2685 // actually become pending until 2ms after they have been created. In order
2686 // to flush all tasks, we need to wait so that we know there are no
2687 // soon-to-be-pending tasks waiting.
Peter Kastinge5a38ed2021-10-02 03:06:352688 FastForwardBy(base::Milliseconds(10));
[email protected]64770b7d2011-11-16 04:30:412689
[email protected]e7b1c6d2c2012-05-05 00:54:032690 // Both sockets should now be idle.
[email protected]64770b7d2011-11-16 04:30:412691 ASSERT_EQ(2, pool_->IdleSocketCount());
2692
2693 // Request a new socket. This should cleanup the unused and timed out ones.
2694 // A new socket will be created rather than reusing the idle one.
Matt Reichhoff0049a0b72021-10-20 20:44:262695 NetLogWithSource net_log_with_source =
2696 NetLogWithSource::Make(NetLogSourceType::NONE);
[email protected]6ecf2b92011-12-15 01:14:522697 TestCompletionCallback callback3;
Anton Bikineev068d2912021-05-15 20:43:522698 rv = handle.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:282699 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502700 callback3.callback(), ClientSocketPool::ProxyAuthCallback(),
Matt Reichhoff0049a0b72021-10-20 20:44:262701 pool_.get(), net_log_with_source);
robpercival214763f2016-07-01 23:27:012702 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
2703 ASSERT_THAT(callback3.WaitForResult(), IsOk());
[email protected]64770b7d2011-11-16 04:30:412704 EXPECT_FALSE(handle.is_reused());
2705
[email protected]e7b1c6d2c2012-05-05 00:54:032706 // Make sure the idle socket is closed.
Matt Menke9fa17d52019-03-25 19:12:262707 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:392708 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:262709 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
[email protected]64770b7d2011-11-16 04:30:412710
Matt Reichhoff0049a0b72021-10-20 20:44:262711 auto entries =
2712 net_log_observer_.GetEntriesForSource(net_log_with_source.source());
[email protected]64770b7d2011-11-16 04:30:412713 EXPECT_FALSE(LogContainsEntryWithType(
mikecirone8b85c432016-09-08 19:11:002714 entries, 1, NetLogEventType::SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
Matt Menke433de6d2020-03-04 00:24:112715 ExpectSocketClosedWithReason(
2716 net_log_source2, TransportClientSocketPool::kIdleTimeLimitExpired);
[email protected]64770b7d2011-11-16 04:30:412717}
2718
[email protected]2041cf342010-02-19 03:15:592719// Make sure that we process all pending requests even when we're stalling
[email protected]4f2abec2010-02-03 18:10:162720// because of multiple releasing disconnected sockets.
2721TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
2722 CreatePoolWithIdleTimeouts(
2723 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2724 base::TimeDelta(), // Time out unused sockets immediately.
Peter Kastinge5a38ed2021-10-02 03:06:352725 base::Days(1)); // Don't time out used sockets.
[email protected]4f2abec2010-02-03 18:10:162726
2727 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2728
2729 // Startup 4 connect jobs. Two of them will be pending.
2730
[email protected]2431756e2010-09-29 20:26:132731 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522732 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502733 int rv = handle.Init(
Anton Bikineev068d2912021-05-15 20:43:522734 TestGroupId("a"), params_, absl::nullopt, LOWEST, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:502735 ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
2736 ClientSocketPool::ProxyAuthCallback(), pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012737 EXPECT_THAT(rv, IsOk());
[email protected]4f2abec2010-02-03 18:10:162738
[email protected]2431756e2010-09-29 20:26:132739 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:522740 TestCompletionCallback callback2;
Anton Bikineev068d2912021-05-15 20:43:522741 rv = handle2.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:282742 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502743 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
2744 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012745 EXPECT_THAT(rv, IsOk());
[email protected]4f2abec2010-02-03 18:10:162746
[email protected]2431756e2010-09-29 20:26:132747 ClientSocketHandle handle3;
[email protected]6ecf2b92011-12-15 01:14:522748 TestCompletionCallback callback3;
Anton Bikineev068d2912021-05-15 20:43:522749 rv = handle3.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:282750 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502751 callback3.callback(), ClientSocketPool::ProxyAuthCallback(),
2752 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012753 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]4f2abec2010-02-03 18:10:162754
[email protected]2431756e2010-09-29 20:26:132755 ClientSocketHandle handle4;
[email protected]6ecf2b92011-12-15 01:14:522756 TestCompletionCallback callback4;
Anton Bikineev068d2912021-05-15 20:43:522757 rv = handle4.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:282758 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:502759 callback4.callback(), ClientSocketPool::ProxyAuthCallback(),
2760 pool_.get(), NetLogWithSource());
robpercival214763f2016-07-01 23:27:012761 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
[email protected]4f2abec2010-02-03 18:10:162762
2763 // Release two disconnected sockets.
2764
[email protected]2431756e2010-09-29 20:26:132765 handle.socket()->Disconnect();
2766 handle.Reset();
2767 handle2.socket()->Disconnect();
2768 handle2.Reset();
[email protected]4f2abec2010-02-03 18:10:162769
robpercival214763f2016-07-01 23:27:012770 EXPECT_THAT(callback3.WaitForResult(), IsOk());
[email protected]2431756e2010-09-29 20:26:132771 EXPECT_FALSE(handle3.is_reused());
robpercival214763f2016-07-01 23:27:012772 EXPECT_THAT(callback4.WaitForResult(), IsOk());
[email protected]2431756e2010-09-29 20:26:132773 EXPECT_FALSE(handle4.is_reused());
[email protected]4f2abec2010-02-03 18:10:162774}
2775
[email protected]d7027bb2010-05-10 18:58:542776// Regression test for http://crbug.com/42267.
2777// When DoReleaseSocket() is processed for one socket, it is blocked because the
2778// other stalled groups all have releasing sockets, so no progress can be made.
2779TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) {
2780 CreatePoolWithIdleTimeouts(
2781 4 /* socket limit */, 4 /* socket limit per group */,
2782 base::TimeDelta(), // Time out unused sockets immediately.
Peter Kastinge5a38ed2021-10-02 03:06:352783 base::Days(1)); // Don't time out used sockets.
[email protected]d7027bb2010-05-10 18:58:542784
2785 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2786
2787 // Max out the socket limit with 2 per group.
2788
[email protected]2431756e2010-09-29 20:26:132789 ClientSocketHandle handle_a[4];
[email protected]6ecf2b92011-12-15 01:14:522790 TestCompletionCallback callback_a[4];
[email protected]2431756e2010-09-29 20:26:132791 ClientSocketHandle handle_b[4];
[email protected]6ecf2b92011-12-15 01:14:522792 TestCompletionCallback callback_b[4];
[email protected]d7027bb2010-05-10 18:58:542793
2794 for (int i = 0; i < 2; ++i) {
Anton Bikineev068d2912021-05-15 20:43:522795 EXPECT_EQ(OK, handle_a[i].Init(TestGroupId("a"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:282796 LOWEST, SocketTag(),
2797 ClientSocketPool::RespectLimits::ENABLED,
2798 callback_a[i].callback(),
2799 ClientSocketPool::ProxyAuthCallback(),
2800 pool_.get(), NetLogWithSource()));
Anton Bikineev068d2912021-05-15 20:43:522801 EXPECT_EQ(OK, handle_b[i].Init(TestGroupId("b"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:282802 LOWEST, SocketTag(),
2803 ClientSocketPool::RespectLimits::ENABLED,
2804 callback_b[i].callback(),
2805 ClientSocketPool::ProxyAuthCallback(),
2806 pool_.get(), NetLogWithSource()));
[email protected]d7027bb2010-05-10 18:58:542807 }
[email protected]b89f7e42010-05-20 20:37:002808
[email protected]d7027bb2010-05-10 18:58:542809 // Make 4 pending requests, 2 per group.
2810
2811 for (int i = 2; i < 4; ++i) {
Matt Menkef09e64c2019-04-23 22:16:282812 EXPECT_EQ(
2813 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522814 handle_a[i].Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:282815 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2816 callback_a[i].callback(),
2817 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
2818 NetLogWithSource()));
2819 EXPECT_EQ(
2820 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522821 handle_b[i].Init(TestGroupId("b"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:282822 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2823 callback_b[i].callback(),
2824 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
2825 NetLogWithSource()));
[email protected]d7027bb2010-05-10 18:58:542826 }
2827
2828 // Release b's socket first. The order is important, because in
2829 // DoReleaseSocket(), we'll process b's released socket, and since both b and
2830 // a are stalled, but 'a' is lower lexicographically, we'll process group 'a'
2831 // first, which has a releasing socket, so it refuses to start up another
2832 // ConnectJob. So, we used to infinite loop on this.
[email protected]2431756e2010-09-29 20:26:132833 handle_b[0].socket()->Disconnect();
2834 handle_b[0].Reset();
2835 handle_a[0].socket()->Disconnect();
2836 handle_a[0].Reset();
[email protected]d7027bb2010-05-10 18:58:542837
2838 // Used to get stuck here.
fdoray5eeb7642016-06-22 16:11:282839 base::RunLoop().RunUntilIdle();
[email protected]d7027bb2010-05-10 18:58:542840
[email protected]2431756e2010-09-29 20:26:132841 handle_b[1].socket()->Disconnect();
2842 handle_b[1].Reset();
2843 handle_a[1].socket()->Disconnect();
2844 handle_a[1].Reset();
[email protected]d7027bb2010-05-10 18:58:542845
2846 for (int i = 2; i < 4; ++i) {
robpercival214763f2016-07-01 23:27:012847 EXPECT_THAT(callback_b[i].WaitForResult(), IsOk());
2848 EXPECT_THAT(callback_a[i].WaitForResult(), IsOk());
[email protected]d7027bb2010-05-10 18:58:542849 }
2850}
2851
[email protected]fd4fe0b2010-02-08 23:02:152852TEST_F(ClientSocketPoolBaseTest,
2853 ReleasingDisconnectedSocketsMaintainsPriorityOrder) {
2854 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2855
2856 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2857
Matt Menkec6b3edf72019-03-19 17:00:392858 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
2859 IsError(ERR_IO_PENDING));
2860 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
2861 IsError(ERR_IO_PENDING));
2862 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
2863 IsError(ERR_IO_PENDING));
2864 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY),
2865 IsError(ERR_IO_PENDING));
[email protected]fd4fe0b2010-02-08 23:02:152866
robpercival214763f2016-07-01 23:27:012867 EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());
2868 EXPECT_THAT((*requests())[1]->WaitForResult(), IsOk());
[email protected]2431756e2010-09-29 20:26:132869 EXPECT_EQ(2u, completion_count());
[email protected]fd4fe0b2010-02-08 23:02:152870
2871 // Releases one connection.
[email protected]2431756e2010-09-29 20:26:132872 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
robpercival214763f2016-07-01 23:27:012873 EXPECT_THAT((*requests())[2]->WaitForResult(), IsOk());
[email protected]fd4fe0b2010-02-08 23:02:152874
[email protected]2431756e2010-09-29 20:26:132875 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
robpercival214763f2016-07-01 23:27:012876 EXPECT_THAT((*requests())[3]->WaitForResult(), IsOk());
[email protected]2431756e2010-09-29 20:26:132877 EXPECT_EQ(4u, completion_count());
[email protected]fd4fe0b2010-02-08 23:02:152878
2879 EXPECT_EQ(1, GetOrderOfRequest(1));
2880 EXPECT_EQ(2, GetOrderOfRequest(2));
2881 EXPECT_EQ(3, GetOrderOfRequest(3));
2882 EXPECT_EQ(4, GetOrderOfRequest(4));
2883
2884 // Make sure we test order of all requests made.
[email protected]2431756e2010-09-29 20:26:132885 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(5));
[email protected]fd4fe0b2010-02-08 23:02:152886}
2887
[email protected]6ecf2b92011-12-15 01:14:522888class TestReleasingSocketRequest : public TestCompletionCallbackBase {
[email protected]4f1e4982010-03-02 18:31:042889 public:
Matt Menke9fa17d52019-03-25 19:12:262890 TestReleasingSocketRequest(TransportClientSocketPool* pool,
[email protected]2431756e2010-09-29 20:26:132891 int expected_result,
[email protected]e60e47a2010-07-14 03:37:182892 bool reset_releasing_handle)
2893 : pool_(pool),
2894 expected_result_(expected_result),
Bence Béky8ddc2492018-06-13 01:02:042895 reset_releasing_handle_(reset_releasing_handle) {}
[email protected]6ecf2b92011-12-15 01:14:522896
Chris Watkins7a41d3552017-12-01 02:13:272897 ~TestReleasingSocketRequest() override = default;
[email protected]4f1e4982010-03-02 18:31:042898
2899 ClientSocketHandle* handle() { return &handle_; }
2900
Bence Béky8ddc2492018-06-13 01:02:042901 CompletionOnceCallback callback() {
2902 return base::BindOnce(&TestReleasingSocketRequest::OnComplete,
2903 base::Unretained(this));
2904 }
[email protected]4f1e4982010-03-02 18:31:042905
2906 private:
[email protected]6ecf2b92011-12-15 01:14:522907 void OnComplete(int result) {
2908 SetResult(result);
2909 if (reset_releasing_handle_)
2910 handle_.Reset();
2911
Matt Menkec6b3edf72019-03-19 17:00:392912 EXPECT_EQ(
2913 expected_result_,
Matt Menke870e19ab2019-04-23 16:23:032914 handle2_.Init(
2915 TestGroupId("a"),
2916 ClientSocketPool::SocketParams::CreateForHttpForTesting(),
Anton Bikineev068d2912021-05-15 20:43:522917 absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menke870e19ab2019-04-23 16:23:032918 ClientSocketPool::RespectLimits::ENABLED, CompletionOnceCallback(),
2919 ClientSocketPool::ProxyAuthCallback(), pool_, NetLogWithSource()));
[email protected]6ecf2b92011-12-15 01:14:522920 }
2921
Keishi Hattori0e45c022021-11-27 09:25:522922 const raw_ptr<TransportClientSocketPool> pool_;
[email protected]e60e47a2010-07-14 03:37:182923 int expected_result_;
2924 bool reset_releasing_handle_;
[email protected]4f1e4982010-03-02 18:31:042925 ClientSocketHandle handle_;
2926 ClientSocketHandle handle2_;
[email protected]4f1e4982010-03-02 18:31:042927};
2928
[email protected]e60e47a2010-07-14 03:37:182929
2930TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
2931 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2932
Matt Menkec6b3edf72019-03-19 17:00:392933 EXPECT_THAT(StartRequest(TestGroupId("b"), DEFAULT_PRIORITY), IsOk());
2934 EXPECT_THAT(StartRequest(TestGroupId("a"), DEFAULT_PRIORITY), IsOk());
2935 EXPECT_THAT(StartRequest(TestGroupId("b"), DEFAULT_PRIORITY), IsOk());
[email protected]e60e47a2010-07-14 03:37:182936
[email protected]2431756e2010-09-29 20:26:132937 EXPECT_EQ(static_cast<int>(requests_size()),
[email protected]e60e47a2010-07-14 03:37:182938 client_socket_factory_.allocation_count());
2939
2940 connect_job_factory_->set_job_type(
2941 TestConnectJob::kMockPendingAdditionalErrorStateJob);
2942 TestReleasingSocketRequest req(pool_.get(), OK, false);
Matt Menkef09e64c2019-04-23 22:16:282943 EXPECT_EQ(ERR_IO_PENDING,
2944 req.handle()->Init(
Anton Bikineev068d2912021-05-15 20:43:522945 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282946 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2947 req.callback(), ClientSocketPool::ProxyAuthCallback(),
2948 pool_.get(), NetLogWithSource()));
[email protected]e60e47a2010-07-14 03:37:182949 // The next job should complete synchronously
2950 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2951
robpercival214763f2016-07-01 23:27:012952 EXPECT_THAT(req.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
[email protected]e60e47a2010-07-14 03:37:182953 EXPECT_FALSE(req.handle()->is_initialized());
2954 EXPECT_FALSE(req.handle()->socket());
2955 EXPECT_TRUE(req.handle()->is_ssl_error());
Matt Menke39b7c5a2019-04-10 19:47:512956 EXPECT_TRUE(req.handle()->ssl_cert_request_info());
[email protected]e60e47a2010-07-14 03:37:182957}
2958
[email protected]b6501d3d2010-06-03 23:53:342959// http://crbug.com/44724 regression test.
2960// We start releasing the pool when we flush on network change. When that
2961// happens, the only active references are in the ClientSocketHandles. When a
2962// ConnectJob completes and calls back into the last ClientSocketHandle, that
2963// callback can release the last reference and delete the pool. After the
2964// callback finishes, we go back to the stack frame within the now-deleted pool.
2965// Executing any code that refers to members of the now-deleted pool can cause
2966// crashes.
2967TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
2968 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2969 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
2970
2971 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522972 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502973 EXPECT_EQ(
2974 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522975 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282976 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2977 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2978 pool_.get(), NetLogWithSource()));
[email protected]b6501d3d2010-06-03 23:53:342979
Matt Menke433de6d2020-03-04 00:24:112980 pool_->FlushWithError(ERR_NETWORK_CHANGED, "Network changed");
[email protected]b6501d3d2010-06-03 23:53:342981
2982 // We'll call back into this now.
2983 callback.WaitForResult();
2984}
2985
[email protected]a7e38572010-06-07 18:22:242986TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
2987 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2988 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2989
2990 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:522991 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:502992 EXPECT_EQ(
2993 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:522994 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:282995 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
2996 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
2997 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:012998 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]a7e38572010-06-07 18:22:242999 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
Matt Menke433de6d2020-03-04 00:24:113000 NetLogSource source = handle.socket()->NetLog().source();
[email protected]a7e38572010-06-07 18:22:243001
Matt Menke433de6d2020-03-04 00:24:113002 pool_->FlushWithError(ERR_NETWORK_CHANGED, "Network changed");
[email protected]a7e38572010-06-07 18:22:243003
3004 handle.Reset();
fdoray5eeb7642016-06-22 16:11:283005 base::RunLoop().RunUntilIdle();
[email protected]a7e38572010-06-07 18:22:243006
Matt Menke28ac03e2019-02-25 22:25:503007 EXPECT_EQ(
3008 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523009 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283010 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
3011 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3012 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:013013 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]a7e38572010-06-07 18:22:243014 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
Matt Menke433de6d2020-03-04 00:24:113015
3016 ExpectSocketClosedWithReason(
3017 source, TransportClientSocketPool::kSocketGenerationOutOfDate);
[email protected]a7e38572010-06-07 18:22:243018}
3019
[email protected]6ecf2b92011-12-15 01:14:523020class ConnectWithinCallback : public TestCompletionCallbackBase {
[email protected]06f92462010-08-31 19:24:143021 public:
Matt Menke9fa17d52019-03-25 19:12:263022 ConnectWithinCallback(
3023 const ClientSocketPool::GroupId& group_id,
Matt Menke84d11e562019-03-27 00:11:193024 const scoped_refptr<ClientSocketPool::SocketParams>& params,
Matt Menke9fa17d52019-03-25 19:12:263025 TransportClientSocketPool* pool)
Matt Menkec6b3edf72019-03-19 17:00:393026 : group_id_(group_id), params_(params), pool_(pool) {}
[email protected]06f92462010-08-31 19:24:143027
Peter Boström293b1342021-09-22 17:31:433028 ConnectWithinCallback(const ConnectWithinCallback&) = delete;
3029 ConnectWithinCallback& operator=(const ConnectWithinCallback&) = delete;
3030
Chris Watkins7a41d3552017-12-01 02:13:273031 ~ConnectWithinCallback() override = default;
[email protected]06f92462010-08-31 19:24:143032
3033 int WaitForNestedResult() {
3034 return nested_callback_.WaitForResult();
3035 }
3036
Bence Béky8ddc2492018-06-13 01:02:043037 CompletionOnceCallback callback() {
3038 return base::BindOnce(&ConnectWithinCallback::OnComplete,
3039 base::Unretained(this));
3040 }
[email protected]6ecf2b92011-12-15 01:14:523041
[email protected]06f92462010-08-31 19:24:143042 private:
[email protected]6ecf2b92011-12-15 01:14:523043 void OnComplete(int result) {
3044 SetResult(result);
Matt Menkef09e64c2019-04-23 22:16:283045 EXPECT_EQ(
3046 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523047 handle_.Init(group_id_, params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283048 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
3049 nested_callback_.callback(),
3050 ClientSocketPool::ProxyAuthCallback(), pool_,
3051 NetLogWithSource()));
[email protected]6ecf2b92011-12-15 01:14:523052 }
3053
Matt Menkec6b3edf72019-03-19 17:00:393054 const ClientSocketPool::GroupId group_id_;
Matt Menke84d11e562019-03-27 00:11:193055 const scoped_refptr<ClientSocketPool::SocketParams> params_;
Keishi Hattori0e45c022021-11-27 09:25:523056 const raw_ptr<TransportClientSocketPool> pool_;
[email protected]06f92462010-08-31 19:24:143057 ClientSocketHandle handle_;
[email protected]6ecf2b92011-12-15 01:14:523058 TestCompletionCallback nested_callback_;
[email protected]06f92462010-08-31 19:24:143059};
3060
3061TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
3062 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3063
3064 // First job will be waiting until it gets aborted.
3065 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3066
3067 ClientSocketHandle handle;
Matt Menkec6b3edf72019-03-19 17:00:393068 ConnectWithinCallback callback(TestGroupId("a"), params_, pool_.get());
Matt Menke28ac03e2019-02-25 22:25:503069 EXPECT_EQ(
3070 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523071 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283072 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
3073 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3074 pool_.get(), NetLogWithSource()));
[email protected]06f92462010-08-31 19:24:143075
3076 // Second job will be started during the first callback, and will
3077 // asynchronously complete with OK.
3078 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
Matt Menke433de6d2020-03-04 00:24:113079 pool_->FlushWithError(ERR_NETWORK_CHANGED, "Network changed");
robpercival214763f2016-07-01 23:27:013080 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NETWORK_CHANGED));
3081 EXPECT_THAT(callback.WaitForNestedResult(), IsOk());
[email protected]06f92462010-08-31 19:24:143082}
3083
Matt Menke141b87f22019-01-30 02:43:033084TEST_F(ClientSocketPoolBaseTest, BackupSocketWaitsForHostResolution) {
Matt Menke9fa17d52019-03-25 19:12:263085 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets,
3086 true /* enable_backup_connect_jobs */);
Matt Menke141b87f22019-01-30 02:43:033087
3088 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3089 ClientSocketHandle handle;
3090 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:503091 EXPECT_EQ(
3092 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523093 handle.Init(TestGroupId("bar"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283094 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
3095 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3096 pool_.get(), NetLogWithSource()));
Matt Menke141b87f22019-01-30 02:43:033097 // The backup timer fires but doesn't start a new ConnectJob while resolving
3098 // the hostname.
3099 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
Peter Kastinge5a38ed2021-10-02 03:06:353100 FastForwardBy(
3101 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
Matt Menke141b87f22019-01-30 02:43:033102 EXPECT_EQ(1, client_socket_factory_.allocation_count());
3103
3104 // Once the ConnectJob has finished resolving the hostname, the backup timer
3105 // will create a ConnectJob when it fires.
3106 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_CONNECTING);
Peter Kastinge5a38ed2021-10-02 03:06:353107 FastForwardBy(
3108 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs));
Matt Menke141b87f22019-01-30 02:43:033109 EXPECT_EQ(2, client_socket_factory_.allocation_count());
3110}
3111
3112// Test that no backup socket is created when a ConnectJob connects before it
3113// completes.
3114TEST_F(ClientSocketPoolBaseTest, NoBackupSocketWhenConnected) {
Matt Menke9fa17d52019-03-25 19:12:263115 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets,
3116 true /* enable_backup_connect_jobs */);
Matt Menke141b87f22019-01-30 02:43:033117
3118 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3119 ClientSocketHandle handle;
3120 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:503121 EXPECT_EQ(
3122 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523123 handle.Init(TestGroupId("bar"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283124 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
3125 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3126 pool_.get(), NetLogWithSource()));
Matt Menke141b87f22019-01-30 02:43:033127 // The backup timer fires but doesn't start a new ConnectJob while resolving
3128 // the hostname.
3129 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
Peter Kastinge5a38ed2021-10-02 03:06:353130 FastForwardBy(
3131 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
Matt Menke141b87f22019-01-30 02:43:033132 EXPECT_EQ(1, client_socket_factory_.allocation_count());
3133
3134 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
3135 client_socket_factory_.SetJobHasEstablishedConnection(0);
Peter Kastinge5a38ed2021-10-02 03:06:353136 FastForwardBy(
3137 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs * 100));
Matt Menke141b87f22019-01-30 02:43:033138 EXPECT_EQ(1, client_socket_factory_.allocation_count());
3139}
3140
[email protected]25eea382010-07-10 23:55:263141// Cancel a pending socket request while we're at max sockets,
3142// and verify that the backup socket firing doesn't cause a crash.
3143TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
3144 // Max 4 sockets globally, max 4 sockets per group.
Matt Menke9fa17d52019-03-25 19:12:263145 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets,
3146 true /* enable_backup_connect_jobs */);
[email protected]25eea382010-07-10 23:55:263147
[email protected]4baaf9d2010-08-31 15:15:443148 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
3149 // timer.
[email protected]25eea382010-07-10 23:55:263150 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3151 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:523152 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:503153 EXPECT_EQ(
3154 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523155 handle.Init(TestGroupId("bar"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283156 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
3157 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3158 pool_.get(), NetLogWithSource()));
[email protected]25eea382010-07-10 23:55:263159
3160 // Start (MaxSockets - 1) connected sockets to reach max sockets.
3161 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3162 ClientSocketHandle handles[kDefaultMaxSockets];
3163 for (int i = 1; i < kDefaultMaxSockets; ++i) {
Anton Bikineev068d2912021-05-15 20:43:523164 EXPECT_EQ(OK, handles[i].Init(TestGroupId("bar"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283165 DEFAULT_PRIORITY, SocketTag(),
tfarina428341112016-09-22 13:38:203166 ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503167 callback.callback(),
3168 ClientSocketPool::ProxyAuthCallback(),
3169 pool_.get(), NetLogWithSource()));
[email protected]25eea382010-07-10 23:55:263170 }
3171
fdoray5eeb7642016-06-22 16:11:283172 base::RunLoop().RunUntilIdle();
[email protected]25eea382010-07-10 23:55:263173
3174 // Cancel the pending request.
3175 handle.Reset();
3176
3177 // Wait for the backup timer to fire (add some slop to ensure it fires)
Peter Kastinge5a38ed2021-10-02 03:06:353178 FastForwardBy(
3179 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
[email protected]25eea382010-07-10 23:55:263180
[email protected]25eea382010-07-10 23:55:263181 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
3182}
3183
[email protected]3f00be82010-09-27 19:50:023184TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
Matt Menke9fa17d52019-03-25 19:12:263185 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets,
3186 true /* enable_backup_connect_jobs */);
[email protected]4baaf9d2010-08-31 15:15:443187
3188 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
3189 // timer.
3190 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3191 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:523192 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:503193 EXPECT_EQ(
3194 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523195 handle.Init(TestGroupId("bar"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283196 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
3197 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3198 pool_.get(), NetLogWithSource()));
Matt Menke9fa17d52019-03-25 19:12:263199 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("bar")));
3200 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("bar")));
3201 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3202 TestGroupId("bar")));
3203 EXPECT_EQ(
3204 0u, pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("bar")));
[email protected]4baaf9d2010-08-31 15:15:443205
3206 // Cancel the socket request. This should cancel the backup timer. Wait for
3207 // the backup time to see if it indeed got canceled.
3208 handle.Reset();
3209 // Wait for the backup timer to fire (add some slop to ensure it fires)
Peter Kastinge5a38ed2021-10-02 03:06:353210 FastForwardBy(
3211 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
Matt Menke9fa17d52019-03-25 19:12:263212 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("bar")));
3213 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("bar")));
[email protected]4baaf9d2010-08-31 15:15:443214}
3215
[email protected]3f00be82010-09-27 19:50:023216TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
Matt Menke9fa17d52019-03-25 19:12:263217 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets,
3218 true /* enable_backup_connect_jobs */);
[email protected]3f00be82010-09-27 19:50:023219
3220 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
3221 // timer.
3222 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3223 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:523224 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:503225 EXPECT_EQ(
3226 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523227 handle.Init(TestGroupId("bar"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283228 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
3229 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3230 pool_.get(), NetLogWithSource()));
[email protected]3f00be82010-09-27 19:50:023231 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3232 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:523233 TestCompletionCallback callback2;
tfarina428341112016-09-22 13:38:203234 EXPECT_EQ(
3235 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523236 handle2.Init(TestGroupId("bar"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283237 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503238 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
3239 pool_.get(), NetLogWithSource()));
Matt Menke9fa17d52019-03-25 19:12:263240 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("bar")));
3241 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("bar")));
[email protected]3f00be82010-09-27 19:50:023242
3243 // Cancel request 1 and then complete request 2. With the requests finished,
3244 // the backup timer should be cancelled.
3245 handle.Reset();
robpercival214763f2016-07-01 23:27:013246 EXPECT_THAT(callback2.WaitForResult(), IsOk());
[email protected]3f00be82010-09-27 19:50:023247 // Wait for the backup timer to fire (add some slop to ensure it fires)
Peter Kastinge5a38ed2021-10-02 03:06:353248 FastForwardBy(
3249 base::Milliseconds(ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
[email protected]3f00be82010-09-27 19:50:023250}
3251
[email protected]eb5a99382010-07-11 03:18:263252// Test delayed socket binding for the case where we have two connects,
3253// and while one is waiting on a connect, the other frees up.
3254// The socket waiting on a connect should switch immediately to the freed
3255// up socket.
3256TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
3257 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3258 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3259
3260 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523261 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:503262 EXPECT_EQ(
3263 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523264 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283265 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503266 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3267 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:013268 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]eb5a99382010-07-11 03:18:263269
3270 // No idle sockets, no pending jobs.
3271 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263272 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263273
3274 // Create a second socket to the same host, but this one will wait.
3275 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3276 ClientSocketHandle handle2;
Matt Menke28ac03e2019-02-25 22:25:503277 EXPECT_EQ(
3278 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523279 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283280 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503281 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3282 pool_.get(), NetLogWithSource()));
[email protected]eb5a99382010-07-11 03:18:263283 // No idle sockets, and one connecting job.
3284 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263285 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263286
3287 // Return the first handle to the pool. This will initiate the delayed
3288 // binding.
3289 handle1.Reset();
3290
fdoray5eeb7642016-06-22 16:11:283291 base::RunLoop().RunUntilIdle();
[email protected]eb5a99382010-07-11 03:18:263292
3293 // Still no idle sockets, still one pending connect job.
3294 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263295 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263296
3297 // The second socket connected, even though it was a Waiting Job.
robpercival214763f2016-07-01 23:27:013298 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]eb5a99382010-07-11 03:18:263299
3300 // And we can see there is still one job waiting.
Matt Menke9fa17d52019-03-25 19:12:263301 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263302
3303 // Finally, signal the waiting Connect.
3304 client_socket_factory_.SignalJobs();
Matt Menke9fa17d52019-03-25 19:12:263305 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263306
fdoray5eeb7642016-06-22 16:11:283307 base::RunLoop().RunUntilIdle();
[email protected]eb5a99382010-07-11 03:18:263308}
3309
3310// Test delayed socket binding when a group is at capacity and one
3311// of the group's sockets frees up.
3312TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
3313 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3314 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3315
3316 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523317 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:503318 EXPECT_EQ(
3319 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523320 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283321 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503322 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3323 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:013324 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]eb5a99382010-07-11 03:18:263325
3326 // No idle sockets, no pending jobs.
3327 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263328 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263329
3330 // Create a second socket to the same host, but this one will wait.
3331 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3332 ClientSocketHandle handle2;
Matt Menke28ac03e2019-02-25 22:25:503333 EXPECT_EQ(
3334 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523335 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283336 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503337 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3338 pool_.get(), NetLogWithSource()));
[email protected]eb5a99382010-07-11 03:18:263339 // No idle sockets, and one connecting job.
3340 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263341 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263342
3343 // Return the first handle to the pool. This will initiate the delayed
3344 // binding.
3345 handle1.Reset();
3346
fdoray5eeb7642016-06-22 16:11:283347 base::RunLoop().RunUntilIdle();
[email protected]eb5a99382010-07-11 03:18:263348
3349 // Still no idle sockets, still one pending connect job.
3350 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263351 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263352
3353 // The second socket connected, even though it was a Waiting Job.
robpercival214763f2016-07-01 23:27:013354 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]eb5a99382010-07-11 03:18:263355
3356 // And we can see there is still one job waiting.
Matt Menke9fa17d52019-03-25 19:12:263357 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263358
3359 // Finally, signal the waiting Connect.
3360 client_socket_factory_.SignalJobs();
Matt Menke9fa17d52019-03-25 19:12:263361 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263362
fdoray5eeb7642016-06-22 16:11:283363 base::RunLoop().RunUntilIdle();
[email protected]eb5a99382010-07-11 03:18:263364}
3365
3366// Test out the case where we have one socket connected, one
3367// connecting, when the first socket finishes and goes idle.
[email protected]2abfe90a2010-08-25 17:49:513368// Although the second connection is pending, the second request
[email protected]eb5a99382010-07-11 03:18:263369// should complete, by taking the first socket's idle socket.
3370TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
3371 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3372 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3373
3374 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523375 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:503376 EXPECT_EQ(
3377 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523378 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283379 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503380 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3381 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:013382 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]eb5a99382010-07-11 03:18:263383
3384 // No idle sockets, no pending jobs.
3385 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263386 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263387
3388 // Create a second socket to the same host, but this one will wait.
3389 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3390 ClientSocketHandle handle2;
Matt Menke28ac03e2019-02-25 22:25:503391 EXPECT_EQ(
3392 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523393 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283394 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503395 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
3396 pool_.get(), NetLogWithSource()));
[email protected]eb5a99382010-07-11 03:18:263397 // No idle sockets, and one connecting job.
3398 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263399 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263400
3401 // Return the first handle to the pool. This will initiate the delayed
3402 // binding.
3403 handle1.Reset();
3404
fdoray5eeb7642016-06-22 16:11:283405 base::RunLoop().RunUntilIdle();
[email protected]eb5a99382010-07-11 03:18:263406
3407 // Still no idle sockets, still one pending connect job.
3408 EXPECT_EQ(0, pool_->IdleSocketCount());
Matt Menke9fa17d52019-03-25 19:12:263409 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263410
3411 // The second socket connected, even though it was a Waiting Job.
robpercival214763f2016-07-01 23:27:013412 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]eb5a99382010-07-11 03:18:263413
3414 // And we can see there is still one job waiting.
Matt Menke9fa17d52019-03-25 19:12:263415 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263416
3417 // Finally, signal the waiting Connect.
3418 client_socket_factory_.SignalJobs();
Matt Menke9fa17d52019-03-25 19:12:263419 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]eb5a99382010-07-11 03:18:263420
fdoray5eeb7642016-06-22 16:11:283421 base::RunLoop().RunUntilIdle();
[email protected]eb5a99382010-07-11 03:18:263422}
3423
[email protected]2abfe90a2010-08-25 17:49:513424// Cover the case where on an available socket slot, we have one pending
3425// request that completes synchronously, thereby making the Group empty.
3426TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) {
3427 const int kUnlimitedSockets = 100;
3428 const int kOneSocketPerGroup = 1;
3429 CreatePool(kUnlimitedSockets, kOneSocketPerGroup);
3430
3431 // Make the first request asynchronous fail.
3432 // This will free up a socket slot later.
3433 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
3434
3435 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523436 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:203437 EXPECT_EQ(
3438 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523439 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283440 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503441 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3442 pool_.get(), NetLogWithSource()));
Matt Menke9fa17d52019-03-25 19:12:263443 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]2abfe90a2010-08-25 17:49:513444
3445 // Make the second request synchronously fail. This should make the Group
3446 // empty.
3447 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3448 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:523449 TestCompletionCallback callback2;
[email protected]2abfe90a2010-08-25 17:49:513450 // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail
3451 // when created.
tfarina428341112016-09-22 13:38:203452 EXPECT_EQ(
3453 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523454 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283455 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503456 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
3457 pool_.get(), NetLogWithSource()));
[email protected]2abfe90a2010-08-25 17:49:513458
Matt Menke9fa17d52019-03-25 19:12:263459 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]2abfe90a2010-08-25 17:49:513460
robpercival214763f2016-07-01 23:27:013461 EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
3462 EXPECT_THAT(callback2.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
Matt Menke9fa17d52019-03-25 19:12:263463 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
[email protected]2abfe90a2010-08-25 17:49:513464}
3465
[email protected]e1b54dc2010-10-06 21:27:223466TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
3467 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3468
3469 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3470
3471 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523472 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:203473 EXPECT_EQ(
3474 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523475 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283476 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503477 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3478 pool_.get(), NetLogWithSource()));
[email protected]e1b54dc2010-10-06 21:27:223479
3480 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:523481 TestCompletionCallback callback2;
tfarina428341112016-09-22 13:38:203482 EXPECT_EQ(
3483 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523484 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283485 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503486 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
3487 pool_.get(), NetLogWithSource()));
[email protected]e1b54dc2010-10-06 21:27:223488 ClientSocketHandle handle3;
[email protected]6ecf2b92011-12-15 01:14:523489 TestCompletionCallback callback3;
tfarina428341112016-09-22 13:38:203490 EXPECT_EQ(
3491 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523492 handle3.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283493 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503494 callback3.callback(), ClientSocketPool::ProxyAuthCallback(),
3495 pool_.get(), NetLogWithSource()));
[email protected]e1b54dc2010-10-06 21:27:223496
robpercival214763f2016-07-01 23:27:013497 EXPECT_THAT(callback1.WaitForResult(), IsOk());
3498 EXPECT_THAT(callback2.WaitForResult(), IsOk());
3499 EXPECT_THAT(callback3.WaitForResult(), IsOk());
[email protected]e1b54dc2010-10-06 21:27:223500
3501 // Use the socket.
Raul Tambre94493c652019-03-11 17:18:353502 EXPECT_EQ(1, handle1.socket()->Write(nullptr, 1, CompletionOnceCallback(),
Ramin Halavati0a08cc82018-02-06 07:46:383503 TRAFFIC_ANNOTATION_FOR_TESTS));
Raul Tambre94493c652019-03-11 17:18:353504 EXPECT_EQ(1, handle3.socket()->Write(nullptr, 1, CompletionOnceCallback(),
Ramin Halavati0a08cc82018-02-06 07:46:383505 TRAFFIC_ANNOTATION_FOR_TESTS));
[email protected]e1b54dc2010-10-06 21:27:223506
3507 handle1.Reset();
3508 handle2.Reset();
3509 handle3.Reset();
3510
Matt Menkec6b3edf72019-03-19 17:00:393511 EXPECT_EQ(OK, handle1.Init(
Anton Bikineev068d2912021-05-15 20:43:523512 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283513 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menkec6b3edf72019-03-19 17:00:393514 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3515 pool_.get(), NetLogWithSource()));
3516 EXPECT_EQ(OK, handle2.Init(
Anton Bikineev068d2912021-05-15 20:43:523517 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283518 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menkec6b3edf72019-03-19 17:00:393519 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
3520 pool_.get(), NetLogWithSource()));
3521 EXPECT_EQ(OK, handle3.Init(
Anton Bikineev068d2912021-05-15 20:43:523522 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283523 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menkec6b3edf72019-03-19 17:00:393524 callback3.callback(), ClientSocketPool::ProxyAuthCallback(),
3525 pool_.get(), NetLogWithSource()));
[email protected]e1b54dc2010-10-06 21:27:223526
3527 EXPECT_TRUE(handle1.socket()->WasEverUsed());
3528 EXPECT_TRUE(handle2.socket()->WasEverUsed());
3529 EXPECT_FALSE(handle3.socket()->WasEverUsed());
3530}
3531
[email protected]2c2bef152010-10-13 00:55:033532TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
3533 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3534 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3535
Anton Bikineev068d2912021-05-15 20:43:523536 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283537 NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033538
Matt Menke9fa17d52019-03-25 19:12:263539 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
3540 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3541 EXPECT_EQ(2u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3542 TestGroupId("a")));
3543 EXPECT_EQ(2u,
3544 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393545 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033546
3547 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523548 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:203549 EXPECT_EQ(
3550 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523551 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283552 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503553 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3554 pool_.get(), NetLogWithSource()));
[email protected]2c2bef152010-10-13 00:55:033555
3556 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:523557 TestCompletionCallback callback2;
tfarina428341112016-09-22 13:38:203558 EXPECT_EQ(
3559 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523560 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283561 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503562 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
3563 pool_.get(), NetLogWithSource()));
[email protected]2c2bef152010-10-13 00:55:033564
Matt Menke9fa17d52019-03-25 19:12:263565 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3566 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3567 TestGroupId("a")));
3568 EXPECT_EQ(0u,
3569 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393570 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033571
robpercival214763f2016-07-01 23:27:013572 EXPECT_THAT(callback1.WaitForResult(), IsOk());
3573 EXPECT_THAT(callback2.WaitForResult(), IsOk());
[email protected]2c2bef152010-10-13 00:55:033574 handle1.Reset();
3575 handle2.Reset();
3576
Matt Menke9fa17d52019-03-25 19:12:263577 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3578 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3579 TestGroupId("a")));
3580 EXPECT_EQ(0u,
3581 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393582 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033583}
3584
3585TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
3586 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3587 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3588
3589 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523590 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:203591 EXPECT_EQ(
3592 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523593 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283594 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503595 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3596 pool_.get(), NetLogWithSource()));
[email protected]2c2bef152010-10-13 00:55:033597
Matt Menke9fa17d52019-03-25 19:12:263598 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
3599 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3600 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3601 TestGroupId("a")));
3602 EXPECT_EQ(0u,
3603 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393604 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033605
Anton Bikineev068d2912021-05-15 20:43:523606 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283607 NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033608
Matt Menke9fa17d52019-03-25 19:12:263609 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3610 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3611 TestGroupId("a")));
3612 EXPECT_EQ(1u,
3613 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393614 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033615
3616 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:523617 TestCompletionCallback callback2;
tfarina428341112016-09-22 13:38:203618 EXPECT_EQ(
3619 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523620 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283621 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503622 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
3623 pool_.get(), NetLogWithSource()));
[email protected]2c2bef152010-10-13 00:55:033624
Matt Menke9fa17d52019-03-25 19:12:263625 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3626 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3627 TestGroupId("a")));
3628 EXPECT_EQ(0u,
3629 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393630 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033631
robpercival214763f2016-07-01 23:27:013632 EXPECT_THAT(callback1.WaitForResult(), IsOk());
3633 EXPECT_THAT(callback2.WaitForResult(), IsOk());
[email protected]2c2bef152010-10-13 00:55:033634 handle1.Reset();
3635 handle2.Reset();
3636
Matt Menke9fa17d52019-03-25 19:12:263637 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3638 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3639 TestGroupId("a")));
3640 EXPECT_EQ(0u,
3641 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393642 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033643}
3644
3645TEST_F(ClientSocketPoolBaseTest,
3646 RequestSocketsWhenAlreadyHaveMultipleConnectJob) {
3647 CreatePool(4, 4);
3648 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3649
3650 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523651 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:203652 EXPECT_EQ(
3653 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523654 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283655 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503656 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3657 pool_.get(), NetLogWithSource()));
[email protected]2c2bef152010-10-13 00:55:033658
3659 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:523660 TestCompletionCallback callback2;
tfarina428341112016-09-22 13:38:203661 EXPECT_EQ(
3662 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523663 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283664 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503665 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
3666 pool_.get(), NetLogWithSource()));
[email protected]2c2bef152010-10-13 00:55:033667
3668 ClientSocketHandle handle3;
[email protected]6ecf2b92011-12-15 01:14:523669 TestCompletionCallback callback3;
tfarina428341112016-09-22 13:38:203670 EXPECT_EQ(
3671 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523672 handle3.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283673 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503674 callback3.callback(), ClientSocketPool::ProxyAuthCallback(),
3675 pool_.get(), NetLogWithSource()));
[email protected]2c2bef152010-10-13 00:55:033676
Matt Menke9fa17d52019-03-25 19:12:263677 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
3678 EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3679 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3680 TestGroupId("a")));
3681 EXPECT_EQ(0u,
3682 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393683 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033684
Anton Bikineev068d2912021-05-15 20:43:523685 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283686 NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033687
Matt Menke9fa17d52019-03-25 19:12:263688 EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3689 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3690 TestGroupId("a")));
3691 EXPECT_EQ(0u,
3692 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393693 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033694
robpercival214763f2016-07-01 23:27:013695 EXPECT_THAT(callback1.WaitForResult(), IsOk());
3696 EXPECT_THAT(callback2.WaitForResult(), IsOk());
3697 EXPECT_THAT(callback3.WaitForResult(), IsOk());
[email protected]2c2bef152010-10-13 00:55:033698 handle1.Reset();
3699 handle2.Reset();
3700 handle3.Reset();
3701
Matt Menke9fa17d52019-03-25 19:12:263702 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3703 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3704 TestGroupId("a")));
3705 EXPECT_EQ(0u,
3706 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393707 EXPECT_EQ(3u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033708}
3709
3710TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) {
3711 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3712 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3713
Matt Menke9fa17d52019-03-25 19:12:263714 ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033715
Anton Bikineev068d2912021-05-15 20:43:523716 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283717 kDefaultMaxSockets, NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033718
Matt Menke9fa17d52019-03-25 19:12:263719 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
Raul Tambre8335a6d2019-02-21 16:57:433720 EXPECT_EQ(kDefaultMaxSockets,
Matt Menkec6b3edf72019-03-19 17:00:393721 static_cast<int>(
Matt Menke9fa17d52019-03-25 19:12:263722 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a"))));
3723 EXPECT_EQ(
3724 kDefaultMaxSockets,
3725 static_cast<int>(pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3726 TestGroupId("a"))));
Raul Tambre8335a6d2019-02-21 16:57:433727 EXPECT_EQ(kDefaultMaxSockets,
Matt Menke9fa17d52019-03-25 19:12:263728 static_cast<int>(pool_->NumUnassignedConnectJobsInGroupForTesting(
3729 TestGroupId("a"))));
[email protected]2c2bef152010-10-13 00:55:033730
Matt Menke9fa17d52019-03-25 19:12:263731 ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("b")));
[email protected]2c2bef152010-10-13 00:55:033732
Anton Bikineev068d2912021-05-15 20:43:523733 pool_->RequestSockets(TestGroupId("b"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283734 kDefaultMaxSockets, NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033735
Matt Menke9fa17d52019-03-25 19:12:263736 ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("b")));
[email protected]2c2bef152010-10-13 00:55:033737}
3738
3739TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
3740 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3741 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3742
Matt Menke9fa17d52019-03-25 19:12:263743 ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033744
Anton Bikineev068d2912021-05-15 20:43:523745 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283746 kDefaultMaxSockets - 1, NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033747
Matt Menke9fa17d52019-03-25 19:12:263748 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:433749 EXPECT_EQ(kDefaultMaxSockets - 1,
Matt Menkec6b3edf72019-03-19 17:00:393750 static_cast<int>(
Matt Menke9fa17d52019-03-25 19:12:263751 pool_->NumConnectJobsInGroupForTesting(TestGroupId("a"))));
3752 EXPECT_EQ(
3753 kDefaultMaxSockets - 1,
3754 static_cast<int>(pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3755 TestGroupId("a"))));
Raul Tambre8335a6d2019-02-21 16:57:433756 EXPECT_EQ(kDefaultMaxSockets - 1,
Matt Menke9fa17d52019-03-25 19:12:263757 static_cast<int>(pool_->NumUnassignedConnectJobsInGroupForTesting(
3758 TestGroupId("a"))));
[email protected]51fdc7c2012-04-10 19:19:483759 EXPECT_FALSE(pool_->IsStalled());
[email protected]2c2bef152010-10-13 00:55:033760
Matt Menke9fa17d52019-03-25 19:12:263761 ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("b")));
[email protected]2c2bef152010-10-13 00:55:033762
Anton Bikineev068d2912021-05-15 20:43:523763 pool_->RequestSockets(TestGroupId("b"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283764 kDefaultMaxSockets, NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033765
Matt Menke9fa17d52019-03-25 19:12:263766 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("b")));
3767 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
[email protected]51fdc7c2012-04-10 19:19:483768 EXPECT_FALSE(pool_->IsStalled());
[email protected]2c2bef152010-10-13 00:55:033769}
3770
3771TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
3772 CreatePool(4, 4);
3773 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3774
3775 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523776 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:203777 EXPECT_EQ(
3778 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523779 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283780 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503781 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3782 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:013783 ASSERT_THAT(callback1.WaitForResult(), IsOk());
[email protected]2c2bef152010-10-13 00:55:033784 handle1.Reset();
3785
Matt Menke9fa17d52019-03-25 19:12:263786 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
3787 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3788 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3789 TestGroupId("a")));
3790 EXPECT_EQ(0u,
3791 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393792 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033793
Anton Bikineev068d2912021-05-15 20:43:523794 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283795 NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033796
Matt Menke9fa17d52019-03-25 19:12:263797 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3798 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3799 TestGroupId("a")));
3800 EXPECT_EQ(1u,
3801 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393802 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033803}
3804
3805TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
3806 CreatePool(4, 4);
3807 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3808
3809 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523810 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:203811 EXPECT_EQ(
3812 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523813 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283814 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503815 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3816 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:013817 ASSERT_THAT(callback1.WaitForResult(), IsOk());
[email protected]2c2bef152010-10-13 00:55:033818
Matt Menke9fa17d52019-03-25 19:12:263819 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
3820 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3821 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3822 TestGroupId("a")));
3823 EXPECT_EQ(0u,
3824 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393825 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:263826 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033827
Anton Bikineev068d2912021-05-15 20:43:523828 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283829 NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033830
Matt Menke9fa17d52019-03-25 19:12:263831 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3832 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3833 TestGroupId("a")));
3834 EXPECT_EQ(1u,
3835 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393836 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:263837 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033838}
3839
3840TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) {
3841 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3842 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3843
Anton Bikineev068d2912021-05-15 20:43:523844 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283845 kDefaultMaxSocketsPerGroup, NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033846
Matt Menke9fa17d52019-03-25 19:12:263847 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
3848 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3849 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3850 TestGroupId("a")));
3851 EXPECT_EQ(0u,
3852 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Raul Tambre8335a6d2019-02-21 16:57:433853 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
Matt Menkec6b3edf72019-03-19 17:00:393854 static_cast<int>(pool_->IdleSocketCountInGroup(TestGroupId("a"))));
[email protected]2c2bef152010-10-13 00:55:033855
Anton Bikineev068d2912021-05-15 20:43:523856 pool_->RequestSockets(TestGroupId("b"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283857 kDefaultMaxSocketsPerGroup, NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033858
Matt Menke9fa17d52019-03-25 19:12:263859 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
3860 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3861 TestGroupId("b")));
3862 EXPECT_EQ(0u,
3863 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("b")));
Raul Tambre8335a6d2019-02-21 16:57:433864 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
Matt Menkec6b3edf72019-03-19 17:00:393865 static_cast<int>(pool_->IdleSocketCountInGroup(TestGroupId("b"))));
[email protected]2c2bef152010-10-13 00:55:033866}
3867
[email protected]3c819f522010-12-02 02:03:123868TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronousError) {
3869 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3870 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3871
Anton Bikineev068d2912021-05-15 20:43:523872 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283873 kDefaultMaxSocketsPerGroup, NetLogWithSource());
[email protected]3c819f522010-12-02 02:03:123874
Matt Menke9fa17d52019-03-25 19:12:263875 ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
[email protected]fd2e53e2011-01-14 20:40:523876
3877 connect_job_factory_->set_job_type(
3878 TestConnectJob::kMockAdditionalErrorStateJob);
Anton Bikineev068d2912021-05-15 20:43:523879 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:283880 kDefaultMaxSocketsPerGroup, NetLogWithSource());
[email protected]fd2e53e2011-01-14 20:40:523881
Matt Menke9fa17d52019-03-25 19:12:263882 ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
[email protected]3c819f522010-12-02 02:03:123883}
3884
[email protected]8159a1c2012-06-07 00:00:103885TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
[email protected]2c2bef152010-10-13 00:55:033886 CreatePool(4, 4);
Lily Chenecebf932018-11-02 17:15:433887 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
[email protected]2c2bef152010-10-13 00:55:033888
Anton Bikineev068d2912021-05-15 20:43:523889 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283890 NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033891
Matt Menke9fa17d52019-03-25 19:12:263892 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
3893 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3894 EXPECT_EQ(2u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3895 TestGroupId("a")));
3896 EXPECT_EQ(2u,
3897 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
3898 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393899 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033900
Anton Bikineev068d2912021-05-15 20:43:523901 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283902 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:263903 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3904 EXPECT_EQ(2u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3905 TestGroupId("a")));
3906 EXPECT_EQ(2u,
3907 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
3908 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393909 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033910
3911 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:523912 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:203913 EXPECT_EQ(
3914 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523915 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283916 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503917 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
3918 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:433919
3920 client_socket_factory_.SignalJob(0);
3921 EXPECT_THAT(callback1.WaitForResult(), IsOk());
3922
Matt Menke9fa17d52019-03-25 19:12:263923 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3924 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3925 TestGroupId("a")));
3926 EXPECT_EQ(1u,
3927 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
3928 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393929 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033930
3931 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:523932 TestCompletionCallback callback2;
Lily Chenecebf932018-11-02 17:15:433933 EXPECT_EQ(
3934 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:523935 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:283936 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:503937 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
3938 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:433939 client_socket_factory_.SignalJob(0);
3940 EXPECT_THAT(callback2.WaitForResult(), IsOk());
[email protected]2c2bef152010-10-13 00:55:033941
Matt Menke9fa17d52019-03-25 19:12:263942 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3943 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3944 TestGroupId("a")));
3945 EXPECT_EQ(0u,
3946 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
3947 EXPECT_EQ(2, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393948 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]8159a1c2012-06-07 00:00:103949
[email protected]2c2bef152010-10-13 00:55:033950 handle1.Reset();
3951 handle2.Reset();
3952
Matt Menke9fa17d52019-03-25 19:12:263953 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3954 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3955 TestGroupId("a")));
3956 EXPECT_EQ(0u,
3957 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
3958 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393959 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033960
Anton Bikineev068d2912021-05-15 20:43:523961 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283962 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:263963 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3964 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3965 TestGroupId("a")));
3966 EXPECT_EQ(0u,
3967 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
3968 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393969 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033970}
3971
3972TEST_F(ClientSocketPoolBaseTest, RequestSocketsDifferentNumSockets) {
3973 CreatePool(4, 4);
3974 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3975
Anton Bikineev068d2912021-05-15 20:43:523976 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
Matt Menkef09e64c2019-04-23 22:16:283977 NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:033978
Matt Menke9fa17d52019-03-25 19:12:263979 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
3980 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3981 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3982 TestGroupId("a")));
3983 EXPECT_EQ(1u,
3984 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393985 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033986
Anton Bikineev068d2912021-05-15 20:43:523987 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:283988 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:263989 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3990 EXPECT_EQ(2u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
3991 TestGroupId("a")));
3992 EXPECT_EQ(2u,
3993 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:393994 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:033995
Anton Bikineev068d2912021-05-15 20:43:523996 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 3,
Matt Menkef09e64c2019-04-23 22:16:283997 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:263998 EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
3999 EXPECT_EQ(3u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4000 TestGroupId("a")));
4001 EXPECT_EQ(3u,
4002 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394003 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:034004
Anton Bikineev068d2912021-05-15 20:43:524005 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
Matt Menkef09e64c2019-04-23 22:16:284006 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:264007 EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4008 EXPECT_EQ(3u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4009 TestGroupId("a")));
4010 EXPECT_EQ(3u,
4011 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394012 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:034013}
4014
4015TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
4016 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
Lily Chenecebf932018-11-02 17:15:434017 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
[email protected]2c2bef152010-10-13 00:55:034018
Anton Bikineev068d2912021-05-15 20:43:524019 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
Matt Menkef09e64c2019-04-23 22:16:284020 NetLogWithSource());
[email protected]2c2bef152010-10-13 00:55:034021
Matt Menke9fa17d52019-03-25 19:12:264022 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
4023 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4024 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4025 TestGroupId("a")));
4026 EXPECT_EQ(1u,
4027 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394028 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:034029
4030 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:524031 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:204032 EXPECT_EQ(
4033 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524034 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284035 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504036 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4037 pool_.get(), NetLogWithSource()));
[email protected]2c2bef152010-10-13 00:55:034038
Matt Menke9fa17d52019-03-25 19:12:264039 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4040 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4041 TestGroupId("a")));
4042 EXPECT_EQ(0u,
4043 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394044 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:034045
Lily Chenecebf932018-11-02 17:15:434046 client_socket_factory_.SignalJobs();
4047 EXPECT_THAT(callback1.WaitForResult(), IsOk());
4048
Matt Menke9fa17d52019-03-25 19:12:264049 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4050 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4051 TestGroupId("a")));
4052 EXPECT_EQ(0u,
4053 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394054 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:264055 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:034056
[email protected]0dc88b32014-03-26 20:12:284057 // Make sure if a preconnected socket is not fully connected when a request
[email protected]034df0f32013-01-07 23:17:484058 // starts, it has a connect start time.
4059 TestLoadTimingInfoConnectedNotReused(handle1);
[email protected]2c2bef152010-10-13 00:55:034060 handle1.Reset();
4061
Matt Menkec6b3edf72019-03-19 17:00:394062 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]2c2bef152010-10-13 00:55:034063}
4064
[email protected]034df0f32013-01-07 23:17:484065// Checks that fully connected preconnect jobs have no connect times, and are
4066// marked as reused.
4067TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
4068 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
4069 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
Anton Bikineev068d2912021-05-15 20:43:524070 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
Matt Menkef09e64c2019-04-23 22:16:284071 NetLogWithSource());
[email protected]034df0f32013-01-07 23:17:484072
Matt Menke9fa17d52019-03-25 19:12:264073 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
4074 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4075 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4076 TestGroupId("a")));
4077 EXPECT_EQ(0u,
4078 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394079 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]034df0f32013-01-07 23:17:484080
4081 ClientSocketHandle handle;
4082 TestCompletionCallback callback;
Matt Menkec6b3edf72019-03-19 17:00:394083 EXPECT_EQ(OK, handle.Init(
Anton Bikineev068d2912021-05-15 20:43:524084 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284085 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menkec6b3edf72019-03-19 17:00:394086 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
4087 pool_.get(), NetLogWithSource()));
[email protected]034df0f32013-01-07 23:17:484088
4089 // Make sure the idle socket was used.
Matt Menkec6b3edf72019-03-19 17:00:394090 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]034df0f32013-01-07 23:17:484091
4092 TestLoadTimingInfoConnectedReused(handle);
4093 handle.Reset();
4094 TestLoadTimingInfoNotConnected(handle);
4095}
4096
[email protected]dcbe168a2010-12-02 03:14:464097// http://crbug.com/64940 regression test.
4098TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
4099 const int kMaxTotalSockets = 3;
4100 const int kMaxSocketsPerGroup = 2;
4101 CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup);
Lily Chenecebf932018-11-02 17:15:434102 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
[email protected]dcbe168a2010-12-02 03:14:464103
Matt Menkef6edce752019-03-19 17:21:564104 // Note that group id ordering matters here. "a" comes before "b", so
[email protected]dcbe168a2010-12-02 03:14:464105 // CloseOneIdleSocket() will try to close "a"'s idle socket.
4106
4107 // Set up one idle socket in "a".
4108 ClientSocketHandle handle1;
[email protected]6ecf2b92011-12-15 01:14:524109 TestCompletionCallback callback1;
tfarina428341112016-09-22 13:38:204110 EXPECT_EQ(
4111 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524112 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284113 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504114 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4115 pool_.get(), NetLogWithSource()));
Matt Menke9fa17d52019-03-25 19:12:264116 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
4117 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4118 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4119 TestGroupId("a")));
4120 EXPECT_EQ(0u,
4121 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394122 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]dcbe168a2010-12-02 03:14:464123
Lily Chenecebf932018-11-02 17:15:434124 client_socket_factory_.SignalJobs();
robpercival214763f2016-07-01 23:27:014125 ASSERT_THAT(callback1.WaitForResult(), IsOk());
Matt Menke9fa17d52019-03-25 19:12:264126 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4127 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4128 TestGroupId("a")));
4129 EXPECT_EQ(0u,
4130 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
4131 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434132
[email protected]dcbe168a2010-12-02 03:14:464133 handle1.Reset();
Matt Menkec6b3edf72019-03-19 17:00:394134 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]dcbe168a2010-12-02 03:14:464135
4136 // Set up two active sockets in "b".
4137 ClientSocketHandle handle2;
[email protected]6ecf2b92011-12-15 01:14:524138 TestCompletionCallback callback2;
tfarina428341112016-09-22 13:38:204139 EXPECT_EQ(
4140 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524141 handle1.Init(TestGroupId("b"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284142 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504143 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4144 pool_.get(), NetLogWithSource()));
tfarina428341112016-09-22 13:38:204145 EXPECT_EQ(
4146 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524147 handle2.Init(TestGroupId("b"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284148 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504149 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
4150 pool_.get(), NetLogWithSource()));
[email protected]dcbe168a2010-12-02 03:14:464151
Matt Menke9fa17d52019-03-25 19:12:264152 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("b")));
4153 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
4154 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4155 TestGroupId("b")));
4156 EXPECT_EQ(0u,
4157 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("b")));
Matt Menkec6b3edf72019-03-19 17:00:394158 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("b")));
Lily Chenecebf932018-11-02 17:15:434159
4160 client_socket_factory_.SignalJobs();
robpercival214763f2016-07-01 23:27:014161 ASSERT_THAT(callback1.WaitForResult(), IsOk());
4162 ASSERT_THAT(callback2.WaitForResult(), IsOk());
Matt Menkec6b3edf72019-03-19 17:00:394163 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("b")));
Matt Menke9fa17d52019-03-25 19:12:264164 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4165 TestGroupId("b")));
4166 EXPECT_EQ(0u,
4167 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("b")));
4168 EXPECT_EQ(2, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("b")));
[email protected]dcbe168a2010-12-02 03:14:464169
4170 // Now we have 1 idle socket in "a" and 2 active sockets in "b". This means
4171 // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3.
4172 // Requesting 2 preconnected sockets for "a" should fail to allocate any more
4173 // sockets for "a", and "b" should still have 2 active sockets.
4174
Anton Bikineev068d2912021-05-15 20:43:524175 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:284176 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:264177 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4178 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4179 TestGroupId("a")));
4180 EXPECT_EQ(0u,
4181 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394182 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:264183 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
4184 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
4185 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4186 TestGroupId("b")));
4187 EXPECT_EQ(0u,
4188 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("b")));
Matt Menkec6b3edf72019-03-19 17:00:394189 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("b")));
Matt Menke9fa17d52019-03-25 19:12:264190 EXPECT_EQ(2, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("b")));
[email protected]dcbe168a2010-12-02 03:14:464191
4192 // Now release the 2 active sockets for "b". This will give us 1 idle socket
4193 // in "a" and 2 idle sockets in "b". Requesting 2 preconnected sockets for
4194 // "a" should result in closing 1 for "b".
4195 handle1.Reset();
4196 handle2.Reset();
Matt Menkec6b3edf72019-03-19 17:00:394197 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(TestGroupId("b")));
Matt Menke9fa17d52019-03-25 19:12:264198 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("b")));
[email protected]dcbe168a2010-12-02 03:14:464199
Anton Bikineev068d2912021-05-15 20:43:524200 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:284201 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:264202 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4203 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4204 TestGroupId("a")));
4205 EXPECT_EQ(1u,
4206 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394207 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:264208 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
4209 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
4210 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4211 TestGroupId("b")));
4212 EXPECT_EQ(0u,
4213 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("b")));
Matt Menkec6b3edf72019-03-19 17:00:394214 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("b")));
Matt Menke9fa17d52019-03-25 19:12:264215 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("b")));
[email protected]dcbe168a2010-12-02 03:14:464216}
4217
[email protected]b7b8be42011-07-12 12:46:414218TEST_F(ClientSocketPoolBaseTest, PreconnectWithoutBackupJob) {
Matt Menke9fa17d52019-03-25 19:12:264219 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
4220 true /* enable_backup_connect_jobs */);
[email protected]a9fc8fc2011-05-10 02:41:074221
4222 // Make the ConnectJob hang until it times out, shorten the timeout.
4223 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
Peter Kastinge5a38ed2021-10-02 03:06:354224 connect_job_factory_->set_timeout_duration(base::Milliseconds(500));
Anton Bikineev068d2912021-05-15 20:43:524225 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
Matt Menkef09e64c2019-04-23 22:16:284226 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:264227 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4228 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4229 TestGroupId("a")));
4230 EXPECT_EQ(1u,
4231 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394232 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]a9fc8fc2011-05-10 02:41:074233
[email protected]b7b8be42011-07-12 12:46:414234 // Verify the backup timer doesn't create a backup job, by making
4235 // the backup job a pending job instead of a waiting job, so it
4236 // *would* complete if it were created.
Lukasz Krakowiak28dcf9d62020-06-04 09:46:594237 base::RunLoop loop;
[email protected]a9fc8fc2011-05-10 02:41:074238 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
skyostil4891b25b2015-06-11 11:43:454239 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
Peter Kastinge5a38ed2021-10-02 03:06:354240 FROM_HERE, loop.QuitClosure(), base::Seconds(1));
Lukasz Krakowiak28dcf9d62020-06-04 09:46:594241 loop.Run();
Matt Menke9fa17d52019-03-25 19:12:264242 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
[email protected]a9fc8fc2011-05-10 02:41:074243}
4244
[email protected]b7b8be42011-07-12 12:46:414245TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) {
Matt Menke9fa17d52019-03-25 19:12:264246 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
4247 true /* enable_backup_connect_jobs */);
[email protected]a9fc8fc2011-05-10 02:41:074248
4249 // Make the ConnectJob hang forever.
4250 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
Anton Bikineev068d2912021-05-15 20:43:524251 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
Matt Menkef09e64c2019-04-23 22:16:284252 NetLogWithSource());
Matt Menke9fa17d52019-03-25 19:12:264253 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4254 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4255 TestGroupId("a")));
4256 EXPECT_EQ(1u,
4257 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394258 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
fdoray5eeb7642016-06-22 16:11:284259 base::RunLoop().RunUntilIdle();
[email protected]a9fc8fc2011-05-10 02:41:074260
4261 // Make the backup job be a pending job, so it completes normally.
4262 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
4263 ClientSocketHandle handle;
[email protected]6ecf2b92011-12-15 01:14:524264 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:504265 EXPECT_EQ(
4266 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524267 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284268 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4269 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
4270 pool_.get(), NetLogWithSource()));
[email protected]b7b8be42011-07-12 12:46:414271 // Timer has started, but the backup connect job shouldn't be created yet.
Matt Menke9fa17d52019-03-25 19:12:264272 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4273 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4274 TestGroupId("a")));
4275 EXPECT_EQ(0u,
4276 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394277 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:264278 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
robpercival214763f2016-07-01 23:27:014279 ASSERT_THAT(callback.WaitForResult(), IsOk());
[email protected]a9fc8fc2011-05-10 02:41:074280
4281 // The hung connect job should still be there, but everything else should be
4282 // complete.
Matt Menke9fa17d52019-03-25 19:12:264283 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4284 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4285 TestGroupId("a")));
4286 EXPECT_EQ(1u,
4287 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394288 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:264289 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
[email protected]a9fc8fc2011-05-10 02:41:074290}
4291
[email protected]0dc88b32014-03-26 20:12:284292// Tests that a preconnect that starts out with unread data can still be used.
4293// http://crbug.com/334467
4294TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) {
4295 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
4296 connect_job_factory_->set_job_type(TestConnectJob::kMockUnreadDataJob);
4297
Anton Bikineev068d2912021-05-15 20:43:524298 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
Matt Menkef09e64c2019-04-23 22:16:284299 NetLogWithSource());
[email protected]0dc88b32014-03-26 20:12:284300
Matt Menke9fa17d52019-03-25 19:12:264301 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
4302 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4303 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4304 TestGroupId("a")));
4305 EXPECT_EQ(0u,
4306 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394307 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]0dc88b32014-03-26 20:12:284308
4309 // Fail future jobs to be sure that handle receives the preconnected socket
4310 // rather than closing it and making a new one.
4311 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
4312 ClientSocketHandle handle;
4313 TestCompletionCallback callback;
Matt Menkec6b3edf72019-03-19 17:00:394314 EXPECT_EQ(OK, handle.Init(
Anton Bikineev068d2912021-05-15 20:43:524315 TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284316 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menkec6b3edf72019-03-19 17:00:394317 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
4318 pool_.get(), NetLogWithSource()));
[email protected]0dc88b32014-03-26 20:12:284319
Matt Menke9fa17d52019-03-25 19:12:264320 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
4321 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4322 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4323 TestGroupId("a")));
4324 EXPECT_EQ(0u,
4325 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394326 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:264327 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
[email protected]0dc88b32014-03-26 20:12:284328
4329 // Drain the pending read.
Raul Tambre94493c652019-03-11 17:18:354330 EXPECT_EQ(1, handle.socket()->Read(nullptr, 1, CompletionOnceCallback()));
[email protected]0dc88b32014-03-26 20:12:284331
4332 TestLoadTimingInfoConnectedReused(handle);
4333 handle.Reset();
4334
4335 // The socket should be usable now that it's idle again.
Matt Menkec6b3edf72019-03-19 17:00:394336 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
[email protected]0dc88b32014-03-26 20:12:284337}
4338
Lily Chenecebf932018-11-02 17:15:434339TEST_F(ClientSocketPoolBaseTest, RequestGetsAssignedJob) {
4340 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
4341 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
4342
4343 ClientSocketHandle handle1;
4344 TestCompletionCallback callback1;
4345 EXPECT_EQ(
4346 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524347 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284348 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504349 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4350 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434351
Matt Menke9fa17d52019-03-25 19:12:264352 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4353 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4354 TestGroupId("a")));
4355 EXPECT_EQ(0u,
4356 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394357 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434358
Matt Menkec6b3edf72019-03-19 17:00:394359 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4360 &handle1));
Lily Chenecebf932018-11-02 17:15:434361}
4362
4363TEST_F(ClientSocketPoolBaseTest, MultipleRequestsGetAssignedJobs) {
4364 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
4365 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
4366
4367 ClientSocketHandle handle1;
4368 TestCompletionCallback callback1;
4369 EXPECT_EQ(
4370 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524371 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284372 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504373 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4374 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434375
Matt Menke9fa17d52019-03-25 19:12:264376 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4377 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4378 TestGroupId("a")));
4379 EXPECT_EQ(0u,
4380 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394381 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434382
4383 ClientSocketHandle handle2;
4384 TestCompletionCallback callback2;
4385 EXPECT_EQ(
4386 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524387 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284388 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504389 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
4390 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434391
Matt Menke9fa17d52019-03-25 19:12:264392 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4393 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4394 TestGroupId("a")));
4395 EXPECT_EQ(0u,
4396 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394397 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434398
Matt Menkec6b3edf72019-03-19 17:00:394399 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4400 &handle1));
4401 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4402 &handle2));
Lily Chenecebf932018-11-02 17:15:434403
4404 // One job completes. The other request should still have its job.
4405 client_socket_factory_.SignalJob(0);
4406 EXPECT_THAT(callback1.WaitForResult(), IsOk());
4407
Matt Menke9fa17d52019-03-25 19:12:264408 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4409 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4410 TestGroupId("a")));
4411 EXPECT_EQ(0u,
4412 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
4413 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394414 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434415
Matt Menkec6b3edf72019-03-19 17:00:394416 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4417 &handle2));
Lily Chenecebf932018-11-02 17:15:434418}
4419
4420TEST_F(ClientSocketPoolBaseTest, PreconnectJobGetsAssignedToRequest) {
4421 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
4422 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
4423
Anton Bikineev068d2912021-05-15 20:43:524424 pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
Matt Menkef09e64c2019-04-23 22:16:284425 NetLogWithSource());
Lily Chenecebf932018-11-02 17:15:434426
Matt Menke9fa17d52019-03-25 19:12:264427 ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
4428 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4429 EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4430 TestGroupId("a")));
4431 EXPECT_EQ(1u,
4432 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394433 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434434
4435 ClientSocketHandle handle1;
4436 TestCompletionCallback callback1;
4437 EXPECT_EQ(
4438 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524439 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284440 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504441 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4442 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434443
Matt Menke9fa17d52019-03-25 19:12:264444 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4445 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4446 TestGroupId("a")));
4447 EXPECT_EQ(0u,
4448 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394449 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434450
Matt Menkec6b3edf72019-03-19 17:00:394451 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4452 &handle1));
Lily Chenecebf932018-11-02 17:15:434453}
4454
4455TEST_F(ClientSocketPoolBaseTest, HigherPriorityRequestStealsJob) {
4456 CreatePool(kDefaultMaxSockets, 1);
4457 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
4458
4459 ClientSocketHandle handle1;
4460 TestCompletionCallback callback1;
4461 EXPECT_EQ(
4462 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524463 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284464 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504465 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4466 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434467
Matt Menke9fa17d52019-03-25 19:12:264468 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4469 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4470 TestGroupId("a")));
4471 EXPECT_EQ(0u,
4472 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394473 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434474
Matt Menkec6b3edf72019-03-19 17:00:394475 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4476 &handle1));
Lily Chenecebf932018-11-02 17:15:434477
4478 // Insert a higher priority request
4479 ClientSocketHandle handle2;
4480 TestCompletionCallback callback2;
4481 EXPECT_EQ(
4482 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524483 handle2.Init(TestGroupId("a"), params_, absl::nullopt, HIGHEST,
Matt Menkef09e64c2019-04-23 22:16:284484 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504485 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
4486 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434487
Matt Menke9fa17d52019-03-25 19:12:264488 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4489 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4490 TestGroupId("a")));
4491 EXPECT_EQ(0u,
4492 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394493 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434494
4495 // The highest priority request should steal the job from the default priority
4496 // request.
Matt Menkec6b3edf72019-03-19 17:00:394497 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4498 &handle2));
4499 EXPECT_FALSE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4500 &handle1));
Lily Chenecebf932018-11-02 17:15:434501}
4502
4503TEST_F(ClientSocketPoolBaseTest, RequestStealsJobFromLowestRequestWithJob) {
4504 CreatePool(3, 3);
4505 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
4506
4507 ClientSocketHandle handle_lowest;
4508 TestCompletionCallback callback_lowest;
Matt Menkef09e64c2019-04-23 22:16:284509 EXPECT_EQ(
4510 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524511 handle_lowest.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:284512 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4513 callback_lowest.callback(),
4514 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
4515 NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434516
Matt Menke9fa17d52019-03-25 19:12:264517 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4518 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4519 TestGroupId("a")));
4520 EXPECT_EQ(0u,
4521 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394522 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434523
4524 ClientSocketHandle handle_highest;
4525 TestCompletionCallback callback_highest;
Matt Menkef09e64c2019-04-23 22:16:284526 EXPECT_EQ(
4527 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524528 handle_highest.Init(TestGroupId("a"), params_, absl::nullopt, HIGHEST,
Matt Menkef09e64c2019-04-23 22:16:284529 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4530 callback_highest.callback(),
4531 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
4532 NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434533
Matt Menke9fa17d52019-03-25 19:12:264534 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4535 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4536 TestGroupId("a")));
4537 EXPECT_EQ(0u,
4538 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394539 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434540
4541 ClientSocketHandle handle_low;
4542 TestCompletionCallback callback_low;
4543 EXPECT_EQ(ERR_IO_PENDING,
Matt Menkef09e64c2019-04-23 22:16:284544 handle_low.Init(
Anton Bikineev068d2912021-05-15 20:43:524545 TestGroupId("a"), params_, absl::nullopt, LOW, SocketTag(),
Matt Menkef09e64c2019-04-23 22:16:284546 ClientSocketPool::RespectLimits::ENABLED,
4547 callback_low.callback(), ClientSocketPool::ProxyAuthCallback(),
4548 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434549
Matt Menke9fa17d52019-03-25 19:12:264550 EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4551 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4552 TestGroupId("a")));
4553 EXPECT_EQ(0u,
4554 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394555 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434556
4557 ClientSocketHandle handle_lowest2;
4558 TestCompletionCallback callback_lowest2;
Matt Menkef09e64c2019-04-23 22:16:284559 EXPECT_EQ(
4560 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524561 handle_lowest2.Init(TestGroupId("a"), params_, absl::nullopt, LOWEST,
Matt Menkef09e64c2019-04-23 22:16:284562 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4563 callback_lowest2.callback(),
4564 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
4565 NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434566
Matt Menke9fa17d52019-03-25 19:12:264567 EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4568 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4569 TestGroupId("a")));
4570 EXPECT_EQ(0u,
4571 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394572 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434573
4574 // The top three requests in the queue should have jobs.
Matt Menkec6b3edf72019-03-19 17:00:394575 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4576 &handle_highest));
4577 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4578 &handle_low));
4579 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4580 &handle_lowest));
4581 EXPECT_FALSE(pool_->RequestInGroupWithHandleHasJobForTesting(
4582 TestGroupId("a"), &handle_lowest2));
Lily Chenecebf932018-11-02 17:15:434583
4584 // Add another request with medium priority. It should steal the job from the
4585 // lowest priority request with a job.
4586 ClientSocketHandle handle_medium;
4587 TestCompletionCallback callback_medium;
Matt Menkef09e64c2019-04-23 22:16:284588 EXPECT_EQ(
4589 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524590 handle_medium.Init(TestGroupId("a"), params_, absl::nullopt, MEDIUM,
Matt Menkef09e64c2019-04-23 22:16:284591 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4592 callback_medium.callback(),
4593 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
4594 NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434595
Matt Menke9fa17d52019-03-25 19:12:264596 EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4597 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4598 TestGroupId("a")));
4599 EXPECT_EQ(0u,
4600 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394601 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
4602 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4603 &handle_highest));
4604 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4605 &handle_medium));
4606 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4607 &handle_low));
4608 EXPECT_FALSE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4609 &handle_lowest));
4610 EXPECT_FALSE(pool_->RequestInGroupWithHandleHasJobForTesting(
4611 TestGroupId("a"), &handle_lowest2));
Lily Chenecebf932018-11-02 17:15:434612}
4613
4614TEST_F(ClientSocketPoolBaseTest, ReprioritizeRequestStealsJob) {
4615 CreatePool(kDefaultMaxSockets, 1);
4616 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
4617
4618 ClientSocketHandle handle1;
4619 TestCompletionCallback callback1;
4620 EXPECT_EQ(
4621 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524622 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284623 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504624 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4625 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434626
Matt Menke9fa17d52019-03-25 19:12:264627 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4628 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4629 TestGroupId("a")));
4630 EXPECT_EQ(0u,
4631 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394632 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434633
4634 ClientSocketHandle handle2;
4635 TestCompletionCallback callback2;
4636 EXPECT_EQ(
4637 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524638 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284639 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504640 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
4641 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434642
Matt Menke9fa17d52019-03-25 19:12:264643 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4644 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4645 TestGroupId("a")));
4646 EXPECT_EQ(0u,
4647 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394648 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434649
4650 // The second request doesn't get a job because we are at the limit.
Matt Menkec6b3edf72019-03-19 17:00:394651 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4652 &handle1));
4653 EXPECT_FALSE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4654 &handle2));
Lily Chenecebf932018-11-02 17:15:434655
4656 // Reprioritizing the second request places it above the first, and it steals
4657 // the job from the first request.
Matt Menkec6b3edf72019-03-19 17:00:394658 pool_->SetPriority(TestGroupId("a"), &handle2, HIGHEST);
4659 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4660 &handle2));
4661 EXPECT_FALSE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4662 &handle1));
Lily Chenecebf932018-11-02 17:15:434663}
4664
4665TEST_F(ClientSocketPoolBaseTest, CancelRequestReassignsJob) {
4666 CreatePool(kDefaultMaxSockets, 1);
4667 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
4668
4669 ClientSocketHandle handle1;
4670 TestCompletionCallback callback1;
4671 EXPECT_EQ(
4672 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524673 handle1.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284674 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504675 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4676 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434677
Matt Menke9fa17d52019-03-25 19:12:264678 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4679 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4680 TestGroupId("a")));
4681 EXPECT_EQ(0u,
4682 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394683 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434684
Matt Menkec6b3edf72019-03-19 17:00:394685 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4686 &handle1));
Lily Chenecebf932018-11-02 17:15:434687
4688 ClientSocketHandle handle2;
4689 TestCompletionCallback callback2;
4690 EXPECT_EQ(
4691 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524692 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284693 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504694 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
4695 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434696
Matt Menke9fa17d52019-03-25 19:12:264697 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4698 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4699 TestGroupId("a")));
4700 EXPECT_EQ(0u,
4701 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394702 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434703
4704 // The second request doesn't get a job because we are the limit.
Matt Menkec6b3edf72019-03-19 17:00:394705 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4706 &handle1));
4707 EXPECT_FALSE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4708 &handle2));
Lily Chenecebf932018-11-02 17:15:434709
4710 // The second request should get a job upon cancelling the first request.
4711 handle1.Reset();
Matt Menke9fa17d52019-03-25 19:12:264712 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4713 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4714 TestGroupId("a")));
4715 EXPECT_EQ(0u,
4716 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394717 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434718
Matt Menkec6b3edf72019-03-19 17:00:394719 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4720 &handle2));
Lily Chenecebf932018-11-02 17:15:434721}
4722
4723TEST_F(ClientSocketPoolBaseTest, JobCompletionReassignsJob) {
4724 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
4725 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
4726
4727 ClientSocketHandle handle1;
4728 TestCompletionCallback callback1;
4729 EXPECT_EQ(
4730 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524731 handle1.Init(TestGroupId("a"), params_, absl::nullopt, HIGHEST,
Matt Menkef09e64c2019-04-23 22:16:284732 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504733 callback1.callback(), ClientSocketPool::ProxyAuthCallback(),
4734 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434735
Matt Menke9fa17d52019-03-25 19:12:264736 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4737 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4738 TestGroupId("a")));
4739 EXPECT_EQ(0u,
4740 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394741 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434742
4743 ClientSocketHandle handle2;
4744 TestCompletionCallback callback2;
4745 EXPECT_EQ(
4746 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524747 handle2.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284748 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:504749 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
4750 pool_.get(), NetLogWithSource()));
Lily Chenecebf932018-11-02 17:15:434751
Matt Menke9fa17d52019-03-25 19:12:264752 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4753 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4754 TestGroupId("a")));
4755 EXPECT_EQ(0u,
4756 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394757 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434758
Matt Menkec6b3edf72019-03-19 17:00:394759 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4760 &handle1));
4761 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4762 &handle2));
Lily Chenecebf932018-11-02 17:15:434763
4764 // The lower-priority job completes first. The higher-priority request should
4765 // get the socket, and the lower-priority request should get the remaining
4766 // job.
4767 client_socket_factory_.SignalJob(1);
4768 EXPECT_THAT(callback1.WaitForResult(), IsOk());
Matt Menke9fa17d52019-03-25 19:12:264769 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
4770 EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
4771 TestGroupId("a")));
4772 EXPECT_EQ(0u,
4773 pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
4774 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:394775 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Lily Chenecebf932018-11-02 17:15:434776 EXPECT_TRUE(handle1.socket());
Matt Menkec6b3edf72019-03-19 17:00:394777 EXPECT_TRUE(pool_->RequestInGroupWithHandleHasJobForTesting(TestGroupId("a"),
4778 &handle2));
Lily Chenecebf932018-11-02 17:15:434779}
4780
[email protected]043b68c82013-08-22 23:41:524781class MockLayeredPool : public HigherLayeredPool {
[email protected]58e562f2013-04-22 17:32:204782 public:
Matt Menke9fa17d52019-03-25 19:12:264783 MockLayeredPool(TransportClientSocketPool* pool,
Matt Menkec6b3edf72019-03-19 17:00:394784 const ClientSocketPool::GroupId& group_id)
4785 : pool_(pool), group_id_(group_id), can_release_connection_(true) {
[email protected]043b68c82013-08-22 23:41:524786 pool_->AddHigherLayeredPool(this);
[email protected]58e562f2013-04-22 17:32:204787 }
4788
Daniel Cheng4496d0822018-04-26 21:52:154789 ~MockLayeredPool() override { pool_->RemoveHigherLayeredPool(this); }
[email protected]58e562f2013-04-22 17:32:204790
Matt Menke9fa17d52019-03-25 19:12:264791 int RequestSocket(TransportClientSocketPool* pool) {
Matt Menke28ac03e2019-02-25 22:25:504792 return handle_.Init(
Matt Menke870e19ab2019-04-23 16:23:034793 group_id_, ClientSocketPool::SocketParams::CreateForHttpForTesting(),
Anton Bikineev068d2912021-05-15 20:43:524794 absl::nullopt, DEFAULT_PRIORITY, SocketTag(),
Matt Menkef09e64c2019-04-23 22:16:284795 ClientSocketPool::RespectLimits::ENABLED, callback_.callback(),
4796 ClientSocketPool::ProxyAuthCallback(), pool, NetLogWithSource());
[email protected]58e562f2013-04-22 17:32:204797 }
4798
Matt Menke9fa17d52019-03-25 19:12:264799 int RequestSocketWithoutLimits(TransportClientSocketPool* pool) {
Matt Menke28ac03e2019-02-25 22:25:504800 return handle_.Init(
Matt Menke870e19ab2019-04-23 16:23:034801 group_id_, ClientSocketPool::SocketParams::CreateForHttpForTesting(),
Anton Bikineev068d2912021-05-15 20:43:524802 absl::nullopt, MAXIMUM_PRIORITY, SocketTag(),
Matt Menke28ac03e2019-02-25 22:25:504803 ClientSocketPool::RespectLimits::DISABLED, callback_.callback(),
4804 ClientSocketPool::ProxyAuthCallback(), pool, NetLogWithSource());
[email protected]58e562f2013-04-22 17:32:204805 }
4806
4807 bool ReleaseOneConnection() {
4808 if (!handle_.is_initialized() || !can_release_connection_) {
4809 return false;
4810 }
4811 handle_.socket()->Disconnect();
4812 handle_.Reset();
4813 return true;
4814 }
4815
4816 void set_can_release_connection(bool can_release_connection) {
4817 can_release_connection_ = can_release_connection;
4818 }
4819
4820 MOCK_METHOD0(CloseOneIdleConnection, bool());
4821
4822 private:
Keishi Hattori0e45c022021-11-27 09:25:524823 const raw_ptr<TransportClientSocketPool> pool_;
[email protected]58e562f2013-04-22 17:32:204824 ClientSocketHandle handle_;
4825 TestCompletionCallback callback_;
Matt Menkec6b3edf72019-03-19 17:00:394826 const ClientSocketPool::GroupId group_id_;
[email protected]58e562f2013-04-22 17:32:204827 bool can_release_connection_;
4828};
4829
[email protected]58e562f2013-04-22 17:32:204830// Tests the basic case of closing an idle socket in a higher layered pool when
4831// a new request is issued and the lower layer pool is stalled.
4832TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
4833 CreatePool(1, 1);
4834 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
4835
Matt Menkec6b3edf72019-03-19 17:00:394836 MockLayeredPool mock_layered_pool(pool_.get(), TestGroupId("foo"));
robpercival214763f2016-07-01 23:27:014837 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
[email protected]58e562f2013-04-22 17:32:204838 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
4839 .WillOnce(Invoke(&mock_layered_pool,
4840 &MockLayeredPool::ReleaseOneConnection));
4841 ClientSocketHandle handle;
4842 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:504843 EXPECT_EQ(
4844 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524845 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284846 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4847 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
4848 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:014849 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]58e562f2013-04-22 17:32:204850}
4851
Matt Menke833678642019-03-05 22:05:514852// Tests the case that trying to close an idle socket in a higher layered pool
4853// fails.
4854TEST_F(ClientSocketPoolBaseTest,
4855 CloseIdleSocketsHeldByLayeredPoolWhenNeededFails) {
4856 CreatePool(1, 1);
4857 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
4858
Matt Menkec6b3edf72019-03-19 17:00:394859 MockLayeredPool mock_layered_pool(pool_.get(), TestGroupId("foo"));
Matt Menke833678642019-03-05 22:05:514860 mock_layered_pool.set_can_release_connection(false);
4861 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
4862 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
4863 .WillOnce(Invoke(&mock_layered_pool,
4864 &MockLayeredPool::ReleaseOneConnection));
4865 ClientSocketHandle handle;
4866 TestCompletionCallback callback;
4867 EXPECT_EQ(
4868 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:524869 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284870 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4871 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
4872 pool_.get(), NetLogWithSource()));
Matt Menke833678642019-03-05 22:05:514873 base::RunLoop().RunUntilIdle();
4874 EXPECT_FALSE(callback.have_result());
4875}
4876
[email protected]58e562f2013-04-22 17:32:204877// Same as above, but the idle socket is in the same group as the stalled
4878// socket, and closes the only other request in its group when closing requests
4879// in higher layered pools. This generally shouldn't happen, but it may be
4880// possible if a higher level pool issues a request and the request is
4881// subsequently cancelled. Even if it's not possible, best not to crash.
4882TEST_F(ClientSocketPoolBaseTest,
4883 CloseIdleSocketsHeldByLayeredPoolWhenNeededSameGroup) {
4884 CreatePool(2, 2);
4885 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
4886
4887 // Need a socket in another group for the pool to be stalled (If a group
4888 // has the maximum number of connections already, it's not stalled).
4889 ClientSocketHandle handle1;
4890 TestCompletionCallback callback1;
Anton Bikineev068d2912021-05-15 20:43:524891 EXPECT_EQ(OK, handle1.Init(TestGroupId("group1"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:284892 DEFAULT_PRIORITY, SocketTag(),
4893 ClientSocketPool::RespectLimits::ENABLED,
4894 callback1.callback(),
4895 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
4896 NetLogWithSource()));
[email protected]58e562f2013-04-22 17:32:204897
Matt Menkec6b3edf72019-03-19 17:00:394898 MockLayeredPool mock_layered_pool(pool_.get(), TestGroupId("group2"));
robpercival214763f2016-07-01 23:27:014899 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
[email protected]58e562f2013-04-22 17:32:204900 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
4901 .WillOnce(Invoke(&mock_layered_pool,
4902 &MockLayeredPool::ReleaseOneConnection));
4903 ClientSocketHandle handle;
4904 TestCompletionCallback callback2;
Matt Menkef09e64c2019-04-23 22:16:284905 EXPECT_EQ(ERR_IO_PENDING,
4906 handle.Init(
Anton Bikineev068d2912021-05-15 20:43:524907 TestGroupId("group2"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284908 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4909 callback2.callback(), ClientSocketPool::ProxyAuthCallback(),
4910 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:014911 EXPECT_THAT(callback2.WaitForResult(), IsOk());
[email protected]58e562f2013-04-22 17:32:204912}
4913
4914// Tests the case when an idle socket can be closed when a new request is
4915// issued, and the new request belongs to a group that was previously stalled.
4916TEST_F(ClientSocketPoolBaseTest,
4917 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded) {
4918 CreatePool(2, 2);
4919 std::list<TestConnectJob::JobType> job_types;
4920 job_types.push_back(TestConnectJob::kMockJob);
4921 job_types.push_back(TestConnectJob::kMockJob);
4922 job_types.push_back(TestConnectJob::kMockJob);
4923 job_types.push_back(TestConnectJob::kMockJob);
4924 connect_job_factory_->set_job_types(&job_types);
4925
4926 ClientSocketHandle handle1;
4927 TestCompletionCallback callback1;
Anton Bikineev068d2912021-05-15 20:43:524928 EXPECT_EQ(OK, handle1.Init(TestGroupId("group1"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:284929 DEFAULT_PRIORITY, SocketTag(),
4930 ClientSocketPool::RespectLimits::ENABLED,
4931 callback1.callback(),
4932 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
4933 NetLogWithSource()));
[email protected]58e562f2013-04-22 17:32:204934
Matt Menkec6b3edf72019-03-19 17:00:394935 MockLayeredPool mock_layered_pool(pool_.get(), TestGroupId("group2"));
robpercival214763f2016-07-01 23:27:014936 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
[email protected]58e562f2013-04-22 17:32:204937 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
4938 .WillRepeatedly(Invoke(&mock_layered_pool,
4939 &MockLayeredPool::ReleaseOneConnection));
4940 mock_layered_pool.set_can_release_connection(false);
4941
4942 // The third request is made when the socket pool is in a stalled state.
4943 ClientSocketHandle handle3;
4944 TestCompletionCallback callback3;
Matt Menkef09e64c2019-04-23 22:16:284945 EXPECT_EQ(ERR_IO_PENDING,
4946 handle3.Init(
Anton Bikineev068d2912021-05-15 20:43:524947 TestGroupId("group3"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284948 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4949 callback3.callback(), ClientSocketPool::ProxyAuthCallback(),
4950 pool_.get(), NetLogWithSource()));
[email protected]58e562f2013-04-22 17:32:204951
4952 base::RunLoop().RunUntilIdle();
4953 EXPECT_FALSE(callback3.have_result());
4954
4955 // The fourth request is made when the pool is no longer stalled. The third
4956 // request should be serviced first, since it was issued first and has the
4957 // same priority.
4958 mock_layered_pool.set_can_release_connection(true);
4959 ClientSocketHandle handle4;
4960 TestCompletionCallback callback4;
Matt Menkef09e64c2019-04-23 22:16:284961 EXPECT_EQ(ERR_IO_PENDING,
4962 handle4.Init(
Anton Bikineev068d2912021-05-15 20:43:524963 TestGroupId("group3"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:284964 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
4965 callback4.callback(), ClientSocketPool::ProxyAuthCallback(),
4966 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:014967 EXPECT_THAT(callback3.WaitForResult(), IsOk());
[email protected]58e562f2013-04-22 17:32:204968 EXPECT_FALSE(callback4.have_result());
4969
4970 // Closing a handle should free up another socket slot.
4971 handle1.Reset();
robpercival214763f2016-07-01 23:27:014972 EXPECT_THAT(callback4.WaitForResult(), IsOk());
[email protected]58e562f2013-04-22 17:32:204973}
4974
4975// Tests the case when an idle socket can be closed when a new request is
4976// issued, and the new request belongs to a group that was previously stalled.
4977//
4978// The two differences from the above test are that the stalled requests are not
4979// in the same group as the layered pool's request, and the the fourth request
4980// has a higher priority than the third one, so gets a socket first.
4981TEST_F(ClientSocketPoolBaseTest,
4982 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded2) {
4983 CreatePool(2, 2);
4984 std::list<TestConnectJob::JobType> job_types;
4985 job_types.push_back(TestConnectJob::kMockJob);
4986 job_types.push_back(TestConnectJob::kMockJob);
4987 job_types.push_back(TestConnectJob::kMockJob);
4988 job_types.push_back(TestConnectJob::kMockJob);
4989 connect_job_factory_->set_job_types(&job_types);
4990
4991 ClientSocketHandle handle1;
4992 TestCompletionCallback callback1;
Anton Bikineev068d2912021-05-15 20:43:524993 EXPECT_EQ(OK, handle1.Init(TestGroupId("group1"), params_, absl::nullopt,
Matt Menkef09e64c2019-04-23 22:16:284994 DEFAULT_PRIORITY, SocketTag(),
4995 ClientSocketPool::RespectLimits::ENABLED,
4996 callback1.callback(),
4997 ClientSocketPool::ProxyAuthCallback(), pool_.get(),
4998 NetLogWithSource()));
[email protected]58e562f2013-04-22 17:32:204999
Matt Menkec6b3edf72019-03-19 17:00:395000 MockLayeredPool mock_layered_pool(pool_.get(), TestGroupId("group2"));
robpercival214763f2016-07-01 23:27:015001 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
[email protected]58e562f2013-04-22 17:32:205002 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
5003 .WillRepeatedly(Invoke(&mock_layered_pool,
5004 &MockLayeredPool::ReleaseOneConnection));
5005 mock_layered_pool.set_can_release_connection(false);
5006
5007 // The third request is made when the socket pool is in a stalled state.
5008 ClientSocketHandle handle3;
5009 TestCompletionCallback callback3;
tfarina428341112016-09-22 13:38:205010 EXPECT_EQ(
5011 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:525012 handle3.Init(TestGroupId("group3"), params_, absl::nullopt, MEDIUM,
Matt Menkef09e64c2019-04-23 22:16:285013 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:505014 callback3.callback(), ClientSocketPool::ProxyAuthCallback(),
5015 pool_.get(), NetLogWithSource()));
[email protected]58e562f2013-04-22 17:32:205016
5017 base::RunLoop().RunUntilIdle();
5018 EXPECT_FALSE(callback3.have_result());
5019
5020 // The fourth request is made when the pool is no longer stalled. This
5021 // request has a higher priority than the third request, so is serviced first.
5022 mock_layered_pool.set_can_release_connection(true);
5023 ClientSocketHandle handle4;
5024 TestCompletionCallback callback4;
tfarina428341112016-09-22 13:38:205025 EXPECT_EQ(
5026 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:525027 handle4.Init(TestGroupId("group3"), params_, absl::nullopt, HIGHEST,
Matt Menkef09e64c2019-04-23 22:16:285028 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
Matt Menke28ac03e2019-02-25 22:25:505029 callback4.callback(), ClientSocketPool::ProxyAuthCallback(),
5030 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:015031 EXPECT_THAT(callback4.WaitForResult(), IsOk());
[email protected]58e562f2013-04-22 17:32:205032 EXPECT_FALSE(callback3.have_result());
5033
5034 // Closing a handle should free up another socket slot.
5035 handle1.Reset();
robpercival214763f2016-07-01 23:27:015036 EXPECT_THAT(callback3.WaitForResult(), IsOk());
[email protected]58e562f2013-04-22 17:32:205037}
5038
5039TEST_F(ClientSocketPoolBaseTest,
5040 CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) {
5041 CreatePool(1, 1);
5042 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
5043
Matt Menkec6b3edf72019-03-19 17:00:395044 MockLayeredPool mock_layered_pool1(pool_.get(), TestGroupId("foo"));
robpercival214763f2016-07-01 23:27:015045 EXPECT_THAT(mock_layered_pool1.RequestSocket(pool_.get()), IsOk());
[email protected]58e562f2013-04-22 17:32:205046 EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection())
5047 .WillRepeatedly(Invoke(&mock_layered_pool1,
5048 &MockLayeredPool::ReleaseOneConnection));
Matt Menkec6b3edf72019-03-19 17:00:395049 MockLayeredPool mock_layered_pool2(pool_.get(), TestGroupId("bar"));
robpercival214763f2016-07-01 23:27:015050 EXPECT_THAT(mock_layered_pool2.RequestSocketWithoutLimits(pool_.get()),
5051 IsOk());
[email protected]58e562f2013-04-22 17:32:205052 EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection())
5053 .WillRepeatedly(Invoke(&mock_layered_pool2,
5054 &MockLayeredPool::ReleaseOneConnection));
5055 ClientSocketHandle handle;
5056 TestCompletionCallback callback;
Matt Menke28ac03e2019-02-25 22:25:505057 EXPECT_EQ(
5058 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:525059 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:285060 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5061 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5062 pool_.get(), NetLogWithSource()));
robpercival214763f2016-07-01 23:27:015063 EXPECT_THAT(callback.WaitForResult(), IsOk());
[email protected]58e562f2013-04-22 17:32:205064}
5065
[email protected]b021ece62013-06-11 11:06:335066// Test that when a socket pool and group are at their limits, a request
mmenked3641e12016-01-28 16:06:155067// with RespectLimits::DISABLED triggers creation of a new socket, and gets the
5068// socket instead of a request with the same priority that was issued earlier,
5069// but has RespectLimits::ENABLED.
[email protected]b021ece62013-06-11 11:06:335070TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) {
[email protected]b021ece62013-06-11 11:06:335071 CreatePool(1, 1);
5072
5073 // Issue a request to reach the socket pool limit.
Matt Menkec6b3edf72019-03-19 17:00:395074 EXPECT_EQ(OK, StartRequestWithIgnoreLimits(
5075 TestGroupId("a"), MAXIMUM_PRIORITY,
5076 ClientSocketPool::RespectLimits::ENABLED));
Matt Menke9fa17d52019-03-25 19:12:265077 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]b021ece62013-06-11 11:06:335078
5079 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
5080
mmenked3641e12016-01-28 16:06:155081 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits(
Matt Menkec6b3edf72019-03-19 17:00:395082 TestGroupId("a"), MAXIMUM_PRIORITY,
mmenked3641e12016-01-28 16:06:155083 ClientSocketPool::RespectLimits::ENABLED));
Matt Menke9fa17d52019-03-25 19:12:265084 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]b021ece62013-06-11 11:06:335085
mmenked3641e12016-01-28 16:06:155086 // Issue a request that ignores the limits, so a new ConnectJob is
5087 // created.
5088 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits(
Matt Menkec6b3edf72019-03-19 17:00:395089 TestGroupId("a"), MAXIMUM_PRIORITY,
mmenked3641e12016-01-28 16:06:155090 ClientSocketPool::RespectLimits::DISABLED));
Matt Menke9fa17d52019-03-25 19:12:265091 ASSERT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]b021ece62013-06-11 11:06:335092
robpercival214763f2016-07-01 23:27:015093 EXPECT_THAT(request(2)->WaitForResult(), IsOk());
[email protected]b021ece62013-06-11 11:06:335094 EXPECT_FALSE(request(1)->have_result());
5095}
5096
[email protected]c55fabd2013-11-04 23:26:565097// Test that when a socket pool and group are at their limits, a ConnectJob
mmenked3641e12016-01-28 16:06:155098// issued for a request with RespectLimits::DISABLED is not cancelled when a
5099// request with RespectLimits::ENABLED issued to the same group is cancelled.
[email protected]c55fabd2013-11-04 23:26:565100TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsCancelOtherJob) {
[email protected]c55fabd2013-11-04 23:26:565101 CreatePool(1, 1);
5102
5103 // Issue a request to reach the socket pool limit.
Matt Menkec6b3edf72019-03-19 17:00:395104 EXPECT_EQ(OK, StartRequestWithIgnoreLimits(
5105 TestGroupId("a"), MAXIMUM_PRIORITY,
5106 ClientSocketPool::RespectLimits::ENABLED));
Matt Menke9fa17d52019-03-25 19:12:265107 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]c55fabd2013-11-04 23:26:565108
5109 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
5110
mmenked3641e12016-01-28 16:06:155111 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits(
Matt Menkec6b3edf72019-03-19 17:00:395112 TestGroupId("a"), MAXIMUM_PRIORITY,
mmenked3641e12016-01-28 16:06:155113 ClientSocketPool::RespectLimits::ENABLED));
Matt Menke9fa17d52019-03-25 19:12:265114 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]c55fabd2013-11-04 23:26:565115
mmenked3641e12016-01-28 16:06:155116 // Issue a request with RespectLimits::DISABLED, so a new ConnectJob is
5117 // created.
5118 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits(
Matt Menkec6b3edf72019-03-19 17:00:395119 TestGroupId("a"), MAXIMUM_PRIORITY,
mmenked3641e12016-01-28 16:06:155120 ClientSocketPool::RespectLimits::DISABLED));
Matt Menke9fa17d52019-03-25 19:12:265121 ASSERT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]b021ece62013-06-11 11:06:335122
mmenked3641e12016-01-28 16:06:155123 // Cancel the pending request with RespectLimits::ENABLED. The ConnectJob
[email protected]b021ece62013-06-11 11:06:335124 // should not be cancelled.
5125 request(1)->handle()->Reset();
Matt Menke9fa17d52019-03-25 19:12:265126 ASSERT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
[email protected]b021ece62013-06-11 11:06:335127
robpercival214763f2016-07-01 23:27:015128 EXPECT_THAT(request(2)->WaitForResult(), IsOk());
[email protected]b021ece62013-06-11 11:06:335129 EXPECT_FALSE(request(1)->have_result());
5130}
5131
Matt Menkeb57663b32019-03-01 17:17:105132TEST_F(ClientSocketPoolBaseTest, ProxyAuthNoAuthCallback) {
5133 CreatePool(1, 1);
5134
5135 connect_job_factory_->set_job_type(TestConnectJob::kMockAuthChallengeOnceJob);
5136
5137 ClientSocketHandle handle;
5138 TestCompletionCallback callback;
5139 EXPECT_EQ(
5140 ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:525141 handle.Init(TestGroupId("a"), params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:285142 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5143 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5144 pool_.get(), NetLogWithSource()));
Matt Menkeb57663b32019-03-01 17:17:105145
Matt Menke9fa17d52019-03-25 19:12:265146 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105147
5148 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_AUTH_REQUESTED));
5149 EXPECT_FALSE(handle.is_initialized());
5150 EXPECT_FALSE(handle.socket());
5151
5152 // The group should now be empty, and thus be deleted.
Matt Menke9fa17d52019-03-25 19:12:265153 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105154}
5155
5156class TestAuthHelper {
5157 public:
5158 TestAuthHelper() = default;
Peter Boström293b1342021-09-22 17:31:435159
5160 TestAuthHelper(const TestAuthHelper&) = delete;
5161 TestAuthHelper& operator=(const TestAuthHelper&) = delete;
5162
Matt Menkeb57663b32019-03-01 17:17:105163 ~TestAuthHelper() = default;
5164
Matt Menkec6b3edf72019-03-19 17:00:395165 void InitHandle(
Matt Menke84d11e562019-03-27 00:11:195166 scoped_refptr<ClientSocketPool::SocketParams> params,
Matt Menke9fa17d52019-03-25 19:12:265167 TransportClientSocketPool* pool,
Matt Menkec6b3edf72019-03-19 17:00:395168 RequestPriority priority = DEFAULT_PRIORITY,
5169 ClientSocketPool::RespectLimits respect_limits =
5170 ClientSocketPool::RespectLimits::ENABLED,
5171 const ClientSocketPool::GroupId& group_id_in = TestGroupId("a")) {
Matt Menkeb57663b32019-03-01 17:17:105172 EXPECT_EQ(ERR_IO_PENDING,
Anton Bikineev068d2912021-05-15 20:43:525173 handle_.Init(group_id_in, params, absl::nullopt, priority,
Matt Menkef09e64c2019-04-23 22:16:285174 SocketTag(), respect_limits, callback_.callback(),
Matt Menkeb57663b32019-03-01 17:17:105175 base::BindRepeating(&TestAuthHelper::AuthCallback,
5176 base::Unretained(this)),
5177 pool, NetLogWithSource()));
5178 }
5179
5180 void WaitForAuth() {
5181 run_loop_ = std::make_unique<base::RunLoop>();
5182 run_loop_->Run();
5183 run_loop_.reset();
5184 }
5185
5186 void WaitForAuthAndRestartSync() {
5187 restart_sync_ = true;
5188 WaitForAuth();
5189 restart_sync_ = false;
5190 }
5191
5192 void WaitForAuthAndResetHandleSync() {
5193 reset_handle_sync_ = true;
5194 WaitForAuth();
5195 reset_handle_sync_ = false;
5196 }
5197
5198 void RestartWithAuth() {
5199 DCHECK(restart_with_auth_callback_);
5200 std::move(restart_with_auth_callback_).Run();
5201 }
5202
5203 int WaitForResult() {
5204 int result = callback_.WaitForResult();
5205 // There shouldn't be any callback waiting to be invoked once the request is
5206 // complete.
5207 EXPECT_FALSE(restart_with_auth_callback_);
5208 // The socket should only be initialized on success.
5209 EXPECT_EQ(result == OK, handle_.is_initialized());
5210 EXPECT_EQ(result == OK, handle_.socket() != nullptr);
5211 return result;
5212 }
5213
5214 ClientSocketHandle* handle() { return &handle_; }
5215 int auth_count() const { return auth_count_; }
5216 int have_result() const { return callback_.have_result(); }
5217
5218 private:
5219 void AuthCallback(const HttpResponseInfo& response,
5220 HttpAuthController* auth_controller,
5221 base::OnceClosure restart_with_auth_callback) {
5222 EXPECT_FALSE(restart_with_auth_callback_);
5223 EXPECT_TRUE(restart_with_auth_callback);
5224
5225 // Once there's a result, this method shouldn't be invoked again.
5226 EXPECT_FALSE(callback_.have_result());
5227
5228 ++auth_count_;
5229 run_loop_->Quit();
5230 if (restart_sync_) {
5231 std::move(restart_with_auth_callback).Run();
5232 return;
5233 }
5234
5235 restart_with_auth_callback_ = std::move(restart_with_auth_callback);
5236
5237 if (reset_handle_sync_) {
5238 handle_.Reset();
5239 return;
5240 }
5241 }
5242
5243 std::unique_ptr<base::RunLoop> run_loop_;
5244 base::OnceClosure restart_with_auth_callback_;
5245
5246 bool restart_sync_ = false;
5247 bool reset_handle_sync_ = false;
5248
5249 ClientSocketHandle handle_;
5250 int auth_count_ = 0;
5251 TestCompletionCallback callback_;
Matt Menkeb57663b32019-03-01 17:17:105252};
5253
5254TEST_F(ClientSocketPoolBaseTest, ProxyAuthOnce) {
5255 CreatePool(1, 1);
5256 connect_job_factory_->set_job_type(TestConnectJob::kMockAuthChallengeOnceJob);
5257
5258 TestAuthHelper auth_helper;
5259 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265260 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menke4b69f932019-03-04 16:20:015261 EXPECT_EQ(LOAD_STATE_CONNECTING,
Matt Menkec6b3edf72019-03-19 17:00:395262 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menkeb57663b32019-03-01 17:17:105263
5264 auth_helper.WaitForAuth();
Matt Menke9fa17d52019-03-25 19:12:265265 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menke4b69f932019-03-04 16:20:015266 EXPECT_EQ(LOAD_STATE_ESTABLISHING_PROXY_TUNNEL,
Matt Menkec6b3edf72019-03-19 17:00:395267 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menkeb57663b32019-03-01 17:17:105268
5269 auth_helper.RestartWithAuth();
Matt Menke9fa17d52019-03-25 19:12:265270 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menke4b69f932019-03-04 16:20:015271 EXPECT_EQ(LOAD_STATE_ESTABLISHING_PROXY_TUNNEL,
Matt Menkec6b3edf72019-03-19 17:00:395272 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menkeb57663b32019-03-01 17:17:105273
5274 EXPECT_THAT(auth_helper.WaitForResult(), IsOk());
5275 EXPECT_EQ(1, auth_helper.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265276 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
5277 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:395278 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105279 EXPECT_EQ(0, pool_->IdleSocketCount());
5280}
5281
5282TEST_F(ClientSocketPoolBaseTest, ProxyAuthOnceSync) {
5283 CreatePool(1, 1);
5284 connect_job_factory_->set_job_type(TestConnectJob::kMockAuthChallengeOnceJob);
5285
5286 TestAuthHelper auth_helper;
5287 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265288 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menke4b69f932019-03-04 16:20:015289 EXPECT_EQ(LOAD_STATE_CONNECTING,
Matt Menkec6b3edf72019-03-19 17:00:395290 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menkeb57663b32019-03-01 17:17:105291
5292 auth_helper.WaitForAuthAndRestartSync();
Matt Menke9fa17d52019-03-25 19:12:265293 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menke4b69f932019-03-04 16:20:015294 EXPECT_EQ(LOAD_STATE_ESTABLISHING_PROXY_TUNNEL,
Matt Menkec6b3edf72019-03-19 17:00:395295 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menkeb57663b32019-03-01 17:17:105296
5297 EXPECT_THAT(auth_helper.WaitForResult(), IsOk());
5298 EXPECT_EQ(1, auth_helper.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265299 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
5300 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:395301 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105302 EXPECT_EQ(0, pool_->IdleSocketCount());
5303}
5304
5305TEST_F(ClientSocketPoolBaseTest, ProxyAuthOnceFails) {
5306 CreatePool(1, 1);
5307 connect_job_factory_->set_job_type(
5308 TestConnectJob::kMockAuthChallengeOnceFailingJob);
5309
5310 TestAuthHelper auth_helper;
5311 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265312 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105313
5314 auth_helper.WaitForAuth();
5315 auth_helper.RestartWithAuth();
5316 EXPECT_THAT(auth_helper.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
5317
5318 EXPECT_EQ(1, auth_helper.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265319 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105320 EXPECT_EQ(0, pool_->IdleSocketCount());
5321}
5322
5323TEST_F(ClientSocketPoolBaseTest, ProxyAuthOnceSyncFails) {
5324 CreatePool(1, 1);
5325 connect_job_factory_->set_job_type(
5326 TestConnectJob::kMockAuthChallengeOnceFailingJob);
5327
5328 TestAuthHelper auth_helper;
5329 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265330 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105331
5332 auth_helper.WaitForAuthAndRestartSync();
5333 EXPECT_THAT(auth_helper.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
5334
5335 EXPECT_EQ(1, auth_helper.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265336 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105337 EXPECT_EQ(0, pool_->IdleSocketCount());
5338}
5339
5340TEST_F(ClientSocketPoolBaseTest, ProxyAuthOnceDeleteHandle) {
5341 CreatePool(1, 1);
5342 connect_job_factory_->set_job_type(TestConnectJob::kMockAuthChallengeOnceJob);
5343
5344 TestAuthHelper auth_helper;
5345 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265346 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105347
5348 auth_helper.WaitForAuth();
Matt Menke9fa17d52019-03-25 19:12:265349 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105350
5351 auth_helper.handle()->Reset();
5352
5353 EXPECT_EQ(1, auth_helper.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265354 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105355 EXPECT_EQ(0, pool_->IdleSocketCount());
5356 EXPECT_FALSE(auth_helper.handle()->is_initialized());
5357 EXPECT_FALSE(auth_helper.handle()->socket());
5358}
5359
5360TEST_F(ClientSocketPoolBaseTest, ProxyAuthOnceDeleteHandleSync) {
5361 CreatePool(1, 1);
5362 connect_job_factory_->set_job_type(TestConnectJob::kMockAuthChallengeOnceJob);
5363
5364 TestAuthHelper auth_helper;
5365 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265366 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105367
5368 auth_helper.WaitForAuthAndResetHandleSync();
5369 EXPECT_EQ(1, auth_helper.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265370 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105371 EXPECT_EQ(0, pool_->IdleSocketCount());
5372 EXPECT_FALSE(auth_helper.handle()->is_initialized());
5373 EXPECT_FALSE(auth_helper.handle()->socket());
5374}
5375
5376TEST_F(ClientSocketPoolBaseTest, ProxyAuthOnceFlushWithError) {
5377 CreatePool(1, 1);
5378 connect_job_factory_->set_job_type(TestConnectJob::kMockAuthChallengeOnceJob);
5379
5380 TestAuthHelper auth_helper;
5381 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265382 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105383
5384 auth_helper.WaitForAuth();
5385
Matt Menke433de6d2020-03-04 00:24:115386 pool_->FlushWithError(ERR_FAILED, "Network changed");
Matt Menkeb57663b32019-03-01 17:17:105387 base::RunLoop().RunUntilIdle();
5388
5389 // When flushing the socket pool, bound sockets should delay returning the
5390 // error until completion.
5391 EXPECT_FALSE(auth_helper.have_result());
Matt Menke9fa17d52019-03-25 19:12:265392 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105393 EXPECT_EQ(0, pool_->IdleSocketCount());
5394
5395 auth_helper.RestartWithAuth();
5396 // The callback should be called asynchronously.
5397 EXPECT_FALSE(auth_helper.have_result());
5398
5399 EXPECT_THAT(auth_helper.WaitForResult(), IsError(ERR_FAILED));
Matt Menke9fa17d52019-03-25 19:12:265400 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105401 EXPECT_EQ(0, pool_->IdleSocketCount());
5402}
5403
5404TEST_F(ClientSocketPoolBaseTest, ProxyAuthTwice) {
5405 CreatePool(1, 1);
5406 connect_job_factory_->set_job_type(
5407 TestConnectJob::kMockAuthChallengeTwiceJob);
5408
5409 TestAuthHelper auth_helper;
5410 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265411 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menke4b69f932019-03-04 16:20:015412 EXPECT_EQ(LOAD_STATE_CONNECTING,
Matt Menkec6b3edf72019-03-19 17:00:395413 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menkeb57663b32019-03-01 17:17:105414
5415 auth_helper.WaitForAuth();
5416 auth_helper.RestartWithAuth();
Matt Menke9fa17d52019-03-25 19:12:265417 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105418 EXPECT_EQ(1, auth_helper.auth_count());
Matt Menke4b69f932019-03-04 16:20:015419 EXPECT_EQ(LOAD_STATE_ESTABLISHING_PROXY_TUNNEL,
Matt Menkec6b3edf72019-03-19 17:00:395420 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menkeb57663b32019-03-01 17:17:105421
5422 auth_helper.WaitForAuth();
Matt Menke9fa17d52019-03-25 19:12:265423 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menke4b69f932019-03-04 16:20:015424 EXPECT_EQ(2, auth_helper.auth_count());
5425 EXPECT_EQ(LOAD_STATE_ESTABLISHING_PROXY_TUNNEL,
Matt Menkec6b3edf72019-03-19 17:00:395426 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menke4b69f932019-03-04 16:20:015427
Matt Menkeb57663b32019-03-01 17:17:105428 auth_helper.RestartWithAuth();
Matt Menke9fa17d52019-03-25 19:12:265429 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105430 EXPECT_EQ(2, auth_helper.auth_count());
Matt Menke4b69f932019-03-04 16:20:015431 EXPECT_EQ(LOAD_STATE_ESTABLISHING_PROXY_TUNNEL,
Matt Menkec6b3edf72019-03-19 17:00:395432 pool_->GetLoadState(TestGroupId("a"), auth_helper.handle()));
Matt Menkeb57663b32019-03-01 17:17:105433
5434 EXPECT_THAT(auth_helper.WaitForResult(), IsOk());
5435 EXPECT_EQ(2, auth_helper.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265436 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
5437 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:395438 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105439 EXPECT_EQ(0, pool_->IdleSocketCount());
5440}
5441
5442TEST_F(ClientSocketPoolBaseTest, ProxyAuthTwiceFails) {
5443 CreatePool(1, 1);
5444 connect_job_factory_->set_job_type(
5445 TestConnectJob::kMockAuthChallengeTwiceFailingJob);
5446
5447 TestAuthHelper auth_helper;
5448 auth_helper.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265449 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105450
5451 auth_helper.WaitForAuth();
5452 auth_helper.RestartWithAuth();
Matt Menke9fa17d52019-03-25 19:12:265453 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105454 EXPECT_EQ(1, auth_helper.auth_count());
5455
5456 auth_helper.WaitForAuth();
5457 auth_helper.RestartWithAuth();
Matt Menke9fa17d52019-03-25 19:12:265458 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105459 EXPECT_EQ(2, auth_helper.auth_count());
5460
5461 EXPECT_THAT(auth_helper.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
5462 EXPECT_EQ(2, auth_helper.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265463 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105464 EXPECT_EQ(0, pool_->IdleSocketCount());
5465}
5466
5467// Makes sure that when a bound request is destroyed, a new ConnectJob is
5468// created, if needed.
5469TEST_F(ClientSocketPoolBaseTest,
5470 ProxyAuthCreateNewConnectJobOnDestroyBoundRequest) {
5471 CreatePool(1 /* max_sockets */, 1 /* max_sockets_per_group */);
5472 connect_job_factory_->set_job_type(
5473 TestConnectJob::kMockAuthChallengeOnceFailingJob);
5474
5475 // First request creates a ConnectJob.
5476 TestAuthHelper auth_helper1;
5477 auth_helper1.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265478 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105479
5480 // A second request come in, but no new ConnectJob is needed, since the limit
5481 // has been reached.
5482 TestAuthHelper auth_helper2;
5483 auth_helper2.InitHandle(params_, pool_.get());
Matt Menke9fa17d52019-03-25 19:12:265484 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105485
5486 // Run until the auth callback for the first request is invoked.
5487 auth_helper1.WaitForAuth();
5488 EXPECT_EQ(0, auth_helper2.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265489 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
5490 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:395491 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105492
5493 // Make connect jobs succeed, then cancel the first request, which should
5494 // destroy the bound ConnectJob, and cause a new ConnectJob to start.
5495 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
5496 auth_helper1.handle()->Reset();
5497 EXPECT_EQ(0, auth_helper2.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265498 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105499
5500 // The second ConnectJob should succeed.
5501 EXPECT_THAT(auth_helper2.WaitForResult(), IsOk());
5502 EXPECT_EQ(0, auth_helper2.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265503 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105504}
5505
5506// Makes sure that when a bound request is destroyed, a new ConnectJob is
5507// created for another group, if needed.
5508TEST_F(ClientSocketPoolBaseTest,
5509 ProxyAuthCreateNewConnectJobOnDestroyBoundRequestDifferentGroups) {
5510 CreatePool(1 /* max_sockets */, 1 /* max_sockets_per_group */);
5511 connect_job_factory_->set_job_type(
5512 TestConnectJob::kMockAuthChallengeOnceFailingJob);
5513
5514 // First request creates a ConnectJob.
5515 TestAuthHelper auth_helper1;
5516 auth_helper1.InitHandle(params_, pool_.get(), DEFAULT_PRIORITY);
Matt Menke9fa17d52019-03-25 19:12:265517 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105518
5519 // A second request come in, but no new ConnectJob is needed, since the limit
5520 // has been reached.
5521 TestAuthHelper auth_helper2;
5522 auth_helper2.InitHandle(params_, pool_.get(), DEFAULT_PRIORITY,
Matt Menkec6b3edf72019-03-19 17:00:395523 ClientSocketPool::RespectLimits::ENABLED,
5524 TestGroupId("b"));
Matt Menke9fa17d52019-03-25 19:12:265525 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
5526 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
Matt Menkeb57663b32019-03-01 17:17:105527
5528 // Run until the auth callback for the first request is invoked.
5529 auth_helper1.WaitForAuth();
5530 EXPECT_EQ(0, auth_helper2.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265531 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
5532 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:395533 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menke9fa17d52019-03-25 19:12:265534 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
5535 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("b")));
Matt Menkec6b3edf72019-03-19 17:00:395536 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("b")));
Matt Menkeb57663b32019-03-01 17:17:105537
5538 // Make connect jobs succeed, then cancel the first request, which should
5539 // destroy the bound ConnectJob, and cause a new ConnectJob to start for the
5540 // other group.
5541 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
5542 auth_helper1.handle()->Reset();
5543 EXPECT_EQ(0, auth_helper2.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265544 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
5545 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
Matt Menkeb57663b32019-03-01 17:17:105546
5547 // The second ConnectJob should succeed.
5548 EXPECT_THAT(auth_helper2.WaitForResult(), IsOk());
5549 EXPECT_EQ(0, auth_helper2.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265550 EXPECT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
5551 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
Matt Menkeb57663b32019-03-01 17:17:105552}
5553
5554// Test that once an auth challenge is bound, that's the request that gets all
5555// subsequent calls and the socket itself.
5556TEST_F(ClientSocketPoolBaseTest, ProxyAuthStaysBound) {
5557 CreatePool(1, 1);
5558 connect_job_factory_->set_job_type(
5559 TestConnectJob::kMockAuthChallengeTwiceJob);
5560
5561 // First request creates a ConnectJob.
5562 TestAuthHelper auth_helper1;
5563 auth_helper1.InitHandle(params_, pool_.get(), LOWEST);
Matt Menke9fa17d52019-03-25 19:12:265564 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105565
5566 // A second, higher priority request is made.
5567 TestAuthHelper auth_helper2;
5568 auth_helper2.InitHandle(params_, pool_.get(), LOW);
Matt Menke9fa17d52019-03-25 19:12:265569 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105570
5571 // Run until the auth callback for the second request is invoked.
5572 auth_helper2.WaitForAuth();
5573 EXPECT_EQ(0, auth_helper1.auth_count());
Matt Menke9fa17d52019-03-25 19:12:265574 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
5575 EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkec6b3edf72019-03-19 17:00:395576 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105577
5578 // Start a higher priority job. It shouldn't be able to steal |auth_helper2|'s
5579 // ConnectJob.
5580 TestAuthHelper auth_helper3;
5581 auth_helper3.InitHandle(params_, pool_.get(), HIGHEST);
Matt Menke9fa17d52019-03-25 19:12:265582 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105583
5584 // Start a higher job that ignores limits, creating a hanging socket. It
5585 // shouldn't be able to steal |auth_helper2|'s ConnectJob.
5586 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
5587 TestAuthHelper auth_helper4;
5588 auth_helper4.InitHandle(params_, pool_.get(), HIGHEST,
5589 ClientSocketPool::RespectLimits::DISABLED);
Matt Menke9fa17d52019-03-25 19:12:265590 EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105591
5592 // Restart with auth, and |auth_helper2|'s auth method should be invoked
5593 // again.
5594 auth_helper2.RestartWithAuth();
5595 auth_helper2.WaitForAuth();
5596 EXPECT_EQ(0, auth_helper1.auth_count());
5597 EXPECT_FALSE(auth_helper1.have_result());
5598 EXPECT_EQ(2, auth_helper2.auth_count());
5599 EXPECT_FALSE(auth_helper2.have_result());
5600 EXPECT_EQ(0, auth_helper3.auth_count());
5601 EXPECT_FALSE(auth_helper3.have_result());
5602 EXPECT_EQ(0, auth_helper4.auth_count());
5603 EXPECT_FALSE(auth_helper4.have_result());
5604
5605 // Advance auth again, and |auth_helper2| should get the socket.
5606 auth_helper2.RestartWithAuth();
5607 EXPECT_THAT(auth_helper2.WaitForResult(), IsOk());
5608 // The hung ConnectJob for the RespectLimits::DISABLED request is still in the
5609 // socket pool.
Matt Menke9fa17d52019-03-25 19:12:265610 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
5611 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
Matt Menkeb57663b32019-03-01 17:17:105612 EXPECT_EQ(0, auth_helper1.auth_count());
5613 EXPECT_FALSE(auth_helper1.have_result());
5614 EXPECT_EQ(0, auth_helper3.auth_count());
5615 EXPECT_FALSE(auth_helper3.have_result());
5616 EXPECT_EQ(0, auth_helper4.auth_count());
5617 EXPECT_FALSE(auth_helper4.have_result());
5618
5619 // If the socket is returned to the socket pool, the RespectLimits::DISABLED
5620 // socket request should be able to claim it.
5621 auth_helper2.handle()->Reset();
5622 EXPECT_THAT(auth_helper4.WaitForResult(), IsOk());
5623 EXPECT_EQ(0, auth_helper1.auth_count());
5624 EXPECT_FALSE(auth_helper1.have_result());
5625 EXPECT_EQ(0, auth_helper3.auth_count());
5626 EXPECT_FALSE(auth_helper3.have_result());
5627 EXPECT_EQ(0, auth_helper4.auth_count());
5628}
5629
David Benjaminbac8dff2019-08-07 01:30:415630enum class RefreshType {
5631 kServer,
5632 kProxy,
5633};
5634
5635// Common base class to test RefreshGroup() when called from either
5636// OnSSLConfigForServerChanged() matching a specific group or the pool's proxy.
5637//
5638// Tests which test behavior specific to one or the other case should use
5639// ClientSocketPoolBaseTest directly. In particular, there is no "other group"
5640// when the pool's proxy matches.
5641class ClientSocketPoolBaseRefreshTest
5642 : public ClientSocketPoolBaseTest,
5643 public testing::WithParamInterface<RefreshType> {
5644 public:
5645 void CreatePoolForRefresh(int max_sockets,
5646 int max_sockets_per_group,
5647 bool enable_backup_connect_jobs = false) {
5648 switch (GetParam()) {
5649 case RefreshType::kServer:
5650 CreatePool(max_sockets, max_sockets_per_group,
5651 enable_backup_connect_jobs);
5652 break;
5653 case RefreshType::kProxy:
5654 CreatePoolWithIdleTimeouts(
5655 max_sockets, max_sockets_per_group, kUnusedIdleSocketTimeout,
5656 ClientSocketPool::used_idle_socket_timeout(),
5657 enable_backup_connect_jobs,
Eric Orth5ccc3f02021-09-23 00:01:575658 PacResultElementToProxyServer("HTTPS myproxy:70"));
David Benjaminbac8dff2019-08-07 01:30:415659 break;
5660 }
5661 }
5662
5663 static ClientSocketPool::GroupId GetGroupId() {
Eric Ortha2e7773212021-06-22 21:49:555664 return TestGroupId("a", 443, url::kHttpsScheme);
David Benjaminbac8dff2019-08-07 01:30:415665 }
5666
David Benjamin6dd7e882019-10-10 02:35:235667 static ClientSocketPool::GroupId GetGroupIdInPartition() {
5668 // Note this GroupId will match GetGroupId() unless
5669 // kPartitionConnectionsByNetworkIsolationKey is enabled.
Matt Menke4807a9a2020-11-21 00:14:415670 const SchemefulSite kSite(GURL("https://b/"));
5671 const NetworkIsolationKey kNetworkIsolationKey(kSite, kSite);
Eric Ortha2e7773212021-06-22 21:49:555672 return TestGroupId("a", 443, url::kHttpsScheme,
David Benjamin6dd7e882019-10-10 02:35:235673 PrivacyMode::PRIVACY_MODE_DISABLED,
5674 kNetworkIsolationKey);
5675 }
5676
David Benjaminbac8dff2019-08-07 01:30:415677 void OnSSLConfigForServerChanged() {
5678 switch (GetParam()) {
5679 case RefreshType::kServer:
5680 pool_->OnSSLConfigForServerChanged(HostPortPair("a", 443));
5681 break;
5682 case RefreshType::kProxy:
5683 pool_->OnSSLConfigForServerChanged(HostPortPair("myproxy", 70));
5684 break;
5685 }
5686 }
5687};
5688
5689INSTANTIATE_TEST_SUITE_P(RefreshType,
5690 ClientSocketPoolBaseRefreshTest,
5691 ::testing::Values(RefreshType::kServer,
5692 RefreshType::kProxy));
5693
5694TEST_P(ClientSocketPoolBaseRefreshTest, RefreshGroupCreatesNewConnectJobs) {
5695 CreatePoolForRefresh(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
5696 const ClientSocketPool::GroupId kGroupId = GetGroupId();
Matt Menkebf3c767d2019-04-15 23:28:245697
5698 // First job will be waiting until it gets aborted.
5699 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
5700
5701 ClientSocketHandle handle;
5702 TestCompletionCallback callback;
5703 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525704 handle.Init(kGroupId, params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:285705 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5706 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5707 pool_.get(), NetLogWithSource()),
Matt Menkebf3c767d2019-04-15 23:28:245708 IsError(ERR_IO_PENDING));
5709
5710 // Switch connect job types, so creating a new ConnectJob will result in
5711 // success.
5712 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
5713
David Benjaminbac8dff2019-08-07 01:30:415714 OnSSLConfigForServerChanged();
Matt Menkebf3c767d2019-04-15 23:28:245715 EXPECT_EQ(OK, callback.WaitForResult());
5716 ASSERT_TRUE(handle.socket());
5717 EXPECT_EQ(0, pool_->IdleSocketCount());
5718 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId));
5719 EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(kGroupId));
5720 EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(kGroupId));
5721 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId));
5722}
5723
David Benjaminbac8dff2019-08-07 01:30:415724TEST_P(ClientSocketPoolBaseRefreshTest, RefreshGroupClosesIdleConnectJobs) {
David Benjamin6dd7e882019-10-10 02:35:235725 base::test::ScopedFeatureList feature_list;
5726 feature_list.InitAndEnableFeature(
5727 features::kPartitionConnectionsByNetworkIsolationKey);
5728
David Benjaminbac8dff2019-08-07 01:30:415729 CreatePoolForRefresh(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
5730 const ClientSocketPool::GroupId kGroupId = GetGroupId();
David Benjamin6dd7e882019-10-10 02:35:235731 const ClientSocketPool::GroupId kGroupIdInPartition = GetGroupIdInPartition();
Matt Menkebf3c767d2019-04-15 23:28:245732
Anton Bikineev068d2912021-05-15 20:43:525733 pool_->RequestSockets(kGroupId, params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:285734 NetLogWithSource());
Anton Bikineev068d2912021-05-15 20:43:525735 pool_->RequestSockets(kGroupIdInPartition, params_, absl::nullopt, 2,
David Benjamin6dd7e882019-10-10 02:35:235736 NetLogWithSource());
Matt Menkebf3c767d2019-04-15 23:28:245737 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId));
David Benjamin6dd7e882019-10-10 02:35:235738 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupIdInPartition));
5739 EXPECT_EQ(4, pool_->IdleSocketCount());
Matt Menkebf3c767d2019-04-15 23:28:245740 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(kGroupId));
David Benjamin6dd7e882019-10-10 02:35:235741 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(kGroupIdInPartition));
Matt Menkebf3c767d2019-04-15 23:28:245742
David Benjaminbac8dff2019-08-07 01:30:415743 OnSSLConfigForServerChanged();
Matt Menkebf3c767d2019-04-15 23:28:245744 EXPECT_EQ(0, pool_->IdleSocketCount());
5745 EXPECT_FALSE(pool_->HasGroupForTesting(kGroupId));
David Benjamin6dd7e882019-10-10 02:35:235746 EXPECT_FALSE(pool_->HasGroupForTesting(kGroupIdInPartition));
Matt Menkebf3c767d2019-04-15 23:28:245747}
5748
5749TEST_F(ClientSocketPoolBaseTest,
5750 RefreshGroupDoesNotCloseIdleConnectJobsInOtherGroup) {
5751 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
David Benjaminbac8dff2019-08-07 01:30:415752 const ClientSocketPool::GroupId kGroupId =
Eric Ortha2e7773212021-06-22 21:49:555753 TestGroupId("a", 443, url::kHttpsScheme);
David Benjaminbac8dff2019-08-07 01:30:415754 const ClientSocketPool::GroupId kOtherGroupId =
Eric Ortha2e7773212021-06-22 21:49:555755 TestGroupId("b", 443, url::kHttpsScheme);
Matt Menkebf3c767d2019-04-15 23:28:245756
Anton Bikineev068d2912021-05-15 20:43:525757 pool_->RequestSockets(kOtherGroupId, params_, absl::nullopt, 2,
Matt Menkef09e64c2019-04-23 22:16:285758 NetLogWithSource());
Matt Menkebf3c767d2019-04-15 23:28:245759 ASSERT_TRUE(pool_->HasGroupForTesting(kOtherGroupId));
5760 EXPECT_EQ(2, pool_->IdleSocketCount());
5761 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(kOtherGroupId));
5762
David Benjaminbac8dff2019-08-07 01:30:415763 pool_->OnSSLConfigForServerChanged(HostPortPair("a", 443));
Matt Menkebf3c767d2019-04-15 23:28:245764 ASSERT_TRUE(pool_->HasGroupForTesting(kOtherGroupId));
5765 EXPECT_EQ(2, pool_->IdleSocketCount());
5766 EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(kOtherGroupId));
5767}
5768
David Benjaminbac8dff2019-08-07 01:30:415769TEST_P(ClientSocketPoolBaseRefreshTest, RefreshGroupPreventsSocketReuse) {
5770 CreatePoolForRefresh(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
5771 const ClientSocketPool::GroupId kGroupId = GetGroupId();
Matt Menkebf3c767d2019-04-15 23:28:245772
5773 ClientSocketHandle handle;
5774 TestCompletionCallback callback;
5775 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525776 handle.Init(kGroupId, params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:285777 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5778 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5779 pool_.get(), NetLogWithSource()),
Matt Menkebf3c767d2019-04-15 23:28:245780 IsOk());
5781 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId));
5782 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId));
5783
David Benjaminbac8dff2019-08-07 01:30:415784 OnSSLConfigForServerChanged();
Matt Menkebf3c767d2019-04-15 23:28:245785
5786 handle.Reset();
5787 EXPECT_EQ(0, pool_->IdleSocketCount());
5788 EXPECT_FALSE(pool_->HasGroupForTesting(kGroupId));
5789}
5790
5791TEST_F(ClientSocketPoolBaseTest,
5792 RefreshGroupDoesNotPreventSocketReuseInOtherGroup) {
5793 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
David Benjaminbac8dff2019-08-07 01:30:415794 const ClientSocketPool::GroupId kGroupId =
Eric Ortha2e7773212021-06-22 21:49:555795 TestGroupId("a", 443, url::kHttpsScheme);
David Benjaminbac8dff2019-08-07 01:30:415796 const ClientSocketPool::GroupId kOtherGroupId =
Eric Ortha2e7773212021-06-22 21:49:555797 TestGroupId("b", 443, url::kHttpsScheme);
Matt Menkebf3c767d2019-04-15 23:28:245798
5799 ClientSocketHandle handle;
5800 TestCompletionCallback callback;
5801 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525802 handle.Init(kOtherGroupId, params_, absl::nullopt, DEFAULT_PRIORITY,
Matt Menkef09e64c2019-04-23 22:16:285803 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5804 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5805 pool_.get(), NetLogWithSource()),
Matt Menkebf3c767d2019-04-15 23:28:245806 IsOk());
5807 ASSERT_TRUE(pool_->HasGroupForTesting(kOtherGroupId));
5808 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kOtherGroupId));
5809
David Benjaminbac8dff2019-08-07 01:30:415810 pool_->OnSSLConfigForServerChanged(HostPortPair("a", 443));
Matt Menkebf3c767d2019-04-15 23:28:245811
5812 handle.Reset();
5813 EXPECT_EQ(1, pool_->IdleSocketCount());
5814 ASSERT_TRUE(pool_->HasGroupForTesting(kOtherGroupId));
5815 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(kOtherGroupId));
5816}
5817
David Benjaminbac8dff2019-08-07 01:30:415818TEST_P(ClientSocketPoolBaseRefreshTest,
5819 RefreshGroupReplacesBoundConnectJobOnConnect) {
5820 CreatePoolForRefresh(1, 1);
5821 const ClientSocketPool::GroupId kGroupId = GetGroupId();
Matt Menkebf3c767d2019-04-15 23:28:245822 connect_job_factory_->set_job_type(TestConnectJob::kMockAuthChallengeOnceJob);
5823
5824 TestAuthHelper auth_helper;
5825 auth_helper.InitHandle(params_, pool_.get(), DEFAULT_PRIORITY,
5826 ClientSocketPool::RespectLimits::ENABLED, kGroupId);
5827 EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(kGroupId));
5828
5829 auth_helper.WaitForAuth();
5830
5831 // This should update the generation, but not cancel the old ConnectJob - it's
5832 // not safe to do anything while waiting on the original ConnectJob.
David Benjaminbac8dff2019-08-07 01:30:415833 OnSSLConfigForServerChanged();
Matt Menkebf3c767d2019-04-15 23:28:245834
5835 // Providing auth credentials and restarting the request with them will cause
5836 // the ConnectJob to complete successfully, but the result will be discarded
5837 // because of the generation mismatch.
5838 auth_helper.RestartWithAuth();
5839
5840 // Despite using ConnectJobs that simulate a single challenge, a second
5841 // challenge will be seen, due to using a new ConnectJob.
5842 auth_helper.WaitForAuth();
5843 auth_helper.RestartWithAuth();
5844
5845 EXPECT_THAT(auth_helper.WaitForResult(), IsOk());
5846 EXPECT_TRUE(auth_helper.handle()->socket());
5847 EXPECT_EQ(2, auth_helper.auth_count());
5848
5849 // When released, the socket will be returned to the socket pool, and
5850 // available for reuse.
5851 auth_helper.handle()->Reset();
5852 EXPECT_EQ(1, pool_->IdleSocketCount());
5853 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId));
5854 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(kGroupId));
5855}
5856
David Benjaminbac8dff2019-08-07 01:30:415857TEST_F(ClientSocketPoolBaseTest, RefreshProxyRefreshesAllGroups) {
5858 CreatePoolWithIdleTimeouts(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
5859 kUnusedIdleSocketTimeout,
5860 ClientSocketPool::used_idle_socket_timeout(),
5861 false /* no backup connect jobs */,
Eric Orth5ccc3f02021-09-23 00:01:575862 PacResultElementToProxyServer("HTTPS myproxy:70"));
David Benjaminbac8dff2019-08-07 01:30:415863
5864 const ClientSocketPool::GroupId kGroupId1 =
Eric Ortha2e7773212021-06-22 21:49:555865 TestGroupId("a", 443, url::kHttpsScheme);
David Benjaminbac8dff2019-08-07 01:30:415866 const ClientSocketPool::GroupId kGroupId2 =
Eric Ortha2e7773212021-06-22 21:49:555867 TestGroupId("b", 443, url::kHttpsScheme);
David Benjaminbac8dff2019-08-07 01:30:415868 const ClientSocketPool::GroupId kGroupId3 =
Eric Ortha2e7773212021-06-22 21:49:555869 TestGroupId("c", 443, url::kHttpsScheme);
David Benjaminbac8dff2019-08-07 01:30:415870
5871 // Make three sockets in three different groups. The third socket is released
5872 // to the pool as idle.
5873 ClientSocketHandle handle1, handle2, handle3;
5874 TestCompletionCallback callback;
5875 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525876 handle1.Init(kGroupId1, params_, absl::nullopt, DEFAULT_PRIORITY,
David Benjaminbac8dff2019-08-07 01:30:415877 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5878 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5879 pool_.get(), NetLogWithSource()),
5880 IsOk());
5881 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525882 handle2.Init(kGroupId2, params_, absl::nullopt, DEFAULT_PRIORITY,
David Benjaminbac8dff2019-08-07 01:30:415883 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5884 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5885 pool_.get(), NetLogWithSource()),
5886 IsOk());
5887 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525888 handle3.Init(kGroupId3, params_, absl::nullopt, DEFAULT_PRIORITY,
David Benjaminbac8dff2019-08-07 01:30:415889 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5890 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5891 pool_.get(), NetLogWithSource()),
5892 IsOk());
5893 handle3.Reset();
5894 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId1));
5895 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId1));
5896 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId2));
5897 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId2));
5898 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId3));
5899 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(kGroupId3));
5900
5901 // Changes to some other proxy do not affect the pool. The idle socket remains
5902 // alive and closing |handle2| makes the socket available for the pool.
5903 pool_->OnSSLConfigForServerChanged(HostPortPair("someotherproxy", 70));
5904
5905 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId1));
5906 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId1));
5907 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId2));
5908 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId2));
5909 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId3));
5910 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(kGroupId3));
5911
5912 handle2.Reset();
5913 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId2));
5914 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(kGroupId2));
5915
5916 // Changes to the matching proxy refreshes all groups.
5917 pool_->OnSSLConfigForServerChanged(HostPortPair("myproxy", 70));
5918
5919 // Idle sockets are closed.
5920 EXPECT_EQ(0, pool_->IdleSocketCount());
5921 EXPECT_FALSE(pool_->HasGroupForTesting(kGroupId2));
5922 EXPECT_FALSE(pool_->HasGroupForTesting(kGroupId3));
5923
5924 // The active socket, however, continues to be active.
5925 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId1));
5926 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId1));
5927
5928 // Closing it does not make it available for the pool.
5929 handle1.Reset();
5930 EXPECT_EQ(0, pool_->IdleSocketCount());
5931 EXPECT_FALSE(pool_->HasGroupForTesting(kGroupId1));
5932}
5933
5934TEST_F(ClientSocketPoolBaseTest, RefreshBothPrivacyAndNormalSockets) {
5935 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
5936
Eric Ortha2e7773212021-06-22 21:49:555937 const ClientSocketPool::GroupId kGroupId = TestGroupId(
5938 "a", 443, url::kHttpsScheme, PrivacyMode::PRIVACY_MODE_DISABLED);
5939 const ClientSocketPool::GroupId kGroupIdPrivacy = TestGroupId(
5940 "a", 443, url::kHttpsScheme, PrivacyMode::PRIVACY_MODE_ENABLED);
David Benjaminbac8dff2019-08-07 01:30:415941 const ClientSocketPool::GroupId kOtherGroupId =
Eric Ortha2e7773212021-06-22 21:49:555942 TestGroupId("b", 443, url::kHttpsScheme);
David Benjaminbac8dff2019-08-07 01:30:415943
5944 // Make a socket in each groups.
5945 ClientSocketHandle handle1, handle2, handle3;
5946 TestCompletionCallback callback;
5947 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525948 handle1.Init(kGroupId, params_, absl::nullopt, DEFAULT_PRIORITY,
David Benjaminbac8dff2019-08-07 01:30:415949 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5950 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5951 pool_.get(), NetLogWithSource()),
5952 IsOk());
5953 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525954 handle2.Init(kGroupIdPrivacy, params_, absl::nullopt, DEFAULT_PRIORITY,
David Benjaminbac8dff2019-08-07 01:30:415955 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5956 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5957 pool_.get(), NetLogWithSource()),
5958 IsOk());
5959 EXPECT_THAT(
Anton Bikineev068d2912021-05-15 20:43:525960 handle3.Init(kOtherGroupId, params_, absl::nullopt, DEFAULT_PRIORITY,
David Benjaminbac8dff2019-08-07 01:30:415961 SocketTag(), ClientSocketPool::RespectLimits::ENABLED,
5962 callback.callback(), ClientSocketPool::ProxyAuthCallback(),
5963 pool_.get(), NetLogWithSource()),
5964 IsOk());
5965 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId));
5966 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId));
5967 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupIdPrivacy));
5968 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupIdPrivacy));
5969 ASSERT_TRUE(pool_->HasGroupForTesting(kOtherGroupId));
5970 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kOtherGroupId));
5971
5972 pool_->OnSSLConfigForServerChanged(HostPortPair("a", 443));
5973
5974 // Active sockets continue to be active.
5975 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId));
5976 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupId));
5977 ASSERT_TRUE(pool_->HasGroupForTesting(kGroupIdPrivacy));
5978 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kGroupIdPrivacy));
5979 ASSERT_TRUE(pool_->HasGroupForTesting(kOtherGroupId));
5980 EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(kOtherGroupId));
5981
5982 // Closing them leaves kOtherGroupId alone, but kGroupId and kGroupIdPrivacy
5983 // are unusable.
5984 handle1.Reset();
5985 handle2.Reset();
5986 handle3.Reset();
5987 EXPECT_EQ(1, pool_->IdleSocketCount());
5988 EXPECT_FALSE(pool_->HasGroupForTesting(kGroupId));
5989 EXPECT_FALSE(pool_->HasGroupForTesting(kGroupIdPrivacy));
5990 EXPECT_TRUE(pool_->HasGroupForTesting(kOtherGroupId));
5991 EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(kOtherGroupId));
5992}
5993
[email protected]f6d1d6eb2009-06-24 20:16:095994} // namespace
5995
5996} // namespace net