Socket Pools Refactor 25: Merge the HTTP proxy pool and its children.
The HTTP proxy pool used to sit on top of an SSL pool and a TCP pool.
This CL removes them and has HTTP proxy ConnectJobs directly create
lower layer connections.
This is part of an effort to flatten the socket pools.
https://docs.google.com/document/d/1g0EA4iDqaDhNXA_mq-YK3SlSX-xRkoKvZetAQqdRrxM/edit
Change-Id: Ie6b059732696e339c9ae5a60673821c03233516f
Reviewed-on: https://chromium-review.googlesource.com/c/1453807
Commit-Queue: Matt Menke <mmenke@chromium.org>
Reviewed-by: Bence Béky <bnc@chromium.org>
Reviewed-by: Eric Roman <eroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#631905}diff --git a/net/http/http_proxy_client_socket_pool_unittest.cc b/net/http/http_proxy_client_socket_pool_unittest.cc
index ae8b45c0..46092912 100644
--- a/net/http/http_proxy_client_socket_pool_unittest.cc
+++ b/net/http/http_proxy_client_socket_pool_unittest.cc
@@ -70,39 +70,7 @@
public WithScopedTaskEnvironment {
protected:
HttpProxyClientSocketPoolTest()
- : transport_socket_pool_(kMaxSockets,
- kMaxSocketsPerGroup,
- &socket_factory_,
- session_deps_.host_resolver.get(),
- nullptr /* proxy_delegate */,
- session_deps_.cert_verifier.get(),
- session_deps_.channel_id_service.get(),
- session_deps_.transport_security_state.get(),
- session_deps_.cert_transparency_verifier.get(),
- session_deps_.ct_policy_enforcer.get(),
- nullptr /* ssl_client_session_cache */,
- std::string() /* ssl_session_cache_shard */,
- session_deps_.ssl_config_service.get(),
- nullptr /* socket_performance_watcher_factory */,
- nullptr /* network_quality_estimator */,
- nullptr /* net_log */),
- ssl_socket_pool_(kMaxSockets,
- kMaxSocketsPerGroup,
- &socket_factory_,
- session_deps_.host_resolver.get(),
- nullptr /* proxy_delegate */,
- session_deps_.cert_verifier.get(),
- session_deps_.channel_id_service.get(),
- session_deps_.transport_security_state.get(),
- session_deps_.cert_transparency_verifier.get(),
- session_deps_.ct_policy_enforcer.get(),
- nullptr /* ssl_client_session_cache */,
- std::string() /* ssl_session_cache_shard */,
- session_deps_.ssl_config_service.get(),
- nullptr /* socket_performance_watcher_factory */,
- nullptr /* network_quality_estimator */,
- nullptr /* net_log */),
- pool_(std::make_unique<TransportClientSocketPool>(
+ : pool_(std::make_unique<TransportClientSocketPool>(
kMaxSockets,
kMaxSocketsPerGroup,
&socket_factory_,
@@ -118,10 +86,7 @@
session_deps_.ssl_config_service.get(),
nullptr /* socket_performance_watcher_factory */,
&estimator_,
- nullptr /* net_log */,
- nullptr /* http_proxy_pool_for_ssl_pool */,
- &transport_socket_pool_,
- &ssl_socket_pool_)) {
+ nullptr /* net_log */)) {
session_deps_.host_resolver->set_synchronous_mode(true);
session_ = CreateNetworkSession();
}
@@ -141,8 +106,7 @@
std::string() /* ssl_session_cache_shard */,
session_deps_.ssl_config_service.get(),
nullptr /* socket_performance_watcher_factory */, &estimator_,
- nullptr /* net_log */, nullptr /* http_proxy_pool_for_ssl_pool */,
- &transport_socket_pool_, &ssl_socket_pool_);
+ nullptr /* net_log */);
}
void AddAuthToCache() {
@@ -241,9 +205,6 @@
TestNetworkQualityEstimator estimator_;
- TransportClientSocketPool transport_socket_pool_;
- TransportClientSocketPool ssl_socket_pool_;
-
std::unique_ptr<HttpNetworkSession> session_;
base::HistogramTester histogram_tester_;
diff --git a/net/http/http_proxy_client_socket_wrapper.cc b/net/http/http_proxy_client_socket_wrapper.cc
index 648643e0..8ab8d6f 100644
--- a/net/http/http_proxy_client_socket_wrapper.cc
+++ b/net/http/http_proxy_client_socket_wrapper.cc
@@ -24,7 +24,6 @@
#include "net/socket/client_socket_handle.h"
#include "net/socket/socket_tag.h"
#include "net/socket/ssl_connect_job.h"
-#include "net/socket/transport_client_socket_pool.h"
#include "net/socket/transport_connect_job.h"
#include "net/spdy/spdy_proxy_client_socket.h"
#include "net/spdy/spdy_session.h"
@@ -41,8 +40,6 @@
base::TimeDelta connect_timeout_duration,
base::TimeDelta proxy_negotiation_timeout_duration,
const CommonConnectJobParams& common_connect_job_params,
- TransportClientSocketPool* transport_pool,
- TransportClientSocketPool* ssl_pool,
const scoped_refptr<TransportSocketParams>& transport_params,
const scoped_refptr<SSLSocketParams>& ssl_params,
quic::QuicTransportVersion quic_version,
@@ -60,8 +57,6 @@
priority_(priority),
connect_timeout_duration_(connect_timeout_duration),
proxy_negotiation_timeout_duration_(proxy_negotiation_timeout_duration),
- transport_pool_(transport_pool),
- ssl_pool_(ssl_pool),
transport_params_(transport_params),
ssl_params_(ssl_params),
quic_version_(quic_version),
@@ -73,6 +68,7 @@
common_connect_job_params_(common_connect_job_params),
using_spdy_(false),
is_trusted_proxy_(is_trusted_proxy),
+ has_established_connection_(false),
quic_stream_factory_(quic_stream_factory),
http_auth_controller_(
tunnel ? new HttpAuthController(
@@ -107,12 +103,11 @@
LoadState HttpProxyClientSocketWrapper::GetConnectLoadState() const {
switch (next_state_) {
- case STATE_BEGIN_CONNECT:
case STATE_TCP_CONNECT:
case STATE_TCP_CONNECT_COMPLETE:
case STATE_SSL_CONNECT:
case STATE_SSL_CONNECT_COMPLETE:
- return transport_socket_handle_->GetLoadState();
+ return nested_connect_job_->GetLoadState();
case STATE_HTTP_PROXY_CONNECT:
case STATE_HTTP_PROXY_CONNECT_COMPLETE:
case STATE_SPDY_PROXY_CREATE_STREAM:
@@ -123,6 +118,7 @@
case STATE_RESTART_WITH_AUTH:
case STATE_RESTART_WITH_AUTH_COMPLETE:
return LOAD_STATE_ESTABLISHING_PROXY_TUNNEL;
+ case STATE_BEGIN_CONNECT:
case STATE_NONE:
// May be possible for this method to be called after an error, shouldn't
// be called after a successful connect.
@@ -144,8 +140,8 @@
priority_ = priority;
- if (transport_socket_handle_)
- transport_socket_handle_->SetPriority(priority);
+ if (nested_connect_job_)
+ nested_connect_job_->ChangePriority(priority);
if (spdy_stream_request_)
spdy_stream_request_->SetPriority(priority);
@@ -219,15 +215,8 @@
next_state_ = STATE_NONE;
spdy_stream_request_.reset();
quic_stream_request_.reset();
- if (transport_socket_handle_) {
- if (transport_socket_handle_->socket())
- transport_socket_handle_->socket()->Disconnect();
- transport_socket_handle_->Reset();
- transport_socket_handle_.reset();
- }
-
- if (transport_socket_)
- transport_socket_->Disconnect();
+ nested_connect_job_.reset();
+ transport_socket_.reset();
}
bool HttpProxyClientSocketWrapper::IsConnected() const {
@@ -385,6 +374,28 @@
return ERR_SOCKET_NOT_CONNECTED;
}
+void HttpProxyClientSocketWrapper::OnConnectJobComplete(int result,
+ ConnectJob* job) {
+ DCHECK_EQ(nested_connect_job_.get(), job);
+ DCHECK(next_state_ == STATE_TCP_CONNECT_COMPLETE ||
+ next_state_ == STATE_SSL_CONNECT_COMPLETE);
+ OnIOComplete(result);
+}
+
+bool HttpProxyClientSocketWrapper::HasEstablishedConnection() {
+ if (has_established_connection_)
+ return true;
+
+ // It's possible the nested connect job has established a connection, but
+ // hasn't completed yet (For example, an SSLConnectJob may be negotiating
+ // SSL).
+ if (nested_connect_job_) {
+ has_established_connection_ =
+ nested_connect_job_->HasEstablishedConnection();
+ }
+ return has_established_connection_;
+}
+
ProxyServer::Scheme HttpProxyClientSocketWrapper::GetProxyServerScheme() const {
if (quic_version_ != quic::QUIC_VERSION_UNSUPPORTED)
return ProxyServer::SCHEME_QUIC;
@@ -477,6 +488,11 @@
switch (GetProxyServerScheme()) {
case ProxyServer::SCHEME_QUIC:
next_state_ = STATE_QUIC_PROXY_CREATE_SESSION;
+ // QUIC connections are always considered to have been established.
+ // |has_established_connection_| is only used to start retries if a
+ // connection hasn't been established yet, and QUIC has its own connection
+ // establishment logic.
+ has_established_connection_ = true;
break;
case ProxyServer::SCHEME_HTTP:
next_state_ = STATE_TCP_CONNECT;
@@ -492,18 +508,9 @@
int HttpProxyClientSocketWrapper::DoTransportConnect() {
next_state_ = STATE_TCP_CONNECT_COMPLETE;
- transport_socket_handle_.reset(new ClientSocketHandle());
- return transport_socket_handle_->Init(
- common_connect_job_params_.group_name,
- TransportClientSocketPool::SocketParams::CreateFromTransportSocketParams(
- transport_params_),
- priority_, common_connect_job_params_.socket_tag,
- common_connect_job_params_.respect_limits
- ? ClientSocketPool::RespectLimits::ENABLED
- : ClientSocketPool::RespectLimits::DISABLED,
- base::Bind(&HttpProxyClientSocketWrapper::OnIOComplete,
- base::Unretained(this)),
- transport_pool_, net_log_);
+ nested_connect_job_ = TransportConnectJob::CreateTransportConnectJob(
+ transport_params_, priority_, common_connect_job_params_, this);
+ return nested_connect_job_->Connect();
}
int HttpProxyClientSocketWrapper::DoTransportConnectComplete(int result) {
@@ -519,6 +526,8 @@
return ERR_PROXY_CONNECTION_FAILED;
}
+ has_established_connection_ = true;
+
// Reset the timer to just the length of time allowed for HttpProxy handshake
// so that a fast TCP connection plus a slow HttpProxy failure doesn't take
// longer to timeout than it should.
@@ -544,26 +553,24 @@
}
}
next_state_ = STATE_SSL_CONNECT_COMPLETE;
- transport_socket_handle_.reset(new ClientSocketHandle());
- return transport_socket_handle_->Init(
- common_connect_job_params_.group_name,
- TransportClientSocketPool::SocketParams::CreateFromSSLSocketParams(
- ssl_params_),
- priority_, common_connect_job_params_.socket_tag,
- common_connect_job_params_.respect_limits,
- base::Bind(&HttpProxyClientSocketWrapper::OnIOComplete,
- base::Unretained(this)),
- ssl_pool_, net_log_);
+ nested_connect_job_ = std::make_unique<SSLConnectJob>(
+ priority_, common_connect_job_params_, ssl_params_,
+ nullptr /* http_proxy_pool */, this);
+ return nested_connect_job_->Connect();
}
int HttpProxyClientSocketWrapper::DoSSLConnectComplete(int result) {
if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
- DCHECK(
- transport_socket_handle_->ssl_error_response_info().cert_request_info);
+ // Not really used to hold a socket.
+ // TODO(mmenke): Implement a better API to get this information.
+ ClientSocketHandle client_socket_handle;
+ nested_connect_job_->GetAdditionalErrorState(&client_socket_handle);
+
+ DCHECK(client_socket_handle.ssl_error_response_info().cert_request_info);
UMA_HISTOGRAM_MEDIUM_TIMES("Net.HttpProxy.ConnectLatency.Secure.Error",
base::TimeTicks::Now() - connect_start_time_);
- error_response_info_.reset(new HttpResponseInfo(
- transport_socket_handle_->ssl_error_response_info()));
+ error_response_info_ = std::make_unique<HttpResponseInfo>(
+ client_socket_handle.ssl_error_response_info());
error_response_info_->cert_request_info->is_proxy = true;
return result;
}
@@ -573,26 +580,24 @@
base::TimeTicks::Now() - connect_start_time_);
// TODO(rch): allow the user to deal with proxy cert errors in the
// same way as server cert errors.
- transport_socket_handle_->socket()->Disconnect();
return ERR_PROXY_CERTIFICATE_INVALID;
}
// A SPDY session to the proxy completed prior to resolving the proxy
// hostname. Surface this error, and allow the delegate to retry.
// See crbug.com/334413.
if (result == ERR_SPDY_SESSION_ALREADY_EXISTS) {
- DCHECK(!transport_socket_handle_->socket());
+ DCHECK(!nested_connect_job_->socket());
return ERR_SPDY_SESSION_ALREADY_EXISTS;
}
if (result < 0) {
UMA_HISTOGRAM_MEDIUM_TIMES("Net.HttpProxy.ConnectLatency.Secure.Error",
base::TimeTicks::Now() - connect_start_time_);
- if (transport_socket_handle_->socket())
- transport_socket_handle_->socket()->Disconnect();
return ERR_PROXY_CONNECTION_FAILED;
}
- negotiated_protocol_ =
- transport_socket_handle_->socket()->GetNegotiatedProtocol();
+ has_established_connection_ = true;
+
+ negotiated_protocol_ = nested_connect_job_->socket()->GetNegotiatedProtocol();
using_spdy_ = negotiated_protocol_ == kProtoHTTP2;
// Reset the timer to just the length of time allowed for HttpProxy handshake
@@ -627,12 +632,13 @@
// Add a HttpProxy connection on top of the tcp socket.
transport_socket_ =
- transport_pool_->client_socket_factory()->CreateProxyClientSocket(
- std::move(transport_socket_handle_), user_agent_, endpoint_,
+ common_connect_job_params_.client_socket_factory->CreateProxyClientSocket(
+ nested_connect_job_->PassSocket(), user_agent_, endpoint_,
ProxyServer(GetProxyServerScheme(), GetDestination()),
http_auth_controller_.get(), tunnel_, using_spdy_,
negotiated_protocol_, common_connect_job_params_.proxy_delegate,
ssl_params_.get() != nullptr, traffic_annotation_);
+ nested_connect_job_.reset();
return transport_socket_->Connect(base::Bind(
&HttpProxyClientSocketWrapper::OnIOComplete, base::Unretained(this)));
}
@@ -658,16 +664,14 @@
/* is_websocket = */ false, net_log_);
// It's possible that a session to the proxy has recently been created
if (spdy_session) {
- if (transport_socket_handle_.get()) {
- if (transport_socket_handle_->socket())
- transport_socket_handle_->socket()->Disconnect();
- transport_socket_handle_->Reset();
- }
+ nested_connect_job_.reset();
} else {
// Create a session direct to the proxy itself
- spdy_session = spdy_session_pool_->CreateAvailableSessionFromSocketHandle(
- key, is_trusted_proxy_, std::move(transport_socket_handle_), net_log_);
+ spdy_session = spdy_session_pool_->CreateAvailableSessionFromSocket(
+ key, is_trusted_proxy_, nested_connect_job_->PassSocket(),
+ nested_connect_job_->connect_timing(), net_log_);
DCHECK(spdy_session);
+ nested_connect_job_.reset();
}
next_state_ = STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE;
diff --git a/net/http/http_proxy_client_socket_wrapper.h b/net/http/http_proxy_client_socket_wrapper.h
index 4134514..361a1f1 100644
--- a/net/http/http_proxy_client_socket_wrapper.h
+++ b/net/http/http_proxy_client_socket_wrapper.h
@@ -31,14 +31,12 @@
namespace net {
-class ClientSocketHandle;
class IOBuffer;
class HttpAuthCache;
class HttpResponseInfo;
class IOBuffer;
class SpdySessionPool;
class SSLSocketParams;
-class TransportClientSocketPool;
class TransportSocketParams;
// Class that establishes connections by calling into the lower layer socket
@@ -53,15 +51,14 @@
// TODO(mmenke): Ideally, we'd have a central location store auth state across
// multiple connections to the same server instead.
class NET_EXPORT_PRIVATE HttpProxyClientSocketWrapper
- : public ProxyClientSocket {
+ : public ProxyClientSocket,
+ public ConnectJob::Delegate {
public:
HttpProxyClientSocketWrapper(
RequestPriority priority,
base::TimeDelta connect_timeout_duration,
base::TimeDelta proxy_negotiation_timeout_duration,
const CommonConnectJobParams& common_connect_job_params,
- TransportClientSocketPool* transport_pool,
- TransportClientSocketPool* ssl_pool,
const scoped_refptr<TransportSocketParams>& transport_params,
const scoped_refptr<SSLSocketParams>& ssl_params,
quic::QuicTransportVersion quic_version,
@@ -127,6 +124,11 @@
int GetPeerAddress(IPEndPoint* address) const override;
int GetLocalAddress(IPEndPoint* address) const override;
+ // ConnectJob::Delegate implementation.
+ void OnConnectJobComplete(int result, ConnectJob* job) override;
+
+ bool HasEstablishedConnection();
+
NetErrorDetails* quic_net_error_details() { return &quic_net_error_details_; }
private:
@@ -188,8 +190,6 @@
const base::TimeDelta connect_timeout_duration_;
const base::TimeDelta proxy_negotiation_timeout_duration_;
- TransportClientSocketPool* const transport_pool_;
- TransportClientSocketPool* const ssl_pool_;
const scoped_refptr<TransportSocketParams> transport_params_;
const scoped_refptr<SSLSocketParams> ssl_params_;
@@ -208,9 +208,13 @@
bool is_trusted_proxy_;
NextProto negotiated_protocol_;
+ // Set to true once a connection has been successfully established. Remains
+ // true even if a new socket is being connected to retry with auth.
+ bool has_established_connection_;
+
std::unique_ptr<HttpResponseInfo> error_response_info_;
- std::unique_ptr<ClientSocketHandle> transport_socket_handle_;
+ std::unique_ptr<ConnectJob> nested_connect_job_;
std::unique_ptr<ProxyClientSocket> transport_socket_;
// Called when a connection is established. Also used when restarting with
diff --git a/net/http/http_proxy_client_socket_wrapper_unittest.cc b/net/http/http_proxy_client_socket_wrapper_unittest.cc
index 6414fda3..1f23885 100644
--- a/net/http/http_proxy_client_socket_wrapper_unittest.cc
+++ b/net/http/http_proxy_client_socket_wrapper_unittest.cc
@@ -303,7 +303,6 @@
/*socket_performance_watcher_factory=*/nullptr,
/*network_quality_estimator=*/nullptr, net_log_.net_log(),
/*websocket_endpoint_lock_manager=*/nullptr),
- /*transport_pool=*/nullptr, /*ssl_pool=*/nullptr,
/*transport_params=*/nullptr, ssl_params, quic_version_, kUserAgent,
endpoint_host_port_, &http_auth_cache_, http_auth_handler_factory_.get(),
/*spdy_session_pool=*/nullptr, quic_stream_factory_.get(),
@@ -369,7 +368,6 @@
/*socket_performance_watcher_factory=*/nullptr,
/*network_quality_estimator=*/nullptr, net_log_.net_log(),
/*websocket_endpoint_lock_manager=*/nullptr),
- /*transport_pool=*/nullptr, /*ssl_pool=*/nullptr,
/*transport_params=*/nullptr, ssl_params, quic_version_, kUserAgent,
endpoint_host_port_, &http_auth_cache_, http_auth_handler_factory_.get(),
/*spdy_session_pool=*/nullptr, quic_stream_factory_.get(),
diff --git a/net/http/http_proxy_connect_job.cc b/net/http/http_proxy_connect_job.cc
index 9861fe36..a202d79 100644
--- a/net/http/http_proxy_connect_job.cc
+++ b/net/http/http_proxy_connect_job.cc
@@ -165,8 +165,6 @@
RequestPriority priority,
const CommonConnectJobParams& common_connect_job_params,
const scoped_refptr<HttpProxySocketParams>& params,
- TransportClientSocketPool* transport_pool,
- TransportClientSocketPool* ssl_pool,
Delegate* delegate)
: ConnectJob(
priority,
@@ -182,8 +180,6 @@
common_connect_job_params.network_quality_estimator),
base::TimeDelta::FromSeconds(kHttpProxyConnectJobTimeoutInSeconds),
common_connect_job_params,
- transport_pool,
- ssl_pool,
params->transport_params(),
params->ssl_params(),
params->quic_version(),
@@ -205,11 +201,7 @@
}
bool HttpProxyConnectJob::HasEstablishedConnection() const {
- // Returning true prevents the socket pool this belongs to from using backup
- // jobs.
- // TODO(https://crbug.com/472729): Implement this, as nested pools are
- // removed.
- return true;
+ return client_socket_->HasEstablishedConnection();
}
void HttpProxyConnectJob::GetAdditionalErrorState(ClientSocketHandle* handle) {
diff --git a/net/http/http_proxy_connect_job.h b/net/http/http_proxy_connect_job.h
index 099d209..1ffa46b 100644
--- a/net/http/http_proxy_connect_job.h
+++ b/net/http/http_proxy_connect_job.h
@@ -28,7 +28,6 @@
class NetworkQualityEstimator;
class SpdySessionPool;
class SSLSocketParams;
-class TransportClientSocketPool;
class TransportSocketParams;
class QuicStreamFactory;
@@ -104,8 +103,6 @@
HttpProxyConnectJob(RequestPriority priority,
const CommonConnectJobParams& common_connect_job_params,
const scoped_refptr<HttpProxySocketParams>& params,
- TransportClientSocketPool* transport_pool,
- TransportClientSocketPool* ssl_pool,
Delegate* delegate);
~HttpProxyConnectJob() override;
diff --git a/net/http/http_proxy_connect_job_unittest.cc b/net/http/http_proxy_connect_job_unittest.cc
index 2a0dba93..f198875a 100644
--- a/net/http/http_proxy_connect_job_unittest.cc
+++ b/net/http/http_proxy_connect_job_unittest.cc
@@ -191,8 +191,7 @@
nullptr /* socket_performance_watcher_factory */,
&network_quality_estimator_, nullptr /* net_log */,
nullptr /* websocket_endpoint_lock_manager */),
- std::move(http_proxy_socket_params), &transport_socket_pool_,
- &ssl_socket_pool_, delegate);
+ std::move(http_proxy_socket_params), delegate);
}
void InitProxyDelegate() {
@@ -299,6 +298,156 @@
}
}
+// Pauses an HttpProxyConnectJob at various states, and check the value of
+// HasEstablishedConnection().
+TEST_P(HttpProxyConnectJobTest, HasEstablishedConnectionNoTunnel) {
+ session_deps_.host_resolver->set_ondemand_mode(true);
+
+ SequencedSocketData data;
+ data.set_connect_data(MockConnect(ASYNC, OK));
+ socket_factory_.AddSocketDataProvider(&data);
+
+ // Set up SSL, if needed.
+ SSLSocketDataProvider ssl_data(ASYNC, OK);
+ switch (GetParam()) {
+ case HTTP:
+ // No SSL needed.
+ break;
+ case HTTPS:
+ // SSL negotiation is the last step in non-tunnel connections over HTTPS
+ // proxies, so pause there, to check the final state before completion.
+ ssl_data = SSLSocketDataProvider(SYNCHRONOUS, ERR_IO_PENDING);
+ socket_factory_.AddSSLSocketDataProvider(&ssl_data);
+ break;
+ case SPDY:
+ InitializeSpdySsl(&ssl_data);
+ socket_factory_.AddSSLSocketDataProvider(&ssl_data);
+ break;
+ }
+
+ TestConnectJobDelegate test_delegate;
+ std::unique_ptr<ConnectJob> connect_job =
+ CreateConnectJobForHttpRequest(&test_delegate);
+
+ // Connecting should run until the request hits the HostResolver.
+ EXPECT_THAT(connect_job->Connect(), test::IsError(ERR_IO_PENDING));
+ EXPECT_FALSE(test_delegate.has_result());
+ EXPECT_TRUE(session_deps_.host_resolver->has_pending_requests());
+ EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, connect_job->GetLoadState());
+ EXPECT_FALSE(connect_job->HasEstablishedConnection());
+
+ // Once the HostResolver completes, the job should start establishing a
+ // connection, which will complete asynchronously.
+ session_deps_.host_resolver->ResolveOnlyRequestNow();
+ EXPECT_FALSE(test_delegate.has_result());
+ EXPECT_EQ(LOAD_STATE_CONNECTING, connect_job->GetLoadState());
+ EXPECT_FALSE(connect_job->HasEstablishedConnection());
+
+ switch (GetParam()) {
+ case HTTP:
+ case SPDY:
+ // Connection completes. Since no tunnel is established, the socket is
+ // returned immediately, and HasEstablishedConnection() is only specified
+ // to work before the ConnectJob completes.
+ EXPECT_THAT(test_delegate.WaitForResult(), test::IsOk());
+ break;
+ case HTTPS:
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(test_delegate.has_result());
+ EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, connect_job->GetLoadState());
+ EXPECT_TRUE(connect_job->HasEstablishedConnection());
+
+ // Unfortunately, there's no API to advance the paused SSL negotiation,
+ // so just end the test here.
+ }
+}
+
+// Pauses an HttpProxyConnectJob at various states, and check the value of
+// HasEstablishedConnection().
+TEST_P(HttpProxyConnectJobTest, HasEstablishedConnectionTunnel) {
+ session_deps_.host_resolver->set_ondemand_mode(true);
+
+ // HTTP proxy CONNECT request / response, with a pause during the read.
+ MockWrite http1_writes[] = {
+ MockWrite(ASYNC, 0,
+ "CONNECT www.endpoint.test:443 HTTP/1.1\r\n"
+ "Host: www.endpoint.test:443\r\n"
+ "Proxy-Connection: keep-alive\r\n\r\n"),
+ };
+ MockRead http1_reads[] = {
+ // Pause at first read.
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ MockRead(ASYNC, 2, "HTTP/1.1 200 Connection Established\r\n\r\n"),
+ };
+ SequencedSocketData http1_data(http1_reads, http1_writes);
+ http1_data.set_connect_data(MockConnect(ASYNC, OK));
+
+ // SPDY proxy CONNECT request / response, with a pause during the read.
+ spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyConnect(
+ nullptr, 0, 1, DEFAULT_PRIORITY, HostPortPair(kEndpointHost, 443)));
+ MockWrite spdy_writes[] = {CreateMockWrite(req, 0)};
+ spdy::SpdySerializedFrame resp(
+ spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
+ MockRead spdy_reads[] = {
+ // Pause at first read.
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(resp, 2, ASYNC),
+ MockRead(ASYNC, 0, 3),
+ };
+ SequencedSocketData spdy_data(spdy_reads, spdy_writes);
+ spdy_data.set_connect_data(MockConnect(ASYNC, OK));
+
+ // Will point to either the HTTP/1.x or SPDY data, depending on GetParam().
+ SequencedSocketData* sequenced_data = nullptr;
+
+ SSLSocketDataProvider ssl_data(ASYNC, OK);
+
+ switch (GetParam()) {
+ case HTTP:
+ sequenced_data = &http1_data;
+ break;
+ case HTTPS:
+ sequenced_data = &http1_data;
+ socket_factory_.AddSSLSocketDataProvider(&ssl_data);
+ break;
+ case SPDY:
+ sequenced_data = &spdy_data;
+ InitializeSpdySsl(&ssl_data);
+ socket_factory_.AddSSLSocketDataProvider(&ssl_data);
+ break;
+ }
+
+ socket_factory_.AddSocketDataProvider(sequenced_data);
+
+ TestConnectJobDelegate test_delegate;
+ std::unique_ptr<ConnectJob> connect_job =
+ CreateConnectJobForTunnel(&test_delegate);
+
+ // Connecting should run until the request hits the HostResolver.
+ EXPECT_THAT(connect_job->Connect(), test::IsError(ERR_IO_PENDING));
+ EXPECT_FALSE(test_delegate.has_result());
+ EXPECT_TRUE(session_deps_.host_resolver->has_pending_requests());
+ EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, connect_job->GetLoadState());
+ EXPECT_FALSE(connect_job->HasEstablishedConnection());
+
+ // Once the HostResolver completes, the job should start establishing a
+ // connection, which will complete asynchronously.
+ session_deps_.host_resolver->ResolveOnlyRequestNow();
+ EXPECT_FALSE(test_delegate.has_result());
+ EXPECT_EQ(LOAD_STATE_CONNECTING, connect_job->GetLoadState());
+ EXPECT_FALSE(connect_job->HasEstablishedConnection());
+
+ // Run until the socket starts reading the proxy's handshake response.
+ sequenced_data->RunUntilPaused();
+ EXPECT_FALSE(test_delegate.has_result());
+ EXPECT_EQ(LOAD_STATE_ESTABLISHING_PROXY_TUNNEL, connect_job->GetLoadState());
+ EXPECT_TRUE(connect_job->HasEstablishedConnection());
+
+ // Finish the read, and run the job until it's complete.
+ sequenced_data->Resume();
+ EXPECT_THAT(test_delegate.WaitForResult(), test::IsOk());
+}
+
TEST_P(HttpProxyConnectJobTest, ProxyDelegateExtraHeaders) {
// TODO(https://crbug.com/926427): The ProxyDelegate API is currently broken
// in the SPDY case.
diff --git a/net/socket/client_socket_pool_manager_impl.cc b/net/socket/client_socket_pool_manager_impl.cc
index a4fda95..f9cb8a84 100644
--- a/net/socket/client_socket_pool_manager_impl.cc
+++ b/net/socket/client_socket_pool_manager_impl.cc
@@ -110,14 +110,6 @@
it.second->FlushWithError(error);
}
- for (const auto& it : ssl_socket_pools_for_https_proxies_) {
- it.second->FlushWithError(error);
- }
-
- for (const auto& it : transport_socket_pools_for_http_proxies_) {
- it.second->FlushWithError(error);
- }
-
for (const auto& it : proxy_socket_pools_) {
it.second->FlushWithError(error);
}
@@ -136,14 +128,6 @@
it.second->CloseIdleSockets();
}
- for (const auto& it : ssl_socket_pools_for_https_proxies_) {
- it.second->CloseIdleSockets();
- }
-
- for (const auto& it : transport_socket_pools_for_http_proxies_) {
- it.second->CloseIdleSockets();
- }
-
for (const auto& it : proxy_socket_pools_) {
it.second->CloseIdleSockets();
}
@@ -183,49 +167,14 @@
TransportSocketPoolMap::const_iterator it =
http_proxy_socket_pools_.find(http_proxy);
- if (it != http_proxy_socket_pools_.end()) {
- DCHECK(base::ContainsKey(transport_socket_pools_for_http_proxies_,
- http_proxy));
- DCHECK(base::ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
+ if (it != http_proxy_socket_pools_.end())
return it->second.get();
- }
-
- DCHECK(
- !base::ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
- DCHECK(!base::ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
-
- int sockets_per_proxy_server = max_sockets_per_proxy_server(pool_type_);
- int sockets_per_group = std::min(sockets_per_proxy_server,
- max_sockets_per_group(pool_type_));
-
- std::pair<TransportSocketPoolMap::iterator, bool> tcp_http_ret =
- transport_socket_pools_for_http_proxies_.insert(std::make_pair(
- http_proxy,
- CreateTransportSocketPool(
- http_proxy, true /* use_socket_performance_watcher_factory */)));
- DCHECK(tcp_http_ret.second);
-
- std::pair<TransportSocketPoolMap::iterator, bool> ssl_https_ret =
- ssl_socket_pools_for_https_proxies_.insert(std::make_pair(
- http_proxy,
- CreateTransportSocketPool(
- http_proxy, true /* use_socket_performance_watcher_factory */)));
- DCHECK(ssl_https_ret.second);
std::pair<TransportSocketPoolMap::iterator, bool> ret =
http_proxy_socket_pools_.insert(std::make_pair(
http_proxy,
- std::make_unique<TransportClientSocketPool>(
- sockets_per_proxy_server, sockets_per_group, socket_factory_,
- host_resolver_, proxy_delegate_, cert_verifier_,
- channel_id_service_, transport_security_state_,
- cert_transparency_verifier_, ct_policy_enforcer_,
- ssl_client_session_cache_, ssl_session_cache_shard_,
- ssl_config_service_, socket_performance_watcher_factory_,
- network_quality_estimator_, net_log_,
- nullptr /* http_proxy_pool_for_ssl_pool */,
- tcp_http_ret.first->second.get(),
- ssl_https_ret.first->second.get())));
+ CreateTransportSocketPool(
+ http_proxy, true /* use_socket_performance_watcher_factory */)));
return ret.first->second.get();
}
@@ -258,9 +207,7 @@
network_quality_estimator_, net_log_,
proxy_server.is_http_like()
? GetSocketPoolForHTTPLikeProxy(proxy_server)
- : nullptr,
- nullptr /* transport_pool_for_http_proxy_pool */,
- nullptr /* ssl_pool_for_http_proxy_pool */)));
+ : nullptr)));
return ret.first->second.get();
}
diff --git a/net/socket/client_socket_pool_manager_impl.h b/net/socket/client_socket_pool_manager_impl.h
index bf02f08..adbaf727cc 100644
--- a/net/socket/client_socket_pool_manager_impl.h
+++ b/net/socket/client_socket_pool_manager_impl.h
@@ -126,8 +126,6 @@
// proxies that use TCP connections.
TransportSocketPoolMap proxy_socket_pools_;
- TransportSocketPoolMap transport_socket_pools_for_http_proxies_;
- TransportSocketPoolMap ssl_socket_pools_for_https_proxies_;
TransportSocketPoolMap http_proxy_socket_pools_;
TransportSocketPoolMap ssl_socket_pools_for_proxies_;
diff --git a/net/socket/connect_job.h b/net/socket/connect_job.h
index ce5380fd..d35ecdd 100644
--- a/net/socket/connect_job.h
+++ b/net/socket/connect_job.h
@@ -126,6 +126,11 @@
// released socket, or nullptr if there was a connection error.
std::unique_ptr<StreamSocket> PassSocket();
+ // Returns the connected socket, or nullptr if PassSocket() has already been
+ // called. Used to query the socket state. May only be called after the
+ // ConnectJob completes.
+ StreamSocket* socket() { return socket_.get(); }
+
void ChangePriority(RequestPriority priority);
// Begins connecting the socket. Returns OK on success, ERR_IO_PENDING if it
@@ -196,7 +201,6 @@
}
void SetSocket(std::unique_ptr<StreamSocket> socket);
- StreamSocket* socket() { return socket_.get(); }
void NotifyDelegateOfCompletion(int rv);
void ResetTimer(base::TimeDelta remaining_time);
diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc
index 8034e4c..32d259f 100644
--- a/net/socket/ssl_client_socket_pool_unittest.cc
+++ b/net/socket/ssl_client_socket_pool_unittest.cc
@@ -72,9 +72,6 @@
new TransportSocketParams(HostPortPair("host", 443),
false,
OnHostResolutionCallback())),
- transport_socket_pool_(kMaxSockets,
- kMaxSocketsPerGroup,
- &socket_factory_),
proxy_transport_socket_params_(
new TransportSocketParams(HostPortPair("proxy", 443),
false,
@@ -108,10 +105,7 @@
nullptr /* ssl_config_service */,
nullptr /* socket_performance_watcher_factory */,
nullptr /* network_quality_estimator */,
- nullptr /* net_log */,
- nullptr /* http_proxy_pool_for_ssl_pool */,
- &transport_socket_pool_,
- nullptr /* ssl_pool_for_http_proxy_pool */) {
+ nullptr /* net_log */) {
ssl_config_service_->GetSSLConfig(&ssl_config_);
}
@@ -179,7 +173,6 @@
const std::unique_ptr<HttpNetworkSession> session_;
scoped_refptr<TransportSocketParams> direct_transport_socket_params_;
- MockTransportClientSocketPool transport_socket_pool_;
scoped_refptr<TransportSocketParams> proxy_transport_socket_params_;
diff --git a/net/socket/ssl_connect_job_unittest.cc b/net/socket/ssl_connect_job_unittest.cc
index a86a748..b6305b1 100644
--- a/net/socket/ssl_connect_job_unittest.cc
+++ b/net/socket/ssl_connect_job_unittest.cc
@@ -101,22 +101,6 @@
new TransportSocketParams(HostPortPair("host", 443),
false,
OnHostResolutionCallback())),
- transport_socket_pool_(kMaxSockets,
- kMaxSocketsPerGroup,
- &socket_factory_,
- &host_resolver_,
- nullptr /* proxy_delegate */,
- nullptr /* cert_verifier */,
- nullptr /* channel_id_server */,
- nullptr /* transport_security_state */,
- nullptr /* cert_transparency_verifier */,
- nullptr /* ct_policy_enforcer */,
- nullptr /* ssl_client_session_cache */,
- std::string() /* ssl_session_cache_shard */,
- nullptr /* ssl_config_service */,
- nullptr /* socket_performance_watcher_factory */,
- nullptr /* network_quality_estimator */,
- nullptr /* net_log */),
proxy_transport_socket_params_(
new TransportSocketParams(HostPortPair("proxy", 443),
false,
@@ -155,10 +139,7 @@
nullptr /* ssl_config_service */,
nullptr /* socket_performance_watcher_factory */,
nullptr /* network_quality_estimator */,
- nullptr /* net_log */,
- nullptr /* http_proxy_pool_for_ssl_pool */,
- &transport_socket_pool_,
- nullptr /* ssl_pool_for_http_proxy_pool */) {
+ nullptr /* net_log */) {
ssl_config_service_->GetSSLConfig(&ssl_config_);
// Set an initial delay to ensure that the first call to TimeTicks::Now()
@@ -236,7 +217,6 @@
SSLClientSocketContext ssl_client_socket_context_;
scoped_refptr<TransportSocketParams> direct_transport_socket_params_;
- TransportClientSocketPool transport_socket_pool_;
scoped_refptr<TransportSocketParams> proxy_transport_socket_params_;
scoped_refptr<SOCKSSocketParams> socks_socket_params_;
diff --git a/net/socket/transport_client_socket_pool.cc b/net/socket/transport_client_socket_pool.cc
index f31ab61..72411d6 100644
--- a/net/socket/transport_client_socket_pool.cc
+++ b/net/socket/transport_client_socket_pool.cc
@@ -38,12 +38,8 @@
RequestPriority priority,
const CommonConnectJobParams& common_connect_job_params,
ConnectJob::Delegate* delegate,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool) {
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool) {
DCHECK(!http_proxy_pool_for_ssl_pool);
- DCHECK(!transport_pool_for_http_proxy_pool);
- DCHECK(!ssl_pool_for_http_proxy_pool);
return TransportConnectJob::CreateTransportConnectJob(
std::move(transport_socket_params), priority, common_connect_job_params,
delegate);
@@ -54,12 +50,8 @@
RequestPriority priority,
const CommonConnectJobParams& common_connect_job_params,
ConnectJob::Delegate* delegate,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool) {
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool) {
DCHECK(!http_proxy_pool_for_ssl_pool);
- DCHECK(!transport_pool_for_http_proxy_pool);
- DCHECK(!ssl_pool_for_http_proxy_pool);
return std::make_unique<SOCKSConnectJob>(priority, common_connect_job_params,
std::move(socks_socket_params),
delegate);
@@ -70,11 +62,7 @@
RequestPriority priority,
const CommonConnectJobParams& common_connect_job_params,
ConnectJob::Delegate* delegate,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool) {
- DCHECK(!transport_pool_for_http_proxy_pool);
- DCHECK(!ssl_pool_for_http_proxy_pool);
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool) {
return std::make_unique<SSLConnectJob>(
priority, common_connect_job_params, std::move(ssl_socket_params),
http_proxy_pool_for_ssl_pool, delegate);
@@ -85,13 +73,10 @@
RequestPriority priority,
const CommonConnectJobParams& common_connect_job_params,
ConnectJob::Delegate* delegate,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool) {
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool) {
DCHECK(!http_proxy_pool_for_ssl_pool);
return std::make_unique<HttpProxyConnectJob>(
priority, common_connect_job_params, std::move(http_proxy_socket_params),
- transport_pool_for_http_proxy_pool, ssl_pool_for_http_proxy_pool,
delegate);
}
@@ -144,9 +129,7 @@
SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
NetworkQualityEstimator* network_quality_estimator,
NetLog* net_log,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool)
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool)
: client_socket_factory_(client_socket_factory),
host_resolver_(host_resolver),
proxy_delegate_(proxy_delegate),
@@ -154,9 +137,7 @@
socket_performance_watcher_factory_(socket_performance_watcher_factory),
network_quality_estimator_(network_quality_estimator),
net_log_(net_log),
- http_proxy_pool_for_ssl_pool_(http_proxy_pool_for_ssl_pool),
- transport_pool_for_http_proxy_pool_(transport_pool_for_http_proxy_pool),
- ssl_pool_for_http_proxy_pool_(ssl_pool_for_http_proxy_pool) {}
+ http_proxy_pool_for_ssl_pool_(http_proxy_pool_for_ssl_pool) {}
TransportClientSocketPool::TransportConnectJobFactory::
~TransportConnectJobFactory() = default;
@@ -175,8 +156,7 @@
ssl_client_socket_context_, socket_performance_watcher_factory_,
network_quality_estimator_, net_log_,
nullptr /* websocket_endpoint_lock_manager */),
- delegate, http_proxy_pool_for_ssl_pool_,
- transport_pool_for_http_proxy_pool_, ssl_pool_for_http_proxy_pool_);
+ delegate, http_proxy_pool_for_ssl_pool_);
}
TransportClientSocketPool::TransportClientSocketPool(
@@ -196,9 +176,7 @@
SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
NetworkQualityEstimator* network_quality_estimator,
NetLog* net_log,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool)
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool)
: base_(this,
max_sockets,
max_sockets_per_group,
@@ -218,9 +196,7 @@
socket_performance_watcher_factory,
network_quality_estimator,
net_log,
- http_proxy_pool_for_ssl_pool,
- transport_pool_for_http_proxy_pool,
- ssl_pool_for_http_proxy_pool)),
+ http_proxy_pool_for_ssl_pool)),
client_socket_factory_(client_socket_factory),
ssl_config_service_(ssl_config_service) {
base_.EnableConnectBackupJobs();
@@ -228,10 +204,6 @@
ssl_config_service_->AddObserver(this);
if (http_proxy_pool_for_ssl_pool)
base_.AddLowerLayeredPool(http_proxy_pool_for_ssl_pool);
- if (transport_pool_for_http_proxy_pool)
- base_.AddLowerLayeredPool(transport_pool_for_http_proxy_pool);
- if (ssl_pool_for_http_proxy_pool)
- base_.AddLowerLayeredPool(ssl_pool_for_http_proxy_pool);
}
TransportClientSocketPool::~TransportClientSocketPool() {
diff --git a/net/socket/transport_client_socket_pool.h b/net/socket/transport_client_socket_pool.h
index 2352b86..143d31f 100644
--- a/net/socket/transport_client_socket_pool.h
+++ b/net/socket/transport_client_socket_pool.h
@@ -50,21 +50,16 @@
// WebSockets should be created.
//
// |http_proxy_pool_for_ssl_pool| is for the case of SSLConnectJobs that will
- // be layered on top of an http proxy socket pool.
+ // be layered on top of an HTTP proxy socket pool.
//
- // |transport_pool_for_http_proxy_pool| and |ssl_pool_for_http_proxy_pool| are
- // socket pools that sit beneath the current pool, for the HTTP proxy case.
- //
- // TODO(https://crbug.com/927084): Remove the TransportClientSocketPool
- // arguments.
+ // TODO(https://crbug.com/927084): Remove the |http_proxy_pool_for_ssl_pool|
+ // argument.
using CreateConnectJobCallback =
base::RepeatingCallback<std::unique_ptr<ConnectJob>(
RequestPriority priority,
const CommonConnectJobParams& common_connect_job_params,
ConnectJob::Delegate* delegate,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool)>;
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool)>;
// "Parameters" that own a single callback for creating a ConnectJob that can
// be of any type.
@@ -106,12 +101,7 @@
// |http_proxy_pool_for_ssl_pool| socket pool is used for HTTP proxy tunnels
// beneath the SSL socket pool.
//
- // If this is being used for an HTTP proxy socket pool, the
- // |transport_pool_for_http_proxy_pool| and |ssl_pool_for_http_proxy_pool| are
- // used for SSL and TCP connections beneath the HTTP proxy socket pool.
- //
- // TODO(https://crbug.com/927084): Remove all pool arguments, once
- // the socket pools are flat.
+ // TODO(https://crbug.com/927084): Remove that argument.
TransportClientSocketPool(
int max_sockets,
int max_sockets_per_group,
@@ -129,9 +119,7 @@
SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
NetworkQualityEstimator* network_quality_estimator,
NetLog* net_log,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool = nullptr,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool = nullptr,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool = nullptr);
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool = nullptr);
~TransportClientSocketPool() override;
@@ -203,9 +191,7 @@
SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
NetworkQualityEstimator* network_quality_estimator,
NetLog* net_log,
- TransportClientSocketPool* http_proxy_pool_for_ssl_pool,
- TransportClientSocketPool* transport_pool_for_http_proxy_pool,
- TransportClientSocketPool* ssl_pool_for_http_proxy_pool);
+ TransportClientSocketPool* http_proxy_pool_for_ssl_pool);
~TransportConnectJobFactory() override;
// ClientSocketPoolBase::ConnectJobFactory methods.
@@ -225,8 +211,6 @@
NetLog* const net_log_;
TransportClientSocketPool* const http_proxy_pool_for_ssl_pool_;
- TransportClientSocketPool* const transport_pool_for_http_proxy_pool_;
- TransportClientSocketPool* const ssl_pool_for_http_proxy_pool_;
DISALLOW_COPY_AND_ASSIGN(TransportConnectJobFactory);
};
diff --git a/net/socket/websocket_transport_client_socket_pool.cc b/net/socket/websocket_transport_client_socket_pool.cc
index b3c8568..ad96a7b 100644
--- a/net/socket/websocket_transport_client_socket_pool.cc
+++ b/net/socket/websocket_transport_client_socket_pool.cc
@@ -155,9 +155,7 @@
network_quality_estimator_, pool_net_log_,
websocket_endpoint_lock_manager_),
connect_job_delegate.get(),
- nullptr /* http_proxy_pool_for_ssl_pool */,
- nullptr /* transport_pool_for_http_proxy_pool */,
- nullptr /* ssl_pool_for_http_proxy_pool */);
+ nullptr /* http_proxy_pool_for_ssl_pool */);
int result = connect_job_delegate->Connect(std::move(connect_job));
