Remove some naked |new| statements in favor of MakeUnique.

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>
 
 #include <limits>
-#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 98 matching lines @@
         last_priority_set_(IDLE) {}
 
   ~TestNetworkStreamThrottler() override {
     EXPECT_TRUE(outstanding_throttles_.empty());
   }
 
   // NetworkThrottleManager
   std::unique_ptr<Throttle> CreateThrottle(ThrottleDelegate* delegate,
                                            RequestPriority priority,
                                            bool ignore_limits) override {
-    std::unique_ptr<TestThrottle> test_throttle(
-        new TestThrottle(throttle_new_requests_, delegate, this));
+    auto test_throttle =
+        base::MakeUnique<TestThrottle>(throttle_new_requests_, delegate, this);
     outstanding_throttles_.insert(test_throttle.get());
     return std::move(test_throttle);
   }
 
   void UnthrottleAllRequests() {
     std::set<TestThrottle*> outstanding_throttles_copy(outstanding_throttles_);
     for (auto* throttle : outstanding_throttles_copy) {
       if (throttle->IsBlocked())
         throttle->Unthrottle();
     }
@@ skipping 218 matching lines @@
 }
 
 // Note that the pointer written into |*throttler| will only be valid
 // for the lifetime of the returned HttpNetworkSession.
 std::unique_ptr<HttpNetworkSession> CreateSessionWithThrottler(
     SpdySessionDependencies* session_deps,
     TestNetworkStreamThrottler** throttler) {
   std::unique_ptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(session_deps));
 
-  std::unique_ptr<TestNetworkStreamThrottler> owned_throttler(
-      new TestNetworkStreamThrottler);
+  auto owned_throttler = base::MakeUnique<TestNetworkStreamThrottler>();
   *throttler = owned_throttler.get();
 
   HttpNetworkSessionPeer peer(session.get());
   peer.SetNetworkStreamThrottler(std::move(owned_throttler));
 
   return session;
 }
 
 }  // namespace
 
@@ skipping 461 matching lines @@
   MockRead data_reads[] = {
       MockRead("hello world"), MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), nullptr, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpRequestInfo request;
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   request.method = "GET";
   request.url = GURL("http://www.example.com:2000/");
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsError(ERR_INVALID_HTTP_RESPONSE));
 }
 
 // Response with no status line, and a weird port.  Option to allow weird ports
 // enabled.
 TEST_F(HttpNetworkTransactionTest, SimpleGETNoHeadersWeirdPortAllowed) {
   MockRead data_reads[] = {
       MockRead("hello world"), MockRead(SYNCHRONOUS, OK),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), nullptr, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   session_deps_.http_09_on_non_default_ports_enabled = true;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpRequestInfo request;
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   request.method = "GET";
   request.url = GURL("http://www.example.com:2000/");
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* info = trans->GetResponseInfo();
   ASSERT_TRUE(info->headers);
   EXPECT_EQ("HTTP/0.9 200 OK", info->headers->GetStatusLine());
@@ skipping 910 matching lines @@
 // Next 2 cases (KeepAliveEarlyClose and KeepAliveEarlyClose2) are regression
 // tests. There was a bug causing HttpNetworkTransaction to hang in the
 // destructor in such situations.
 // See http://crbug.com/154712 and http://crbug.com/156609.
 TEST_F(HttpNetworkTransactionTest, KeepAliveEarlyClose) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Connection: keep-alive\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead("hello"),
     MockRead(SYNCHRONOUS, 0),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
@@ skipping 18 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 TEST_F(HttpNetworkTransactionTest, KeepAliveEarlyClose2) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Connection: keep-alive\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(SYNCHRONOUS, 0),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 85 matching lines @@
   data.set_busy_before_sync_reads(true);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   const int kNumUnreadBodies = arraysize(data_writes) - 1;
   std::string response_lines[kNumUnreadBodies];
 
   uint32_t first_socket_log_id = NetLogSource::kInvalidId;
   for (size_t i = 0; i < kNumUnreadBodies; ++i) {
     TestCompletionCallback callback;
 
-    std::unique_ptr<HttpNetworkTransaction> trans(
-        new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+    auto trans = base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY,
+                                                          session.get());
 
     int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
     LoadTimingInfo load_timing_info;
     EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
     if (i == 0) {
       TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
       first_socket_log_id = load_timing_info.socket_log_id;
     } else {
@@ skipping 78 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "HEAD";
   request1.url = GURL("http://www.borked.com/");
 
-  std::unique_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans1 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1);
   ASSERT_TRUE(response1->headers);
   EXPECT_EQ(200, response1->headers->response_code());
   EXPECT_TRUE(response1->headers->IsKeepAlive());
 
   std::string response_data1;
   EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk());
   EXPECT_EQ("", response_data1);
   // Deleting the transaction attempts to release the socket back into the
   // socket pool.
   trans1.reset();
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("http://www.borked.com/foo");
 
-  std::unique_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans2 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   rv = trans2->Start(&request2, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2);
   ASSERT_TRUE(response2->headers);
   EXPECT_EQ(200, response2->headers->response_code());
 
   std::string response_data2;
   EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk());
@@ skipping 32 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("http://www.borked.com/");
 
-  std::unique_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans1 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1);
   ASSERT_TRUE(response1->headers);
   EXPECT_EQ(200, response1->headers->response_code());
   EXPECT_TRUE(response1->headers->IsKeepAlive());
 
   std::string response_data1;
   EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk());
   EXPECT_EQ("This server is borked.", response_data1);
   // Deleting the transaction attempts to release the socket back into the
   // socket pool.
   trans1.reset();
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("http://www.borked.com/foo");
 
-  std::unique_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans2 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   rv = trans2->Start(&request2, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2);
   ASSERT_TRUE(response2->headers);
   EXPECT_EQ(200, response2->headers->response_code());
 
   std::string response_data2;
   EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk());
@@ skipping 32 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("http://www.borked.com/");
 
-  std::unique_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans1 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1);
   ASSERT_TRUE(response1->headers);
   EXPECT_EQ(200, response1->headers->response_code());
   EXPECT_TRUE(response1->headers->IsKeepAlive());
 
   std::string response_data1;
   EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk());
   EXPECT_EQ("This server is borked.", response_data1);
   // Deleting the transaction attempts to release the socket back into the
   // socket pool.
   trans1.reset();
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("http://www.borked.com/foo");
 
-  std::unique_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans2 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   rv = trans2->Start(&request2, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2);
   ASSERT_TRUE(response2->headers);
   EXPECT_EQ(200, response2->headers->response_code());
 
   std::string response_data2;
   EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk());
@@ skipping 21 matching lines @@
   };
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("http://www.borked.com/");
 
-  std::unique_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
-  int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
+  int rv = trans->Start(&request1, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
-  const HttpResponseInfo* response1 = trans1->GetResponseInfo();
+  const HttpResponseInfo* response1 = trans->GetResponseInfo();
   ASSERT_TRUE(response1);
   ASSERT_TRUE(response1->headers);
   EXPECT_EQ(200, response1->headers->response_code());
   EXPECT_TRUE(response1->headers->IsKeepAlive());
 
   // Deleting the transaction creates an HttpResponseBodyDrainer to read the
   // response body.
-  trans1.reset();
+  trans.reset();
 
   // Let the HttpResponseBodyDrainer drain the socket.  It should determine the
   // socket can't be reused, rather than returning it to the socket pool.
   base::RunLoop().RunUntilIdle();
 
   // There should be no idle sockets in the pool.
   EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 // Test the request-challenge-retry sequence for basic auth.
@@ skipping 654 matching lines @@
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback1.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLogEventType::HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
@@ skipping 102 matching lines @@
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback1.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLogEventType::HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
@@ skipping 331 matching lines @@
   data1.set_busy_before_sync_reads(true);
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   SequencedSocketData data2(data_reads2, arraysize(data_reads2), data_writes2,
                             arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_THAT(callback1.GetResult(rv), IsOk());
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLogEventType::HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLogEventPhase::NONE);
   ExpectLogContainsSomewhere(
@@ skipping 350 matching lines @@
 TEST_F(HttpNetworkTransactionTest,
        AuthAllowsDefaultCredentialsTunnelConnectionClose) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service =
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
 
-  std::unique_ptr<HttpAuthHandlerMock::Factory> auth_handler_factory(
-      new HttpAuthHandlerMock::Factory());
+  auto auth_handler_factory = base::MakeUnique<HttpAuthHandlerMock::Factory>();
   auth_handler_factory->set_do_init_from_challenge(true);
-  std::unique_ptr<HttpAuthHandlerMock> mock_handler(new HttpAuthHandlerMock());
+  auto mock_handler = base::MakeUnique<HttpAuthHandlerMock>();
   mock_handler->set_allows_default_credentials(true);
   auth_handler_factory->AddMockHandler(mock_handler.release(),
                                        HttpAuth::AUTH_PROXY);
   session_deps_.http_auth_handler_factory = std::move(auth_handler_factory);
 
   // Add NetLog just so can verify load timing information gets a NetLog ID.
   NetLog net_log;
   session_deps_.net_log = &net_log;
   std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
 
@@ skipping 39 matching lines @@
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_FALSE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
@@ skipping 32 matching lines @@
 TEST_F(HttpNetworkTransactionTest,
        AuthAllowsDefaultCredentialsTunnelServerClosesConnection) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service =
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
 
-  std::unique_ptr<HttpAuthHandlerMock::Factory> auth_handler_factory(
-      new HttpAuthHandlerMock::Factory());
+  auto auth_handler_factory = base::MakeUnique<HttpAuthHandlerMock::Factory>();
   auth_handler_factory->set_do_init_from_challenge(true);
-  std::unique_ptr<HttpAuthHandlerMock> mock_handler(new HttpAuthHandlerMock());
+  auto mock_handler = base::MakeUnique<HttpAuthHandlerMock>();
   mock_handler->set_allows_default_credentials(true);
   auth_handler_factory->AddMockHandler(mock_handler.release(),
                                        HttpAuth::AUTH_PROXY);
   session_deps_.http_auth_handler_factory = std::move(auth_handler_factory);
 
   // Add NetLog just so can verify load timing information gets a NetLog ID.
   NetLog net_log;
   session_deps_.net_log = &net_log;
   std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
 
@@ skipping 42 matching lines @@
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
@@ skipping 34 matching lines @@
 TEST_F(HttpNetworkTransactionTest,
        AuthAllowsDefaultCredentialsTunnelServerClosesConnectionTwice) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service =
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
 
-  std::unique_ptr<HttpAuthHandlerMock::Factory> auth_handler_factory(
-      new HttpAuthHandlerMock::Factory());
+  auto auth_handler_factory = base::MakeUnique<HttpAuthHandlerMock::Factory>();
   auth_handler_factory->set_do_init_from_challenge(true);
-  std::unique_ptr<HttpAuthHandlerMock> mock_handler(new HttpAuthHandlerMock());
+  auto mock_handler = base::MakeUnique<HttpAuthHandlerMock>();
   mock_handler->set_allows_default_credentials(true);
   auth_handler_factory->AddMockHandler(mock_handler.release(),
                                        HttpAuth::AUTH_PROXY);
   session_deps_.http_auth_handler_factory = std::move(auth_handler_factory);
 
   // Add NetLog just so can verify load timing information gets a NetLog ID.
   NetLog net_log;
   session_deps_.net_log = &net_log;
   std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
 
@@ skipping 35 matching lines @@
       MockRead(SYNCHRONOUS, ERR_CONNECTION_CLOSED),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
@@ skipping 17 matching lines @@
 TEST_F(HttpNetworkTransactionTest,
        AuthAllowsDefaultCredentialsTunnelServerChallengesTwice) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service =
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
 
-  std::unique_ptr<HttpAuthHandlerMock::Factory> auth_handler_factory(
-      new HttpAuthHandlerMock::Factory());
+  auto auth_handler_factory = base::MakeUnique<HttpAuthHandlerMock::Factory>();
   auth_handler_factory->set_do_init_from_challenge(true);
-  std::unique_ptr<HttpAuthHandlerMock> mock_handler(new HttpAuthHandlerMock());
+  auto mock_handler = base::MakeUnique<HttpAuthHandlerMock>();
   mock_handler->set_allows_default_credentials(true);
   auth_handler_factory->AddMockHandler(mock_handler.release(),
                                        HttpAuth::AUTH_PROXY);
   // Add another handler for the second challenge. It supports default
   // credentials, but they shouldn't be used, since they were already tried.
-  mock_handler.reset(new HttpAuthHandlerMock());
+  mock_handler = base::MakeUnique<HttpAuthHandlerMock>();
   mock_handler->set_allows_default_credentials(true);
   auth_handler_factory->AddMockHandler(mock_handler.release(),
                                        HttpAuth::AUTH_PROXY);
   session_deps_.http_auth_handler_factory = std::move(auth_handler_factory);
 
   // Add NetLog just so can verify load timing information gets a NetLog ID.
   NetLog net_log;
   session_deps_.net_log = &net_log;
   std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
 
@@ skipping 30 matching lines @@
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
@@ skipping 19 matching lines @@
 // A more nuanced test than GenerateAuthToken test which asserts that
 // ERR_INVALID_AUTH_CREDENTIALS does not cause the auth scheme to be
 // unnecessarily invalidated, and that if the server co-operates, the
 // authentication handshake can continue with the same scheme but with a
 // different identity.
 TEST_F(HttpNetworkTransactionTest, NonPermanentGenerateAuthTokenError) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
 
-  std::unique_ptr<HttpAuthHandlerMock::Factory> auth_handler_factory(
-      new HttpAuthHandlerMock::Factory());
+  auto auth_handler_factory = base::MakeUnique<HttpAuthHandlerMock::Factory>();
   auth_handler_factory->set_do_init_from_challenge(true);
 
   // First handler. Uses default credentials, but barfs at generate auth token.
-  std::unique_ptr<HttpAuthHandlerMock> mock_handler(new HttpAuthHandlerMock());
+  auto mock_handler = base::MakeUnique<HttpAuthHandlerMock>();
   mock_handler->set_allows_default_credentials(true);
   mock_handler->set_allows_explicit_credentials(true);
   mock_handler->set_connection_based(true);
   mock_handler->SetGenerateExpectation(true, ERR_INVALID_AUTH_CREDENTIALS);
   auth_handler_factory->AddMockHandler(mock_handler.release(),
                                        HttpAuth::AUTH_SERVER);
 
   // Add another handler for the second challenge. It supports default
   // credentials, but they shouldn't be used, since they were already tried.
-  mock_handler.reset(new HttpAuthHandlerMock());
+  mock_handler = base::MakeUnique<HttpAuthHandlerMock>();
   mock_handler->set_allows_default_credentials(true);
   mock_handler->set_allows_explicit_credentials(true);
   mock_handler->set_connection_based(true);
   auth_handler_factory->AddMockHandler(mock_handler.release(),
                                        HttpAuth::AUTH_SERVER);
   session_deps_.http_auth_handler_factory = std::move(auth_handler_factory);
 
   std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
 
   MockWrite data_writes1[] = {
@@ skipping 43 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
 
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
 
   StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
                                  data_writes3, arraysize(data_writes3));
   session_deps_.socket_factory->AddSocketDataProvider(&data3);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
@@ skipping 73 matching lines @@
     MockRead(SYNCHRONOUS, "22"),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
-  std::unique_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans1 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1->Start(&request1, callback1.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback1.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1);
   EXPECT_TRUE(response1->proxy_server.is_http());
   ASSERT_TRUE(response1->headers);
   EXPECT_EQ(1, response1->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info1;
   EXPECT_TRUE(trans1->GetLoadTimingInfo(&load_timing_info1));
   TestLoadTimingNotReused(load_timing_info1, CONNECT_TIMING_HAS_SSL_TIMES);
 
   trans1.reset();
 
   TestCompletionCallback callback2;
-  std::unique_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans2 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans2->Start(&request2, callback2.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback2.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2);
   EXPECT_TRUE(response2->proxy_server.is_http());
@@ skipping 56 matching lines @@
     MockRead(SYNCHRONOUS, "22"),
   };
 
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
                                  data_writes1, arraysize(data_writes1));
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
-  std::unique_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans1 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans1->Start(&request1, callback1.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback1.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1);
   ASSERT_TRUE(response1->headers);
   EXPECT_EQ(1, response1->headers->GetContentLength());
 
   LoadTimingInfo load_timing_info1;
   EXPECT_TRUE(trans1->GetLoadTimingInfo(&load_timing_info1));
   TestLoadTimingNotReusedWithPac(load_timing_info1,
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 
   trans1.reset();
 
   TestCompletionCallback callback2;
-  std::unique_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans2 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans2->Start(&request2, callback2.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback2.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
   ASSERT_TRUE(response2);
   ASSERT_TRUE(response2->headers);
@@ skipping 713 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
 
   TestCompletionCallback callback;
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   int rv = trans->Start(&request1, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   scoped_refptr<IOBuffer> buf(new IOBuffer(256));
   EXPECT_EQ(1, trans->Read(buf.get(), 256, callback.callback()));
   trans.reset();
 
-  std::unique_ptr<HttpNetworkTransaction> trans2(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans2 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   rv = trans2->Start(&request2, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   LoadTimingInfo load_timing_info2;
   EXPECT_TRUE(trans2->GetLoadTimingInfo(&load_timing_info2));
   TestLoadTimingReused(load_timing_info2);
 
@@ skipping 56 matching lines @@
   SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes,
                                 arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   int rv = trans->Start(&request1, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReused(load_timing_info,
                           CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
@@ skipping 830 matching lines @@
 TEST_F(HttpNetworkTransactionTest, DontRecycleTransportSocketForSSLTunnel) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service = ProxyService::CreateFixed("myproxy:70");
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes1[] = {
       MockWrite("CONNECT www.example.org:443 HTTP/1.1\r\n"
                 "Host: www.example.org:443\r\n"
                 "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   // The proxy responds to the connect with a 404, using a persistent
   // connection. Usually a proxy would return 501 (not implemented),
@@ skipping 170 matching lines @@
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   StaticSocketDataProvider data2(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
 
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_THAT(rv, IsOk());
   EXPECT_EQ("hello world", response_data);
 
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
   base::RunLoop().RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
   EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 
   // Now start the second transaction, which should reuse the previous socket.
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans->Start(&request, callback.callback(), NetLogWithSource());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 1614 matching lines @@
   // Negotiate SPDY to the proxy
   SSLSocketDataProvider proxy(ASYNC, OK);
   proxy.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
   // Vanilla SSL to the server
   SSLSocketDataProvider server(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&server);
 
   TestCompletionCallback callback1;
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback1.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
       entries, 0, NetLogEventType::HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
@@ skipping 37 matching lines @@
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 
   trans.reset();
   session->CloseAllConnections();
 }
 
 // Test that an explicitly trusted SPDY proxy can push a resource from an
 // origin that is different from that of its associated resource.
 TEST_F(HttpNetworkTransactionTest, CrossOriginSPDYProxyPush) {
   // Configure the proxy delegate to allow cross-origin SPDY pushes.
-  std::unique_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
+  auto proxy_delegate = base::MakeUnique<TestProxyDelegate>();
   proxy_delegate->set_trusted_spdy_proxy(net::ProxyServer::FromURI(
       "https://myproxy:443", net::ProxyServer::SCHEME_HTTP));
   HttpRequestInfo request;
   HttpRequestInfo push_request;
 
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   push_request.method = "GET";
   push_request.url = GURL("http://www.another-origin.com/foo.dat");
 
@@ skipping 37 matching lines @@
   };
 
   SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes,
                                 arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
   // Negotiate SPDY to the proxy
   SSLSocketDataProvider proxy(ASYNC, OK);
   proxy.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
-  std::unique_ptr<HttpNetworkTransaction> push_trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto push_trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   rv = push_trans->Start(&push_request, callback.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   const HttpResponseInfo* push_response = push_trans->GetResponseInfo();
 
   ASSERT_TRUE(response);
   EXPECT_TRUE(response->headers->IsKeepAlive());
 
@@ skipping 27 matching lines @@
             push_load_timing_info.socket_log_id);
 
   trans.reset();
   push_trans.reset();
   session->CloseAllConnections();
 }
 
 // Test that an explicitly trusted SPDY proxy cannot push HTTPS content.
 TEST_F(HttpNetworkTransactionTest, CrossOriginProxyPushCorrectness) {
   // Configure the proxy delegate to allow cross-origin SPDY pushes.
-  std::unique_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
+  auto proxy_delegate = base::MakeUnique<TestProxyDelegate>();
   proxy_delegate->set_trusted_spdy_proxy(net::ProxyServer::FromURI(
       "https://myproxy:443", net::ProxyServer::SCHEME_HTTP));
   HttpRequestInfo request;
 
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
 
   session_deps_.proxy_service =
       ProxyService::CreateFixed("https://myproxy:443");
   BoundTestNetLog log;
@@ skipping 30 matching lines @@
   };
 
   SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes,
                                 arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
   // Negotiate SPDY to the proxy
   SSLSocketDataProvider proxy(ASYNC, OK);
   proxy.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response);
   EXPECT_TRUE(response->headers->IsKeepAlive());
 
   EXPECT_EQ(200, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_THAT(rv, IsOk());
   EXPECT_EQ("hello!", response_data);
 
   trans.reset();
   session->CloseAllConnections();
 }
 
 // Test that an explicitly trusted SPDY proxy can push same-origin HTTPS
 // resources.
 TEST_F(HttpNetworkTransactionTest, SameOriginProxyPushCorrectness) {
   // Configure the proxy delegate to allow cross-origin SPDY pushes.
-  std::unique_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
+  auto proxy_delegate = base::MakeUnique<TestProxyDelegate>();
   proxy_delegate->set_trusted_spdy_proxy(
       net::ProxyServer::FromURI("myproxy:70", net::ProxyServer::SCHEME_HTTP));
 
   HttpRequestInfo request;
 
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
 
   // Configure against https proxy server "myproxy:70".
   session_deps_.proxy_service = ProxyService::CreateFixed("https://myproxy:70");
@@ skipping 37 matching lines @@
   };
 
   SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes,
                                 arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
   // Negotiate SPDY to the proxy
   SSLSocketDataProvider proxy(ASYNC, OK);
   proxy.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response);
   EXPECT_TRUE(response->headers->IsKeepAlive());
@@ skipping 876 matching lines @@
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     session_deps_.proxy_service =
         ProxyService::CreateFixed(tests[i].proxy_server);
     std::unique_ptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(&session_deps_));
 
     HttpNetworkSessionPeer peer(session.get());
     CaptureGroupNameTransportSocketPool* transport_conn_pool =
-        new CaptureGroupNameTransportSocketPool(NULL, NULL);
+        new CaptureGroupNameTransportSocketPool(nullptr, nullptr);
     CaptureGroupNameSSLSocketPool* ssl_conn_pool =
-        new CaptureGroupNameSSLSocketPool(NULL, NULL);
-    std::unique_ptr<MockClientSocketPoolManager> mock_pool_manager(
-        new MockClientSocketPoolManager);
+        new CaptureGroupNameSSLSocketPool(nullptr, nullptr);
+    auto mock_pool_manager = base::MakeUnique<MockClientSocketPoolManager>();
     mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
     mock_pool_manager->SetSSLSocketPool(ssl_conn_pool);
     peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
 
     EXPECT_EQ(ERR_IO_PENDING,
               GroupNameTransactionHelper(tests[i].url, session.get()));
     if (tests[i].ssl)
       EXPECT_EQ(tests[i].expected_group_name,
                 ssl_conn_pool->last_group_name_received());
     else
@@ skipping 40 matching lines @@
     std::unique_ptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(&session_deps_));
 
     HttpNetworkSessionPeer peer(session.get());
 
     HostPortPair proxy_host("http_proxy", 80);
     CaptureGroupNameHttpProxySocketPool* http_proxy_pool =
         new CaptureGroupNameHttpProxySocketPool(NULL, NULL);
     CaptureGroupNameSSLSocketPool* ssl_conn_pool =
         new CaptureGroupNameSSLSocketPool(NULL, NULL);
-
-    std::unique_ptr<MockClientSocketPoolManager> mock_pool_manager(
-        new MockClientSocketPoolManager);
+    auto mock_pool_manager = base::MakeUnique<MockClientSocketPoolManager>();
     mock_pool_manager->SetSocketPoolForHTTPProxy(
         proxy_host, base::WrapUnique(http_proxy_pool));
     mock_pool_manager->SetSocketPoolForSSLWithProxy(
         proxy_host, base::WrapUnique(ssl_conn_pool));
     peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
 
     EXPECT_EQ(ERR_IO_PENDING,
               GroupNameTransactionHelper(tests[i].url, session.get()));
     if (tests[i].ssl)
       EXPECT_EQ(tests[i].expected_group_name,
@@ skipping 47 matching lines @@
     std::unique_ptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(&session_deps_));
 
     HttpNetworkSessionPeer peer(session.get());
 
     HostPortPair proxy_host("socks_proxy", 1080);
     CaptureGroupNameSOCKSSocketPool* socks_conn_pool =
         new CaptureGroupNameSOCKSSocketPool(NULL, NULL);
     CaptureGroupNameSSLSocketPool* ssl_conn_pool =
         new CaptureGroupNameSSLSocketPool(NULL, NULL);
-
-    std::unique_ptr<MockClientSocketPoolManager> mock_pool_manager(
-        new MockClientSocketPoolManager);
+    auto mock_pool_manager = base::MakeUnique<MockClientSocketPoolManager>();
     mock_pool_manager->SetSocketPoolForSOCKSProxy(
         proxy_host, base::WrapUnique(socks_conn_pool));
     mock_pool_manager->SetSocketPoolForSSLWithProxy(
         proxy_host, base::WrapUnique(ssl_conn_pool));
     peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
 
     HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
 
     EXPECT_EQ(ERR_IO_PENDING,
               GroupNameTransactionHelper(tests[i].url, session.get()));
@@ skipping 34 matching lines @@
 // bypass the cache, the DNS cache is not used.
 void HttpNetworkTransactionTest::BypassHostCacheOnRefreshHelper(
     int load_flags) {
   // Issue a request, asking to bypass the cache(s).
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.load_flags = load_flags;
   request_info.url = GURL("http://www.example.org/");
 
   // Select a host resolver that does caching.
-  session_deps_.host_resolver.reset(new MockCachingHostResolver);
+  session_deps_.host_resolver = base::MakeUnique<MockCachingHostResolver>();
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
 
   // Warm up the host cache so it has an entry for "www.example.org".
   AddressList addrlist;
   TestCompletionCallback callback;
   std::unique_ptr<HostResolver::Request> request1;
   int rv = session_deps_.host_resolver->Resolve(
       HostResolver::RequestInfo(HostPortPair("www.example.org", 80)),
@@ skipping 374 matching lines @@
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(base::WrapUnique(fake_reader));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/upload");
   request.upload_data_stream = &upload_data_stream;
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   StaticSocketDataProvider data;
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   base::RunLoop().RunUntilIdle();
 
   // Transaction is pending on request body initialization.
@@ skipping 981 matching lines @@
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_non_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps_.socket_factory->AddSocketDataProvider(
       &hanging_non_alternate_protocol_socket);
 
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
@@ skipping 146 matching lines @@
 
   // 2nd request is just a copy of the first one, over HTTP/1.1 again.
   StaticSocketDataProvider second_transaction(data_reads, arraysize(data_reads),
                                               NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&second_transaction);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
@@ skipping 31 matching lines @@
 class CapturingProxyResolverFactory : public ProxyResolverFactory {
  public:
   explicit CapturingProxyResolverFactory(CapturingProxyResolver* resolver)
       : ProxyResolverFactory(false), resolver_(resolver) {}
 
   int CreateProxyResolver(
       const scoped_refptr<ProxyResolverScriptData>& pac_script,
       std::unique_ptr<ProxyResolver>* resolver,
       const net::CompletionCallback& callback,
       std::unique_ptr<Request>* request) override {
-    resolver->reset(new ForwardingProxyResolver(resolver_));
+    *resolver = base::MakeUnique<ForwardingProxyResolver>(resolver_);
     return OK;
   }
 
  private:
   ProxyResolver* resolver_;
 };
 
 // Test that proxy is resolved using the origin url,
 // regardless of the alternative server.
 TEST_F(HttpNetworkTransactionTest, UseOriginNotAlternativeForProxy) {
@@ skipping 79 matching lines @@
   // Origin host bypasses proxy, no resolution should have happened.
   ASSERT_TRUE(capturing_proxy_resolver.resolved().empty());
 }
 
 TEST_F(HttpNetworkTransactionTest, UseAlternativeServiceForTunneledNpnSpdy) {
   ProxyConfig proxy_config;
   proxy_config.set_auto_detect(true);
   proxy_config.set_pac_url(GURL("http://fooproxyurl"));
 
   CapturingProxyResolver capturing_proxy_resolver;
-  session_deps_.proxy_service.reset(
-      new ProxyService(base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
-                       base::MakeUnique<CapturingProxyResolverFactory>(
-                           &capturing_proxy_resolver),
-                       NULL));
+  session_deps_.proxy_service = base::MakeUnique<ProxyService>(
+      base::MakeUnique<ProxyConfigServiceFixed>(proxy_config),
+      base::MakeUnique<CapturingProxyResolverFactory>(
+          &capturing_proxy_resolver),
+      nullptr);
   TestNetLog net_log;
   session_deps_.net_log = &net_log;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
 
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead(kAlternativeServiceHttpHeader),
@@ skipping 39 matching lines @@
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_non_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps_.socket_factory->AddSocketDataProvider(
       &hanging_non_alternate_protocol_socket);
 
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/0.9 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_alpn_negotiated);
 
   std::string response_data;
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello world", response_data);
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
@@ skipping 47 matching lines @@
   };
 
   SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes,
                                 arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   TestCompletionCallback callback;
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello world", response_data);
 
   // Set up an initial SpdySession in the pool to reuse.
   HostPortPair host_port_pair("www.example.org", 443);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
                      PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> spdy_session =
       CreateSecureSpdySession(session.get(), key, NetLogWithSource());
 
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
@@ skipping 889 matching lines @@
       }
 
       // Add an SSL sequence if necessary.
       if (round >= test_config.first_ssl_round)
         session_deps_.socket_factory->AddSSLSocketDataProvider(
             &ssl_socket_data_provider);
     }
 
     std::vector<std::unique_ptr<StaticSocketDataProvider>> data_providers;
     for (size_t i = 0; i < mock_reads.size(); ++i) {
-      data_providers.push_back(base::WrapUnique(new StaticSocketDataProvider(
+      data_providers.push_back(base::MakeUnique<StaticSocketDataProvider>(
           mock_reads[i].data(), mock_reads[i].size(), mock_writes[i].data(),
-          mock_writes[i].size())));
+          mock_writes[i].size()));
       session_deps_.socket_factory->AddSocketDataProvider(
           data_providers.back().get());
     }
 
     // Transaction must be created after DataProviders, so it's destroyed before
     // they are as well.
     HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
 
     for (int round = 0; round < test_config.num_auth_rounds; ++round) {
       SCOPED_TRACE(round);
@@ skipping 57 matching lines @@
 
   // Use a TCP Socket Pool with only one connection per group. This is used
   // to validate that the TCP socket is not released to the pool between
   // each round of multi-round authentication.
   HttpNetworkSessionPeer session_peer(session.get());
   TransportClientSocketPool* transport_pool = new TransportClientSocketPool(
       50,  // Max sockets for pool
       1,   // Max sockets per group
       session_deps_.host_resolver.get(), session_deps_.socket_factory.get(),
       NULL, session_deps_.net_log);
-  std::unique_ptr<MockClientSocketPoolManager> mock_pool_manager(
-      new MockClientSocketPoolManager);
+  auto mock_pool_manager = base::MakeUnique<MockClientSocketPoolManager>();
   mock_pool_manager->SetTransportSocketPool(transport_pool);
   session_peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
 
   const MockWrite kGet(
       "GET / HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
       "Connection: keep-alive\r\n\r\n");
@@ skipping 266 matching lines @@
     MockRead(SYNCHRONOUS, "hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
 
   session_deps_.host_resolver->set_synchronous_mode(true);
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   data.set_connect_data(mock_connect);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   BoundTestNetLog log;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@@ skipping 727 matching lines @@
     ASSERT_FALSE(session->ssl_client_auth_cache()->Lookup(
         HostPortPair("proxy", 70), &client_cert, &client_private_key));
     ASSERT_FALSE(session->ssl_client_auth_cache()->Lookup(
         HostPortPair("www.example.com", 443), &client_cert,
         &client_private_key));
   }
 }
 
 TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) {
   // Set up a special HttpNetworkSession with a MockCachingHostResolver.
-  session_deps_.host_resolver.reset(new MockCachingHostResolver());
+  session_deps_.host_resolver = base::MakeUnique<MockCachingHostResolver>();
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   AddSSLSocketData();
 
   SpdySerializedFrame host1_req(
       spdy_util_.ConstructSpdyGet("https://www.example.org", 1, LOWEST));
   spdy_util_.UpdateWithStreamDestruction(1);
   SpdySerializedFrame host2_req(
       spdy_util_.ConstructSpdyGet("https://mail.example.com", 3, LOWEST));
   MockWrite spdy_writes[] = {
@@ skipping 64 matching lines @@
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_alpn_negotiated);
   ASSERT_THAT(ReadTransaction(&trans2, &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
 }
 
 TEST_F(HttpNetworkTransactionTest, UseIPConnectionPoolingAfterResolution) {
   // Set up a special HttpNetworkSession with a MockCachingHostResolver.
-  session_deps_.host_resolver.reset(new MockCachingHostResolver());
+  session_deps_.host_resolver = base::MakeUnique<MockCachingHostResolver>();
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   AddSSLSocketData();
 
   SpdySerializedFrame host1_req(
       spdy_util_.ConstructSpdyGet("https://www.example.org", 1, LOWEST));
   spdy_util_.UpdateWithStreamDestruction(1);
   SpdySerializedFrame host2_req(
       spdy_util_.ConstructSpdyGet("https://mail.example.com", 3, LOWEST));
   MockWrite spdy_writes[] = {
@@ skipping 61 matching lines @@
 // The server might not be able to serve an IP pooled request, and might send a
 // 421 Misdirected Request response status to indicate this.
 // HttpNetworkTransaction should reset the request and retry without IP pooling.
 TEST_F(HttpNetworkTransactionTest, RetryWithoutConnectionPooling) {
   // Two hosts resolve to the same IP address.
   const std::string ip_addr = "1.2.3.4";
   IPAddress ip;
   ASSERT_TRUE(ip.AssignFromIPLiteral(ip_addr));
   IPEndPoint peer_addr = IPEndPoint(ip, 443);
 
-  session_deps_.host_resolver.reset(new MockCachingHostResolver());
+  session_deps_.host_resolver = base::MakeUnique<MockCachingHostResolver>();
   session_deps_.host_resolver->rules()->AddRule("www.example.org", ip_addr);
   session_deps_.host_resolver->rules()->AddRule("mail.example.org", ip_addr);
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Two requests on the first connection.
   SpdySerializedFrame req1(
       spdy_util_.ConstructSpdyGet("https://www.example.org", 1, LOWEST));
   spdy_util_.UpdateWithStreamDestruction(1);
   SpdySerializedFrame req2(
@@ skipping 107 matching lines @@
 // Test that HTTP 421 responses are properly returned to the caller if received
 // on the retry as well. HttpNetworkTransaction should not infinite loop or lose
 // portions of the response.
 TEST_F(HttpNetworkTransactionTest, ReturnHTTP421OnRetry) {
   // Two hosts resolve to the same IP address.
   const std::string ip_addr = "1.2.3.4";
   IPAddress ip;
   ASSERT_TRUE(ip.AssignFromIPLiteral(ip_addr));
   IPEndPoint peer_addr = IPEndPoint(ip, 443);
 
-  session_deps_.host_resolver.reset(new MockCachingHostResolver());
+  session_deps_.host_resolver = base::MakeUnique<MockCachingHostResolver>();
   session_deps_.host_resolver->rules()->AddRule("www.example.org", ip_addr);
   session_deps_.host_resolver->rules()->AddRule("mail.example.org", ip_addr);
 
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Two requests on the first connection.
   SpdySerializedFrame req1(
       spdy_util_.ConstructSpdyGet("https://www.example.org", 1, LOWEST));
   spdy_util_.UpdateWithStreamDestruction(1);
   SpdySerializedFrame req2(
@@ skipping 737 matching lines @@
 
   SequencedSocketData data2(reads2, arraysize(reads2), writes2,
                             arraysize(writes2));
   MockConnect connect_data2(ASYNC, OK);
   data2.set_connect_data(connect_data2);
 
   // Set up a proxy config that sends HTTP requests to a proxy, and
   // all others direct.
   ProxyConfig proxy_config;
   proxy_config.proxy_rules().ParseFromString("http=https://proxy:443");
-  session_deps_.proxy_service.reset(new ProxyService(
-      base::WrapUnique(new ProxyConfigServiceFixed(proxy_config)), nullptr,
-      NULL));
+  session_deps_.proxy_service = base::MakeUnique<ProxyService>(
+      base::MakeUnique<ProxyConfigServiceFixed>(proxy_config), nullptr,
+      nullptr);
 
   SSLSocketDataProvider ssl1(ASYNC, OK);  // to the proxy
   ssl1.next_proto = kProtoHTTP2;
   // Load a valid cert.  Note, that this does not need to
   // be valid for proxy because the MockSSLClientSocket does
   // not actually verify it.  But SpdySession will use this
   // to see if it is valid for the new origin
   ssl1.cert = ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem");
   ASSERT_TRUE(ssl1.cert);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1);
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
 
   SSLSocketDataProvider ssl2(ASYNC, OK);  // to the server
   ssl2.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
 
-  session_deps_.host_resolver.reset(new MockCachingHostResolver());
+  session_deps_.host_resolver = base::MakeUnique<MockCachingHostResolver>();
   session_deps_.host_resolver->rules()->AddRule("news.example.org", ip_addr);
   session_deps_.host_resolver->rules()->AddRule("proxy", ip_addr);
 
   std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
 
   // Start the first transaction to set up the SpdySession
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL(url1);
   request1.load_flags = 0;
@@ skipping 120 matching lines @@
   SpdySerializedFrame host1_resp_body(
       spdy_util_.ConstructSpdyDataFrame(1, true));
   MockRead spdy1_reads[] = {
       CreateMockRead(host1_resp, 1), CreateMockRead(host1_resp_body, 2),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 3),
   };
 
   // Use a separate test instance for the separate SpdySession that will be
   // created.
   SpdyTestUtil spdy_util_2;
-  std::unique_ptr<SequencedSocketData> spdy1_data(
-      new SequencedSocketData(spdy1_reads, arraysize(spdy1_reads), spdy1_writes,
-                              arraysize(spdy1_writes)));
+  auto spdy1_data = base::MakeUnique<SequencedSocketData>(
+      spdy1_reads, arraysize(spdy1_reads), spdy1_writes,
+      arraysize(spdy1_writes));
   session_deps_.socket_factory->AddSocketDataProvider(spdy1_data.get());
 
   SpdySerializedFrame host2_req(
       spdy_util_2.ConstructSpdyGet("https://www.b.com", 1, DEFAULT_PRIORITY));
   MockWrite spdy2_writes[] = {
       CreateMockWrite(host2_req, 0),
   };
   SpdySerializedFrame host2_resp(spdy_util_2.ConstructSpdyGetReply(NULL, 0, 1));
   SpdySerializedFrame host2_resp_body(
       spdy_util_2.ConstructSpdyDataFrame(1, true));
   MockRead spdy2_reads[] = {
       CreateMockRead(host2_resp, 1), CreateMockRead(host2_resp_body, 2),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 3),
   };
 
-  std::unique_ptr<SequencedSocketData> spdy2_data(
-      new SequencedSocketData(spdy2_reads, arraysize(spdy2_reads), spdy2_writes,
-                              arraysize(spdy2_writes)));
+  auto spdy2_data = base::MakeUnique<SequencedSocketData>(
+      spdy2_reads, arraysize(spdy2_reads), spdy2_writes,
+      arraysize(spdy2_writes));
   session_deps_.socket_factory->AddSocketDataProvider(spdy2_data.get());
 
   MockWrite http_write[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.a.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead http_read[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 6\r\n\r\n"),
     MockRead("hello!"),
   };
   StaticSocketDataProvider http_data(http_read, arraysize(http_read),
                                      http_write, arraysize(http_write));
   session_deps_.socket_factory->AddSocketDataProvider(&http_data);
 
   HostPortPair host_port_pair_a("www.a.com", 443);
   SpdySessionKey spdy_session_key_a(
       host_port_pair_a, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   EXPECT_FALSE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_a));
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.a.com/");
   request1.load_flags = 0;
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   int rv = trans->Start(&request1, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_alpn_negotiated);
 
   std::string response_data;
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
   trans.reset();
   EXPECT_TRUE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_a));
 
   HostPortPair host_port_pair_b("www.b.com", 443);
   SpdySessionKey spdy_session_key_b(
       host_port_pair_b, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   EXPECT_FALSE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_b));
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://www.b.com/");
   request2.load_flags = 0;
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans->Start(&request2, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_alpn_negotiated);
   ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
   EXPECT_FALSE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_a));
   EXPECT_TRUE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_b));
 
   HostPortPair host_port_pair_a1("www.a.com", 80);
   SpdySessionKey spdy_session_key_a1(
       host_port_pair_a1, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   EXPECT_FALSE(
       HasSpdySession(session->spdy_session_pool(), spdy_session_key_a1));
   HttpRequestInfo request3;
   request3.method = "GET";
   request3.url = GURL("http://www.a.com/");
   request3.load_flags = 0;
-  trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   rv = trans->Start(&request3, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
@@ skipping 987 matching lines @@
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("http://www.foo.com/");
   request1.load_flags = 0;
 
-  std::unique_ptr<HttpNetworkTransaction> trans1(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans1 =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());
 
   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
   ASSERT_TRUE(response1);
 
   EXPECT_TRUE(response1->headers);
   EXPECT_EQ("HTTP/1.1 200 Peachy", response1->headers->GetStatusLine());
 
   std::string response_data1;
   rv = ReadTransaction(trans1.get(), &response_data1);
   EXPECT_THAT(rv, IsOk());
   EXPECT_EQ("first response", response_data1);
   // Delete the transaction to release the socket back into the socket pool.
   trans1.reset();
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("foo", 3)));
+      base::MakeUnique<UploadBytesElementReader>("foo", 3));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request2;
   request2.method = "POST";
   request2.url = GURL("http://www.foo.com/");
   request2.upload_data_stream = &upload_data_stream;
   request2.load_flags = 0;
 
   HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
   rv = trans2.Start(&request2, callback.callback(), NetLogWithSource());
@@ skipping 389 matching lines @@
       MockRead("Connection: Upgrade\r\n"),
       MockRead("Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n\r\n"),
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   FakeWebSocketStreamCreateHelper websocket_stream_create_helper;
   trans->SetWebSocketHandshakeStreamCreateHelper(
       &websocket_stream_create_helper);
 
   {
     TestCompletionCallback callback;
 
     int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
@@ skipping 77 matching lines @@
   };
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   session->http_auth_cache()->Add(
       GURL("http://myproxy:70/"), "MyRealm1", HttpAuth::AUTH_SCHEME_BASIC,
       "Basic realm=MyRealm1", AuthCredentials(kFoo, kBar), "/");
 
-  std::unique_ptr<HttpNetworkTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
   FakeWebSocketStreamCreateHelper websocket_stream_create_helper;
   trans->SetWebSocketHandshakeStreamCreateHelper(
       &websocket_stream_create_helper);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = callback.WaitForResult();
@@ skipping 152 matching lines @@
 TEST_F(HttpNetworkTransactionTest, ThrottlingUnthrottled) {
   TestNetworkStreamThrottler* throttler(nullptr);
   std::unique_ptr<HttpNetworkSession> session(
       CreateSessionWithThrottler(&session_deps_, &throttler));
 
   // Send a simple request and make sure it goes through.
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
 
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   MockWrite data_writes[] = {
       MockWrite("GET / HTTP/1.1\r\n"
                 "Host: www.example.org\r\n"
                 "Connection: keep-alive\r\n\r\n"),
   };
   MockRead data_reads[] = {
       MockRead("HTTP/1.0 200 OK\r\n\r\n"), MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
   };
@@ skipping 27 matching lines @@
       MockRead("HTTP/1.0 200 OK\r\n\r\n"), MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider reads(data_reads, arraysize(data_reads), data_writes,
                                  arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&reads);
 
   // Start a request that will be throttled at start; confirm it
   // doesn't complete.
   throttler->set_throttle_new_requests(true);
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_THROTTLED, trans->GetLoadState());
   EXPECT_FALSE(callback.have_result());
 
   // Confirm the request goes on to complete when unthrottled.
@@ skipping 23 matching lines @@
       MockRead("HTTP/1.0 200 OK\r\n\r\n"), MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider reads(data_reads, arraysize(data_reads), data_writes,
                                  arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&reads);
 
   // Start a request that will be throttled at start; confirm it
   // doesn't complete.
   throttler->set_throttle_new_requests(true);
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_THROTTLED, trans->GetLoadState());
   EXPECT_FALSE(callback.have_result());
 
   EXPECT_EQ(1u, throttler->num_outstanding_requests());
@@ skipping 19 matching lines @@
   };
   MockRead data_reads[] = {
       MockRead("HTTP/1.0 200 OK\r\n\r\n"), MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider reads(data_reads, arraysize(data_reads), data_writes,
                                  arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&reads);
 
   throttler->set_throttle_new_requests(true);
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(IDLE, session.get()));
+  auto trans = base::MakeUnique<HttpNetworkTransaction>(IDLE, session.get());
   // Start the transaction to associate a throttle with it.
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(0, throttler->num_set_priority_calls());
   trans->SetPriority(LOW);
   EXPECT_EQ(1, throttler->num_set_priority_calls());
   EXPECT_EQ(LOW, throttler->last_priority_set());
 
@@ skipping 28 matching lines @@
                                  arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&reads);
 
   StaticSocketDataProvider reads1(data_reads, arraysize(data_reads),
                                   data_writes, arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&reads1);
 
   // Start a request that will be throttled at start; confirm it
   // doesn't complete.
   throttler->set_throttle_new_requests(true);
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_THROTTLED, trans->GetLoadState());
   EXPECT_FALSE(callback.have_result());
 
   // Create a new request, call SetPriority on it to unthrottle,
   // and make sure that allows the original request to complete.
-  std::unique_ptr<HttpTransaction> trans1(
-      new HttpNetworkTransaction(LOW, session.get()));
+  auto trans1 = base::MakeUnique<HttpNetworkTransaction>(LOW, session.get());
   throttler->set_priority_change_closure(
       base::Bind(&TestNetworkStreamThrottler::UnthrottleAllRequests,
                  base::Unretained(throttler)));
 
   // Start the transaction to associate a throttle with it.
   TestCompletionCallback callback1;
   rv = trans1->Start(&request, callback1.callback(), NetLogWithSource());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   trans1->SetPriority(IDLE);
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(callback.have_result());
   EXPECT_EQ(OK, callback.WaitForResult());
   ASSERT_TRUE(callback1.have_result());
   EXPECT_EQ(OK, callback1.WaitForResult());
 }
 
 // Transaction will be destroyed when the unique_ptr goes out of scope.
-void DestroyTransaction(std::unique_ptr<HttpTransaction> transaction) {}
+void DestroyTransaction(std::unique_ptr<HttpNetworkTransaction> transaction) {}
 
 // Confirm that destroying a transaction from a SetPriority call by the
 // throttler works properly.
 TEST_F(HttpNetworkTransactionTest, ThrottlingPrioritySetDestroy) {
   TestNetworkStreamThrottler* throttler(nullptr);
   std::unique_ptr<HttpNetworkSession> session(
       CreateSessionWithThrottler(&session_deps_, &throttler));
 
   // Send a simple request and make sure it goes through.
   HttpRequestInfo request;
@@ skipping 13 matching lines @@
                                  arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&reads);
 
   StaticSocketDataProvider reads1(data_reads, arraysize(data_reads),
                                   data_writes, arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&reads1);
 
   // Start a request that will be throttled at start; confirm it
   // doesn't complete.
   throttler->set_throttle_new_requests(true);
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+  auto trans =
+      base::MakeUnique<HttpNetworkTransaction>(DEFAULT_PRIORITY, session.get());
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_THROTTLED, trans->GetLoadState());
   EXPECT_FALSE(callback.have_result());
 
   // Arrange for the set priority call on the above transaction to delete
   // the transaction.
-  HttpTransaction* trans_ptr(trans.get());
+  HttpNetworkTransaction* trans_ptr(trans.get());
   throttler->set_priority_change_closure(
       base::Bind(&DestroyTransaction, base::Passed(&trans)));
 
   // Call it and check results (partially a "doesn't crash" test).
   trans_ptr->SetPriority(IDLE);
   trans_ptr = nullptr;  // No longer a valid pointer.
 
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(callback.have_result());
 }
@@ skipping 10 matching lines @@
   ssl.token_binding_key_param = TB_PARAM_ECDSAP256;
   ssl.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true));
   MockRead reads[] = {CreateMockRead(resp), CreateMockRead(body),
                       MockRead(ASYNC, ERR_IO_PENDING)};
   StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
-  session_deps_.channel_id_service.reset(
-      new ChannelIDService(new DefaultChannelIDStore(nullptr)));
+  session_deps_.channel_id_service =
+      base::MakeUnique<ChannelIDService>(new DefaultChannelIDStore(nullptr));
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             trans.Start(&request, callback.callback(), NetLogWithSource()));
 
   NetTestSuite::GetScopedTaskEnvironment()->RunUntilIdle();
 
   EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy);
@@ skipping 70 matching lines @@
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "", false);
 }
 
 TEST_F(HttpNetworkTransactionTest, MatchContentEncoding4) {
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "www.foo.com/other", true);
 }
 
 }  // namespace net