Change the API of disk_cache::CreateCacheBackend to use scoped_ptr

net/disk_cache/backend_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 "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/port.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 23 matching lines @@
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 using base::Time;
 
 namespace {
 
 const char kExistingEntryKey[] = "existing entry key";
 
-disk_cache::BackendImpl* CreateExistingEntryCache(
+scoped_ptr<disk_cache::BackendImpl> CreateExistingEntryCache(
     const base::Thread& cache_thread,
     base::FilePath& cache_path) {
   net::TestCompletionCallback cb;
 
-  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
-      cache_path, cache_thread.message_loop_proxy(), NULL);
+  scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
+      cache_path, cache_thread.message_loop_proxy(), NULL));
   int rv = cache->Init(cb.callback());
   if (cb.GetResult(rv) != net::OK)
-    return NULL;
+    return scoped_ptr<disk_cache::BackendImpl>();
 
   disk_cache::Entry* entry = NULL;
   rv = cache->CreateEntry(kExistingEntryKey, &entry, cb.callback());
-  if (cb.GetResult(rv) != net::OK) {
-    delete cache;
-    return NULL;
-  }
+  if (cb.GetResult(rv) != net::OK)
+    return scoped_ptr<disk_cache::BackendImpl>();
   entry->Close();
 
-  return cache;
+  return cache.Pass();
 }
 
 }  // namespace
 
 // Tests that can run with different types of caches.
 class DiskCacheBackendTest : public DiskCacheTestWithCache {
  protected:
   void BackendBasics();
   void BackendKeying();
   void BackendShutdownWithPendingFileIO(bool fast);
@@ skipping 187 matching lines @@
 TEST_F(DiskCacheTest, CreateBackend) {
   net::TestCompletionCallback cb;
 
   {
     ASSERT_TRUE(CleanupCacheDir());
     base::Thread cache_thread("CacheThread");
     ASSERT_TRUE(cache_thread.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
     // Test the private factory method(s).
-    disk_cache::Backend* cache = NULL;
+    scoped_ptr<disk_cache::Backend> cache;
     cache = disk_cache::MemBackendImpl::CreateBackend(0, NULL);
-    ASSERT_TRUE(cache);
-    delete cache;
-    cache = NULL;
+    ASSERT_TRUE(cache.get());
+    cache.reset();
 
     // Now test the public API.
     int rv =
         disk_cache::CreateCacheBackend(net::DISK_CACHE,
                                        net::CACHE_BACKEND_DEFAULT,
                                        cache_path_,
                                        0,
                                        false,
                                        cache_thread.message_loop_proxy().get(),
                                        NULL,
                                        &cache,
                                        cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
-    ASSERT_TRUE(cache);
-    delete cache;
-    cache = NULL;
+    ASSERT_TRUE(cache.get());
+    cache.reset();
 
     rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE,
                                         net::CACHE_BACKEND_DEFAULT,
                                         base::FilePath(), 0,
                                         false, NULL, NULL, &cache,
                                         cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
-    ASSERT_TRUE(cache);
-    delete cache;
+    ASSERT_TRUE(cache.get());
+    cache.reset();
   }
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // Tests that |BackendImpl| fails to initialize with a missing file.
 TEST_F(DiskCacheBackendTest, CreateBackend_MissingFile) {
   ASSERT_TRUE(CopyTestCache("bad_entry"));
   base::FilePath filename = cache_path_.AppendASCII("data_1");
   base::DeleteFile(filename, false);
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
-  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
-      cache_path_, cache_thread.message_loop_proxy().get(), NULL);
+  scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
+      cache_path_, cache_thread.message_loop_proxy().get(), NULL));
   int rv = cache->Init(cb.callback());
   ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
   base::ThreadRestrictions::SetIOAllowed(prev);
 
-  delete cache;
+  cache.reset();
   DisableIntegrityCheck();
 }
 
 TEST_F(DiskCacheBackendTest, ExternalFiles) {
   InitCache();
   // First, let's create a file on the folder.
   base::FilePath filename = cache_path_.AppendASCII("f_000001");
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
@@ skipping 49 matching lines @@
       if (rv == net::ERR_IO_PENDING)
         break;
       EXPECT_EQ(kSize, rv);
     }
 
     // Don't call Close() to avoid going through the queue or we'll deadlock
     // waiting for the operation to finish.
     entry->Release();
 
     // The cache destructor will see one pending operation here.
-    delete cache_;
-    // Prevent the TearDown() to delete the backend again.
-    cache_ = NULL;
+    cache_.reset();
 
     if (rv == net::ERR_IO_PENDING) {
       if (fast)
         EXPECT_FALSE(cb.have_result());
       else
         EXPECT_TRUE(cb.have_result());
     }
   }
 
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 35 matching lines @@
 
     CreateBackend(flags, &cache_thread);
 
     disk_cache::Entry* entry;
     int rv = cache_->CreateEntry("some key", &entry, cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
 
     entry->Close();
 
     // The cache destructor will see one pending operation here.
-    delete cache_;
-    // Prevent the TearDown() to delete the backend again.
-    cache_ = NULL;
+    cache_.reset();
   }
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO) {
   BackendShutdownWithPendingIO(false);
 }
 
 // We'll be leaking from this test.
@@ skipping 15 matching lines @@
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
     disk_cache::BackendFlags flags =
       fast ? disk_cache::kNone : disk_cache::kNoRandom;
     CreateBackend(flags, &cache_thread);
 
     disk_cache::Entry* entry;
     int rv = cache_->CreateEntry("some key", &entry, cb.callback());
     ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
-    delete cache_;
-    // Prevent the TearDown() to delete the backend again.
-    cache_ = NULL;
+    cache_.reset();
     EXPECT_FALSE(cb.have_result());
   }
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate) {
   BackendShutdownWithPendingCreate(false);
 }
 
 // We'll be leaking an entry from this test.
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate_Fast) {
   // The integrity test sets kNoRandom so there's a version mismatch if we don't
   // force new eviction.
   SetNewEviction();
   BackendShutdownWithPendingCreate(true);
 }
 
 TEST_F(DiskCacheTest, TruncatedIndex) {
   ASSERT_TRUE(CleanupCacheDir());
   base::FilePath index = cache_path_.AppendASCII("index");
   ASSERT_EQ(5, file_util::WriteFile(index, "hello", 5));
 
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
-  disk_cache::Backend* backend = NULL;
+  scoped_ptr<disk_cache::Backend> backend;
   int rv =
       disk_cache::CreateCacheBackend(net::DISK_CACHE,
                                      net::CACHE_BACKEND_BLOCKFILE,
                                      cache_path_,
                                      0,
                                      false,
                                      cache_thread.message_loop_proxy().get(),
                                      NULL,
                                      &backend,
                                      cb.callback());
   ASSERT_NE(net::OK, cb.GetResult(rv));
 
-  ASSERT_TRUE(backend == NULL);
-  delete backend;
+  ASSERT_FALSE(backend);
 }
 
 void DiskCacheBackendTest::BackendSetSize() {
   const int cache_size = 0x10000;  // 64 kB
   SetMaxSize(cache_size);
   InitCache();
 
   std::string first("some key");
   std::string second("something else");
   disk_cache::Entry* entry;
@@ skipping 1051 matching lines @@
   ASSERT_NE(net::OK, OpenEntry(key, &entry1));
 
   int actual = cache_->GetEntryCount();
   if (num_entries != actual) {
     ASSERT_TRUE(load);
     // If there is a heavy load, inserting an entry will make another entry
     // dirty (on the hash bucket) so two entries are removed.
     ASSERT_EQ(num_entries - 1, actual);
   }
 
-  delete cache_;
-  cache_ = NULL;
+  cache_.reset();
   cache_impl_ = NULL;
 
   ASSERT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask));
   success_ = true;
 }
 
 void DiskCacheBackendTest::BackendRecoverInsert() {
   // Tests with an empty cache.
   BackendTransaction("insert_empty1", 0, false);
   ASSERT_TRUE(success_) << "insert_empty1";
@@ skipping 98 matching lines @@
 }
 
 // Tests that the |BackendImpl| fails to start with the wrong cache version.
 TEST_F(DiskCacheTest, WrongVersion) {
   ASSERT_TRUE(CopyTestCache("wrong_version"));
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
-  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
-      cache_path_, cache_thread.message_loop_proxy().get(), NULL);
+  scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
+      cache_path_, cache_thread.message_loop_proxy().get(), NULL));
   int rv = cache->Init(cb.callback());
   ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
-
-  delete cache;
 }
 
 class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
  public:
   virtual ~BadEntropyProvider() {}
 
   virtual double GetEntropyForTrial(const std::string& trial_name,
                                     uint32 randomization_seed) const OVERRIDE {
     return 0.5;
   }
 };
 
 // Tests that the disk cache successfully joins the control group, dropping the
 // existing cache in favour of a new empty cache.
 TEST_F(DiskCacheTest, SimpleCacheControlJoin) {
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
-  disk_cache::BackendImpl* cache = CreateExistingEntryCache(cache_thread,
-                                                            cache_path_);
-  ASSERT_TRUE(cache);
-  delete cache;
-  cache = NULL;
+  scoped_ptr<disk_cache::BackendImpl> cache =
+      CreateExistingEntryCache(cache_thread, cache_path_);
+  ASSERT_TRUE(cache.get());
+  cache.reset();
 
   // Instantiate the SimpleCacheTrial, forcing this run into the
   // ExperimentControl group.
   base::FieldTrialList field_trial_list(new BadEntropyProvider());
   base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
                                          "ExperimentControl");
   net::TestCompletionCallback cb;
-  disk_cache::Backend* base_cache = NULL;
+  scoped_ptr<disk_cache::Backend> base_cache;
   int rv =
       disk_cache::CreateCacheBackend(net::DISK_CACHE,
                                      net::CACHE_BACKEND_BLOCKFILE,
                                      cache_path_,
                                      0,
                                      true,
                                      cache_thread.message_loop_proxy().get(),
                                      NULL,
                                      &base_cache,
                                      cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
-  cache = static_cast<disk_cache::BackendImpl*>(base_cache);
   EXPECT_EQ(0, base_cache->GetEntryCount());
-  delete cache;
 }
 
 // Tests that the disk cache can restart in the control group preserving
 // existing entries.
 TEST_F(DiskCacheTest, SimpleCacheControlRestart) {
   // Instantiate the SimpleCacheTrial, forcing this run into the
   // ExperimentControl group.
   base::FieldTrialList field_trial_list(new BadEntropyProvider());
   base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
                                          "ExperimentControl");
 
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
-  disk_cache::BackendImpl* cache = CreateExistingEntryCache(cache_thread,
-                                                            cache_path_);
-  ASSERT_TRUE(cache);
-  delete cache;
-  cache = NULL;
+  scoped_ptr<disk_cache::BackendImpl> cache =
+      CreateExistingEntryCache(cache_thread, cache_path_);
+  ASSERT_TRUE(cache.get());
 
   net::TestCompletionCallback cb;
 
   const int kRestartCount = 5;
   for (int i=0; i < kRestartCount; ++i) {
-    cache = new disk_cache::BackendImpl(cache_path_,
-                                        cache_thread.message_loop_proxy(),
-                                        NULL);
+    cache.reset(new disk_cache::BackendImpl(
+        cache_path_, cache_thread.message_loop_proxy(), NULL));
     int rv = cache->Init(cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     EXPECT_EQ(1, cache->GetEntryCount());
 
     disk_cache::Entry* entry = NULL;
     rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
     EXPECT_EQ(net::OK, cb.GetResult(rv));
     EXPECT_TRUE(entry);
     entry->Close();
-    delete cache;
-    cache = NULL;
   }
 }
 
 // Tests that the disk cache can leave the control group preserving existing
 // entries.
 TEST_F(DiskCacheTest, SimpleCacheControlLeave) {
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   {
     // Instantiate the SimpleCacheTrial, forcing this run into the
     // ExperimentControl group.
     base::FieldTrialList field_trial_list(new BadEntropyProvider());
     base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
                                            "ExperimentControl");
 
-    disk_cache::BackendImpl* cache = CreateExistingEntryCache(cache_thread,
-                                                              cache_path_);
-    ASSERT_TRUE(cache);
-    delete cache;
+    scoped_ptr<disk_cache::BackendImpl> cache =
+        CreateExistingEntryCache(cache_thread, cache_path_);
+    ASSERT_TRUE(cache.get());
   }
 
   // Instantiate the SimpleCacheTrial, forcing this run into the
   // ExperimentNo group.
   base::FieldTrialList field_trial_list(new BadEntropyProvider());
   base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial", "ExperimentNo");
   net::TestCompletionCallback cb;
 
   const int kRestartCount = 5;
   for (int i = 0; i < kRestartCount; ++i) {
-    disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
-        cache_path_, cache_thread.message_loop_proxy(), NULL);
+    scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
+        cache_path_, cache_thread.message_loop_proxy(), NULL));
     int rv = cache->Init(cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     EXPECT_EQ(1, cache->GetEntryCount());
 
     disk_cache::Entry* entry = NULL;
     rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
     EXPECT_EQ(net::OK, cb.GetResult(rv));
     EXPECT_TRUE(entry);
     entry->Close();
-    delete cache;
-    cache = NULL;
   }
 }
 
 // Tests that the cache is properly restarted on recovery error.
 TEST_F(DiskCacheBackendTest, DeleteOld) {
   ASSERT_TRUE(CopyTestCache("wrong_version"));
   SetNewEviction();
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   net::TestCompletionCallback cb;
   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
   base::FilePath path(cache_path_);
   int rv =
       disk_cache::CreateCacheBackend(net::DISK_CACHE,
                                      net::CACHE_BACKEND_BLOCKFILE,
                                      path,
                                      0,
                                      true,
                                      cache_thread.message_loop_proxy().get(),
                                      NULL,
                                      &cache_,
                                      cb.callback());
   path.clear();  // Make sure path was captured by the previous call.
   ASSERT_EQ(net::OK, cb.GetResult(rv));
   base::ThreadRestrictions::SetIOAllowed(prev);
-  delete cache_;
-  cache_ = NULL;
+  cache_.reset();
   EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
 }
 
 // We want to be able to deal with messed up entries on disk.
 void DiskCacheBackendTest::BackendInvalidEntry2() {
   ASSERT_TRUE(CopyTestCache("bad_entry"));
   DisableFirstCleanup();
   InitCache();
 
   disk_cache::Entry *entry1, *entry2;
@@ skipping 755 matching lines @@
   entry->Close();
   FlushQueueForTest();
 
   disk_cache::StatsItems stats;
   cache_->GetStats(&stats);
   EXPECT_FALSE(stats.empty());
 
   disk_cache::StatsItems::value_type hits("Create hit", "0x1");
   EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
 
-  delete cache_;
+  cache_.reset();
 
   // Now open the cache and verify that the stats are still there.
   DisableFirstCleanup();
   InitCache();
   EXPECT_EQ(1, cache_->GetEntryCount());
 
   stats.clear();
   cache_->GetStats(&stats);
   EXPECT_FALSE(stats.empty());
 
@@ skipping 105 matching lines @@
   base::ScopedTempDir store1, store2;
   ASSERT_TRUE(store1.CreateUniqueTempDir());
   ASSERT_TRUE(store2.CreateUniqueTempDir());
 
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   const int kNumberOfCaches = 2;
-  disk_cache::Backend* cache[kNumberOfCaches];
+  scoped_ptr<disk_cache::Backend> cache[kNumberOfCaches];
 
   int rv =
       disk_cache::CreateCacheBackend(net::DISK_CACHE,
                                      net::CACHE_BACKEND_DEFAULT,
                                      store1.path(),
                                      0,
                                      false,
                                      cache_thread.message_loop_proxy().get(),
                                      NULL,
                                      &cache[0],
                                      cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
   rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE,
                                       net::CACHE_BACKEND_DEFAULT,
                                       store2.path(),
                                       0,
                                       false,
                                       cache_thread.message_loop_proxy().get(),
                                       NULL,
                                       &cache[1],
                                       cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
 
-  ASSERT_TRUE(cache[0] != NULL && cache[1] != NULL);
+  ASSERT_TRUE(cache[0].get() != NULL && cache[1].get() != NULL);
 
   std::string key("the first key");
   disk_cache::Entry* entry;
   for (int i = 0; i < kNumberOfCaches; i++) {
     rv = cache[i]->CreateEntry(key, &entry, cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     entry->Close();
   }
-  delete cache[0];
-  delete cache[1];
 }
 
 // Test the six regions of the curve that determines the max cache size.
 TEST_F(DiskCacheTest, AutomaticMaxSize) {
   const int kDefaultSize = 80 * 1024 * 1024;
   int64 large_size = kDefaultSize;
   int64 largest_size = kint32max;
 
   // Region 1: expected = available * 0.8
   EXPECT_EQ((kDefaultSize - 1) * 8 / 10,
@@ skipping 190 matching lines @@
   TrimForTest(false);
 
   // Make sure the older key remains.
   EXPECT_EQ(1, cache_->GetEntryCount());
   ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
   entry->Close();
 }
 
 void DiskCacheBackendTest::TracingBackendBasics() {
   InitCache();
-  cache_ = new disk_cache::TracingCacheBackend(cache_);
+  cache_.reset(new disk_cache::TracingCacheBackend(cache_.Pass()));
   cache_impl_ = NULL;
   EXPECT_EQ(net::DISK_CACHE, cache_->GetCacheType());
   if (!simple_cache_mode_) {
     EXPECT_EQ(0, cache_->GetEntryCount());
   }
 
   net::TestCompletionCallback cb;
   disk_cache::Entry* entry = NULL;
   EXPECT_NE(net::OK, OpenEntry("key", &entry));
   EXPECT_TRUE(NULL == entry);
@@ skipping 174 matching lines @@
 TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
   // Create a cache structure with the |BackendImpl|.
   InitCache();
   disk_cache::Entry* entry;
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
   ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
   entry->Close();
-  delete cache_;
-  cache_ = NULL;
+  cache_.reset();
 
   // Check that the |SimpleBackendImpl| does not favor this structure.
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   disk_cache::SimpleBackendImpl* simple_cache =
       new disk_cache::SimpleBackendImpl(cache_path_,
                                         0,
                                         net::DISK_CACHE,
                                         cache_thread.message_loop_proxy().get(),
@@ skipping 11 matching lines @@
   // Create a cache structure with the |SimpleBackendImpl|.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* entry;
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
   ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
   entry->Close();
-  delete cache_;
-  cache_ = NULL;
+  cache_.reset();
 
   // Check that the |BackendImpl| does not favor this structure.
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
       cache_path_, base::MessageLoopProxy::current().get(), NULL);
   cache->SetUnitTestMode();
   net::TestCompletionCallback cb;
   int rv = cache->Init(cb.callback());
@@ skipping 148 matching lines @@
   void* iter = NULL;
   size_t count = 0;
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
   cache_->EndEnumeration(&iter);
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
 }
 
 #endif  // !defined(OS_WIN)