Rename QuicStreamFactory to QuicSessionPool.

This class used to create QUIC streams, but now creates and pools QUIC
sessions instead. This rename brings it in line with SpdySessionPool and
its `RequestSession` method.

This CL has no functional impact. It is a mechanistic rename, performed
with `sed`. It avoids renaming existing metrics, preferring continuity
of data over accuracy of the name.

```
sed -i 's/quic_stream_factory/quic_session_pool/g;s/QUIC_STREAM_FACTORY/QUIC_SESSION_POOL/g;s/QuicStreamFactory/QuicSessionPool/g' $(git grep -il 'quic.\?stream.\?factory')
sed -i 's/quic_stream_request/quic_session_request/g;s/QUIC_STREAM_REQUEST/QUIC_SESSION_REQUEST/g;s/QuicStreamRequest/QuicSessionRequest/g' $(git grep -il 'quic.\?stream.\?request')
for f in  net/quic/*quic_stream_factory*; do n=$(echo $f | sed -e s/stream/session/g); git mv $f $n; done
sed -i 's/Net\.QuicSessionPool/Net.QuicStreamFactory/g' $(git grep -il 'Net.QuicSession' net/ tools/)
git cl format
```

Change-Id: I20ceb3d8a0a97cd9c8888bb7414b983b9fe5fa51
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5190439
Reviewed-by: Ryan Hamilton <rch@chromium.org>
Commit-Queue: Dustin Mitchell <djmitche@chromium.org>
Reviewed-by: Elly FJ <ellyjones@chromium.org>
Code-Coverage: findit-for-me@appspot.gserviceaccount.com <findit-for-me@appspot.gserviceaccount.com>
Reviewed-by: Paul Semel <paulsemel@chromium.org>
Reviewed-by: Tibor Goldschwendt <tiborg@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Reviewed-by: David Schinazi <dschinazi@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1248827}

docs/memory-infra/probe-net.md

@@ -65,7 +65,7 @@ URLRequestContext and “main_isolated_media” URLRequestContext.
 
       This object owns HTTP/2 sessions.
 
-  - QuicStreamFactory (“quic_stream_factory”)
+  - QuicSessionPool (“quic_session_pool”)
 
       This object owns QUIC sessions and streams.
 

ios/net/http_cache_helper.cc

@@ -18,7 +18,7 @@
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_transaction_factory.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
@@ -70,7 +70,7 @@ void ClearHttpCacheOnIOThread(
 
   // Clear QUIC server information from memory and the disk cache.
   http_cache->GetSession()
-      ->quic_stream_factory()
+      ->quic_session_pool()
       ->ClearCachedStatesInCryptoConfig(
           base::RepeatingCallback<bool(const GURL&)>());
 

net/BUILD.gn

@@ -798,8 +798,8 @@ component("net") {
     "quic/quic_server_info.h",
     "quic/quic_session_key.cc",
     "quic/quic_session_key.h",
-    "quic/quic_stream_factory.cc",
-    "quic/quic_stream_factory.h",
+    "quic/quic_session_pool.cc",
+    "quic/quic_session_pool.h",
     "quic/set_quic_flag.cc",
     "quic/set_quic_flag.h",
     "quic/web_transport_client.cc",
@@ -2661,9 +2661,9 @@ test("net_unittests") {
     "quic/quic_http_utils_test.cc",
     "quic/quic_network_transaction_unittest.cc",
     "quic/quic_proxy_client_socket_unittest.cc",
-    "quic/quic_stream_factory_peer.cc",
-    "quic/quic_stream_factory_peer.h",
-    "quic/quic_stream_factory_test.cc",
+    "quic/quic_session_pool_peer.cc",
+    "quic/quic_session_pool_peer.h",
+    "quic/quic_session_pool_test.cc",
     "quic/quic_test_packet_maker.cc",
     "quic/quic_test_packet_maker.h",
     "quic/quic_test_packet_printer.cc",
@@ -3809,8 +3809,8 @@ fuzzer_test("net_reporting_header_parser_fuzzer") {
   ]
 }
 
-fuzzer_test("net_quic_stream_factory_fuzzer") {
-  sources = [ "quic/quic_stream_factory_fuzzer.cc" ]
+fuzzer_test("net_quic_session_pool_fuzzer") {
+  sources = [ "quic/quic_session_pool_fuzzer.cc" ]
 
   deps = [
     ":net_fuzzer_test_support",

net/http/alternative_service.h

@@ -28,7 +28,7 @@ NET_EXPORT void HistogramAlternateProtocolUsage(AlternateProtocolUsage usage,
 
 enum BrokenAlternateProtocolLocation {
   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_JOB = 0,
-  BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY = 1,
+  BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_SESSION_POOL = 1,
   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_JOB_ALT = 2,
   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_JOB_MAIN = 3,
   BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_HTTP_STREAM = 4,

net/http/http_network_session.cc

@@ -26,7 +26,7 @@
 #include "net/proxy_resolution/proxy_resolution_service.h"
 #include "net/quic/platform/impl/quic_chromium_clock.h"
 #include "net/quic/quic_crypto_client_stream_factory.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_pool_manager_impl.h"
 #include "net/socket/next_proto.h"
@@ -145,17 +145,17 @@ HttpNetworkSession::HttpNetworkSession(const HttpNetworkSessionParams& params,
                           context.transport_security_state,
                           &ssl_client_session_cache_,
                           context.sct_auditing_delegate),
-      quic_stream_factory_(context.net_log,
-                           context.host_resolver,
-                           context.ssl_config_service,
-                           context.client_socket_factory,
-                           context.http_server_properties,
-                           context.cert_verifier,
-                           context.transport_security_state,
-                           context.sct_auditing_delegate,
-                           context.socket_performance_watcher_factory,
-                           context.quic_crypto_client_stream_factory,
-                           context.quic_context),
+      quic_session_pool_(context.net_log,
+                         context.host_resolver,
+                         context.ssl_config_service,
+                         context.client_socket_factory,
+                         context.http_server_properties,
+                         context.cert_verifier,
+                         context.transport_security_state,
+                         context.sct_auditing_delegate,
+                         context.socket_performance_watcher_factory,
+                         context.quic_crypto_client_stream_factory,
+                         context.quic_context),
       spdy_session_pool_(context.host_resolver,
                          &ssl_client_context_,
                          context.http_server_properties,
@@ -263,7 +263,7 @@ std::unique_ptr<base::Value> HttpNetworkSession::SpdySessionPoolInfoToValue()
 
 base::Value HttpNetworkSession::QuicInfoToValue() const {
   base::Value::Dict dict;
-  dict.Set("sessions", quic_stream_factory_.QuicStreamFactoryInfoToValue());
+  dict.Set("sessions", quic_session_pool_.QuicSessionPoolInfoToValue());
   dict.Set("quic_enabled", IsQuicEnabled());
 
   const QuicParams* quic_params = context_.quic_context->params();
@@ -337,7 +337,7 @@ void HttpNetworkSession::CloseAllConnections(int net_error,
   websocket_socket_pool_manager_->FlushSocketPoolsWithError(
       net_error, net_log_reason_utf8);
   spdy_session_pool_.CloseCurrentSessions(static_cast<net::Error>(net_error));
-  quic_stream_factory_.CloseAllSessions(net_error, quic::QUIC_PEER_GOING_AWAY);
+  quic_session_pool_.CloseAllSessions(net_error, quic::QUIC_PEER_GOING_AWAY);
 }
 
 void HttpNetworkSession::CloseIdleConnections(const char* net_log_reason_utf8) {
@@ -369,10 +369,9 @@ CommonConnectJobParams HttpNetworkSession::CreateCommonConnectJobParams(
   return CommonConnectJobParams(
       context_.client_socket_factory, context_.host_resolver, &http_auth_cache_,
       context_.http_auth_handler_factory, &spdy_session_pool_,
-      &context_.quic_context->params()->supported_versions,
-      &quic_stream_factory_, context_.proxy_delegate,
-      context_.http_user_agent_settings, &ssl_client_context_,
-      context_.socket_performance_watcher_factory,
+      &context_.quic_context->params()->supported_versions, &quic_session_pool_,
+      context_.proxy_delegate, context_.http_user_agent_settings,
+      &ssl_client_context_, context_.socket_performance_watcher_factory,
       context_.network_quality_estimator, context_.net_log,
       for_websockets ? &websocket_endpoint_lock_manager_ : nullptr,
       context_.http_server_properties, &next_protos_, &application_settings_,

net/http/http_network_session.h

@@ -30,7 +30,7 @@
 #include "net/http/http_auth_cache.h"
 #include "net/http/http_stream_factory.h"
 #include "net/net_buildflags.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/socket/connect_job.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/websocket_endpoint_lock_manager.h"
@@ -245,7 +245,7 @@ class NET_EXPORT HttpNetworkSession {
     return &websocket_endpoint_lock_manager_;
   }
   SpdySessionPool* spdy_session_pool() { return &spdy_session_pool_; }
-  QuicStreamFactory* quic_stream_factory() { return &quic_stream_factory_; }
+  QuicSessionPool* quic_session_pool() { return &quic_session_pool_; }
   HttpAuthHandlerFactory* http_auth_handler_factory() {
     return http_auth_handler_factory_;
   }
@@ -339,7 +339,7 @@ class NET_EXPORT HttpNetworkSession {
   WebSocketEndpointLockManager websocket_endpoint_lock_manager_;
   std::unique_ptr<ClientSocketPoolManager> normal_socket_pool_manager_;
   std::unique_ptr<ClientSocketPoolManager> websocket_socket_pool_manager_;
-  QuicStreamFactory quic_stream_factory_;
+  QuicSessionPool quic_session_pool_;
   SpdySessionPool spdy_session_pool_;
   std::unique_ptr<HttpStreamFactory> http_stream_factory_;
   std::set<std::unique_ptr<HttpResponseBodyDrainer>, base::UniquePtrComparator>

net/http/http_network_transaction_unittest.cc

@@ -410,7 +410,7 @@ class HttpNetworkTransactionTestBase : public PlatformTest,
             /*http_auth_handler_factory=*/nullptr,
             /*spdy_session_pool=*/nullptr,
             /*quic_supported_versions=*/nullptr,
-            /*quic_stream_factory=*/nullptr,
+            /*quic_session_pool=*/nullptr,
             /*proxy_delegate=*/nullptr,
             /*http_user_agent_settings=*/nullptr,
             /*ssl_client_context=*/nullptr,

net/http/http_proxy_connect_job.cc

@@ -30,7 +30,7 @@
 #include "net/nqe/network_quality_estimator.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_proxy_client_socket.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/ssl_client_socket.h"
@@ -683,13 +683,13 @@ int HttpProxyConnectJob::DoQuicProxyCreateSession() {
 
   next_state_ = STATE_QUIC_PROXY_CREATE_STREAM;
   const HostPortPair& proxy_server = params_->proxy_server().host_port_pair();
-  quic_stream_request_ = std::make_unique<QuicStreamRequest>(
-      common_connect_job_params()->quic_stream_factory);
+  quic_session_request_ = std::make_unique<QuicSessionRequest>(
+      common_connect_job_params()->quic_session_pool);
 
   // Use default QUIC version, which is the version listed supported version.
   quic::ParsedQuicVersion quic_version =
       common_connect_job_params()->quic_supported_versions->front();
-  return quic_stream_request_->Request(
+  return quic_session_request_->Request(
       // TODO(crbug.com/1206799) Pass the destination directly once it's
       // converted to contain scheme.
       url::SchemeHostPort(url::kHttpsScheme, proxy_server.host(),
@@ -708,13 +708,13 @@ int HttpProxyConnectJob::DoQuicProxyCreateSession() {
 
 int HttpProxyConnectJob::DoQuicProxyCreateStream(int result) {
   if (result < 0) {
-    quic_stream_request_.reset();
+    quic_session_request_.reset();
     return result;
   }
 
   next_state_ = STATE_QUIC_PROXY_CREATE_STREAM_COMPLETE;
-  quic_session_ = quic_stream_request_->ReleaseSessionHandle();
-  quic_stream_request_.reset();
+  quic_session_ = quic_session_request_->ReleaseSessionHandle();
+  quic_session_request_.reset();
 
   return quic_session_->RequestStream(
       false,
@@ -802,7 +802,7 @@ int HttpProxyConnectJob::DoRestartWithAuthComplete(int result) {
 
 void HttpProxyConnectJob::ChangePriorityInternal(RequestPriority priority) {
   // Do not set the priority on |spdy_stream_request_| or
-  // |quic_stream_request_|, since those should always use
+  // |quic_session_request_|, since those should always use
   // kH2QuicTunnelPriority.
   if (nested_connect_job_) {
     nested_connect_job_->ChangePriority(priority);

net/http/http_proxy_connect_job.h

@@ -36,7 +36,7 @@ class ProxyClientSocket;
 class SpdyStreamRequest;
 class SSLSocketParams;
 class TransportSocketParams;
-class QuicStreamRequest;
+class QuicSessionRequest;
 
 // HttpProxySocketParams only needs the socket params for one of the proxy
 // types.  The other param must be NULL.  When using an HTTP proxy,
@@ -249,7 +249,7 @@ class NET_EXPORT_PRIVATE HttpProxyConnectJob : public ConnectJob,
 
   std::unique_ptr<SpdyStreamRequest> spdy_stream_request_;
 
-  std::unique_ptr<QuicStreamRequest> quic_stream_request_;
+  std::unique_ptr<QuicSessionRequest> quic_session_request_;
   std::unique_ptr<QuicChromiumClientSession::Handle> quic_session_;
 
   scoped_refptr<HttpAuthController> http_auth_controller_;

net/http/http_stream_factory_job.cc

@@ -158,7 +158,7 @@ HttpStreamFactory::Job::Job(
                   job_type == PRECONNECT_DNS_ALPN_H3),
       quic_version_(quic_version),
       expect_spdy_(alternative_protocol == kProtoHTTP2 && !using_quic_),
-      quic_request_(session_->quic_stream_factory()),
+      quic_request_(session_->quic_session_pool()),
       spdy_session_key_(
           using_quic_
               ? SpdySessionKey()

net/http/http_stream_factory_job.h

@@ -23,7 +23,7 @@
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory.h"
 #include "net/http/http_stream_request.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/client_socket_pool_manager.h"
@@ -430,7 +430,7 @@ class HttpStreamFactory::Job
   // True if this job might succeed with a different proxy config.
   bool should_reconsider_proxy_ = false;
 
-  QuicStreamRequest quic_request_;
+  QuicSessionRequest quic_request_;
 
   // Only valid for a QUIC job. Set when a QUIC connection is started. If true,
   // then OnQuicHostResolution() is expected to be called in the future.

net/http/http_stream_factory_job_controller.cc

@@ -1309,7 +1309,7 @@ HttpStreamFactory::JobController::GetAlternativeServiceInfoInternal(
     }
     RewriteUrlWithHostMappingRules(destination);
 
-    if (session_->quic_stream_factory()->CanUseExistingSession(
+    if (session_->quic_session_pool()->CanUseExistingSession(
             session_key, url::SchemeHostPort(destination))) {
       return alternative_service_info;
     }

net/http/http_stream_factory_job_controller_unittest.cc

@@ -56,8 +56,8 @@
 #include "net/quic/mock_quic_context.h"
 #include "net/quic/mock_quic_data.h"
 #include "net/quic/quic_http_stream.h"
-#include "net/quic/quic_stream_factory.h"
-#include "net/quic/quic_stream_factory_peer.h"
+#include "net/quic/quic_session_pool.h"
+#include "net/quic/quic_session_pool_peer.h"
 #include "net/quic/quic_test_packet_maker.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_session_key.h"
@@ -86,7 +86,7 @@ namespace {
 
 const char kServerHostname[] = "www.example.com";
 
-// The default delay for main job defined in QuicStreamFactory::
+// The default delay for main job defined in QuicSessionPool::
 // GetTimeDelayForWaitingJob().
 const int kDefaultDelayMilliSecsForWaitingJob = 300;
 
@@ -1937,7 +1937,7 @@ TEST_P(HttpStreamFactoryJobControllerTest, CancelJobsBeforeBinding) {
   // to serve Request yet and JobController will notify the factory to delete
   // itself upon completion.
   request_.reset();
-  // QuicStreamFactory::Job::Request will not complete since the Jobs are
+  // QuicSessionPool::Job::Request will not complete since the Jobs are
   // canceled, so there is no need to check if all read data was consumed.
   should_check_data_consumed_ = false;
   VerifyBrokenAlternateProtocolMapping(request_info, false);
@@ -1997,8 +1997,8 @@ void HttpStreamFactoryJobControllerTestBase::
       quic_context_.params()->supported_versions);
 
   // Enable QUIC but mark the alternative service as recently broken.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
   session_->http_server_properties()->MarkAlternativeServiceRecentlyBroken(
       alternative_service, NetworkAnonymizationKey());
 
@@ -2073,8 +2073,8 @@ void HttpStreamFactoryJobControllerTestBase::
       quic_context_.params()->supported_versions);
 
   // Enable QUIC but mark the alternative service as recently broken.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
   session_->http_server_properties()->MarkAlternativeServiceRecentlyBroken(
       alternative_service, NetworkAnonymizationKey());
 
@@ -3267,8 +3267,8 @@ TEST_P(HttpStreamFactoryJobControllerTest, HostResolutionHang) {
   quic_data.AddSocketDataToFactory(session_deps_.socket_factory.get());
 
   // Enable delayed TCP and set time delay for waiting job.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
   ServerNetworkStats stats1;
   stats1.srtt = base::Microseconds(10);
   session_->http_server_properties()->SetServerNetworkStats(
@@ -3344,8 +3344,8 @@ TEST_P(HttpStreamFactoryJobControllerTest, ResumeMainJobLaterCanceled) {
   Initialize(request_info);
 
   // Enable delayed TCP and set time delay for waiting job.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
   ServerNetworkStats stats1;
   stats1.srtt = base::Microseconds(10);
   session_->http_server_properties()->SetServerNetworkStats(
@@ -3421,8 +3421,8 @@ TEST_P(HttpStreamFactoryJobControllerTest, DelayedTCPWithLargeSrtt) {
   quic_data.AddSocketDataToFactory(session_deps_.socket_factory.get());
 
   // Enable delayed TCP and set time delay for waiting job.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
   ServerNetworkStats stats1;
   stats1.srtt = base::Seconds(100);
   session_->http_server_properties()->SetServerNetworkStats(
@@ -3484,8 +3484,8 @@ TEST_P(HttpStreamFactoryJobControllerTest,
   quic_data.AddSocketDataToFactory(session_deps_.socket_factory.get());
 
   // Enable delayed TCP and set time delay for waiting job.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
   ServerNetworkStats stats1;
   stats1.srtt = base::Microseconds(10);
   session_->http_server_properties()->SetServerNetworkStats(
@@ -3718,8 +3718,8 @@ void HttpStreamFactoryJobControllerTestBase::
   quic_data.AddSocketDataToFactory(session_deps_.socket_factory.get());
 
   // Enable delayed TCP and set time delay for waiting job.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
   ServerNetworkStats stats1;
   stats1.srtt = base::Milliseconds(100);
   session_->http_server_properties()->SetServerNetworkStats(
@@ -4952,7 +4952,7 @@ class HttpStreamFactoryJobControllerDnsHttpsAlpnTest
       bool alt_destination,
       bool require_dns_https_alpn) {
     NetErrorDetails net_error_details;
-    QuicStreamRequest quic_request(session_->quic_stream_factory());
+    QuicSessionRequest quic_request(session_->quic_session_pool());
     url::SchemeHostPort scheme_host_port(
         url::kHttpsScheme,
         alt_destination ? "alt.example.org" : "www.example.org", 443);
@@ -5184,8 +5184,8 @@ TEST_F(HttpStreamFactoryJobControllerDnsHttpsAlpnTest,
   PrepareForMainJob();
   Initialize(HttpRequestInfo());
 
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
 
   request_ = CreateJobControllerAndStart(CreateTestHttpRequestInfo());
 
@@ -5311,8 +5311,8 @@ TEST_F(HttpStreamFactoryJobControllerDnsHttpsAlpnTest,
   RegisterMockHttpsRecord();
 
   Initialize(HttpRequestInfo());
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
 
   request_ = CreateJobControllerAndStart(CreateTestHttpRequestInfo());
 
@@ -5395,8 +5395,8 @@ TEST_F(HttpStreamFactoryJobControllerDnsHttpsAlpnTest,
   // the delaying logic of main job would work when the main job is blocked.
   // Note: In this test, we don't need this because the main job is not blocked.
   // But we set here because we want to check that the main job is not blocked.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
 
   // Put a SpdySession in the pool.
   SpdySessionKey key(HostPortPair::FromURL(request_info.url),
@@ -5456,8 +5456,8 @@ TEST_F(HttpStreamFactoryJobControllerDnsHttpsAlpnTest, MainJobHasActiveSocket) {
 
   // Set |is_quic_known_to_work_on_current_network| flag so that
   // the delaying logic of main job would work when the main job is blocked.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
 
   request_ = CreateJobControllerAndStart(request_info);
   CheckJobsStatus(/*main_job_exists=*/true, /*alternative_job_exists=*/false,
@@ -5503,8 +5503,8 @@ TEST_F(HttpStreamFactoryJobControllerDnsHttpsAlpnTest,
 
   // Set |is_quic_known_to_work_on_current_network| flag so that
   // the delaying logic of main job would work when the main job is blocked.
-  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
-  quic_stream_factory->set_is_quic_known_to_work_on_current_network(true);
+  QuicSessionPool* quic_session_pool = session_->quic_session_pool();
+  quic_session_pool->set_is_quic_known_to_work_on_current_network(true);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, "alt.example.org", 443);

net/http/http_stream_factory_unittest.cc

@@ -56,7 +56,7 @@
 #include "net/quic/mock_crypto_client_stream_factory.h"
 #include "net/quic/mock_quic_context.h"
 #include "net/quic/quic_http_utils.h"
-#include "net/quic/quic_stream_factory_peer.h"
+#include "net/quic/quic_session_pool_peer.h"
 #include "net/quic/quic_test_packet_maker.h"
 #include "net/quic/quic_test_packet_printer.h"
 #include "net/socket/client_socket_handle.h"
@@ -877,8 +877,8 @@ TEST_F(HttpStreamFactoryTest, QuicProxyMarkedAsBad) {
 
     auto session =
         std::make_unique<HttpNetworkSession>(session_params, session_context);
-    session->quic_stream_factory()
-        ->set_is_quic_known_to_work_on_current_network(true);
+    session->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
+        true);
 
     StaticSocketDataProvider socket_data1;
     socket_data1.set_connect_data(
@@ -1999,8 +1999,8 @@ class HttpStreamFactoryBidirectionalQuicTest
     session_context.ssl_config_service = ssl_config_service_.get();
     session_context.client_socket_factory = &socket_factory_;
     session_ = std::make_unique<HttpNetworkSession>(params_, session_context);
-    session_->quic_stream_factory()
-        ->set_is_quic_known_to_work_on_current_network(true);
+    session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
+        true);
   }
 
   void AddQuicAlternativeService(const url::SchemeHostPort& request_url,

net/log/net_log_event_type_list.h

@@ -1218,14 +1218,14 @@ EVENT_TYPE(HTTP_STREAM_JOB_INIT_CONNECTION)
 //   }
 EVENT_TYPE(HTTP_STREAM_REQUEST_BOUND_TO_JOB)
 
-// Identifies the NetLogSource() for the QuicStreamFactory::Job that the
+// Identifies the NetLogSource() for the QuicSessionPool::Job that the
 // HttpStreamFactory::Job was attached to.
 // The event parameters are:
 //  {
-//      "source_dependency": <Source identifier for the QuicStreamFactory::Job
+//      "source_dependency": <Source identifier for the QuicSessionPool::Job
 //                            to which we were attached>,
 //  }
-EVENT_TYPE(HTTP_STREAM_JOB_BOUND_TO_QUIC_STREAM_FACTORY_JOB)
+EVENT_TYPE(HTTP_STREAM_JOB_BOUND_TO_QUIC_SESSION_POOL_JOB)
 
 // Identifies the NetLogSource() for the Request that the Job was attached to.
 // The event parameters are:
@@ -1776,7 +1776,7 @@ EVENT_TYPE(HTTP2_PROXY_CLIENT_SESSION)
 //   }
 
 // ------------------------------------------------------------------------
-// QuicStreamFactory
+// QuicSessionPool
 // ------------------------------------------------------------------------
 
 // This event is emitted whenever a platform notification is received that
@@ -1785,19 +1785,19 @@ EVENT_TYPE(HTTP2_PROXY_CLIENT_SESSION)
 //     "signal": <Type of the platform notification>,
 //     "network": <The network that triggered the notification>,
 //   }
-EVENT_TYPE(QUIC_STREAM_FACTORY_PLATFORM_NOTIFICATION)
+EVENT_TYPE(QUIC_SESSION_POOL_PLATFORM_NOTIFICATION)
 
-// These events track QuicStreamFactory's handling of OnIPAddressChanged and
+// These events track QuicSessionPool's handling of OnIPAddressChanged and
 // whether QuicSessions are closed or marked as going away.
-EVENT_TYPE(QUIC_STREAM_FACTORY_ON_IP_ADDRESS_CHANGED)
-EVENT_TYPE(QUIC_STREAM_FACTORY_CLOSE_ALL_SESSIONS)
-EVENT_TYPE(QUIC_STREAM_FACTORY_MARK_ALL_ACTIVE_SESSIONS_GOING_AWAY)
+EVENT_TYPE(QUIC_SESSION_POOL_ON_IP_ADDRESS_CHANGED)
+EVENT_TYPE(QUIC_SESSION_POOL_CLOSE_ALL_SESSIONS)
+EVENT_TYPE(QUIC_SESSION_POOL_MARK_ALL_ACTIVE_SESSIONS_GOING_AWAY)
 
 // ------------------------------------------------------------------------
-// QuicStreamFactory::Job
+// QuicSessionPool::Job
 // ------------------------------------------------------------------------
 
-// Measures the time taken to execute the QuicStreamFactory::Job.
+// Measures the time taken to execute the QuicSessionPool::Job.
 // The event parameters are:
 //   {
 //     "host": <The origin hostname that the Job serves>,
@@ -1805,7 +1805,7 @@ EVENT_TYPE(QUIC_STREAM_FACTORY_MARK_ALL_ACTIVE_SESSIONS_GOING_AWAY)
 //     "privacy_mode": <The privacy mode of the Job>,
 //     "network_anonymization_key": <The NetworkAnonymizationKey of the Job>,
 //   }
-EVENT_TYPE(QUIC_STREAM_FACTORY_JOB)
+EVENT_TYPE(QUIC_SESSION_POOL_JOB)
 
 // Identifies the NetLogSource() for the HttpStreamFactory::Job that the Job was
 // attached to.
@@ -1814,7 +1814,7 @@ EVENT_TYPE(QUIC_STREAM_FACTORY_JOB)
 //     "source_dependency": <Source identifier for the HttpStreamFactory::Job to
 //                           which we were attached>,
 //  }
-EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_BOUND_TO_HTTP_STREAM_JOB)
+EVENT_TYPE(QUIC_SESSION_POOL_JOB_BOUND_TO_HTTP_STREAM_JOB)
 
 // Measures the time taken to establish a QUIC connection.
 // The event parameters are:
@@ -1822,24 +1822,24 @@ EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_BOUND_TO_HTTP_STREAM_JOB)
 //     "require_confirmation": <True if we require handshake confirmation
 //                              in the connection>
 //  }
-EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_CONNECT)
+EVENT_TYPE(QUIC_SESSION_POOL_JOB_CONNECT)
 
 // This event indicates that the connection on the default network has failed
 // before the handshake completed and a new connection on the alternate network
 // will be attempted soon.
-EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_RETRY_ON_ALTERNATE_NETWORK)
+EVENT_TYPE(QUIC_SESSION_POOL_JOB_RETRY_ON_ALTERNATE_NETWORK)
 
 // This event indicates that the stale host result is used to try connecting.
-EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_STALE_HOST_TRIED_ON_CONNECTION)
+EVENT_TYPE(QUIC_SESSION_POOL_JOB_STALE_HOST_TRIED_ON_CONNECTION)
 
 // This event indicates that stale host was not used to try connecting.
-EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_STALE_HOST_NOT_USED_ON_CONNECTION)
+EVENT_TYPE(QUIC_SESSION_POOL_JOB_STALE_HOST_NOT_USED_ON_CONNECTION)
 
 // This event indicates that the stale host doesn't match with fresh host.
-EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_STALE_HOST_RESOLUTION_NO_MATCH)
+EVENT_TYPE(QUIC_SESSION_POOL_JOB_STALE_HOST_RESOLUTION_NO_MATCH)
 
 // This event indicates that stale host matches with fresh resolution.
-EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_STALE_HOST_RESOLUTION_MATCHED)
+EVENT_TYPE(QUIC_SESSION_POOL_JOB_STALE_HOST_RESOLUTION_MATCHED)
 
 // ------------------------------------------------------------------------
 // quic::QuicSession

net/log/net_log_source_type_list.h

@@ -36,7 +36,7 @@ SOURCE_TYPE(BIDIRECTIONAL_STREAM)
 SOURCE_TYPE(NETWORK_QUALITY_ESTIMATOR)
 SOURCE_TYPE(HTTP_STREAM_JOB_CONTROLLER)
 SOURCE_TYPE(CT_TREE_STATE_TRACKER)
-SOURCE_TYPE(QUIC_STREAM_FACTORY_JOB)
+SOURCE_TYPE(QUIC_SESSION_POOL_JOB)
 SOURCE_TYPE(HTTP_SERVER_PROPERTIES)
 SOURCE_TYPE(HOST_CACHE_PERSISTENCE_MANAGER)
 SOURCE_TYPE(COOKIE_STORE)
@@ -47,5 +47,5 @@ SOURCE_TYPE(NETWORK_SERVICE_HOST_RESOLVER)
 SOURCE_TYPE(DNS_OVER_HTTPS)
 SOURCE_TYPE(DNS_TRANSACTION)
 SOURCE_TYPE(NETWORK_CHANGE_NOTIFIER)
-SOURCE_TYPE(QUIC_STREAM_FACTORY)
+SOURCE_TYPE(QUIC_SESSION_POOL)
 SOURCE_TYPE(UDP_CLIENT_SOCKET)

net/quic/bidirectional_stream_quic_impl_unittest.cc

@@ -39,7 +39,7 @@
 #include "net/quic/quic_crypto_client_config_handle.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_server_info.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/quic/quic_test_packet_maker.h"
 #include "net/quic/quic_test_packet_printer.h"
 #include "net/quic/test_quic_crypto_client_config_handle.h"

net/quic/quic_chromium_client_session.cc

@@ -46,7 +46,7 @@
 #include "net/quic/quic_chromium_packet_writer.h"
 #include "net/quic/quic_crypto_client_stream_factory.h"
 #include "net/quic/quic_server_info.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/socket/datagram_client_socket.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_log_util.h"
@@ -884,7 +884,7 @@ void QuicChromiumClientSession::QuicChromiumPathValidationWriterDelegate::
 QuicChromiumClientSession::QuicChromiumClientSession(
     quic::QuicConnection* connection,
     std::unique_ptr<DatagramClientSocket> socket,
-    QuicStreamFactory* stream_factory,
+    QuicSessionPool* session_pool,
     QuicCryptoClientStreamFactory* crypto_client_stream_factory,
     const quic::QuicClock* clock,
     TransportSecurityState* transport_security_state,
@@ -941,7 +941,7 @@ QuicChromiumClientSession::QuicChromiumClientSession(
       most_recent_stream_close_time_(tick_clock_->NowTicks()),
       most_recent_write_error_timestamp_(base::TimeTicks()),
       crypto_config_(std::move(crypto_config)),
-      stream_factory_(stream_factory),
+      session_pool_(session_pool),
       transport_security_state_(transport_security_state),
       ssl_config_service_(ssl_config_service),
       server_info_(std::move(server_info)),
@@ -1573,7 +1573,7 @@ quic::QuicSSLConfig QuicChromiumClientSession::GetSSLConfig() const {
 
 void QuicChromiumClientSession::OnConfigNegotiated() {
   quic::QuicSpdyClientSessionBase::OnConfigNegotiated();
-  if (!stream_factory_ || !stream_factory_->allow_server_migration()) {
+  if (!session_pool_ || !session_pool_->allow_server_migration()) {
     return;
   }
   if (!config()->HasReceivedPreferredAddressConnectionIdAndToken()) {
@@ -1923,10 +1923,10 @@ void QuicChromiumClientSession::OnConnectionClosed(
     // connection timed out with open streams then QUIC traffic has become
     // blackholed. Alternatively, if too many retransmission timeouts occur
     // then QUIC traffic has become blackholed.
-    if (stream_factory_ && (error == quic::QUIC_TOO_MANY_RTOS ||
-                            (error == quic::QUIC_NETWORK_IDLE_TIMEOUT &&
-                             GetNumActiveStreams() > 0))) {
-      stream_factory_->OnBlackholeAfterHandshakeConfirmed(this);
+    if (session_pool_ && (error == quic::QUIC_TOO_MANY_RTOS ||
+                          (error == quic::QUIC_NETWORK_IDLE_TIMEOUT &&
+                           GetNumActiveStreams() > 0))) {
+      session_pool_->OnBlackholeAfterHandshakeConfirmed(this);
     }
     UMA_HISTOGRAM_COUNTS_100(
         "Net.QuicSession.CryptoRetransmitCount.HandshakeConfirmed",
@@ -2052,7 +2052,7 @@ int QuicChromiumClientSession::HandleWriteError(
     }
   }
 
-  if (error_code == ERR_MSG_TOO_BIG || stream_factory_ == nullptr ||
+  if (error_code == ERR_MSG_TOO_BIG || session_pool_ == nullptr ||
       !migrate_session_on_network_change_v2_ || !OneRttKeysAvailable()) {
     return error_code;
   }
@@ -2097,7 +2097,7 @@ void QuicChromiumClientSession::MigrateSessionOnWriteError(
   most_recent_write_error_timestamp_ = tick_clock_->NowTicks();
   most_recent_write_error_ = error_code;
 
-  if (stream_factory_ == nullptr) {
+  if (session_pool_ == nullptr) {
     // Close the connection if migration failed. Do not cause a
     // connection close packet to be sent since socket may be borked.
     connection()->CloseConnection(quic::QUIC_PACKET_WRITE_ERROR,
@@ -2134,7 +2134,7 @@ void QuicChromiumClientSession::MigrateSessionOnWriteError(
   }
 
   handles::NetworkHandle new_network =
-      stream_factory_->FindAlternateNetwork(GetCurrentNetwork());
+      session_pool_->FindAlternateNetwork(GetCurrentNetwork());
   if (new_network == handles::kInvalidNetworkHandle) {
     // No alternate network found.
     HistogramAndLogMigrationFailure(MIGRATION_STATUS_NO_ALTERNATE_NETWORK,
@@ -2559,7 +2559,7 @@ void QuicChromiumClientSession::OnNetworkDisconnectedV2(
 
   // Attempt to find alternative network.
   handles::NetworkHandle new_network =
-      stream_factory_->FindAlternateNetwork(disconnected_network);
+      session_pool_->FindAlternateNetwork(disconnected_network);
 
   if (new_network == handles::kInvalidNetworkHandle) {
     OnNoNewNetwork();
@@ -2732,7 +2732,7 @@ void QuicChromiumClientSession::OnPathDegrading() {
     observer.OnSessionPathDegrading(this, current_network);
   }
 
-  if (!stream_factory_ || connection()->multi_port_stats()) {
+  if (!session_pool_ || connection()->multi_port_stats()) {
     return;
   }
 
@@ -2906,7 +2906,7 @@ void QuicChromiumClientSession::MaybeMigrateToDifferentPortOnPathDegrading() {
 
   net_log_.BeginEvent(NetLogEventType::QUIC_PORT_MIGRATION_TRIGGERED);
 
-  if (!stream_factory_) {
+  if (!session_pool_) {
     return;
   }
 
@@ -2942,7 +2942,7 @@ void QuicChromiumClientSession::
   }
 
   handles::NetworkHandle alternate_network =
-      stream_factory_->FindAlternateNetwork(GetCurrentNetwork());
+      session_pool_->FindAlternateNetwork(GetCurrentNetwork());
   if (alternate_network == handles::kInvalidNetworkHandle) {
     HistogramAndLogMigrationFailure(MIGRATION_STATUS_NO_ALTERNATE_NETWORK,
                                     connection_id(),
@@ -2975,7 +2975,7 @@ void QuicChromiumClientSession::MaybeStartProbing(
     ProbingCallback probing_callback,
     handles::NetworkHandle network,
     const quic::QuicSocketAddress& peer_address) {
-  if (!stream_factory_) {
+  if (!session_pool_) {
     task_runner_->PostTask(
         FROM_HERE, base::BindOnce(std::move(probing_callback),
                                   ProbingResult::DISABLED_WITH_IDLE_SESSION));
@@ -3023,21 +3023,21 @@ void QuicChromiumClientSession::CreateContextForMultiPortPath(
     std::unique_ptr<quic::MultiPortPathContextObserver> context_observer) {
   // Create and configure socket on default network
   std::unique_ptr<DatagramClientSocket> probing_socket =
-      stream_factory_->CreateSocket(net_log_.net_log(), net_log_.source());
+      session_pool_->CreateSocket(net_log_.net_log(), net_log_.source());
   if (base::FeatureList::IsEnabled(net::features::kAsyncMultiPortPath)) {
     DatagramClientSocket* probing_socket_ptr = probing_socket.get();
     CompletionOnceCallback configure_callback = base::BindOnce(
         &QuicChromiumClientSession::FinishCreateContextForMultiPortPath,
         weak_factory_.GetWeakPtr(), std::move(context_observer),
         std::move(probing_socket));
-    stream_factory_->ConnectAndConfigureSocket(
+    session_pool_->ConnectAndConfigureSocket(
         std::move(configure_callback), probing_socket_ptr,
         ToIPEndPoint(peer_address()), default_network_,
         session_key_.socket_tag());
     return;
   }
 
-  if (stream_factory_->ConfigureSocket(
+  if (session_pool_->ConfigureSocket(
           probing_socket.get(), ToIPEndPoint(peer_address()), default_network_,
           session_key_.socket_tag()) != OK) {
     return;
@@ -3116,7 +3116,7 @@ void QuicChromiumClientSession::StartProbing(
 
   // Create and configure socket on |network|.
   std::unique_ptr<DatagramClientSocket> probing_socket =
-      stream_factory_->CreateSocket(net_log_.net_log(), net_log_.source());
+      session_pool_->CreateSocket(net_log_.net_log(), net_log_.source());
   DatagramClientSocket* probing_socket_ptr = probing_socket.get();
   CompletionOnceCallback configure_callback =
       base::BindOnce(&QuicChromiumClientSession::FinishStartProbing,
@@ -3128,7 +3128,7 @@ void QuicChromiumClientSession::StartProbing(
     std::move(MidMigrationCallbackForTesting()).Run();  // IN-TEST
   }
 
-  stream_factory_->ConnectAndConfigureSocket(
+  session_pool_->ConnectAndConfigureSocket(
       std::move(configure_callback), probing_socket_ptr,
       ToIPEndPoint(peer_address), network, session_key_.socket_tag());
 
@@ -3500,10 +3500,10 @@ base::Value::Dict QuicChromiumClientSession::GetInfoAsValue(
 }
 
 bool QuicChromiumClientSession::gquic_zero_rtt_disabled() const {
-  if (!stream_factory_) {
+  if (!session_pool_) {
     return false;
   }
-  return stream_factory_->gquic_zero_rtt_disabled();
+  return session_pool_->gquic_zero_rtt_disabled();
 }
 
 std::unique_ptr<QuicChromiumClientSession::Handle>
@@ -3565,8 +3565,8 @@ bool QuicChromiumClientSession::OnPacket(
 
 void QuicChromiumClientSession::NotifyFactoryOfSessionGoingAway() {
   going_away_ = true;
-  if (stream_factory_) {
-    stream_factory_->OnSessionGoingAway(this);
+  if (session_pool_) {
+    session_pool_->OnSessionGoingAway(this);
   }
 }
 
@@ -3584,14 +3584,14 @@ void QuicChromiumClientSession::NotifyFactoryOfSessionClosed() {
   going_away_ = true;
   DCHECK_EQ(0u, GetNumActiveStreams());
   // Will delete |this|.
-  if (stream_factory_) {
-    stream_factory_->OnSessionClosed(this);
+  if (session_pool_) {
+    session_pool_->OnSessionClosed(this);
   }
 }
 
 void QuicChromiumClientSession::OnCryptoHandshakeComplete() {
-  if (stream_factory_) {
-    stream_factory_->set_is_quic_known_to_work_on_current_network(true);
+  if (session_pool_) {
+    session_pool_->set_is_quic_known_to_work_on_current_network(true);
   }
 
   // Update |connect_end| only when handshake is confirmed. This should also
@@ -3644,7 +3644,7 @@ void QuicChromiumClientSession::Migrate(handles::NetworkHandle network,
                                         MigrationCallback migration_callback) {
   quic_connection_migration_attempted_ = true;
   quic_connection_migration_successful_ = false;
-  if (!stream_factory_) {
+  if (!session_pool_) {
     task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&QuicChromiumClientSession::DoMigrationCallback,
@@ -3677,7 +3677,7 @@ void QuicChromiumClientSession::Migrate(handles::NetworkHandle network,
 
   // Create and configure socket on |network|.
   std::unique_ptr<DatagramClientSocket> socket(
-      stream_factory_->CreateSocket(net_log_.net_log(), net_log_.source()));
+      session_pool_->CreateSocket(net_log_.net_log(), net_log_.source()));
   DatagramClientSocket* socket_ptr = socket.get();
   DVLOG(1) << "Force blocking the packet writer";
   static_cast<QuicChromiumPacketWriter*>(connection()->writer())
@@ -3696,9 +3696,9 @@ void QuicChromiumClientSession::Migrate(handles::NetworkHandle network,
     std::move(MidMigrationCallbackForTesting()).Run();  // IN-TEST
   }
 
-  stream_factory_->ConnectAndConfigureSocket(std::move(connect_callback),
-                                             socket_ptr, peer_address, network,
-                                             session_key_.socket_tag());
+  session_pool_->ConnectAndConfigureSocket(std::move(connect_callback),
+                                           socket_ptr, peer_address, network,
+                                           session_key_.socket_tag());
 }
 
 void QuicChromiumClientSession::FinishMigrate(
@@ -3839,7 +3839,7 @@ void QuicChromiumClientSession::OnServerPreferredAddressAvailable(
   net_log_.BeginEvent(
       NetLogEventType::QUIC_ON_SERVER_PREFERRED_ADDRESS_AVAILABLE);
 
-  if (!stream_factory_) {
+  if (!session_pool_) {
     return;
   }
 
@@ -3864,8 +3864,8 @@ const std::set<std::string>&
 QuicChromiumClientSession::GetDnsAliasesForSessionKey(
     const QuicSessionKey& key) const {
   static const base::NoDestructor<std::set<std::string>> emptyset_result;
-  return stream_factory_ ? stream_factory_->GetDnsAliasesForSessionKey(key)
-                         : *emptyset_result;
+  return session_pool_ ? session_pool_->GetDnsAliasesForSessionKey(key)
+                       : *emptyset_result;
 }
 
 #if BUILDFLAG(ENABLE_WEBSOCKETS)

net/quic/quic_chromium_client_session.h

@@ -69,7 +69,7 @@ struct HostResolverEndpointResult;
 class NetLog;
 class QuicCryptoClientStreamFactory;
 class QuicServerInfo;
-class QuicStreamFactory;
+class QuicSessionPool;
 class SSLConfigService;
 class SSLInfo;
 class TransportSecurityState;
@@ -269,7 +269,7 @@ class NET_EXPORT_PRIVATE QuicChromiumClientSession
     bool WasEverUsed() const;
 
     // Retrieves any DNS aliases for the given session key from the map stored
-    // in `stream_factory_`. Includes all known aliases, e.g. from A, AAAA, or
+    // in `session_pool_`. Includes all known aliases, e.g. from A, AAAA, or
     // HTTPS, not just from the address used for the connection, in no
     // particular order.
     const std::set<std::string>& GetDnsAliasesForSessionKey(
@@ -546,7 +546,7 @@ class NET_EXPORT_PRIVATE QuicChromiumClientSession
   };
 
   // Constructs a new session which will own |connection|, but not
-  // |stream_factory|, which must outlive this session.
+  // |session_pool|, which must outlive this session.
   // TODO(rch): decouple the factory from the session via a Delegate interface.
   //
   // If |require_confirmation| is true, the returned session will wait for a
@@ -557,7 +557,7 @@ class NET_EXPORT_PRIVATE QuicChromiumClientSession
   QuicChromiumClientSession(
       quic::QuicConnection* connection,
       std::unique_ptr<DatagramClientSocket> socket,
-      QuicStreamFactory* stream_factory,
+      QuicSessionPool* session_pool,
       QuicCryptoClientStreamFactory* crypto_client_stream_factory,
       const quic::QuicClock* clock,
       TransportSecurityState* transport_security_state,
@@ -875,7 +875,7 @@ class NET_EXPORT_PRIVATE QuicChromiumClientSession
   bool require_confirmation() const { return require_confirmation_; }
 
   // Retrieves any DNS aliases for the given session key from the map stored
-  // in `stream_factory_`. Includes all known aliases, e.g. from A, AAAA, or
+  // in `session_pool_`. Includes all known aliases, e.g. from A, AAAA, or
   // HTTPS, not just from the address used for the connection, in no particular
   // order.
   const std::set<std::string>& GetDnsAliasesForSessionKey(
@@ -1052,7 +1052,7 @@ class NET_EXPORT_PRIVATE QuicChromiumClientSession
   std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_;
 
   std::unique_ptr<quic::QuicCryptoClientStream> crypto_stream_;
-  raw_ptr<QuicStreamFactory> stream_factory_;
+  raw_ptr<QuicSessionPool> session_pool_;
   base::ObserverList<ConnectivityObserver> connectivity_observer_list_;
   std::vector<std::unique_ptr<QuicChromiumPacketReader>> packet_readers_;
   raw_ptr<TransportSecurityState> transport_security_state_;

net/quic/quic_crypto_client_config_handle.h

@@ -22,7 +22,7 @@ namespace net {
 //
 // This ownership model is used instead of refcounting for stronger safety
 // guarantees, and because the underlying QuicCryptoClientConfig depends on
-// other network objects that may be deleted after the QuicStreamFactory.
+// other network objects that may be deleted after the QuicSessionPool.
 class NET_EXPORT_PRIVATE QuicCryptoClientConfigHandle {
  public:
   QuicCryptoClientConfigHandle& operator=(const QuicCryptoClientConfigHandle&) =

net/quic/quic_http_stream.cc

@@ -712,7 +712,7 @@ void QuicHttpStream::SetResponseStatus(int response_status) {
 int QuicHttpStream::ComputeResponseStatus() const {
   DCHECK(!has_response_status_);
 
-  // If the handshake has failed this will be handled by the QuicStreamFactory
+  // If the handshake has failed this will be handled by the QuicSessionPool
   // and HttpStreamFactory to mark QUIC as broken if TCP is actually working.
   if (!quic_session()->OneRttKeysAvailable()) {
     return ERR_QUIC_HANDSHAKE_FAILED;

net/quic/quic_http_stream_test.cc

@@ -48,7 +48,7 @@
 #include "net/quic/quic_crypto_client_config_handle.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_server_info.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/quic/quic_test_packet_maker.h"
 #include "net/quic/quic_test_packet_printer.h"
 #include "net/quic/test_quic_crypto_client_config_handle.h"

net/quic/quic_network_transaction_unittest.cc

@@ -57,7 +57,7 @@
 #include "net/quic/quic_context.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/quic/quic_http_utils.h"
-#include "net/quic/quic_stream_factory_peer.h"
+#include "net/quic/quic_session_pool_peer.h"
 #include "net/quic/quic_test_packet_maker.h"
 #include "net/quic/test_task_runner.h"
 #include "net/socket/client_socket_factory.h"
@@ -575,8 +575,8 @@ class QuicNetworkTransactionTest
 
     session_ =
         std::make_unique<HttpNetworkSession>(session_params_, session_context_);
-    session_->quic_stream_factory()
-        ->set_is_quic_known_to_work_on_current_network(true);
+    session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
+        true);
     SpdySessionPoolPeer spdy_pool_peer(session_->spdy_session_pool());
     spdy_pool_peer.SetEnableSendingInitialData(false);
   }
@@ -2518,8 +2518,8 @@ TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -2698,8 +2698,8 @@ TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken2) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -3395,8 +3395,8 @@ TEST_P(QuicNetworkTransactionTest,
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   CreateSession();
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -3539,8 +3539,8 @@ TEST_P(QuicNetworkTransactionTest, UseExistingAlternativeServiceForQuic) {
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -3601,8 +3601,8 @@ TEST_P(QuicNetworkTransactionTest, PoolByOrigin) {
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -3694,8 +3694,8 @@ TEST_P(QuicNetworkTransactionTest, PoolByDestination) {
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -3827,8 +3827,8 @@ TEST_P(QuicNetworkTransactionTest,
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -4333,7 +4333,7 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
                                            "");
 
   CreateSession();
-  session_->quic_stream_factory()->set_is_quic_known_to_work_on_current_network(
+  session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
       false);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
@@ -4407,8 +4407,8 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithTooEarlyResponse) {
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -4492,8 +4492,8 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithMultipleTooEarlyResponse) {
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
                                                  context_.clock()));
 
@@ -4556,7 +4556,7 @@ TEST_P(QuicNetworkTransactionTest,
                                            "");
 
   CreateSession();
-  session_->quic_stream_factory()->set_is_quic_known_to_work_on_current_network(
+  session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
       false);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
@@ -4620,7 +4620,7 @@ TEST_P(QuicNetworkTransactionTest,
                                            "");
 
   CreateSession();
-  session_->quic_stream_factory()->set_is_quic_known_to_work_on_current_network(
+  session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
       false);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
@@ -4685,7 +4685,7 @@ TEST_P(QuicNetworkTransactionTest, RstStreamErrorHandling) {
                                            "");
 
   CreateSession();
-  session_->quic_stream_factory()->set_is_quic_known_to_work_on_current_network(
+  session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
       false);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
@@ -4755,7 +4755,7 @@ TEST_P(QuicNetworkTransactionTest, RstStreamBeforeHeaders) {
                                            "");
 
   CreateSession();
-  session_->quic_stream_factory()->set_is_quic_known_to_work_on_current_network(
+  session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
       false);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
@@ -4952,8 +4952,8 @@ TEST_P(QuicNetworkTransactionTest, DelayTCPOnStartWithQuicSupportOnSameIP) {
   // No HTTP data is mocked as TCP job never starts in this case.
 
   CreateSession();
-  // QuicStreamFactory by default requires confirmation on construction.
-  session_->quic_stream_factory()->set_is_quic_known_to_work_on_current_network(
+  // QuicSessionPool by default requires confirmation on construction.
+  session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
       false);
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
@@ -5023,7 +5023,7 @@ TEST_P(QuicNetworkTransactionTest,
   // No HTTP data is mocked as TCP job will be delayed and never starts.
 
   CreateSession();
-  session_->quic_stream_factory()->set_is_quic_known_to_work_on_current_network(
+  session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
       false);
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
 
@@ -5075,7 +5075,7 @@ TEST_P(QuicNetworkTransactionTest, NetErrorDetailsSetBeforeHandshake) {
   // Require handshake confirmation to ensure that no QUIC streams are
   // created, and to ensure that the TCP job does not wait for the QUIC
   // job to fail before it starts.
-  session_->quic_stream_factory()->set_is_quic_known_to_work_on_current_network(
+  session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
       false);
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
@@ -5523,8 +5523,8 @@ TEST_P(QuicNetworkTransactionTest, MaxRetriesAfterAsyncNoBufferSpace) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  QuicStreamFactoryPeer::SetTaskRunner(session_->quic_stream_factory(),
-                                       quic_task_runner_.get());
+  QuicSessionPoolPeer::SetTaskRunner(session_->quic_session_pool(),
+                                     quic_task_runner_.get());
 
   quic::QuicTime start = context_.clock()->Now();
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
@@ -5561,8 +5561,8 @@ TEST_P(QuicNetworkTransactionTest, MaxRetriesAfterSynchronousNoBufferSpace) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  QuicStreamFactoryPeer::SetTaskRunner(session_->quic_stream_factory(),
-                                       quic_task_runner_.get());
+  QuicSessionPoolPeer::SetTaskRunner(session_->quic_session_pool(),
+                                     quic_task_runner_.get());
 
   quic::QuicTime start = context_.clock()->Now();
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
@@ -5798,8 +5798,8 @@ class QuicNetworkTransactionWithDestinationTest
 
     session_ =
         std::make_unique<HttpNetworkSession>(session_params, session_context);
-    session_->quic_stream_factory()
-        ->set_is_quic_known_to_work_on_current_network(false);
+    session_->quic_session_pool()->set_is_quic_known_to_work_on_current_network(
+        false);
   }
 
   void TearDown() override {
@@ -6097,8 +6097,8 @@ TEST_P(QuicNetworkTransactionWithDestinationTest, PoolIfCertificateValid) {
 
   auto quic_task_runner =
       base::MakeRefCounted<TestTaskRunner>(context_.mock_clock());
-  QuicStreamFactoryPeer::SetAlarmFactory(
-      session_->quic_stream_factory(),
+  QuicSessionPoolPeer::SetAlarmFactory(
+      session_->quic_session_pool(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner.get(),
                                                  context_.clock()));
 

net/quic/quic_proxy_client_socket_unittest.cc

@@ -43,7 +43,7 @@
 #include "net/quic/quic_crypto_client_config_handle.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_server_info.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/quic/quic_test_packet_maker.h"
 #include "net/quic/test_quic_crypto_client_config_handle.h"
 #include "net/quic/test_task_runner.h"

net/quic/quic_session_pool.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef NET_QUIC_QUIC_STREAM_FACTORY_H_
-#define NET_QUIC_QUIC_STREAM_FACTORY_H_
+#ifndef NET_QUIC_QUIC_SESSION_POOL_H_
+#define NET_QUIC_QUIC_SESSION_POOL_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -77,7 +77,7 @@ class NetworkAnonymizationKey;
 class QuicChromiumConnectionHelper;
 class QuicCryptoClientStreamFactory;
 class QuicServerInfo;
-class QuicStreamFactory;
+class QuicSessionPool;
 class QuicContext;
 class SCTAuditingDelegate;
 class SocketPerformanceWatcherFactory;
@@ -85,7 +85,7 @@ class SocketTag;
 class TransportSecurityState;
 
 namespace test {
-class QuicStreamFactoryPeer;
+class QuicSessionPoolPeer;
 }  // namespace test
 
 // Maximum number of not currently in use QuicCryptoClientConfig that can be
@@ -124,15 +124,15 @@ enum CreateSessionFailure {
 
 // Encapsulates a pending request for a QuicChromiumClientSession.
 // If the request is still pending when it is destroyed, it will
-// cancel the request with the factory.
-class NET_EXPORT_PRIVATE QuicStreamRequest {
+// cancel the request with the pool.
+class NET_EXPORT_PRIVATE QuicSessionRequest {
  public:
-  explicit QuicStreamRequest(QuicStreamFactory* factory);
+  explicit QuicSessionRequest(QuicSessionPool* pool);
 
-  QuicStreamRequest(const QuicStreamRequest&) = delete;
-  QuicStreamRequest& operator=(const QuicStreamRequest&) = delete;
+  QuicSessionRequest(const QuicSessionRequest&) = delete;
+  QuicSessionRequest& operator=(const QuicSessionRequest&) = delete;
 
-  ~QuicStreamRequest();
+  ~QuicSessionRequest();
 
   // |cert_verify_flags| is bitwise OR'd of CertVerifier::VerifyFlags and it is
   // passed to CertVerifier::Verify.
@@ -167,11 +167,11 @@ class NET_EXPORT_PRIVATE QuicStreamRequest {
   // ERR_IO_PENDING.
   bool WaitForHostResolution(CompletionOnceCallback callback);
 
-  // Tells QuicStreamRequest it should expect OnHostResolutionComplete()
+  // Tells QuicSessionRequest it should expect OnHostResolutionComplete()
   // to be called in the future.
   void ExpectOnHostResolution();
 
-  // Will be called by the associated QuicStreamFactory::Job when host
+  // Will be called by the associated QuicSessionPool::Job when host
   // resolution completes asynchronously after Request().
   void OnHostResolutionComplete(int rv);
 
@@ -183,11 +183,11 @@ class NET_EXPORT_PRIVATE QuicStreamRequest {
   // `callback` will be run with ERR_IO_PENDING.
   bool WaitForQuicSessionCreation(CompletionOnceCallback callback);
 
-  // Tells QuicStreamRequest it should expect OnQuicSessionCreationComplete()
+  // Tells QuicSessionRequest it should expect OnQuicSessionCreationComplete()
   // to be called in the future.
   void ExpectQuicSessionCreation();
 
-  // Will be called by the associated QuicStreamFactory::Job when session
+  // Will be called by the associated QuicSessionPool::Job when session
   // creation completes asynchronously after Request().
   void OnQuicSessionCreationComplete(int rv);
 
@@ -198,7 +198,7 @@ class NET_EXPORT_PRIVATE QuicStreamRequest {
   // network.
   void OnConnectionFailedOnDefaultNetwork();
 
-  // Helper method that calls |factory_|'s GetTimeDelayForWaitingJob(). It
+  // Helper method that calls |pool_|'s GetTimeDelayForWaitingJob(). It
   // returns the amount of time waiting job should be delayed.
   base::TimeDelta GetTimeDelayForWaitingJob() const;
 
@@ -228,7 +228,7 @@ class NET_EXPORT_PRIVATE QuicStreamRequest {
       const url::SchemeHostPort& destination) const;
 
  private:
-  raw_ptr<QuicStreamFactory> factory_;
+  raw_ptr<QuicSessionPool> pool_;
   QuicSessionKey session_key_;
   NetLogWithSource net_log_;
   CompletionOnceCallback callback_;
@@ -247,8 +247,8 @@ class NET_EXPORT_PRIVATE QuicStreamRequest {
   CompletionOnceCallback create_session_callback_;
 };
 
-// A factory for fetching QuicChromiumClientSessions.
-class NET_EXPORT_PRIVATE QuicStreamFactory
+// Manages a pool of QuicChromiumClientSessions.
+class NET_EXPORT_PRIVATE QuicSessionPool
     : public NetworkChangeNotifier::IPAddressObserver,
       public NetworkChangeNotifier::NetworkObserver,
       public CertDatabase::Observer,
@@ -284,7 +284,7 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
     QuicSessionKey session_key_;
   };
 
-  QuicStreamFactory(
+  QuicSessionPool(
       NetLog* net_log,
       HostResolver* host_resolver,
       SSLConfigService* ssl_config_service,
@@ -297,10 +297,10 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
       QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
       QuicContext* context);
 
-  QuicStreamFactory(const QuicStreamFactory&) = delete;
-  QuicStreamFactory& operator=(const QuicStreamFactory&) = delete;
+  QuicSessionPool(const QuicSessionPool&) = delete;
+  QuicSessionPool& operator=(const QuicSessionPool&) = delete;
 
-  ~QuicStreamFactory() override;
+  ~QuicSessionPool() override;
 
   // Returns true if there is an existing session for |session_key| or if the
   // request can be pooled to an existing session to the IP address of
@@ -308,23 +308,23 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
   bool CanUseExistingSession(const QuicSessionKey& session_key,
                              const url::SchemeHostPort& destination) const;
 
-  // Fetches a QuicChromiumClientSession to |host_port_pair| which will be
-  // owned by |request|.
+  // Requests a QuicChromiumClientSession to |host_port_pair|, a handle for
+  // which will be owned by |request|.
   // If a matching session already exists, this method will return OK.  If no
   // matching session exists, this will return ERR_IO_PENDING and will invoke
   // OnRequestComplete asynchronously.
   // When |use_dns_aliases| is true, any DNS aliases found in host resolution
   // are stored in the |dns_aliases_by_session_key_| map. |use_dns_aliases|
   // should be false in the case of a proxy.
-  int Create(const QuicSessionKey& session_key,
-             url::SchemeHostPort destination,
-             quic::ParsedQuicVersion quic_version,
-             RequestPriority priority,
-             bool use_dns_aliases,
-             int cert_verify_flags,
-             const GURL& url,
-             const NetLogWithSource& net_log,
-             QuicStreamRequest* request);
+  int RequestSession(const QuicSessionKey& session_key,
+                     url::SchemeHostPort destination,
+                     quic::ParsedQuicVersion quic_version,
+                     RequestPriority priority,
+                     bool use_dns_aliases,
+                     int cert_verify_flags,
+                     const GURL& url,
+                     const NetLogWithSource& net_log,
+                     QuicSessionRequest* request);
 
   // Called by a session when it is going away and no more streams should be
   // created on it.
@@ -337,16 +337,17 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
   void OnBlackholeAfterHandshakeConfirmed(QuicChromiumClientSession* session);
 
   // Cancels a pending request.
-  void CancelRequest(QuicStreamRequest* request);
+  void CancelRequest(QuicSessionRequest* request);
 
   // Sets priority of a request.
-  void SetRequestPriority(QuicStreamRequest* request, RequestPriority priority);
+  void SetRequestPriority(QuicSessionRequest* request,
+                          RequestPriority priority);
 
   // Closes all current sessions with specified network, QUIC error codes.
   // It sends connection close packet when closing connections.
   void CloseAllSessions(int error, quic::QuicErrorCode quic_error);
 
-  base::Value QuicStreamFactoryInfoToValue() const;
+  base::Value QuicSessionPoolInfoToValue() const;
 
   // Delete cached state objects in |crypto_config_|. If |origin_filter| is not
   // null, only objects on matching origins will be deleted.
@@ -383,7 +384,7 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
   // handles::kInvalidNetworkHandle. This method calls
   // DatagramClientSocket::Connect and completes synchronously. Returns
   // net_error code.
-  // TODO(liza): Remove this once QuicStreamFactory::Job calls
+  // TODO(liza): Remove this once QuicSessionPool::Job calls
   // ConnectAndConfigureSocket.
   int ConfigureSocket(DatagramClientSocket* socket,
                       IPEndPoint addr,
@@ -454,8 +455,8 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
   class Job;
   class QuicCryptoClientConfigOwner;
   class CryptoClientConfigHandle;
-  friend class MockQuicStreamFactory;
-  friend class test::QuicStreamFactoryPeer;
+  friend class MockQuicSessionPool;
+  friend class test::QuicSessionPoolPeer;
 
   using SessionMap = std::map<QuicSessionKey, QuicChromiumClientSession*>;
   using SessionIdMap =
@@ -733,9 +734,9 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
   quic::DeterministicConnectionIdGenerator connection_id_generator_{
       quic::kQuicDefaultConnectionIdLength};
 
-  base::WeakPtrFactory<QuicStreamFactory> weak_factory_{this};
+  base::WeakPtrFactory<QuicSessionPool> weak_factory_{this};
 };
 
 }  // namespace net
 
-#endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_
+#endif  // NET_QUIC_QUIC_SESSION_POOL_H_

net/quic/quic_session_pool_fuzzer.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 
 #include <fuzzer/FuzzedDataProvider.h>
 
@@ -137,15 +137,13 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
     }
   }
 
-  std::unique_ptr<QuicStreamFactory> factory =
-      std::make_unique<QuicStreamFactory>(
-          env->net_log.net_log(), host_resolver.get(),
-          env->ssl_config_service.get(), &socket_factory,
-          &http_server_properties, env->cert_verifier.get(),
-          &env->transport_security_state, nullptr, nullptr,
-          &env->crypto_client_stream_factory, &env->quic_context);
+  std::unique_ptr<QuicSessionPool> factory = std::make_unique<QuicSessionPool>(
+      env->net_log.net_log(), host_resolver.get(),
+      env->ssl_config_service.get(), &socket_factory, &http_server_properties,
+      env->cert_verifier.get(), &env->transport_security_state, nullptr,
+      nullptr, &env->crypto_client_stream_factory, &env->quic_context);
 
-  QuicStreamRequest request(factory.get());
+  QuicSessionRequest request(factory.get());
   TestCompletionCallback callback;
   NetErrorDetails net_error_details;
   quic::ParsedQuicVersionVector versions = AllSupportedQuicVersions();

net/quic/quic_session_pool_peer.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/quic/quic_stream_factory_peer.h"
+#include "net/quic/quic_session_pool_peer.h"
 
 #include <string>
 #include <vector>
@@ -14,7 +14,7 @@
 #include "net/quic/platform/impl/quic_chromium_clock.h"
 #include "net/quic/quic_chromium_client_session.h"
 #include "net/quic/quic_http_stream.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "net/third_party/quiche/src/quiche/quic/core/crypto/quic_crypto_client_config.h"
@@ -24,20 +24,20 @@ using std::string;
 
 namespace net::test {
 
-const quic::QuicConfig* QuicStreamFactoryPeer::GetConfig(
-    QuicStreamFactory* factory) {
+const quic::QuicConfig* QuicSessionPoolPeer::GetConfig(
+    QuicSessionPool* factory) {
   return &factory->config_;
 }
 
 std::unique_ptr<QuicCryptoClientConfigHandle>
-QuicStreamFactoryPeer::GetCryptoConfig(
-    QuicStreamFactory* factory,
+QuicSessionPoolPeer::GetCryptoConfig(
+    QuicSessionPool* factory,
     const NetworkAnonymizationKey& network_anonymization_key) {
   return factory->GetCryptoConfigForTesting(network_anonymization_key);
 }
 
-bool QuicStreamFactoryPeer::HasActiveSession(
-    QuicStreamFactory* factory,
+bool QuicSessionPoolPeer::HasActiveSession(
+    QuicSessionPool* factory,
     const quic::QuicServerId& server_id,
     const NetworkAnonymizationKey& network_anonymization_key,
     bool require_dns_https_alpn) {
@@ -46,32 +46,31 @@ bool QuicStreamFactoryPeer::HasActiveSession(
                      SecureDnsPolicy::kAllow, require_dns_https_alpn));
 }
 
-bool QuicStreamFactoryPeer::HasActiveJob(QuicStreamFactory* factory,
-                                         const quic::QuicServerId& server_id,
-                                         bool require_dns_https_alpn) {
+bool QuicSessionPoolPeer::HasActiveJob(QuicSessionPool* factory,
+                                       const quic::QuicServerId& server_id,
+                                       bool require_dns_https_alpn) {
   return factory->HasActiveJob(
       QuicSessionKey(server_id, SocketTag(), NetworkAnonymizationKey(),
                      SecureDnsPolicy::kAllow, require_dns_https_alpn));
 }
 
 // static
-QuicChromiumClientSession* QuicStreamFactoryPeer::GetPendingSession(
-    QuicStreamFactory* factory,
+QuicChromiumClientSession* QuicSessionPoolPeer::GetPendingSession(
+    QuicSessionPool* factory,
     const quic::QuicServerId& server_id,
     url::SchemeHostPort destination) {
   QuicSessionKey session_key(server_id, SocketTag(), NetworkAnonymizationKey(),
                              SecureDnsPolicy::kAllow,
                              /*require_dns_https_alpn=*/false);
-  QuicStreamFactory::QuicSessionAliasKey key(std::move(destination),
-                                             session_key);
+  QuicSessionPool::QuicSessionAliasKey key(std::move(destination), session_key);
   DCHECK(factory->HasActiveJob(session_key));
   DCHECK_EQ(factory->all_sessions_.size(), 1u);
   DCHECK(key == factory->all_sessions_.begin()->second);
   return factory->all_sessions_.begin()->first;
 }
 
-QuicChromiumClientSession* QuicStreamFactoryPeer::GetActiveSession(
-    QuicStreamFactory* factory,
+QuicChromiumClientSession* QuicSessionPoolPeer::GetActiveSession(
+    QuicSessionPool* factory,
     const quic::QuicServerId& server_id,
     const NetworkAnonymizationKey& network_anonymization_key,
     bool require_dns_https_alpn) {
@@ -81,15 +80,15 @@ QuicChromiumClientSession* QuicStreamFactoryPeer::GetActiveSession(
   return factory->active_sessions_[session_key];
 }
 
-bool QuicStreamFactoryPeer::HasLiveSession(QuicStreamFactory* factory,
-                                           url::SchemeHostPort destination,
-                                           const quic::QuicServerId& server_id,
-                                           bool require_dns_https_alpn) {
+bool QuicSessionPoolPeer::HasLiveSession(QuicSessionPool* factory,
+                                         url::SchemeHostPort destination,
+                                         const quic::QuicServerId& server_id,
+                                         bool require_dns_https_alpn) {
   QuicSessionKey session_key =
       QuicSessionKey(server_id, SocketTag(), NetworkAnonymizationKey(),
                      SecureDnsPolicy::kAllow, require_dns_https_alpn);
-  QuicStreamFactory::QuicSessionAliasKey alias_key(std::move(destination),
-                                                   session_key);
+  QuicSessionPool::QuicSessionAliasKey alias_key(std::move(destination),
+                                                 session_key);
   for (const auto& it : factory->all_sessions_) {
     if (it.second == alias_key) {
       return true;
@@ -98,8 +97,8 @@ bool QuicStreamFactoryPeer::HasLiveSession(QuicStreamFactory* factory,
   return false;
 }
 
-bool QuicStreamFactoryPeer::IsLiveSession(QuicStreamFactory* factory,
-                                          QuicChromiumClientSession* session) {
+bool QuicSessionPoolPeer::IsLiveSession(QuicSessionPool* factory,
+                                        QuicChromiumClientSession* session) {
   for (const auto& it : factory->all_sessions_) {
     if (it.first == session) {
       return true;
@@ -108,43 +107,43 @@ bool QuicStreamFactoryPeer::IsLiveSession(QuicStreamFactory* factory,
   return false;
 }
 
-void QuicStreamFactoryPeer::SetTaskRunner(
-    QuicStreamFactory* factory,
+void QuicSessionPoolPeer::SetTaskRunner(
+    QuicSessionPool* factory,
     base::SequencedTaskRunner* task_runner) {
   factory->task_runner_ = task_runner;
 }
 
-void QuicStreamFactoryPeer::SetTickClock(QuicStreamFactory* factory,
-                                         const base::TickClock* tick_clock) {
+void QuicSessionPoolPeer::SetTickClock(QuicSessionPool* factory,
+                                       const base::TickClock* tick_clock) {
   factory->tick_clock_ = tick_clock;
 }
 
-quic::QuicTime::Delta QuicStreamFactoryPeer::GetPingTimeout(
-    QuicStreamFactory* factory) {
+quic::QuicTime::Delta QuicSessionPoolPeer::GetPingTimeout(
+    QuicSessionPool* factory) {
   return factory->ping_timeout_;
 }
 
-void QuicStreamFactoryPeer::SetYieldAfterPackets(QuicStreamFactory* factory,
-                                                 int yield_after_packets) {
+void QuicSessionPoolPeer::SetYieldAfterPackets(QuicSessionPool* factory,
+                                               int yield_after_packets) {
   factory->yield_after_packets_ = yield_after_packets;
 }
 
-void QuicStreamFactoryPeer::SetYieldAfterDuration(
-    QuicStreamFactory* factory,
+void QuicSessionPoolPeer::SetYieldAfterDuration(
+    QuicSessionPool* factory,
     quic::QuicTime::Delta yield_after_duration) {
   factory->yield_after_duration_ = yield_after_duration;
 }
 
-bool QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(
-    QuicStreamFactory* factory,
+bool QuicSessionPoolPeer::CryptoConfigCacheIsEmpty(
+    QuicSessionPool* factory,
     const quic::QuicServerId& quic_server_id,
     const NetworkAnonymizationKey& network_anonymization_key) {
   return factory->CryptoConfigCacheIsEmptyForTesting(quic_server_id,
                                                      network_anonymization_key);
 }
 
-void QuicStreamFactoryPeer::CacheDummyServerConfig(
-    QuicStreamFactory* factory,
+void QuicSessionPoolPeer::CacheDummyServerConfig(
+    QuicSessionPool* factory,
     const quic::QuicServerId& quic_server_id,
     const NetworkAnonymizationKey& network_anonymization_key) {
   // Minimum SCFG that passes config validation checks.
@@ -182,13 +181,12 @@ void QuicStreamFactoryPeer::CacheDummyServerConfig(
   DCHECK(!cached->certs().empty());
 }
 
-size_t QuicStreamFactoryPeer::GetNumDegradingSessions(
-    QuicStreamFactory* factory) {
+size_t QuicSessionPoolPeer::GetNumDegradingSessions(QuicSessionPool* factory) {
   return factory->connectivity_monitor_.GetNumDegradingSessions();
 }
 
-void QuicStreamFactoryPeer::SetAlarmFactory(
-    QuicStreamFactory* factory,
+void QuicSessionPoolPeer::SetAlarmFactory(
+    QuicSessionPool* factory,
     std::unique_ptr<quic::QuicAlarmFactory> alarm_factory) {
   factory->alarm_factory_ = std::move(alarm_factory);
 }

net/quic/quic_session_pool_peer.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef NET_QUIC_QUIC_STREAM_FACTORY_PEER_H_
-#define NET_QUIC_QUIC_STREAM_FACTORY_PEER_H_
+#ifndef NET_QUIC_QUIC_SESSION_POOL_PEER_H_
+#define NET_QUIC_QUIC_SESSION_POOL_PEER_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -30,71 +30,71 @@ namespace net {
 class NetLogWithSource;
 class QuicChromiumClientSession;
 class QuicCryptoClientConfigHandle;
-class QuicStreamFactory;
+class QuicSessionPool;
 
 namespace test {
 
-class QuicStreamFactoryPeer {
+class QuicSessionPoolPeer {
  public:
-  QuicStreamFactoryPeer(const QuicStreamFactoryPeer&) = delete;
-  QuicStreamFactoryPeer& operator=(const QuicStreamFactoryPeer&) = delete;
+  QuicSessionPoolPeer(const QuicSessionPoolPeer&) = delete;
+  QuicSessionPoolPeer& operator=(const QuicSessionPoolPeer&) = delete;
 
-  static const quic::QuicConfig* GetConfig(QuicStreamFactory* factory);
+  static const quic::QuicConfig* GetConfig(QuicSessionPool* factory);
 
   static std::unique_ptr<QuicCryptoClientConfigHandle> GetCryptoConfig(
-      QuicStreamFactory* factory,
+      QuicSessionPool* factory,
       const NetworkAnonymizationKey& network_anonymization_key);
 
   static bool HasActiveSession(
-      QuicStreamFactory* factory,
+      QuicSessionPool* factory,
       const quic::QuicServerId& server_id,
       const NetworkAnonymizationKey& network_anonymization_key =
           NetworkAnonymizationKey(),
       bool require_dns_https_alpn = false);
 
-  static bool HasActiveJob(QuicStreamFactory* factory,
+  static bool HasActiveJob(QuicSessionPool* factory,
                            const quic::QuicServerId& server_id,
                            bool require_dns_https_alpn = false);
 
   static QuicChromiumClientSession* GetPendingSession(
-      QuicStreamFactory* factory,
+      QuicSessionPool* factory,
       const quic::QuicServerId& server_id,
       url::SchemeHostPort destination);
 
   static QuicChromiumClientSession* GetActiveSession(
-      QuicStreamFactory* factory,
+      QuicSessionPool* factory,
       const quic::QuicServerId& server_id,
       const NetworkAnonymizationKey& network_anonymization_key =
           NetworkAnonymizationKey(),
       bool require_dns_https_alpn = false);
 
-  static bool HasLiveSession(QuicStreamFactory* factory,
+  static bool HasLiveSession(QuicSessionPool* factory,
                              url::SchemeHostPort destination,
                              const quic::QuicServerId& server_id,
                              bool require_dns_https_alpn = false);
 
-  static bool IsLiveSession(QuicStreamFactory* factory,
+  static bool IsLiveSession(QuicSessionPool* factory,
                             QuicChromiumClientSession* session);
 
-  static void SetTickClock(QuicStreamFactory* factory,
+  static void SetTickClock(QuicSessionPool* factory,
                            const base::TickClock* tick_clock);
 
-  static void SetTaskRunner(QuicStreamFactory* factory,
+  static void SetTaskRunner(QuicSessionPool* factory,
                             base::SequencedTaskRunner* task_runner);
 
-  static quic::QuicTime::Delta GetPingTimeout(QuicStreamFactory* factory);
+  static quic::QuicTime::Delta GetPingTimeout(QuicSessionPool* factory);
 
-  static void SetYieldAfterPackets(QuicStreamFactory* factory,
+  static void SetYieldAfterPackets(QuicSessionPool* factory,
                                    int yield_after_packets);
 
-  static void SetYieldAfterDuration(QuicStreamFactory* factory,
+  static void SetYieldAfterDuration(QuicSessionPool* factory,
                                     quic::QuicTime::Delta yield_after_duration);
 
-  static size_t GetNumberOfActiveJobs(QuicStreamFactory* factory,
+  static size_t GetNumberOfActiveJobs(QuicSessionPool* factory,
                                       const quic::QuicServerId& server_id);
 
   static bool CryptoConfigCacheIsEmpty(
-      QuicStreamFactory* factory,
+      QuicSessionPool* factory,
       const quic::QuicServerId& quic_server_id,
       const NetworkAnonymizationKey& network_anonymization_key);
 
@@ -102,18 +102,18 @@ class QuicStreamFactoryPeer {
   // onto a QuicCryptoClientConfigHandle for the corresponding
   // |network_anonymization_key|.
   static void CacheDummyServerConfig(
-      QuicStreamFactory* factory,
+      QuicSessionPool* factory,
       const quic::QuicServerId& quic_server_id,
       const NetworkAnonymizationKey& network_anonymization_key);
 
-  static size_t GetNumDegradingSessions(QuicStreamFactory* factory);
+  static size_t GetNumDegradingSessions(QuicSessionPool* factory);
 
   static void SetAlarmFactory(
-      QuicStreamFactory* factory,
+      QuicSessionPool* factory,
       std::unique_ptr<quic::QuicAlarmFactory> alarm_factory);
 };
 
 }  // namespace test
 }  // namespace net
 
-#endif  // NET_QUIC_QUIC_STREAM_FACTORY_PEER_H_
+#endif  // NET_QUIC_QUIC_SESSION_POOL_PEER_H_

net/socket/client_socket_pool_base_unittest.cc

@@ -702,7 +702,7 @@ class ClientSocketPoolBaseTest : public TestWithTaskEnvironment {
       /*http_auth_handler_factory=*/nullptr,
       /*spdy_session_pool=*/nullptr,
       /*quic_supported_versions=*/nullptr,
-      /*quic_stream_factory=*/nullptr,
+      /*quic_session_pool=*/nullptr,
       /*proxy_delegate=*/nullptr,
       /*http_user_agent_settings=*/nullptr,
       /*ssl_client_context=*/nullptr,

net/socket/connect_job.cc

@@ -34,7 +34,7 @@ CommonConnectJobParams::CommonConnectJobParams(
     HttpAuthHandlerFactory* http_auth_handler_factory,
     SpdySessionPool* spdy_session_pool,
     const quic::ParsedQuicVersionVector* quic_supported_versions,
-    QuicStreamFactory* quic_stream_factory,
+    QuicSessionPool* quic_session_pool,
     ProxyDelegate* proxy_delegate,
     const HttpUserAgentSettings* http_user_agent_settings,
     SSLClientContext* ssl_client_context,
@@ -53,7 +53,7 @@ CommonConnectJobParams::CommonConnectJobParams(
       http_auth_handler_factory(http_auth_handler_factory),
       spdy_session_pool(spdy_session_pool),
       quic_supported_versions(quic_supported_versions),
-      quic_stream_factory(quic_stream_factory),
+      quic_session_pool(quic_session_pool),
       proxy_delegate(proxy_delegate),
       http_user_agent_settings(http_user_agent_settings),
       ssl_client_context(ssl_client_context),

net/socket/connect_job.h

@@ -46,7 +46,7 @@ class NetLog;
 class NetLogWithSource;
 class NetworkQualityEstimator;
 class ProxyDelegate;
-class QuicStreamFactory;
+class QuicSessionPool;
 class SocketPerformanceWatcherFactory;
 class SocketTag;
 class SpdySessionPool;
@@ -69,7 +69,7 @@ struct NET_EXPORT_PRIVATE CommonConnectJobParams {
       HttpAuthHandlerFactory* http_auth_handler_factory,
       SpdySessionPool* spdy_session_pool,
       const quic::ParsedQuicVersionVector* quic_supported_versions,
-      QuicStreamFactory* quic_stream_factory,
+      QuicSessionPool* quic_session_pool,
       ProxyDelegate* proxy_delegate,
       const HttpUserAgentSettings* http_user_agent_settings,
       SSLClientContext* ssl_client_context,
@@ -93,7 +93,7 @@ struct NET_EXPORT_PRIVATE CommonConnectJobParams {
   raw_ptr<HttpAuthHandlerFactory> http_auth_handler_factory;
   raw_ptr<SpdySessionPool> spdy_session_pool;
   raw_ptr<const quic::ParsedQuicVersionVector> quic_supported_versions;
-  raw_ptr<QuicStreamFactory> quic_stream_factory;
+  raw_ptr<QuicSessionPool> quic_session_pool;
   raw_ptr<ProxyDelegate> proxy_delegate;
   raw_ptr<const HttpUserAgentSettings> http_user_agent_settings;
   raw_ptr<SSLClientContext> ssl_client_context;

net/socket/connect_job_factory_unittest.cc

@@ -179,7 +179,7 @@ class ConnectJobFactoryTest : public TestWithTaskEnvironment {
       /*http_auth_handler_factory=*/nullptr,
       /*spdy_session_pool=*/nullptr,
       /*quic_supported_versions=*/nullptr,
-      /*quic_stream_factory=*/nullptr,
+      /*quic_session_pool=*/nullptr,
       /*proxy_delegate=*/nullptr,
       /*http_user_agent_settings=*/nullptr,
       /*ssl_client_context=*/nullptr,

net/socket/connect_job_unittest.cc

@@ -100,7 +100,7 @@ class ConnectJobTest : public testing::Test {
             /*http_auth_handler_factory=*/nullptr,
             /*spdy_session_pool=*/nullptr,
             /*quic_supported_versions=*/nullptr,
-            /*quic_stream_factory=*/nullptr,
+            /*quic_session_pool=*/nullptr,
             /*proxy_delegate=*/nullptr,
             /*http_user_agent_settings=*/nullptr,
             /*ssl_client_context=*/nullptr,

net/socket/socks_connect_job_unittest.cc

@@ -57,7 +57,7 @@ class SOCKSConnectJobTest : public testing::Test, public WithTaskEnvironment {
             /*http_auth_handler_factory=*/nullptr,
             /*spdy_session_pool=*/nullptr,
             /*quic_supported_versions=*/nullptr,
-            /*quic_stream_factory=*/nullptr,
+            /*quic_session_pool=*/nullptr,
             /*proxy_delegate=*/nullptr,
             /*http_user_agent_settings=*/nullptr,
             /*ssl_client_context=*/nullptr,

net/socket/transport_connect_job_unittest.cc

@@ -59,7 +59,7 @@ class TransportConnectJobTest : public WithTaskEnvironment,
             /*http_auth_handler_factory=*/nullptr,
             /*spdy_session_pool=*/nullptr,
             /*quic_supported_versions=*/nullptr,
-            /*quic_stream_factory=*/nullptr,
+            /*quic_session_pool=*/nullptr,
             /*proxy_delegate=*/nullptr,
             /*http_user_agent_settings=*/nullptr,
             &ssl_client_context_,

net/socket/websocket_transport_client_socket_pool_unittest.cc

@@ -96,7 +96,7 @@ class WebSocketTransportClientSocketPoolTest : public TestWithTaskEnvironment {
             /*http_auth_handler_factory=*/nullptr,
             /*spdy_session_pool=*/nullptr,
             /*quic_supported_versions=*/nullptr,
-            /*quic_stream_factory=*/nullptr,
+            /*quic_session_pool=*/nullptr,
             /*proxy_delegate=*/nullptr,
             /*http_user_agent_settings=*/nullptr,
             /*ssl_client_context=*/nullptr,

net/url_request/url_request_context_builder.cc

@@ -43,7 +43,7 @@
 #include "net/nqe/network_quality_estimator.h"
 #include "net/proxy_resolution/configured_proxy_resolution_service.h"
 #include "net/quic/quic_context.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/socket/network_binding_client_socket_factory.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/static_http_user_agent_settings.h"

net/websockets/websocket_basic_stream_test.cc

@@ -129,7 +129,7 @@ class WebSocketBasicStreamSocketTest : public TestWithTaskEnvironment {
             /*http_auth_handler_factory=*/nullptr,
             /*spdy_session_pool=*/nullptr,
             /*quic_supported_versions=*/nullptr,
-            /*quic_stream_factory=*/nullptr,
+            /*quic_session_pool=*/nullptr,
             /*proxy_delegate=*/nullptr,
             /*http_user_agent_settings=*/nullptr,
             /*ssl_client_context=*/nullptr,

net/websockets/websocket_handshake_stream_create_helper_test.cc

@@ -138,7 +138,7 @@ class MockClientSocketHandleFactory {
             /*http_auth_handler_factory=*/nullptr,
             /*spdy_session_pool=*/nullptr,
             /*quic_supported_versions=*/nullptr,
-            /*quic_stream_factory=*/nullptr,
+            /*quic_session_pool=*/nullptr,
             /*proxy_delegate=*/nullptr,
             /*http_user_agent_settings=*/nullptr,
             /*ssl_client_context=*/nullptr,

net/websockets/websocket_http3_handshake_stream.h

@@ -22,7 +22,7 @@
 #include "net/base/request_priority.h"
 #include "net/log/net_log_with_source.h"
 #include "net/quic/quic_chromium_client_session.h"
-#include "net/quic/quic_stream_factory.h"
+#include "net/quic/quic_session_pool.h"
 #include "net/third_party/quiche/src/quiche/spdy/core/http2_header_block.h"
 #include "net/websockets/websocket_basic_stream_adapters.h"
 #include "net/websockets/websocket_handshake_stream_base.h"

services/network/http_cache_data_remover.cc

@@ -79,7 +79,7 @@ std::unique_ptr<HttpCacheDataRemover> HttpCacheDataRemover::CreateAndStart(
   // TODO(crbug.com/817849): add a browser test to validate the QUIC information
   // is cleared.
   http_cache->GetSession()
-      ->quic_stream_factory()
+      ->quic_session_pool()
       ->ClearCachedStatesInCryptoConfig(remover->url_matcher_);
 
   net::CompletionOnceCallback callback =

testing/libfuzzer/getting_started_with_libfuzzer.md

@@ -121,7 +121,7 @@ create a new fuzzing test.
 **Note:** Most of the targets are small. They may perform one or a few API calls
 using the data provided by the fuzzing engine as an argument. However, fuzz
 targets may be more complex if a certain initialization procedure needs to be
-performed. [quic_stream_factory_fuzzer.cc] is a good example of a complex fuzz
+performed. [quic_session_pool_fuzzer.cc] is a good example of a complex fuzz
 target.
 ***
 
@@ -425,5 +425,5 @@ fuzzing engine.
 [code coverage report]: efficient_fuzzing.md#Code-coverage
 [upstream documentation]: https://github.com/google/fuzzing/blob/master/docs/split-inputs.md#fuzzed-data-provider
 [libFuzzer's output documentation]: http://llvm.org/docs/LibFuzzer.html#output
-[quic_stream_factory_fuzzer.cc]: https://cs.chromium.org/chromium/src/net/quic/quic_stream_factory_fuzzer.cc
+[quic_session_pool_fuzzer.cc]: https://cs.chromium.org/chromium/src/net/quic/quic_session_pool_fuzzer.cc
 [getting started guide here]: getting_started.md

tools/code_coverage/coverage_consts.py

@@ -257,7 +257,7 @@ FUZZERS_WITH_CORPORA = [
     'net_quic_crypto_framer_parse_message_fuzzer',
     'net_quic_framer_fuzzer',
     'net_quic_framer_process_data_packet_fuzzer',
-    'net_quic_stream_factory_fuzzer',
+    'net_quic_session_pool_fuzzer',
     'net_socks5_client_socket_fuzzer',
     'net_socks_client_socket_fuzzer',
     'net_structured_headers_fuzzer',

tools/metrics/histograms/metadata/net/enums.xml

@@ -117,7 +117,7 @@ chromium-metrics-reviews@google.com.
 
 <enum name="BrokenAlternateProtocolLocation">
   <int value="0" label="HTTP_STREAM_FACTORY_JOB"/>
-  <int value="1" label="QUIC_STREAM_FACTORY"/>
+  <int value="1" label="QUIC_SESSION_POOL"/>
   <int value="2" label="HTTP_STREAM_FACTORY_JOB_ALT"/>
   <int value="3" label="HTTP_STREAM_FACTORY_JOB_MAIN"/>
   <int value="4" label="QUIC_HTTP_STREAM"/>

tools/metrics/histograms/metadata/net/histograms.xml

@@ -2175,7 +2175,7 @@ chromium-metrics-reviews@google.com.
   <owner>dschinazi@chromium.org</owner>
   <owner>src/net/quic/OWNERS</owner>
   <summary>
-    The number of QUIC sessions when the QuicStreamFactory is destroyed.
+    The number of QUIC sessions when the QuicSessionPool is destroyed.
   </summary>
 </histogram>
 
@@ -4208,7 +4208,7 @@ chromium-metrics-reviews@google.com.
   <owner>renjietang@chromium.org</owner>
   <owner>src/net/quic/OWNERS</owner>
   <summary>
-    The time a QuicStreamFactory Job takes from host rersolution to connection
+    The time a QuicSessionPool Job takes from host rersolution to connection
     confirmation.
   </summary>
 </histogram>
@@ -4415,7 +4415,7 @@ chromium-metrics-reviews@google.com.
   <owner>src/net/quic/OWNERS</owner>
   <summary>
     Records, for initial socket created for each new QUIC connection, whether
-    the bound network matched the default network tracked by QuicStreamFactory.
+    the bound network matched the default network tracked by QuicSessionPool.
   </summary>
 </histogram>
 
@@ -4436,7 +4436,7 @@ chromium-metrics-reviews@google.com.
   <owner>renjietang@chromium.org</owner>
   <owner>src/net/quic/OWNERS</owner>
   <summary>
-    Log the location in QuicStreamFactory where QUIC_PROTOCOL_ERROR is reported.
+    Log the location in QuicSessionPool where QUIC_PROTOCOL_ERROR is reported.
   </summary>
 </histogram>