Pass ClientSocketHandle ownership around in unique_ptr.

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 "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/http/http_stream_factory_test_util.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_service.h"
 #include "net/quic/test_tools/quic_stream_factory_peer.h"
@@ skipping 209 matching lines @@
   request_info.url = GURL("http://www.google.com");
 
   request_.reset(
       job_controller_->Start(request_info, &request_delegate_, nullptr,
                              BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
 
   // There's no other alternative job. Thus when stream is ready, it should
   // notify Request.
   HttpStream* http_stream =
-      new HttpBasicStream(new ClientSocketHandle(), false);
+      new HttpBasicStream(base::MakeUnique<ClientSocketHandle>(), false);
   job_factory_.main_job()->SetStream(http_stream);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   job_controller_->OnStreamReady(job_factory_.main_job(), SSLConfig(),
                                  ProxyInfo());
 }
 
 // Test we cancel Jobs correctly when the Request is explicitly canceled
 // before any Job is bound to Request.
@@ skipping 97 matching lines @@
       job_controller_->Start(request_info, &request_delegate_, nullptr,
                              BoundNetLog(), HttpStreamRequest::HTTP_STREAM,
                              DEFAULT_PRIORITY, SSLConfig(), SSLConfig()));
   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.
   HttpStream* http_stream =
-      new HttpBasicStream(new ClientSocketHandle(), false);
+      new HttpBasicStream(base::MakeUnique<ClientSocketHandle>(), false);
   job_factory_.main_job()->SetStream(http_stream);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   EXPECT_CALL(*job_factory_.alternative_job(), MarkOtherJobComplete(_))
       .Times(1);
   job_controller_->OnStreamReady(job_factory_.main_job(), SSLConfig(),
                                  ProxyInfo());
 
   // JobController shouldn't report the status of second job as request
@@ skipping 38 matching lines @@
   // The alternative job will mark the main job complete.
   EXPECT_CALL(request_delegate_, OnStreamFailed(_, _)).Times(0);
   EXPECT_CALL(*job_factory_.alternative_job(), MarkOtherJobComplete(_))
       .Times(1);
 
   job_controller_->OnStreamFailed(job_factory_.main_job(), ERR_FAILED,
                                   SSLConfig());
 
   // |alternative_job| succeeds and should report status to Request.
   HttpStream* http_stream =
-      new HttpBasicStream(new ClientSocketHandle(), false);
+      new HttpBasicStream(base::MakeUnique<ClientSocketHandle>(), false);
   job_factory_.alternative_job()->SetStream(http_stream);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   job_controller_->OnStreamReady(job_factory_.alternative_job(), SSLConfig(),
                                  ProxyInfo());
 }
 
 // Regression test for crbug/621069.
 // Get load state after main job fails and before alternative job succeeds.
@@ skipping 30 matching lines @@
       .Times(1);
 
   job_controller_->OnStreamFailed(job_factory_.main_job(), ERR_FAILED,
                                   SSLConfig());
 
   // Controller should use alternative job to get load state.
   job_controller_->GetLoadState();
 
   // |alternative_job| succeeds and should report status to Request.
   HttpStream* http_stream =
-      new HttpBasicStream(new ClientSocketHandle(), false);
+      new HttpBasicStream(base::MakeUnique<ClientSocketHandle>(), false);
   job_factory_.alternative_job()->SetStream(http_stream);
 
   EXPECT_CALL(request_delegate_, OnStreamReady(_, _, http_stream))
       .WillOnce(Invoke(DeleteHttpStreamPointer));
   job_controller_->OnStreamReady(job_factory_.alternative_job(), SSLConfig(),
                                  ProxyInfo());
 }
 
 TEST_F(HttpStreamFactoryImplJobControllerTest, DoNotResumeMainJobBeforeWait) {
   // Use failing ProxyResolverFactory which is unable to create ProxyResolver
@@ skipping 222 matching lines @@
   // request and controller should resume the main job after delay.
   // Verify the waiting time for delayed main job.
   EXPECT_CALL(*job_factory_.main_job(), Resume())
       .WillOnce(Invoke(testing::CreateFunctor(
           &JobControllerPeer::VerifyWaitingTimeForMainJob, job_controller_,
           base::TimeDelta::FromMicroseconds(15))));
 
   base::RunLoop().RunUntilIdle();
 }
 }  // namespace net