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

net/http/http_cache_unittest.cc

 // Copyright (c) 2012 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_cache.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 720 matching lines @@
                                   NetLogEventType::HTTP_CACHE_CREATE_ENTRY));
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
   TestLoadTimingNetworkRequest(load_timing_info);
 }
 
 TEST(HttpCache, SimpleGETNoDiskCache2) {
   // This will initialize a cache object with NULL backend.
-  std::unique_ptr<MockBlockingBackendFactory> factory(
-      new MockBlockingBackendFactory());
+  auto factory = base::MakeUnique<MockBlockingBackendFactory>();
   factory->set_fail(true);
   factory->FinishCreation();  // We'll complete synchronously.
   MockHttpCache cache(std::move(factory));
 
   // Read from the network, and don't use the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_FALSE(cache.http_cache()->GetCurrentBackend());
 }
@@ skipping 40 matching lines @@
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that disk failures after the transaction has started don't cause the
 // request to fail.
 TEST(HttpCache, SimpleGETWithDiskFailures2) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  std::unique_ptr<Context> c(new Context());
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = c->callback.WaitForResult();
 
   // Start failing request now.
   cache.disk_cache()->set_soft_failures(true);
 
@@ skipping 24 matching lines @@
   // Read from the network, and write to the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   cache.disk_cache()->set_soft_failures(true);
 
   // Now fail to read from the cache.
-  std::unique_ptr<Context> c(new Context());
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   MockHttpRequest request(kSimpleGET_Transaction);
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(c->callback.GetResult(rv), IsOk());
 
   // Now verify that the entry was removed from the cache.
   cache.disk_cache()->set_soft_failures(false);
 
@@ skipping 479 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 TEST(HttpCache, SimpleGET_ManyReaders) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
     EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   }
 
   // All requests are waiting for the active entry.
   for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, c->trans->GetLoadState());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // All requests depend on the writer, and the writer is between Start and
   // Read, i.e. idle.
   for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
   }
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     if (c->result == ERR_IO_PENDING)
       c->result = c->callback.WaitForResult();
     ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
   }
 
   // We should not have had to re-open the disk entry
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
-
-  for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
-    delete c;
-  }
 }
 
 // This is a test for http://code.google.com/p/chromium/issues/detail?id=4769.
 // If cancelling a request is racing with another request for the same resource
 // finishing, we have to make sure that we remove both transactions from the
 // entry.
 TEST(HttpCache, SimpleGET_RacingReaders) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
   MockHttpRequest reader_request(kSimpleGET_Transaction);
   reader_request.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
 
     MockHttpRequest* this_request = &request;
     if (i == 1 || i == 2)
       this_request = &reader_request;
 
     c->result = c->trans->Start(this_request, c->callback.callback(),
                                 NetLogWithSource());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
-  Context* c = context_list[0];
+  Context* c = context_list[0].get();
   ASSERT_THAT(c->result, IsError(ERR_IO_PENDING));
   c->result = c->callback.WaitForResult();
   ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
 
   // Now we have 2 active readers and two queued transactions.
 
   EXPECT_EQ(LOAD_STATE_IDLE, context_list[2]->trans->GetLoadState());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE,
             context_list[3]->trans->GetLoadState());
 
-  c = context_list[1];
+  c = context_list[1].get();
   ASSERT_THAT(c->result, IsError(ERR_IO_PENDING));
   c->result = c->callback.WaitForResult();
   if (c->result == OK)
     ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
 
   // At this point we have one reader, two pending transactions and a task on
   // the queue to move to the next transaction. Now we cancel the request that
   // is the current reader, and expect the queued task to be able to start the
   // next request.
 
-  c = context_list[2];
+  c = context_list[2].get();
   c->trans.reset();
 
   for (int i = 3; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     if (c->result == ERR_IO_PENDING)
       c->result = c->callback.WaitForResult();
     if (c->result == OK)
       ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
   }
 
   // We should not have had to re-open the disk entry.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
-
-  for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
-    delete c;
-  }
 }
 
 // Tests that we can doom an entry with pending transactions and delete one of
 // the pending transactions before the first one completes.
 // See http://code.google.com/p/chromium/issues/detail?id=25588
 TEST(HttpCache, SimpleGET_DoomWithPending) {
   // We need simultaneous doomed / not_doomed entries so let's use a real cache.
   MockHttpCache cache(HttpCache::DefaultBackend::InMemory(1024 * 1024));
 
   MockHttpRequest request(kSimpleGET_Transaction);
   MockHttpRequest writer_request(kSimpleGET_Transaction);
   writer_request.load_flags = LOAD_BYPASS_CACHE;
 
   std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 4;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(base::WrapUnique(new Context()));
+    context_list.push_back(base::MakeUnique<Context>());
     Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
 
     MockHttpRequest* this_request = &request;
     if (i == 3)
       this_request = &writer_request;
 
     c->result = c->trans->Start(this_request, c->callback.callback(),
@@ skipping 22 matching lines @@
 // We may attempt to delete an entry synchronously with the act of adding a new
 // transaction to said entry.
 TEST(HttpCache, FastNoStoreGET_DoneWithPending) {
   MockHttpCache cache;
 
   // The headers will be served right from the call to Start() the request.
   MockHttpRequest request(kFastNoStoreGET_Transaction);
   FastTransactionServer request_handler;
   AddMockTransaction(&kFastNoStoreGET_Transaction);
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Now, make sure that the second request asks for the entry not to be stored.
   request_handler.set_no_store(true);
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     if (c->result == ERR_IO_PENDING)
       c->result = c->callback.WaitForResult();
     ReadAndVerifyTransaction(c->trans.get(), kFastNoStoreGET_Transaction);
-    delete c;
+    context_list[i].reset();
   }
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kFastNoStoreGET_Transaction);
 }
 
 TEST(HttpCache, SimpleGET_ManyWriters_CancelFirst) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 2;
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     if (c->result == ERR_IO_PENDING)
       c->result = c->callback.WaitForResult();
     // Destroy only the first transaction.
     if (i == 0) {
-      delete c;
-      context_list[i] = NULL;
+      context_list[i].reset();
     }
   }
 
   // Complete the rest of the transactions.
   for (int i = 1; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
   }
 
   // We should have had to re-open the disk entry.
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
-
-  for (int i = 1; i < kNumTransactions; ++i) {
-    Context* c = context_list[i];
-    delete c;
-  }
 }
 
 // Tests that we can cancel requests that are queued waiting to open the disk
 // cache entry.
 TEST(HttpCache, SimpleGET_ManyWriters_CancelCreate) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; i++) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   }
 
   // The first request should be creating the disk cache entry and the others
   // should be pending.
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Cancel a request from the pending queue.
-  delete context_list[3];
-  context_list[3] = NULL;
+  context_list[3].reset();
 
   // Cancel the request that is creating the entry. This will force the pending
   // operations to restart.
-  delete context_list[0];
-  context_list[0] = NULL;
+  context_list[0].reset();
 
   // Complete the rest of the transactions.
   for (int i = 1; i < kNumTransactions; i++) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     if (c) {
       c->result = c->callback.GetResult(c->result);
       ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
     }
   }
 
   // We should have had to re-create the disk entry.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
-
-  for (int i = 1; i < kNumTransactions; ++i) {
-    delete context_list[i];
-  }
 }
 
 // Tests that we can cancel a single request to open a disk cache entry.
 TEST(HttpCache, SimpleGET_CancelCreate) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
 
   c->result = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(c->result, IsOk());
 
   c->result =
       c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(c->result, IsError(ERR_IO_PENDING));
 
   // Release the reference that the mock disk cache keeps for this entry, so
   // that we test that the http cache handles the cancellation correctly.
   cache.disk_cache()->ReleaseAll();
-  delete c;
+  c.reset();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we delete/create entries even if multiple requests are queued.
 TEST(HttpCache, SimpleGET_ManyWriters_BypassCache) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
   request.load_flags = LOAD_BYPASS_CACHE;
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; i++) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   }
 
   // The first request should be deleting the disk cache entry and the others
   // should be pending.
 
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 
   // Complete the transactions.
   for (int i = 0; i < kNumTransactions; i++) {
-    Context* c = context_list[i];
+    Context* c = context_list[i].get();
     c->result = c->callback.GetResult(c->result);
     ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
   }
 
   // We should have had to re-create the disk entry multiple times.
 
   EXPECT_EQ(5, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(5, cache.disk_cache()->create_count());
-
-  for (int i = 0; i < kNumTransactions; ++i) {
-    delete context_list[i];
-  }
 }
 
 // Tests that a (simulated) timeout allows transactions waiting on the cache
 // lock to continue.
 TEST(HttpCache, SimpleGET_WriterTimeout) {
   MockHttpCache cache;
   cache.SimulateCacheLockTimeout();
 
   MockHttpRequest request(kSimpleGET_Transaction);
   Context c1, c2;
@@ skipping 67 matching lines @@
   trans.reset();
 
   // Make sure we pump any pending events, which should include a call to
   // HttpCache::Transaction::OnCacheReadCompleted.
   base::RunLoop().RunUntilIdle();
 }
 
 // Tests that we can delete the HttpCache and deal with queued transactions
 // ("waiting for the backend" as opposed to Active or Doomed entries).
 TEST(HttpCache, SimpleGET_ManyWriters_DeleteCache) {
-  std::unique_ptr<MockHttpCache> cache(
-      new MockHttpCache(base::WrapUnique(new MockBackendNoCbFactory())));
+  auto cache = base::MakeUnique<MockHttpCache>(
+      base::MakeUnique<MockBackendNoCbFactory>());
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; i++) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache->CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   }
 
   // The first request should be creating the disk cache entry and the others
   // should be pending.
 
   EXPECT_EQ(0, cache->network_layer()->transaction_count());
   EXPECT_EQ(0, cache->disk_cache()->open_count());
   EXPECT_EQ(0, cache->disk_cache()->create_count());
 
   cache.reset();
-
-  // There is not much to do with the transactions at this point... they are
-  // waiting for a callback that will not fire.
-  for (int i = 0; i < kNumTransactions; ++i) {
-    delete context_list[i];
-  }
 }
 
 // Tests that we queue requests when initializing the backend.
 TEST(HttpCache, SimpleGET_WaitForBackend) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
   MockHttpCache cache(base::WrapUnique(factory));
 
   MockHttpRequest request0(kSimpleGET_Transaction);
   MockHttpRequest request1(kTypicalGET_Transaction);
   MockHttpRequest request2(kETagGET_Transaction);
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; i++) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
   }
 
   context_list[0]->result = context_list[0]->trans->Start(
       &request0, context_list[0]->callback.callback(), NetLogWithSource());
   context_list[1]->result = context_list[1]->trans->Start(
       &request1, context_list[1]->callback.callback(), NetLogWithSource());
   context_list[2]->result = context_list[2]->trans->Start(
       &request2, context_list[2]->callback.callback(), NetLogWithSource());
 
   // Just to make sure that everything is still pending.
   base::RunLoop().RunUntilIdle();
 
   // The first request should be creating the disk cache.
   EXPECT_FALSE(context_list[0]->callback.have_result());
 
   factory->FinishCreation();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(3, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
     EXPECT_TRUE(context_list[i]->callback.have_result());
-    delete context_list[i];
+    context_list[i].reset();
   }
 }
 
 // Tests that we can cancel requests that are queued waiting for the backend
 // to be initialized.
 TEST(HttpCache, SimpleGET_WaitForBackend_CancelCreate) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
   MockHttpCache cache(base::WrapUnique(factory));
 
   MockHttpRequest request0(kSimpleGET_Transaction);
   MockHttpRequest request1(kTypicalGET_Transaction);
   MockHttpRequest request2(kETagGET_Transaction);
 
-  std::vector<Context*> context_list;
+  std::vector<std::unique_ptr<Context>> context_list;
   const int kNumTransactions = 3;
 
   for (int i = 0; i < kNumTransactions; i++) {
-    context_list.push_back(new Context());
-    Context* c = context_list[i];
+    context_list.push_back(base::MakeUnique<Context>());
+    Context* c = context_list[i].get();
 
     c->result = cache.CreateTransaction(&c->trans);
     ASSERT_THAT(c->result, IsOk());
   }
 
   context_list[0]->result = context_list[0]->trans->Start(
       &request0, context_list[0]->callback.callback(), NetLogWithSource());
   context_list[1]->result = context_list[1]->trans->Start(
       &request1, context_list[1]->callback.callback(), NetLogWithSource());
   context_list[2]->result = context_list[2]->trans->Start(
       &request2, context_list[2]->callback.callback(), NetLogWithSource());
 
   // Just to make sure that everything is still pending.
   base::RunLoop().RunUntilIdle();
 
   // The first request should be creating the disk cache.
   EXPECT_FALSE(context_list[0]->callback.have_result());
 
   // Cancel a request from the pending queue.
-  delete context_list[1];
-  context_list[1] = NULL;
+  context_list[1].reset();
 
   // Cancel the request that is creating the entry.
-  delete context_list[0];
-  context_list[0] = NULL;
+  context_list[0].reset();
 
   // Complete the last transaction.
   factory->FinishCreation();
 
   context_list[2]->result =
       context_list[2]->callback.GetResult(context_list[2]->result);
   ReadAndVerifyTransaction(context_list[2]->trans.get(), kETagGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
-
-  delete context_list[2];
 }
 
 // Tests that we can delete the cache while creating the backend.
 TEST(HttpCache, DeleteCacheWaitingForBackend) {
   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
-  std::unique_ptr<MockHttpCache> cache(
-      new MockHttpCache(base::WrapUnique(factory)));
+  auto cache = base::MakeUnique<MockHttpCache>(base::WrapUnique(factory));
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  std::unique_ptr<Context> c(new Context());
+  auto c = base::MakeUnique<Context>();
   c->result = cache->CreateTransaction(&c->trans);
   ASSERT_THAT(c->result, IsOk());
 
   c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
 
   // Just to make sure that everything is still pending.
   base::RunLoop().RunUntilIdle();
 
   // The request should be creating the disk cache.
   EXPECT_FALSE(c->callback.have_result());
@@ skipping 17 matching lines @@
   MockHttpCache* cache = new MockHttpCache(base::WrapUnique(factory));
 
   DeleteCacheCompletionCallback cb(cache);
   disk_cache::Backend* backend;
   int rv = cache->http_cache()->GetBackend(&backend, cb.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Now let's queue a regular transaction
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  std::unique_ptr<Context> c(new Context());
+  auto c = base::MakeUnique<Context>();
   c->result = cache->CreateTransaction(&c->trans);
   ASSERT_THAT(c->result, IsOk());
 
   c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
 
   // And another direct backend request.
   TestCompletionCallback cb2;
   rv = cache->http_cache()->GetBackend(&backend, cb2.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
@@ skipping 1015 matching lines @@
 TEST(HttpCache, SimplePOST_WithRanges) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.request_headers = "Range: bytes = 0-4\r\n";
 
   const int64_t kUploadId = 1;  // Just a dummy value.
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers),
                                               kUploadId);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 // Tests that a POST is cached separately from a GET.
 TEST(HttpCache, SimplePOST_SeparateCache) {
   MockHttpCache cache;
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 1);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   MockHttpRequest req1(transaction);
   req1.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 19 matching lines @@
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 1);
 
   transaction.method = "POST";
   transaction.status = "HTTP/1.1 205 No Content";
   MockHttpRequest req2(transaction);
   req2.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
@@ skipping 19 matching lines @@
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   transaction.method = "POST";
   transaction.status = "HTTP/1.1 205 No Content";
   MockHttpRequest req2(transaction);
   req2.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that processing a POST before creating the backend doesn't crash.
 TEST(HttpCache, SimplePOST_NoUploadId_NoBackend) {
   // This will initialize a cache object with NULL backend.
-  std::unique_ptr<MockBlockingBackendFactory> factory(
-      new MockBlockingBackendFactory());
+  auto factory = base::MakeUnique<MockBlockingBackendFactory>();
   factory->set_fail(true);
   factory->FinishCreation();
   MockHttpCache cache(std::move(factory));
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   AddMockTransaction(&transaction);
   MockHttpRequest req(transaction);
   req.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req, NULL);
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we don't invalidate entries as a result of a failed POST.
 TEST(HttpCache, SimplePOST_DontInvalidate_100) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 1);
 
   transaction.method = "POST";
   transaction.status = "HTTP/1.1 100 Continue";
   MockHttpRequest req2(transaction);
   req2.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
@@ skipping 291 matching lines @@
 
 // Tests that we do not cache the response of a PUT.
 TEST(HttpCache, SimplePUT_Miss) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.method = "PUT";
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 // Tests that we invalidate entries as a result of a PUT.
 TEST(HttpCache, SimplePUT_Invalidate) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimpleGET_Transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   transaction.method = "PUT";
   MockHttpRequest req2(transaction);
   req2.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
@@ skipping 16 matching lines @@
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   transaction.method = "PUT";
   transaction.status = "HTTP/1.1 305 Use Proxy";
   MockHttpRequest req2(transaction);
   req2.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
@@ skipping 18 matching lines @@
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   transaction.method = "PUT";
   transaction.status = "HTTP/1.1 404 Not Found";
   MockHttpRequest req2(transaction);
   req2.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
@@ skipping 10 matching lines @@
 
 // Tests that we do not cache the response of a DELETE.
 TEST(HttpCache, SimpleDELETE_Miss) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.method = "DELETE";
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 // Tests that we invalidate entries as a result of a DELETE.
 TEST(HttpCache, SimpleDELETE_Invalidate) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimpleGET_Transaction);
   MockHttpRequest req1(transaction);
 
   // Attempt to populate the cache.
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
-      base::WrapUnique(new UploadBytesElementReader("hello", 5)));
+      base::MakeUnique<UploadBytesElementReader>("hello", 5));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   transaction.method = "DELETE";
   MockHttpRequest req2(transaction);
   req2.upload_data_stream = &upload_data_stream;
 
   RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
@@ skipping 1536 matching lines @@
 #else
 #define MAYBE_RangeGET_Cancel RangeGET_Cancel
 #endif
 // Tests that we don't delete a sparse entry when we cancel a request.
 TEST(HttpCache, MAYBE_RangeGET_Cancel) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   MockHttpRequest request(kRangeGET_TransactionOK);
 
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(10));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // Destroy the transaction.
-  delete c;
+  c.reset();
 
   // Verify that the entry has not been deleted.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
   entry->Close();
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Fails only on bots. crbug.com/533640
 #if defined(OS_ANDROID)
 #define MAYBE_RangeGET_Cancel2 DISABLED_RangeGET_Cancel2
 #else
 #define MAYBE_RangeGET_Cancel2 RangeGET_Cancel2
 #endif
 // Tests that we don't delete a sparse entry when we start a new request after
 // cancelling the previous one.
 TEST(HttpCache, MAYBE_RangeGET_Cancel2) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.load_flags |= LOAD_VALIDATE_CACHE;
 
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that we revalidate the entry and read from the cache (a single
   // read will return while waiting for the network).
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(5));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(5, c->callback.GetResult(rv));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Destroy the transaction before completing the read.
-  delete c;
+  c.reset();
 
   // We have the read and the delete (OnProcessPendingQueue) waiting on the
   // message loop. This means that a new transaction will just reuse the same
   // active entry (no open or create).
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // A slight variation of the previous test, this time we cancel two requests in
 // a row, making sure that the second is waiting for the entry to be ready.
 TEST(HttpCache, RangeGET_Cancel3) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.load_flags |= LOAD_VALIDATE_CACHE;
 
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = c->callback.WaitForResult();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that we revalidate the entry and read from the cache (a single
   // read will return while waiting for the network).
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(5));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(5, c->callback.GetResult(rv));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
-  // Destroy the transaction before completing the read.
-  delete c;
+  // Destroy the previous transaction before completing the read.
+  c.reset();
 
   // We have the read and the delete (OnProcessPendingQueue) waiting on the
   // message loop. This means that a new transaction will just reuse the same
   // active entry (no open or create).
 
-  c = new Context();
+  c = base::MakeUnique<Context>();
   rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   MockDiskEntry::IgnoreCallbacks(true);
   base::RunLoop().RunUntilIdle();
   MockDiskEntry::IgnoreCallbacks(false);
 
   // The new transaction is waiting for the query range callback.
-  delete c;
+  c.reset();
 
   // And we should not crash when the callback is delivered.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
@@ skipping 121 matching lines @@
   disk_cache::Entry* en;
   ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &en));
   en->Close();
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 // Tests that we don't crash with a range request if the disk cache was not
 // initialized properly.
 TEST(HttpCache, RangeGET_NoDiskCache) {
-  std::unique_ptr<MockBlockingBackendFactory> factory(
-      new MockBlockingBackendFactory());
+  auto factory = base::MakeUnique<MockBlockingBackendFactory>();
   factory->set_fail(true);
   factory->FinishCreation();  // We'll complete synchronously.
   MockHttpCache cache(std::move(factory));
 
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
@@ skipping 177 matching lines @@
   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
 }
 
 // Tests that we delete an entry when the request is cancelled before starting
 // to read from the network.
 TEST(HttpCache, DoomOnDestruction) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     c->result = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Destroy the transaction. We only have the headers so we should delete this
   // entry.
-  delete c;
+  c.reset();
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we delete an entry when the request is cancelled if the response
 // does not have content-length and strong validators.
 TEST(HttpCache, DoomOnDestruction2) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(10));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // Destroy the transaction.
-  delete c;
+  c.reset();
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we delete an entry when the request is cancelled if the response
 // has an "Accept-Ranges: none" header.
 TEST(HttpCache, DoomOnDestruction3) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Content-Length: 22\n"
       "Accept-Ranges: none\n"
       "Etag: \"foopy\"\n";
   AddMockTransaction(&transaction);
   MockHttpRequest request(transaction);
 
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(10));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   EXPECT_EQ(buf->size(), rv);
 
   // Destroy the transaction.
-  delete c;
+  c.reset();
 
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we mark an entry as incomplete when the request is cancelled.
 TEST(HttpCache, SetTruncatedFlag) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Content-Length: 22\n"
       "Etag: \"foopy\"\n";
   MockHttpRequest request(transaction);
 
-  std::unique_ptr<Context> c(new Context());
+  auto c = base::MakeUnique<Context>();
 
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 32 matching lines @@
 TEST(HttpCache, DontSetTruncatedFlag) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Content-Length: 22\n"
       "Etag: \"foopy\"\n";
   MockHttpRequest request(transaction);
 
-  std::unique_ptr<Context> c(new Context());
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(c->callback.GetResult(rv), IsOk());
 
   // Read everything.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(22));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(buf->size(), c->callback.GetResult(rv));
 
   // Destroy the transaction.
   c->trans.reset();
 
   // Verify that the entry is not marked as truncated.
   VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, false, 0);
 }
 
 // Tests that sparse entries don't set the truncate flag.
 TEST(HttpCache, RangeGET_DontTruncate) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 0-19\r\n" EXTRA_HEADER;
 
-  std::unique_ptr<MockHttpRequest> request(new MockHttpRequest(transaction));
+  auto request = base::MakeUnique<MockHttpRequest>(transaction);
   std::unique_ptr<HttpTransaction> trans;
 
   int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
   EXPECT_THAT(rv, IsOk());
 
   TestCompletionCallback cb;
   rv = trans->Start(request.get(), cb.callback(), NetLogWithSource());
   EXPECT_EQ(0, cb.GetResult(rv));
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(10));
   rv = trans->Read(buf.get(), 10, cb.callback());
   EXPECT_EQ(10, cb.GetResult(rv));
 
   // Should not trigger any DCHECK.
   trans.reset();
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, false, 0);
 }
 
 // Tests that sparse entries don't set the truncate flag (when the byte range
 //  starts after 0).
 TEST(HttpCache, RangeGET_DontTruncate2) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 30-49\r\n" EXTRA_HEADER;
 
-  std::unique_ptr<MockHttpRequest> request(new MockHttpRequest(transaction));
+  auto request = base::MakeUnique<MockHttpRequest>(transaction);
   std::unique_ptr<HttpTransaction> trans;
 
   int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
   EXPECT_THAT(rv, IsOk());
 
   TestCompletionCallback cb;
   rv = trans->Start(request.get(), cb.callback(), NetLogWithSource());
   EXPECT_EQ(0, cb.GetResult(rv));
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(10));
@@ skipping 101 matching lines @@
   // Now make a regular request.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = EXTRA_HEADER;
   std::string response_headers(transaction.response_headers);
   response_headers += ("Cache-Control: no-store\n");
   transaction.response_headers = response_headers.c_str();
   transaction.data = kFullRangeData;
   AddMockTransaction(&transaction);
 
   MockHttpRequest request(transaction);
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
 
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   // Queue another request to this transaction. We have to start this request
   // before the first one gets the response from the server and dooms the entry,
   // otherwise it will just create a new entry without being queued to the first
   // request.
-  Context* pending = new Context();
+  auto pending = base::MakeUnique<Context>();
   ASSERT_THAT(cache.CreateTransaction(&pending->trans), IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_EQ(ERR_IO_PENDING,
             pending->trans->Start(&request, pending->callback.callback(),
                                   NetLogWithSource()));
   EXPECT_THAT(c->callback.GetResult(rv), IsOk());
 
   // Make sure that the entry has some data stored.
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(5));
   rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
   EXPECT_EQ(5, c->callback.GetResult(rv));
 
   // Cancel the requests.
-  delete c;
-  delete pending;
+  c.reset();
+  pending.reset();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   base::RunLoop().RunUntilIdle();
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we delete truncated entries if the server changes its mind midway.
@@ skipping 46 matching lines @@
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   // Now make a regular request.
   std::string headers;
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = EXTRA_HEADER;
   transaction.data = kFullRangeData;
 
-  std::unique_ptr<Context> c(new Context);
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   MockHttpRequest request(transaction);
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(c->callback.GetResult(rv), IsOk());
 
   // We should have checked with the server before finishing Start().
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
@@ skipping 14 matching lines @@
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   // Now make a regular request.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "X-Require-Mock-Auth: dummy\r\n"
                                 EXTRA_HEADER;
   transaction.data = kFullRangeData;
   RangeTransactionServer handler;
 
-  std::unique_ptr<Context> c(new Context);
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   MockHttpRequest request(transaction);
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(c->callback.GetResult(rv), IsOk());
 
   const HttpResponseInfo* response = c->trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_EQ(401, response->headers->response_code());
@@ skipping 30 matching lines @@
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   // And now read from the cache and the network.  10-19 will get a
   // 401, but will have already returned 0-9.
   // We do not set X-Require-Mock-Auth because that causes the mock
   // network transaction to become IsReadyToRestartForAuth().
   transaction.request_headers =
       "Range: bytes = 0-79\r\n"
       "X-Require-Mock-Auth-Alt: dummy\r\n" EXTRA_HEADER;
 
-  std::unique_ptr<Context> c(new Context);
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   MockHttpRequest request(transaction);
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = c->callback.WaitForResult();
   std::string content;
   rv = ReadTransaction(c->trans.get(), &content);
@@ skipping 38 matching lines @@
                           "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
                           "ETag: \"foo\"\n"
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   // Now make a regular request.
   transaction.request_headers = EXTRA_HEADER;
 
   MockHttpRequest request(transaction);
-  Context* c = new Context();
+  auto c = base::MakeUnique<Context>();
   int rv = cache.CreateTransaction(&c->trans);
   ASSERT_THAT(rv, IsOk());
 
   rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   EXPECT_THAT(c->callback.GetResult(rv), IsOk());
 
   // Read 20 bytes from the cache, and 10 from the net.
   scoped_refptr<IOBuffer> buf(new IOBuffer(100));
   rv = c->trans->Read(buf.get(), 20, c->callback.callback());
   EXPECT_EQ(20, c->callback.GetResult(rv));
   rv = c->trans->Read(buf.get(), 10, c->callback.callback());
   EXPECT_EQ(10, c->callback.GetResult(rv));
 
   // At this point, we are already reading so canceling the request should leave
   // a truncated one.
-  delete c;
+  c.reset();
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Verify that the disk entry was updated: now we have 30 bytes.
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, true, 30);
 }
 
 // Tests that we can handle range requests when we have a truncated entry.
@@ skipping 309 matching lines @@
   ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
 
   int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
 }
 
 // Ensure that we don't crash by if left-behind transactions.
 TEST(HttpCache, OutlivedTransactions) {
-  MockHttpCache* cache = new MockHttpCache;
+  auto cache = base::MakeUnique<MockHttpCache>();
 
   std::unique_ptr<HttpTransaction> trans;
   EXPECT_THAT(cache->CreateTransaction(&trans), IsOk());
 
-  delete cache;
+  cache.reset();
   trans.reset();
 }
 
 // Test that the disabled mode works.
 TEST(HttpCache, CacheDisabledMode) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
@@ skipping 1286 matching lines @@
 // Makes sure that a request stops using the cache when the response headers
 // with "Cache-Control: no-store" arrives. That means that another request for
 // the same URL can be processed before the response body of the original
 // request arrives.
 TEST(HttpCache, NoStoreResponseShouldNotBlockFollowingRequests) {
   MockHttpCache cache;
   ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
   mock_transaction.response_headers = "Cache-Control: no-store\n";
   MockHttpRequest request(mock_transaction);
 
-  std::unique_ptr<Context> first(new Context);
+  auto first = base::MakeUnique<Context>();
   first->result = cache.CreateTransaction(&first->trans);
   ASSERT_THAT(first->result, IsOk());
   EXPECT_EQ(LOAD_STATE_IDLE, first->trans->GetLoadState());
   first->result = first->trans->Start(&request, first->callback.callback(),
                                       NetLogWithSource());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, first->trans->GetLoadState());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_IDLE, first->trans->GetLoadState());
   ASSERT_TRUE(first->trans->GetResponseInfo());
   EXPECT_TRUE(first->trans->GetResponseInfo()->headers->HasHeaderValue(
       "Cache-Control", "no-store"));
   // Here we have read the response header but not read the response body yet.
 
   // Let us create the second (read) transaction.
-  std::unique_ptr<Context> second(new Context);
+  auto second = base::MakeUnique<Context>();
   second->result = cache.CreateTransaction(&second->trans);
   ASSERT_THAT(second->result, IsOk());
   EXPECT_EQ(LOAD_STATE_IDLE, second->trans->GetLoadState());
   second->result = second->trans->Start(&request, second->callback.callback(),
                                         NetLogWithSource());
 
   // Here the second transaction proceeds without reading the first body.
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, second->trans->GetLoadState());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_IDLE, second->trans->GetLoadState());
@@ skipping 217 matching lines @@
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(),
                                      kTypicalGET_Transaction, &response_info);
 
   EXPECT_FALSE(response_info.was_cached);
   EXPECT_TRUE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE,
             response_info.cache_entry_status);
 
   base::trace_event::MemoryDumpArgs dump_args = {GetParam()};
-  std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
-      new base::trace_event::ProcessMemoryDump(nullptr, dump_args));
+  auto process_memory_dump =
+      base::MakeUnique<base::trace_event::ProcessMemoryDump>(nullptr,
+                                                             dump_args);
   base::trace_event::MemoryAllocatorDump* parent_dump =
       process_memory_dump->CreateAllocatorDump(
           "net/url_request_context/main/0x123");
   cache.http_cache()->DumpMemoryStats(process_memory_dump.get(),
                                       parent_dump->absolute_name());
 
   const base::trace_event::MemoryAllocatorDump* dump =
       process_memory_dump->GetAllocatorDump(
           "net/url_request_context/main/0x123/http_cache");
   ASSERT_NE(nullptr, dump);
   std::unique_ptr<base::Value> raw_attrs =
       dump->attributes_for_testing()->ToBaseValue();
   base::DictionaryValue* attrs;
   ASSERT_TRUE(raw_attrs->GetAsDictionary(&attrs));
   base::DictionaryValue* size_attrs;
   ASSERT_TRUE(attrs->GetDictionary(
       base::trace_event::MemoryAllocatorDump::kNameSize, &size_attrs));
   std::string size;
   ASSERT_TRUE(size_attrs->GetString("value", &size));
   int actual_size = 0;
   ASSERT_TRUE(base::HexStringToInt(size, &actual_size));
   ASSERT_LT(0, actual_size);
 }
 
 }  // namespace net