Change the API of disk_cache::CreateCacheBackend to use scoped_ptr

net/disk_cache/disk_cache_test_base.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/disk_cache/disk_cache_test_base.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "net/base/io_buffer.h"
@@ skipping 32 matching lines @@
 
 bool DiskCacheTest::CleanupCacheDir() {
   return DeleteCache(cache_path_);
 }
 
 void DiskCacheTest::TearDown() {
   base::RunLoop().RunUntilIdle();
 }
 
 DiskCacheTestWithCache::DiskCacheTestWithCache()
-    : cache_(NULL),
-      cache_impl_(NULL),
+    : cache_impl_(NULL),
       simple_cache_impl_(NULL),
       mem_cache_(NULL),
       mask_(0),
       size_(0),
       type_(net::DISK_CACHE),
       memory_only_(false),
       simple_cache_mode_(false),
       simple_cache_wait_for_index_(true),
       force_creation_(false),
       new_eviction_(false),
@@ skipping 17 matching lines @@
 }
 
 // We are expected to leak memory when simulating crashes.
 void DiskCacheTestWithCache::SimulateCrash() {
   ASSERT_TRUE(!memory_only_);
   net::TestCompletionCallback cb;
   int rv = cache_impl_->FlushQueueForTest(cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
   cache_impl_->ClearRefCountForTest();
 
-  delete cache_impl_;
+  cache_.reset();
   EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
 
   CreateBackend(disk_cache::kNoRandom, &cache_thread_);
 }
 
 void DiskCacheTestWithCache::SetTestMode() {
   ASSERT_TRUE(!memory_only_);
   cache_impl_->SetUnitTestMode();
 }
 
@@ skipping 120 matching lines @@
 
 void DiskCacheTestWithCache::AddDelay() {
   base::Time initial = base::Time::Now();
   while (base::Time::Now() <= initial) {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
   };
 }
 
 void DiskCacheTestWithCache::TearDown() {
   base::RunLoop().RunUntilIdle();
-  delete cache_;
+  cache_.reset();
   if (cache_thread_.IsRunning())
     cache_thread_.Stop();
 
   if (!memory_only_ && !simple_cache_mode_ && integrity_) {
     EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
   }
 
   PlatformTest::TearDown();
 }
 
 void DiskCacheTestWithCache::InitMemoryCache() {
   mem_cache_ = new disk_cache::MemBackendImpl(NULL);
-  cache_ = mem_cache_;
-  ASSERT_TRUE(NULL != cache_);
+  cache_.reset(mem_cache_);
+  ASSERT_TRUE(cache_);
 
   if (size_)
     EXPECT_TRUE(mem_cache_->SetMaxSize(size_));
 
   ASSERT_TRUE(mem_cache_->Init());
 }
 
 void DiskCacheTestWithCache::InitDiskCache() {
   if (first_cleanup_)
     ASSERT_TRUE(CleanupCacheDir());
 
   if (!cache_thread_.IsRunning()) {
     ASSERT_TRUE(cache_thread_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   }
   ASSERT_TRUE(cache_thread_.message_loop() != NULL);
 
   CreateBackend(disk_cache::kNoRandom, &cache_thread_);
 }
 
 void DiskCacheTestWithCache::CreateBackend(uint32 flags, base::Thread* thread) {
   base::MessageLoopProxy* runner;
   if (use_current_thread_)
     runner = base::MessageLoopProxy::current().get();
   else
     runner = thread->message_loop_proxy().get();
 
   if (simple_cache_mode_) {
     net::TestCompletionCallback cb;
-    disk_cache::SimpleBackendImpl* simple_backend =
+    scoped_ptr<disk_cache::SimpleBackendImpl> simple_backend(
         new disk_cache::SimpleBackendImpl(
-            cache_path_, size_, type_, make_scoped_refptr(runner).get(), NULL);
+            cache_path_, size_, type_, make_scoped_refptr(runner).get(), NULL));
     int rv = simple_backend->Init(cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
-    cache_ = simple_cache_impl_ = simple_backend;
+    simple_cache_impl_ = simple_backend.get();
+    cache_ = simple_backend.PassAs<disk_cache::Backend>();
     if (simple_cache_wait_for_index_) {
       net::TestCompletionCallback wait_for_index_cb;
-      rv = simple_backend->index()->ExecuteWhenReady(
+      rv = simple_cache_impl_->index()->ExecuteWhenReady(
           wait_for_index_cb.callback());
       ASSERT_EQ(net::OK, wait_for_index_cb.GetResult(rv));
     }
     return;
   }
 
   if (mask_)
     cache_impl_ = new disk_cache::BackendImpl(cache_path_, mask_, runner, NULL);
   else
     cache_impl_ = new disk_cache::BackendImpl(cache_path_, runner, NULL);
-  cache_ = cache_impl_;
-  ASSERT_TRUE(NULL != cache_);
+  cache_.reset(cache_impl_);
+  ASSERT_TRUE(cache_);
   if (size_)
     EXPECT_TRUE(cache_impl_->SetMaxSize(size_));
   if (new_eviction_)
     cache_impl_->SetNewEviction();
   cache_impl_->SetType(type_);
   cache_impl_->SetFlags(flags);
   net::TestCompletionCallback cb;
   int rv = cache_impl_->Init(cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
-  cache_ = cache_impl_;
 }