Return Request as unique_ptr from JobController::Start().

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 <string>
+#include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/scoped_mock_time_message_loop_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "net/base/test_proxy_delegate.h"
@@ skipping 289 matching lines @@
       base::WrapUnique(new FailingProxyResolverFactory), nullptr));
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   Initialize(request_info);
 
   EXPECT_CALL(request_delegate_,
               OnStreamFailed(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, _))
       .Times(1);
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
 
   EXPECT_FALSE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->alternative_job());
 
   // Make sure calling GetLoadState() when before job creation does not crash.
   // Regression test for crbug.com/723920.
   EXPECT_EQ(LOAD_STATE_IDLE, job_controller_->GetLoadState());
 
   base::RunLoop().RunUntilIdle();
   request_.reset();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, ProxyResolutionFailsAsync) {
   ProxyConfig proxy_config;
   proxy_config.set_pac_url(GURL("http://fooproxyurl"));
   proxy_config.set_pac_mandatory(true);
   MockAsyncProxyResolverFactory* proxy_resolver_factory =
       new MockAsyncProxyResolverFactory(false);
   MockAsyncProxyResolver resolver;
   session_deps_.proxy_service.reset(
       new ProxyService(base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
                        base::WrapUnique(proxy_resolver_factory), nullptr));
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   Initialize(request_info);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
 
   EXPECT_FALSE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->alternative_job());
 
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL,
             job_controller_->GetLoadState());
 
   EXPECT_CALL(request_delegate_,
               OnStreamFailed(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, _))
       .Times(1);
   proxy_resolver_factory->pending_requests()[0]->CompleteNowWithForwarder(
       ERR_FAILED, &resolver);
   base::RunLoop().RunUntilIdle();
   request_.reset();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, NoSupportedProxies) {
   session_deps_.proxy_service =
       ProxyService::CreateFixedFromPacResult("QUIC myproxy.org:443");
   session_deps_.enable_quic = false;
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   Initialize(request_info);
 
   EXPECT_CALL(request_delegate_, OnStreamFailed(ERR_NO_SUPPORTED_PROXIES, _))
       .Times(1);
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
 
   EXPECT_FALSE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->alternative_job());
 
   base::RunLoop().RunUntilIdle();
   request_.reset();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
 class JobControllerReconsiderProxyAfterErrorTest
@@ skipping 12 matching lines @@
   }
 
   std::unique_ptr<HttpStreamRequest> CreateJobController(
       const HttpRequestInfo& request_info) {
     HttpStreamFactoryImpl::JobController* job_controller =
         new HttpStreamFactoryImpl::JobController(
             factory_, &request_delegate_, session_.get(), &default_job_factory_,
             request_info, is_preconnect_, enable_ip_based_pooling_,
             enable_alternative_services_, SSLConfig(), SSLConfig());
     HttpStreamFactoryImplPeer::AddJobController(factory_, job_controller);
-    return base::WrapUnique(job_controller->Start(
+    return job_controller->Start(
         &request_delegate_, nullptr, NetLogWithSource(),
-        HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+        HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   }
 
  private:
   // Use real Jobs so that Job::Resume() is not mocked out. When main job is
   // resumed it will use mock socket data.
   HttpStreamFactoryImpl::JobFactory default_job_factory_;
 };
 
 INSTANTIATE_TEST_CASE_P(
     /* no prefix */,
@@ skipping 116 matching lines @@
        OnStreamFailedWithNoAlternativeJob) {
   tcp_data_ = base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
   tcp_data_->set_connect_data(MockConnect(ASYNC, ERR_FAILED));
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   Initialize(request_info);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
 
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->alternative_job());
 
   // There's no other alternative job. Thus when stream failed, it should
   // notify Request of the stream failure.
   EXPECT_CALL(request_delegate_, OnStreamFailed(ERR_FAILED, _)).Times(1);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest,
        OnStreamReadyWithNoAlternativeJob) {
   tcp_data_ = base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
   tcp_data_->set_connect_data(MockConnect(ASYNC, OK));
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
 
   Initialize(request_info);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
 
   // There's no other alternative job. Thus when a stream is ready, it should
   // notify Request.
   EXPECT_TRUE(job_controller_->main_job());
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   base::RunLoop().RunUntilIdle();
 }
 
@@ skipping 10 matching lines @@
   tcp_data_->set_connect_data(MockConnect(ASYNC, OK));
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // Reset the Request will cancel all the Jobs since there's no Job determined
   // to serve Request yet and JobController will notify the factory to delete
   // itself upon completion.
   request_.reset();
   VerifyBrokenAlternateProtocolMapping(request_info, false);
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, OnStreamFailedForBothJobs) {
   quic_data_ = base::MakeUnique<test::MockQuicData>();
   quic_data_->AddConnect(ASYNC, ERR_FAILED);
   tcp_data_ = base::MakeUnique<SequencedSocketData>(nullptr, 0, nullptr, 0);
   tcp_data_->set_connect_data(MockConnect(ASYNC, ERR_FAILED));
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // The failure of second Job should be reported to Request as there's no more
   // pending Job to serve the Request.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(1);
   base::RunLoop().RunUntilIdle();
   VerifyBrokenAlternateProtocolMapping(request_info, false);
   request_.reset();
   EXPECT_TRUE(HttpStreamFactoryImplPeer::IsJobControllerDeleted(factory_));
@@ skipping 13 matching lines @@
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // Main job succeeds, starts serving Request and it should report status
   // to Request. The alternative job will mark the main job complete and gets
   // orphaned.
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   // JobController shouldn't report the status of second job as request
   // is already successfully served.
@@ skipping 18 matching lines @@
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
   EXPECT_TRUE(JobControllerPeer::main_job_is_blocked(job_controller_));
 
   // |alternative_job| succeeds and should report status to |request_delegate_|.
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
 
   base::RunLoop().RunUntilIdle();
 
@@ skipping 21 matching lines @@
   request_info.method = "GET";
   request_info.url =
       GURL(base::StringPrintf("https://%s:%u", origin_host, origin_port));
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoHTTP2, alternative_host,
                                          alternative_port);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
 
   HostPortPair main_host_port_pair =
       HttpStreamFactoryImplJobPeer::GetSpdySessionKey(
           job_controller_->main_job())
           .host_port_pair();
   EXPECT_EQ(origin_host, main_host_port_pair.host());
   EXPECT_EQ(origin_port, main_host_port_pair.port());
 
   HostPortPair alternative_host_port_pair =
       HttpStreamFactoryImplJobPeer::GetSpdySessionKey(
@@ skipping 21 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
   // main job should not be blocked because alt job returned ERR_IO_PENDING.
   EXPECT_FALSE(JobControllerPeer::main_job_is_blocked(job_controller_));
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
 
   // Complete main job now.
   base::RunLoop().RunUntilIdle();
@@ skipping 33 matching lines @@
 
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
   // |main_job| fails but should not report status to Request.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   base::RunLoop().RunUntilIdle();
 
   // Make |alternative_job| succeed.
   HttpStream* http_stream =
       new HttpBasicStream(base::MakeUnique<ClientSocketHandle>(), false, false);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
@@ skipping 22 matching lines @@
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   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);
   // |main_job| succeeds and should report status to Request.
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
 
   base::RunLoop().RunUntilIdle();
@@ skipping 21 matching lines @@
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   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);
   // |main_job| succeeds and should report status to Request.
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   base::RunLoop().RunUntilIdle();
 
@@ skipping 19 matching lines @@
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // |main_job| fails but should not report status to Request.
   // The alternative job will mark the main job complete.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
 
   base::RunLoop().RunUntilIdle();
 
   // Controller should use alternative job to get load state.
@@ skipping 25 matching lines @@
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   Initialize(request_info);
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // Alt job is stalled and main job should complete successfully.
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, InvalidPortForQuic) {
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
 
   // Using a restricted port 101 for QUIC should fail and the alternative job
   // should post OnStreamFailedCall on the controller to resume the main job.
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 101);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
 
   EXPECT_TRUE(job_factory_.main_job()->is_waiting());
 
   // Wait until OnStreamFailedCallback is executed on the alternative job.
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, DelayedTCP) {
   base::ScopedMockTimeMessageLoopTaskRunner test_task_runner;
@@ skipping 13 matching lines @@
   quic_stream_factory->set_require_confirmation(false);
   ServerNetworkStats stats1;
   stats1.srtt = base::TimeDelta::FromMicroseconds(10);
   session_->http_server_properties()->SetServerNetworkStats(
       url::SchemeHostPort(GURL("https://www.google.com")), stats1);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   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.
   EXPECT_TRUE(test_task_runner->HasPendingTask());
   EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
   test_task_runner->FastForwardBy(base::TimeDelta::FromMicroseconds(15));
@@ skipping 44 matching lines @@
   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(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   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.
   EXPECT_TRUE(test_task_runner->HasPendingTask());
   EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
 
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
@@ skipping 36 matching lines @@
       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);
 
   // The alternative job stalls as host resolution hangs when creating the QUIC
   // request and controller should resume the main job with delay.
   // OnStreamFailed should resume the main job immediately.
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   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);
   // Now unblock Resolver to fail the alternate job.
@@ skipping 22 matching lines @@
   // Using hanging resolver will cause the alternative job to hang indefinitely.
   HangingResolver* resolver = new HangingResolver();
   session_deps_.host_resolver.reset(resolver);
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://mail.example.org/");
   Initialize(request_info);
   EXPECT_TRUE(test_proxy_delegate()->alternative_proxy_server().is_quic());
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->main_job()->is_waiting());
   EXPECT_FALSE(job_controller_->alternative_job());
 
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(0);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, test_proxy_delegate()->get_alternative_proxy_invocations());
 }
 
 // Verifies that the alternative proxy server job is not created if the main job
 // does not fetch the resource through a proxy.
 TEST_F(HttpStreamFactoryImplJobControllerTest, HttpURLWithNoProxy) {
   // Using hanging resolver will cause the alternative job to hang indefinitely.
   HangingResolver* resolver = new HangingResolver();
   session_deps_.host_resolver.reset(resolver);
 
   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());
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_FALSE(job_controller_->main_job()->is_waiting());
   EXPECT_FALSE(job_controller_->alternative_job());
 
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(0);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, test_proxy_delegate()->get_alternative_proxy_invocations());
 }
 
@@ skipping 19 matching lines @@
   EXPECT_TRUE(test_proxy_delegate()->alternative_proxy_server().is_quic());
 
   // Enable delayed TCP and set time delay for waiting job.
   QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
   quic_stream_factory->set_require_confirmation(false);
   ServerNetworkStats stats1;
   stats1.srtt = base::TimeDelta::FromMicroseconds(10);
   session_->http_server_properties()->SetServerNetworkStats(
       url::SchemeHostPort(GURL("https://myproxy.org")), stats1);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->main_job()->is_waiting());
   EXPECT_TRUE(job_controller_->alternative_job());
   // The main job is unblocked but is resumed one message loop iteration later.
   EXPECT_FALSE(JobControllerPeer::main_job_is_blocked(job_controller_));
   EXPECT_FALSE(JobControllerPeer::main_job_is_resumed(job_controller_));
   EXPECT_EQ(1u, test_task_runner->GetPendingTaskCount());
 
   // Move forward the delay and verify the main job is resumed.
   EXPECT_CALL(*job_factory_.main_job(), Resume()).Times(1);
@@ skipping 33 matching lines @@
   EXPECT_TRUE(test_proxy_delegate()->alternative_proxy_server().is_quic());
 
   // Enable delayed TCP and set time delay for waiting job.
   QuicStreamFactory* quic_stream_factory = session_->quic_stream_factory();
   quic_stream_factory->set_require_confirmation(false);
   ServerNetworkStats stats1;
   stats1.srtt = base::TimeDelta::FromMicroseconds(300 * 1000);
   session_->http_server_properties()->SetServerNetworkStats(
       url::SchemeHostPort(GURL("https://myproxy.org")), stats1);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(job_controller_->alternative_job());
   EXPECT_TRUE(job_controller_->main_job());
@@ skipping 21 matching lines @@
 
   UseAlternativeProxy();
 
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   EXPECT_TRUE(job_controller_->alternative_job());
 
   // Main job succeeds, starts serving Request and it should report status
   // to Request. The alternative job will mark the main job complete and gets
   // orphaned.
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
 
   base::RunLoop().RunUntilIdle();
@@ skipping 77 matching lines @@
     DisableIPBasedPooling();
   if (!enable_alternative_services)
     DisableAlternativeServices();
 
   Initialize(request_info);
 
   url::SchemeHostPort server(request_info.url);
   AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
   SetAlternativeService(request_info, alternative_service);
 
-  request_.reset(
+  request_ =
       job_controller_->Start(&request_delegate_, nullptr, NetLogWithSource(),
-                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY));
+                             HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
   EXPECT_TRUE(job_controller_->main_job());
   if (enable_alternative_services) {
     EXPECT_TRUE(job_controller_->alternative_job());
   } else {
     EXPECT_FALSE(job_controller_->alternative_job());
   }
 
   // |main_job| succeeds and should report status to Request.
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, _))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
@@ skipping 66 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