Cap the delay time for the main job when racing with QUIC for delayed

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 <memory>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
@@ skipping 928 matching lines @@
 
   EXPECT_FALSE(JobControllerPeer::main_job_is_blocked(job_controller_));
   // OnStreamFailed will not resume the main job again since it's been resumed
   // already.
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(0);
 
   job_controller_->OnStreamFailed(job_factory_.alternative_job(),
                                   ERR_NETWORK_CHANGED, SSLConfig());
 }
 
+// Test that main job is blocked for kMaxDelayTimeForMainJob(3s) if
+// http_server_properties cached an inappropriate large srtt for the server,
+// which would potentially delay the main job for a extremely long time in
+// delayed tcp case.
+TEST_F(HttpStreamFactoryImplJobControllerTest, DelayedTCPWithLargeSrtt) {
+  // The max delay time should be in sync with .cc file.
+  base::TimeDelta kMaxDelayTimeForMainJob = base::TimeDelta::FromSeconds(3);
+  HangingResolver* resolver = new HangingResolver();
+  session_deps_.host_resolver.reset(resolver);
+
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.google.com");
+
+  Initialize(request_info, false, false);
+
+  // Enable delayed TCP and set a extremely large time delay for waiting job.
+  QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
+  test::QuicStreamFactoryPeer::SetDelayTcpRace(quic_stream_factory, true);
+  quic_stream_factory->set_require_confirmation(false);
+  ServerNetworkStats stats1;
+  stats1.srtt = base::TimeDelta::FromSeconds(100);
+  session_->http_server_properties()->SetServerNetworkStats(
+      url::SchemeHostPort(GURL("https://www.google.com")), stats1);
+
+  // Set a SPDY alternative service for the server.
+  url::SchemeHostPort server(request_info.url);
+  AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
+  SetAlternativeService(request_info, alternative_service);
+
+  request_.reset(
+      job_controller_->Start(request_info, &request_delegate_, nullptr,
+                             NetLogWithSource(), HttpStreamRequest::HTTP_STREAM,
+                             DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
+  EXPECT_TRUE(job_controller_->main_job());
+  EXPECT_TRUE(job_controller_->alternative_job());
+  EXPECT_TRUE(job_controller_->main_job()->is_waiting());
+
+  // The alternative job stalls as host resolution hangs when creating the QUIC
+  // request and controller should resume the main job after delay.
+  base::RunLoop run_loop;
+  EXPECT_CALL(*job_factory_.main_job(), Resume())
+      .Times(1)
+      .WillOnce(
+          testing::DoAll(testing::Invoke(testing::CreateFunctor(
+                             &JobControllerPeer::VerifyWaitingTimeForMainJob,
+                             job_controller_, kMaxDelayTimeForMainJob)),

[Ryan Hamilton, 2017/02/15 22:26:55]

I don't' think I understand how this tests that the resume task is posted to be
3 sec in the future and not 100 sec in the future. Can you explain?

+                         testing::Invoke([&run_loop]() { run_loop.Quit(); })));
+
+  // Wait for the main job to be resumed.
+  run_loop.Run();
+}

[Ryan Hamilton, 2017/02/15 22:26:55]

To confirm, this test fails with the old code?

[Zhongyi Shi, 2017/02/15 23:32:33]

Yup.

+
 TEST_F(HttpStreamFactoryImplJobControllerTest,
        ResumeMainJobImmediatelyOnStreamFailed) {
   HangingResolver* resolver = new HangingResolver();
   session_deps_.host_resolver.reset(resolver);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info, false, false);
@@ skipping 338 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