Throttle HttpStreamFactoryImpl::Job to HTTP/2-supported servers

net/http/http_stream_factory_impl_job_controller_unittest.cc

 // Copyright (c) 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_stream_factory_impl_job_controller.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 142 matching lines @@
     return job_controller->main_job_is_blocked_;
   }
   static bool main_job_is_resumed(
       HttpStreamFactoryImpl::JobController* job_controller) {
     return job_controller->main_job_is_resumed_;
   }
 };
 
 class HttpStreamFactoryImplJobControllerTest : public ::testing::Test {
  public:
-  HttpStreamFactoryImplJobControllerTest()
-      : session_deps_(ProxyService::CreateDirect()),
-        random_generator_(0),
-        client_maker_(HttpNetworkSession::Params().quic_supported_versions[0],
-                      0,
-                      &clock_,
-                      kServerHostname,
-                      Perspective::IS_CLIENT),
-        use_alternative_proxy_(false),
-        is_preconnect_(false),
-        enable_ip_based_pooling_(true),
-        enable_alternative_services_(true),
-        test_proxy_delegate_(nullptr) {
-    session_deps_.enable_quic = true;
-  }
+  HttpStreamFactoryImplJobControllerTest() { session_deps_.enable_quic = true; }
 
   void UseAlternativeProxy() {
     ASSERT_FALSE(test_proxy_delegate_);
     use_alternative_proxy_ = true;
   }
 
   void SetPreconnect() {
     ASSERT_FALSE(test_proxy_delegate_);
     is_preconnect_ = true;
   }
 
   void DisableIPBasedPooling() {
     ASSERT_FALSE(test_proxy_delegate_);
     enable_ip_based_pooling_ = false;
   }
 
   void DisableAlternativeServices() {
     ASSERT_FALSE(test_proxy_delegate_);
     enable_alternative_services_ = false;
   }
 
+  void SkipCreatingJobController() {
+    ASSERT_FALSE(job_controller_);
+    create_job_controller_ = false;
+  }
+
   void Initialize(const HttpRequestInfo& request_info) {
     ASSERT_FALSE(test_proxy_delegate_);
     auto test_proxy_delegate = base::MakeUnique<TestProxyDelegate>();
     test_proxy_delegate_ = test_proxy_delegate.get();
 
     test_proxy_delegate->set_alternative_proxy_server(
         ProxyServer::FromPacString("QUIC myproxy.org:443"));
     EXPECT_TRUE(test_proxy_delegate->alternative_proxy_server().is_quic());
     session_deps_.proxy_delegate = std::move(test_proxy_delegate);
 
@@ skipping 11 matching lines @@
         SpdySessionDependencies::CreateSessionParams(&session_deps_);
     HttpNetworkSession::Context session_context =
         SpdySessionDependencies::CreateSessionContext(&session_deps_);
 
     session_context.quic_crypto_client_stream_factory =
         &crypto_client_stream_factory_;
     session_context.quic_random = &random_generator_;
     session_ = base::MakeUnique<HttpNetworkSession>(params, session_context);
     factory_ =
         static_cast<HttpStreamFactoryImpl*>(session_->http_stream_factory());
-    job_controller_ = new HttpStreamFactoryImpl::JobController(
-        factory_, &request_delegate_, session_.get(), &job_factory_,
-        request_info, is_preconnect_, enable_ip_based_pooling_,
-        enable_alternative_services_, SSLConfig(), SSLConfig());
-    HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller_);
+    if (create_job_controller_) {
+      job_controller_ = new HttpStreamFactoryImpl::JobController(
+          factory_, &request_delegate_, session_.get(), &job_factory_,
+          request_info, is_preconnect_, enable_ip_based_pooling_,
+          enable_alternative_services_, SSLConfig(), SSLConfig());
+      HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller_);
+    }
   }
 
   TestProxyDelegate* test_proxy_delegate() const {
     return test_proxy_delegate_;
   }
 
   ~HttpStreamFactoryImplJobControllerTest() override {
     if (quic_data_) {
       EXPECT_TRUE(quic_data_->AllReadDataConsumed());
       EXPECT_TRUE(quic_data_->AllWriteDataConsumed());
@@ skipping 19 matching lines @@
     const AlternativeServiceInfoVector alternative_service_info_vector =
         session_->http_server_properties()->GetAlternativeServiceInfos(server);
     EXPECT_EQ(1u, alternative_service_info_vector.size());
     EXPECT_EQ(should_mark_broken,
               session_->http_server_properties()->IsAlternativeServiceBroken(
                   alternative_service_info_vector[0].alternative_service()));
   }
 
   TestJobFactory job_factory_;
   MockHttpStreamRequestDelegate request_delegate_;
-  SpdySessionDependencies session_deps_;
+  SpdySessionDependencies session_deps_{ProxyService::CreateDirect()};
   std::unique_ptr<HttpNetworkSession> session_;
-  HttpStreamFactoryImpl* factory_;
-  HttpStreamFactoryImpl::JobController* job_controller_;
+  HttpStreamFactoryImpl* factory_ = nullptr;
+  HttpStreamFactoryImpl::JobController* job_controller_ = nullptr;
   std::unique_ptr<HttpStreamFactoryImpl::Request> request_;
   std::unique_ptr<SequencedSocketData> tcp_data_;
   std::unique_ptr<test::MockQuicData> quic_data_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockClock clock_;
-  test::MockRandom random_generator_;
-  test::QuicTestPacketMaker client_maker_;
+  test::MockRandom random_generator_{0};
+  test::QuicTestPacketMaker client_maker_{
+      HttpNetworkSession::Params().quic_supported_versions[0], 0, &clock_,
+      kServerHostname, Perspective::IS_CLIENT};
 
  protected:
-  bool use_alternative_proxy_;
-  bool is_preconnect_;
-  bool enable_ip_based_pooling_;
-  bool enable_alternative_services_;
+  bool use_alternative_proxy_ = false;
+  bool is_preconnect_ = false;
+  bool enable_ip_based_pooling_ = true;
+  bool enable_alternative_services_ = true;
 
  private:
   // Not owned by |this|.
-  TestProxyDelegate* test_proxy_delegate_;
+  TestProxyDelegate* test_proxy_delegate_ = nullptr;
+  bool create_job_controller_ = true;
 
   DISALLOW_COPY_AND_ASSIGN(HttpStreamFactoryImplJobControllerTest);
 };
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, ProxyResolutionFailsSync) {
   ProxyConfig proxy_config;
   proxy_config.set_pac_url(GURL("http://fooproxyurl"));
   proxy_config.set_pac_mandatory(true);
   session_deps_.proxy_service.reset(new ProxyService(
       base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
@@ skipping 1251 matching lines @@
        PreconnectMultipleStreamsToH2Server) {
   tcp_data_ = base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
   tcp_data_->set_connect_data(MockConnect(ASYNC, OK));
   SetPreconnect();
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.example.com");
   Initialize(request_info);
 
+  // Sets server support Http/2.
   url::SchemeHostPort server(request_info.url);
-
-  // Sets server support Http/2.
   session_->http_server_properties()->SetSupportsSpdy(server, true);
 
   job_controller_->Preconnect(/*num_streams=*/5);
   // Only one job is started.
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->alternative_job());
   EXPECT_EQ(HttpStreamFactoryImpl::PRECONNECT,
             job_controller_->main_job()->job_type());
   // There is only 1 connect even though multiple streams were requested.
   EXPECT_EQ(1, HttpStreamFactoryImplJobPeer::GetNumStreams(
                    job_controller_->main_job()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
+class JobControllerLimitMultipleH2Requests
+    : public HttpStreamFactoryImplJobControllerTest {
+ protected:
+  const int kNumRequests = 5;
+  void SetUp() override { SkipCreatingJobController(); }
+};
+
+TEST_F(JobControllerLimitMultipleH2Requests, MultipleRequests) {
+  // Make sure there is only one socket connect.
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
+  tcp_data_ = base::MakeUnique<SequencedSocketData>(reads, arraysize(reads),
+                                                    nullptr, 0);
+  tcp_data_->set_connect_data(MockConnect(ASYNC, OK));
+  auto ssl_data = base::MakeUnique<SSLSocketDataProvider>(ASYNC, OK);
+  ssl_data->next_proto = kProtoHTTP2;
+  session_deps_.socket_factory->AddSSLSocketDataProvider(ssl_data.get());
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.com");
+  Initialize(request_info);
+  SpdySessionPoolPeer pool_peer(session_->spdy_session_pool());
+  pool_peer.SetEnableSendingInitialData(false);
+
+  // Sets server support Http/2.
+  url::SchemeHostPort server(request_info.url);
+  session_->http_server_properties()->SetSupportsSpdy(server, true);
+
+  std::vector<std::unique_ptr<MockHttpStreamRequestDelegate>> request_delegates;
+  std::vector<std::unique_ptr<HttpStreamRequest>> requests;
+  for (int i = 0; i < kNumRequests; ++i) {
+    request_delegates.emplace_back(
+        base::MakeUnique<MockHttpStreamRequestDelegate>());
+    HttpStreamFactoryImpl::JobController* job_controller =
+        new HttpStreamFactoryImpl::JobController(
+            factory_, request_delegates[i].get(), session_.get(), &job_factory_,
+            request_info, is_preconnect_, enable_ip_based_pooling_,
+            enable_alternative_services_, SSLConfig(), SSLConfig());
+    HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller);
+    auto request = job_controller->Start(
+        request_delegates[i].get(), nullptr, NetLogWithSource(),
+        HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
+    EXPECT_TRUE(job_controller->main_job());
+    EXPECT_FALSE(job_controller->alternative_job());
+    requests.push_back(std::move(request));
+  }
+
+  for (int i = 0; i < kNumRequests; ++i) {
+    EXPECT_CALL(*request_delegates[i].get(), OnStreamReadyImpl(_, _, _));
+  }
+
+  base::RunLoop().RunUntilIdle();
+  requests.clear();
+  EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
+}
+
+TEST_F(JobControllerLimitMultipleH2Requests, MultipleRequestsFirstRequestHang) {
+  base::ScopedMockTimeMessageLoopTaskRunner test_task_runner;
+  // First socket connect hang.
+  auto hangdata = base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
+  hangdata->set_connect_data(MockConnect(SYNCHRONOUS, ERR_IO_PENDING));
+  session_deps_.socket_factory->AddSocketDataProvider(hangdata.get());
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
+  std::vector<std::unique_ptr<SequencedSocketData>> socket_data;
+  std::vector<std::unique_ptr<SSLSocketDataProvider>> ssl_socket_data;
+  // kNumRequests - 1 will resume themselves after a delay. There will be
+  // kNumRequests - 1 sockets opened.
+  for (int i = 0; i < kNumRequests - 1; i++) {
+    // Only the first one needs a MockRead because subsequent sockets are
+    // not used to establish a SpdySession.
+    auto tcp_data =
+        i == 0 ? base::MakeUnique<SequencedSocketData>(reads, arraysize(reads),
+                                                       nullptr, 0)
+               : base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
+    tcp_data->set_connect_data(MockConnect(ASYNC, OK));
+    auto ssl_data = base::MakeUnique<SSLSocketDataProvider>(ASYNC, OK);
+    ssl_data->next_proto = kProtoHTTP2;
+    session_deps_.socket_factory->AddSocketDataProvider(tcp_data.get());
+    session_deps_.socket_factory->AddSSLSocketDataProvider(ssl_data.get());
+    socket_data.push_back(std::move(tcp_data));
+    ssl_socket_data.push_back(std::move(ssl_data));
+  }
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.com");
+  Initialize(request_info);
+  SpdySessionPoolPeer pool_peer(session_->spdy_session_pool());
+  pool_peer.SetEnableSendingInitialData(false);
+
+  // Sets server support Http/2.
+  url::SchemeHostPort server(request_info.url);
+  session_->http_server_properties()->SetSupportsSpdy(server, true);
+
+  std::vector<std::unique_ptr<MockHttpStreamRequestDelegate>> request_delegates;
+  std::vector<std::unique_ptr<HttpStreamRequest>> requests;
+  for (int i = 0; i < kNumRequests; ++i) {
+    request_delegates.push_back(
+        base::MakeUnique<MockHttpStreamRequestDelegate>());
+    HttpStreamFactoryImpl::JobController* job_controller =
+        new HttpStreamFactoryImpl::JobController(
+            factory_, request_delegates[i].get(), session_.get(), &job_factory_,
+            request_info, is_preconnect_, enable_ip_based_pooling_,
+            enable_alternative_services_, SSLConfig(), SSLConfig());
+    HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller);
+    auto request = job_controller->Start(
+        request_delegates[i].get(), nullptr, NetLogWithSource(),
+        HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
+    EXPECT_TRUE(job_controller->main_job());
+    EXPECT_FALSE(job_controller->alternative_job());
+    requests.push_back(std::move(request));
+  }
+
+  for (int i = 0; i < kNumRequests; ++i) {
+    // When a request is completed, delete it. This is needed because
+    // otherwise request will be completed twice. See crbug.com/706974.
+    EXPECT_CALL(*request_delegates[i].get(), OnStreamReadyImpl(_, _, _))
+        .WillOnce(testing::InvokeWithoutArgs(
+            [this, &requests, i]() { requests[i].reset(); }));
+  }
+
+  EXPECT_TRUE(test_task_runner->HasPendingTask());
+  test_task_runner->FastForwardBy(base::TimeDelta::FromMilliseconds(
+      HttpStreamFactoryImpl::Job::kHTTP2ThrottleMs));
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
+  for (const auto& data : socket_data) {
+    EXPECT_TRUE(data->AllReadDataConsumed());
+    EXPECT_TRUE(data->AllWriteDataConsumed());
+  }
+}
+
+TEST_F(JobControllerLimitMultipleH2Requests,
+       MultipleRequestsFirstRequestCanceled) {
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
+  auto first_socket = base::MakeUnique<SequencedSocketData>(
+      reads, arraysize(reads), nullptr, 0);
+  first_socket->set_connect_data(MockConnect(ASYNC, OK));
+  auto ssl_data = base::MakeUnique<SSLSocketDataProvider>(ASYNC, OK);
+  ssl_data->next_proto = kProtoHTTP2;
+  session_deps_.socket_factory->AddSocketDataProvider(first_socket.get());
+  session_deps_.socket_factory->AddSSLSocketDataProvider(ssl_data.get());
+  auto second_socket =
+      base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
+  second_socket->set_connect_data(MockConnect(ASYNC, OK));
+  session_deps_.socket_factory->AddSocketDataProvider(second_socket.get());
+  session_deps_.socket_factory->AddSSLSocketDataProvider(ssl_data.get());
+
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.com");
+  Initialize(request_info);
+  SpdySessionPoolPeer pool_peer(session_->spdy_session_pool());
+  pool_peer.SetEnableSendingInitialData(false);
+
+  // Sets server support Http/2.
+  url::SchemeHostPort server(request_info.url);
+  session_->http_server_properties()->SetSupportsSpdy(server, true);
+
+  std::vector<std::unique_ptr<MockHttpStreamRequestDelegate>> request_delegates;
+  std::vector<std::unique_ptr<HttpStreamRequest>> requests;
+  for (int i = 0; i < kNumRequests; ++i) {
+    request_delegates.emplace_back(
+        base::MakeUnique<MockHttpStreamRequestDelegate>());
+    HttpStreamFactoryImpl::JobController* job_controller =
+        new HttpStreamFactoryImpl::JobController(
+            factory_, request_delegates[i].get(), session_.get(), &job_factory_,
+            request_info, is_preconnect_, enable_ip_based_pooling_,
+            enable_alternative_services_, SSLConfig(), SSLConfig());
+    HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller);
+    auto request = job_controller->Start(
+        request_delegates[i].get(), nullptr, NetLogWithSource(),
+        HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
+    EXPECT_TRUE(job_controller->main_job());
+    EXPECT_FALSE(job_controller->alternative_job());
+    requests.push_back(std::move(request));
+  }
+  // Cancel the first one.
+  requests[0].reset();
+
+  for (int i = 1; i < kNumRequests; ++i) {
+    EXPECT_CALL(*request_delegates[i].get(), OnStreamReadyImpl(_, _, _));
+  }
+  base::RunLoop().RunUntilIdle();
+  requests.clear();
+  EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
+  EXPECT_TRUE(first_socket->AllReadDataConsumed());
+  EXPECT_TRUE(second_socket->AllReadDataConsumed());
+}
+
+TEST_F(JobControllerLimitMultipleH2Requests, MultiplePreconnects) {
+  // Make sure there is only one socket connect.
+  tcp_data_ = base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
+  tcp_data_->set_connect_data(MockConnect(ASYNC, OK));
+  auto ssl_data = base::MakeUnique<SSLSocketDataProvider>(ASYNC, OK);
+  ssl_data->next_proto = kProtoHTTP2;
+  session_deps_.socket_factory->AddSSLSocketDataProvider(ssl_data.get());
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.com");
+  SetPreconnect();
+  Initialize(request_info);
+  SpdySessionPoolPeer pool_peer(session_->spdy_session_pool());

[Bence, 2017/06/13 16:04:51]

|pool_peer| is unused.

[xunjieli, 2017/06/15 13:19:26]

Done.

+
+  // Sets server support Http/2.
+  url::SchemeHostPort server(request_info.url);
+  session_->http_server_properties()->SetSupportsSpdy(server, true);
+
+  std::vector<std::unique_ptr<MockHttpStreamRequestDelegate>> request_delegates;
+  for (int i = 0; i < kNumRequests; ++i) {
+    request_delegates.emplace_back(
+        base::MakeUnique<MockHttpStreamRequestDelegate>());
+    HttpStreamFactoryImpl::JobController* job_controller =
+        new HttpStreamFactoryImpl::JobController(
+            factory_, request_delegates[i].get(), session_.get(), &job_factory_,
+            request_info, is_preconnect_, enable_ip_based_pooling_,
+            enable_alternative_services_, SSLConfig(), SSLConfig());
+    HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller);
+    job_controller->Preconnect(1);
+    EXPECT_TRUE(job_controller->main_job());
+    EXPECT_FALSE(job_controller->alternative_job());
+  }
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
+}
+
+TEST_F(JobControllerLimitMultipleH2Requests, H1NegotiatedForFirstRequest) {
+  // First socket is an HTTP/1.1 socket.
+  auto first_socket =
+      base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
+  first_socket->set_connect_data(MockConnect(ASYNC, OK));
+  auto ssl_data = base::MakeUnique<SSLSocketDataProvider>(ASYNC, OK);
+  session_deps_.socket_factory->AddSocketDataProvider(first_socket.get());
+  session_deps_.socket_factory->AddSSLSocketDataProvider(ssl_data.get());
+  // Second socket is an HTTP/2 socket.
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
+  auto second_socket = base::MakeUnique<SequencedSocketData>(
+      reads, arraysize(reads), nullptr, 0);
+  second_socket->set_connect_data(MockConnect(ASYNC, OK));
+  auto second_ssl_data = base::MakeUnique<SSLSocketDataProvider>(ASYNC, OK);
+  second_ssl_data->next_proto = kProtoHTTP2;
+  session_deps_.socket_factory->AddSocketDataProvider(second_socket.get());
+  session_deps_.socket_factory->AddSSLSocketDataProvider(second_ssl_data.get());
+
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.com");
+  Initialize(request_info);
+  SpdySessionPoolPeer pool_peer(session_->spdy_session_pool());
+  pool_peer.SetEnableSendingInitialData(false);
+
+  // Sets server support Http/2.
+  url::SchemeHostPort server(request_info.url);
+  session_->http_server_properties()->SetSupportsSpdy(server, true);
+
+  std::vector<std::unique_ptr<MockHttpStreamRequestDelegate>> request_delegates;
+  std::vector<std::unique_ptr<HttpStreamRequest>> requests;
+  for (int i = 0; i < 2; ++i) {
+    request_delegates.emplace_back(
+        base::MakeUnique<MockHttpStreamRequestDelegate>());
+    HttpStreamFactoryImpl::JobController* job_controller =
+        new HttpStreamFactoryImpl::JobController(
+            factory_, request_delegates[i].get(), session_.get(), &job_factory_,
+            request_info, is_preconnect_, enable_ip_based_pooling_,
+            enable_alternative_services_, SSLConfig(), SSLConfig());
+    HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller);
+    auto request = job_controller->Start(
+        request_delegates[i].get(), nullptr, NetLogWithSource(),
+        HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
+    EXPECT_TRUE(job_controller->main_job());
+    EXPECT_FALSE(job_controller->alternative_job());
+    requests.push_back(std::move(request));
+  }
+
+  for (int i = 0; i < 2; ++i) {
+    // When a request is completed, delete it. This is needed because
+    // otherwise request will be completed twice. See crbug.com/706974.
+    EXPECT_CALL(*request_delegates[i].get(), OnStreamReadyImpl(_, _, _))
+        .WillOnce(testing::InvokeWithoutArgs(
+            [this, &requests, i]() { requests[i].reset(); }));
+  }
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
+  EXPECT_TRUE(first_socket->AllReadDataConsumed());
+  EXPECT_FALSE(second_socket->AllReadDataConsumed());
+}
+
 class HttpStreamFactoryImplJobControllerMisdirectedRequestRetry
     : public HttpStreamFactoryImplJobControllerTest,
       public ::testing::WithParamInterface<::testing::tuple<bool, bool>> {};
 
 INSTANTIATE_TEST_CASE_P(
     /* no prefix */,
     HttpStreamFactoryImplJobControllerMisdirectedRequestRetry,
     ::testing::Combine(::testing::Bool(), ::testing::Bool()));
 
 TEST_P(HttpStreamFactoryImplJobControllerMisdirectedRequestRetry,
@@ skipping 107 matching lines @@
   Preconnect(kNumPreconects);
   // If experiment is enabled, only 1 stream is requested.
   EXPECT_EQ(
       (int)actual_num_connects,
       HttpStreamFactoryImplJobPeer::GetNumStreams(job_controller_->main_job()));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
 }  // namespace net