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

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 15209 matching lines @@
  public:
   FakeStreamFactory() {}
   ~FakeStreamFactory() override {}
 
   // Returns a WeakPtr<> to the last HttpStreamRequest returned by
   // RequestStream() (which may be NULL if it was destroyed already).
   base::WeakPtr<FakeStreamRequest> last_stream_request() {
     return last_stream_request_;
   }
 
-  HttpStreamRequest* RequestStream(const HttpRequestInfo& info,
-                                   RequestPriority priority,
-                                   const SSLConfig& server_ssl_config,
-                                   const SSLConfig& proxy_ssl_config,
-                                   HttpStreamRequest::Delegate* delegate,
-                                   bool enable_ip_based_pooling,
-                                   bool enable_alternative_services,
-                                   const NetLogWithSource& net_log) override {
-    FakeStreamRequest* fake_request = new FakeStreamRequest(priority, delegate);
-    last_stream_request_ = fake_request->AsWeakPtr();
-    return fake_request;
-  }
-
-  HttpStreamRequest* RequestBidirectionalStreamImpl(
+  std::unique_ptr<HttpStreamRequest> RequestStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
+      const SSLConfig& proxy_ssl_config,
+      HttpStreamRequest::Delegate* delegate,
+      bool enable_ip_based_pooling,
+      bool enable_alternative_services,
+      const NetLogWithSource& net_log) override {
+    auto fake_request = base::MakeUnique<FakeStreamRequest>(priority, delegate);
+    last_stream_request_ = fake_request->AsWeakPtr();
+    return std::move(fake_request);
+  }
+
+  std::unique_ptr<HttpStreamRequest> RequestBidirectionalStreamImpl(
+      const HttpRequestInfo& info,
+      RequestPriority priority,
+      const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       bool enable_ip_based_pooling,
       bool enable_alternative_services,
       const NetLogWithSource& net_log) override {
     NOTREACHED();
     return nullptr;
   }
 
-  HttpStreamRequest* RequestWebSocketHandshakeStream(
+  std::unique_ptr<HttpStreamRequest> RequestWebSocketHandshakeStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       WebSocketHandshakeStreamBase::CreateHelper* create_helper,
       bool enable_ip_based_pooling,
       bool enable_alternative_services,
       const NetLogWithSource& net_log) override {
-    FakeStreamRequest* fake_request =
-        new FakeStreamRequest(priority, delegate, create_helper);
+    auto fake_request =
+        base::MakeUnique<FakeStreamRequest>(priority, delegate, create_helper);
     last_stream_request_ = fake_request->AsWeakPtr();
-    return fake_request;
+    return std::move(fake_request);
   }
 
   void PreconnectStreams(int num_streams,
                          const HttpRequestInfo& info) override {
     ADD_FAILURE();
   }
 
   const HostMappingRules* GetHostMappingRules() const override {
     ADD_FAILURE();
     return NULL;
@@ skipping 1669 matching lines @@
 
   TestCompletionCallback callback;
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NO_SUPPORTED_PROXIES));
 }
 
 }  // namespace net