Return Job as unique_ptr from factory methods.

net/http/http_stream_factory_impl_job_controller.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 "base/memory/ptr_util.h"
@@ skipping 756 matching lines @@
 
   // Create an alternative job if alternative service is set up for this domain.
   const AlternativeService alternative_service =
       GetAlternativeServiceFor(request_info_, delegate_, stream_type_);
 
   if (is_preconnect_) {
     // Due to how the socket pools handle priorities and idle sockets, only IDLE
     // priority currently makes sense for preconnects. The priority for
     // preconnects is currently ignored (see RequestSocketsForPool()), but could
     // be used at some point for proxy resolution or something.
-    main_job_.reset(job_factory_->CreateAltSvcJob(
+    main_job_ = job_factory_->CreateAltSvcJob(
         this, PRECONNECT, session_, request_info_, IDLE, proxy_info_,
         server_ssl_config_, proxy_ssl_config_, destination, origin_url,
-        alternative_service, enable_ip_based_pooling_, session_->net_log()));
+        alternative_service, enable_ip_based_pooling_, session_->net_log());
     main_job_->Preconnect(num_streams_);
     return OK;
   }
-  main_job_.reset(job_factory_->CreateMainJob(
+  main_job_ = job_factory_->CreateMainJob(
       this, MAIN, session_, request_info_, priority_, proxy_info_,
       server_ssl_config_, proxy_ssl_config_, destination, origin_url,
-      enable_ip_based_pooling_, net_log_.net_log()));
+      enable_ip_based_pooling_, net_log_.net_log());
   // Alternative Service can only be set for HTTPS requests while Alternative
   // Proxy is set for HTTP requests.
   if (alternative_service.protocol != kProtoUnknown) {
     // Never share connection with other jobs for FTP requests.
     DVLOG(1) << "Selected alternative service (host: "
              << alternative_service.host_port_pair().host()
              << " port: " << alternative_service.host_port_pair().port() << ")";
 
     DCHECK(!request_info_.url.SchemeIs(url::kFtpScheme));
     HostPortPair alternative_destination(alternative_service.host_port_pair());
     ignore_result(
         ApplyHostMappingRules(request_info_.url, &alternative_destination));
 
-    alternative_job_.reset(job_factory_->CreateAltSvcJob(
+    alternative_job_ = job_factory_->CreateAltSvcJob(
         this, ALTERNATIVE, session_, request_info_, priority_, proxy_info_,
         server_ssl_config_, proxy_ssl_config_, alternative_destination,
         origin_url, alternative_service, enable_ip_based_pooling_,
-        net_log_.net_log()));
+        net_log_.net_log());
 
     main_job_is_blocked_ = true;
     alternative_job_->Start(request_->stream_type());
   } else {
     ProxyServer alternative_proxy_server;
     if (ShouldCreateAlternativeProxyServerJob(proxy_info_, request_info_.url,
                                               &alternative_proxy_server)) {
       DCHECK(!main_job_is_blocked_);
       ProxyInfo alternative_proxy_info;
       alternative_proxy_info.UseProxyServer(alternative_proxy_server);
 
-      alternative_job_.reset(job_factory_->CreateAltProxyJob(
+      alternative_job_ = job_factory_->CreateAltProxyJob(
           this, ALTERNATIVE, session_, request_info_, priority_,
           alternative_proxy_info, server_ssl_config_, proxy_ssl_config_,
           destination, origin_url, alternative_proxy_server,
-          enable_ip_based_pooling_, net_log_.net_log()));
+          enable_ip_based_pooling_, net_log_.net_log());
 
       can_start_alternative_proxy_job_ = false;
       main_job_is_blocked_ = true;
       alternative_job_->Start(request_->stream_type());
     }
   }
   // Even if |alternative_job| has already finished, it will not have notified
   // the request yet, since we defer that to the next iteration of the
   // MessageLoop, so starting |main_job_| is always safe.
   main_job_->Start(request_->stream_type());
@@ skipping 424 matching lines @@
     // If ReconsiderProxyAfterError() failed synchronously, it means
     // there was nothing left to fall-back to, so fail the transaction
     // with the last connection error we got.
     // TODO(eroman): This is a confusing contract, make it more obvious.
     rv = error;
   }
   return rv;
 }
 
 }  // namespace net