Check callback is run in QuicStreamFactory::Job

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 54 matching lines @@
   int Resolve(const RequestInfo& info,
               RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
               std::unique_ptr<Request>* out_req,
               const NetLogWithSource& net_log) override {
     return ERR_NAME_NOT_RESOLVED;
   }
 };
 
+// TODO(xunjieli): This should just use HangingHostResolver from
+// mock_host_resolver.h
 class HangingResolver : public MockHostResolverBase {
  public:
   HangingResolver() : MockHostResolverBase(false /*use_caching*/) {}
   ~HangingResolver() override {}
 
   int Resolve(const RequestInfo& info,
               RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
               std::unique_ptr<Request>* out_req,
@@ skipping 807 matching lines @@
   // Wait until OnStreamFailedCallback is executed on the alternative job.
   // Request shouldn't be notified as the main job is still pending status.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, DelayedTCP) {
   base::ScopedMockTimeMessageLoopTaskRunner test_task_runner;
-  HangingResolver* resolver = new HangingResolver();
-  session_deps_.host_resolver.reset(resolver);
+  auto failing_resolver = base::MakeUnique<MockHostResolver>();
+  failing_resolver->set_ondemand_mode(true);
+  failing_resolver->rules()->AddSimulatedFailure("*google.com");
+  session_deps_.host_resolver = std::move(failing_resolver);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
 
   // Enable delayed TCP and set time delay for waiting job.
   QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
   test::QuicStreamFactoryPeer::SetDelayTcpRace(quic_stream_factory, true);
@@ skipping 27 matching lines @@
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // |alternative_job| fails but should not report status to Request.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
 
   EXPECT_FALSE(JobControllerPeer::main_job_is_blocked(job_controller_));
   // OnStreamFailed will post a task to resume the main job immediately but
   // won't call Resume() on the main job 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());
+  // Now unblock Resolver so that alternate job (and QuicStreamFactory::Job) can
+  // be cleaned up.
+  session_deps_.host_resolver->ResolveAllPending();
   EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
   test_task_runner->FastForwardUntilNoTasksRemain();
+  EXPECT_FALSE(job_controller_->alternative_job());
 }
 
 // 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) {
   // Overrides the main thread's message loop with a mock tick clock so that we
   // could verify the main job is resumed with appropriate delay.
   base::ScopedMockTimeMessageLoopTaskRunner test_task_runner;
   // 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);
+  auto failing_resolver = base::MakeUnique<MockHostResolver>();
+  failing_resolver->set_ondemand_mode(true);
+  failing_resolver->rules()->AddSimulatedFailure("*google.com");
+  session_deps_.host_resolver = std::move(failing_resolver);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
 
   // 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);
@@ skipping 19 matching lines @@
   // The alternative job stalls as host resolution hangs when creating the QUIC
   // request and controller should resume the main job after delay.
   EXPECT_TRUE(test_task_runner->HasPendingTask());
   EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
 
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
   // Move forward the task runner with kMaxDelayTimeForMainJob and verify the
   // main job is resumed.
   test_task_runner->FastForwardBy(kMaxDelayTimeForMainJob);
   EXPECT_FALSE(test_task_runner->HasPendingTask());
+
+  // Now unblock Resolver so that alternate job (and QuicStreamFactory::Job) can
+  // be cleaned up.
+  session_deps_.host_resolver->ResolveAllPending();
+  EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
+  test_task_runner->FastForwardUntilNoTasksRemain();
+  EXPECT_FALSE(job_controller_->alternative_job());
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest,
        ResumeMainJobImmediatelyOnStreamFailed) {
   // Overrides the main thread's message loop with a mock tick clock so that we
   // could verify the main job is resumed with appropriate delay.
   base::ScopedMockTimeMessageLoopTaskRunner test_task_runner;
 
-  HangingResolver* resolver = new HangingResolver();
-  session_deps_.host_resolver.reset(resolver);
+  auto failing_resolver = base::MakeUnique<MockHostResolver>();
+  failing_resolver->set_ondemand_mode(true);
+  failing_resolver->rules()->AddSimulatedFailure("*google.com");
+  session_deps_.host_resolver = std::move(failing_resolver);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
 
   // Enable delayed TCP and set time delay for waiting job.
   QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
   test::QuicStreamFactoryPeer::SetDelayTcpRace(quic_stream_factory, true);
@@ skipping 17 matching lines @@
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
   EXPECT_TRUE(job_controller_->main_job()->is_waiting());
 
   EXPECT_TRUE(test_task_runner->HasPendingTask());
   EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
 
   // |alternative_job| fails but should not report status to Request.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
-  job_controller_->OnStreamFailed(job_factory_.alternative_job(),
-                                  ERR_NETWORK_CHANGED, SSLConfig());
+  // Now unblock Resolver to fail the alternate job.
+  session_deps_.host_resolver->ResolveAllPending();
   EXPECT_EQ(2u, test_task_runner->GetPendingTaskCount());
 
   // Verify the main job will be resumed immediately.
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
   // Execute tasks that have no remaining delay. Tasks with nonzero delay will
   // remain queued.
   test_task_runner->RunUntilIdle();
 
   // Verify there is another task to resume main job with delay but should
   // not call Resume() on the main job as main job has been resumed.
   EXPECT_TRUE(test_task_runner->HasPendingTask());
   EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(0);
   test_task_runner->FastForwardBy(base::TimeDelta::FromMicroseconds(15));
   EXPECT_FALSE(test_task_runner->HasPendingTask());
+  EXPECT_FALSE(job_controller_->alternative_job());
 }
 
 // Verifies that the alternative proxy server job is not created if the URL
 // scheme is HTTPS.
 TEST_F(HttpStreamFactoryImplJobControllerTest, HttpsURL) {
   // Using hanging resolver will cause the alternative job to hang indefinitely.
   HangingResolver* resolver = new HangingResolver();
   session_deps_.host_resolver.reset(resolver);
 
   HttpRequestInfo request_info;
@@ skipping 43 matching lines @@
   EXPECT_EQ(0, test_proxy_delegate()->get_alternative_proxy_invocations());
 }
 
 // Verifies that the main job is resumed properly after a delay when the
 // alternative proxy server job hangs.
 TEST_F(HttpStreamFactoryImplJobControllerTest, DelayedTCPAlternativeProxy) {
   // Overrides the main thread's message loop with a mock tick clock so that we
   // could verify the main job is resumed with appropriate delay.
   base::ScopedMockTimeMessageLoopTaskRunner test_task_runner;
 
-  // Using hanging resolver will cause the alternative job to hang indefinitely.
-  HangingResolver* resolver = new HangingResolver();
-  session_deps_.host_resolver.reset(resolver);
+  auto failing_resolver = base::MakeUnique<MockHostResolver>();
+  failing_resolver->set_ondemand_mode(true);
+  failing_resolver->rules()->AddSimulatedFailure("*myproxy.org");
+  session_deps_.host_resolver = std::move(failing_resolver);
 
   UseAlternativeProxy();
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://mail.example.org/");
   Initialize(request_info);
 
   EXPECT_TRUE(test_proxy_delegate()->alternative_proxy_server().is_quic());
 
@@ skipping 28 matching lines @@
 
   // Move forward the delay and verify the main job is resumed.
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
   test_task_runner->FastForwardBy(base::TimeDelta::FromMicroseconds(15));
   EXPECT_FALSE(JobControllerPeer::main_job_is_blocked(job_controller_));
 
   test_task_runner->RunUntilIdle();
   EXPECT_TRUE(test_proxy_delegate()->alternative_proxy_server().is_valid());
   EXPECT_EQ(1, test_proxy_delegate()->get_alternative_proxy_invocations());
   EXPECT_FALSE(test_task_runner->HasPendingTask());
+
+  // Now unblock Resolver so that alternate job (and QuicStreamFactory::Job) can
+  // be cleaned up.
+  session_deps_.host_resolver->ResolveAllPending();
+  EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
+  test_task_runner->FastForwardUntilNoTasksRemain();
+  EXPECT_FALSE(job_controller_->alternative_job());
 }
 
 // Verifies that the alternative proxy server job fails immediately, and the
 // main job is not blocked.
 TEST_F(HttpStreamFactoryImplJobControllerTest, FailAlternativeProxy) {
   base::ScopedMockTimeMessageLoopTaskRunner test_task_runner;
   // Using failing resolver will cause the alternative job to fail.
   FailingHostResolver* resolver = new FailingHostResolver();
   session_deps_.host_resolver.reset(resolver);
 
@@ skipping 186 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