chromeos: Destruct DriveResourceMetadata on the blocking pool

chrome/browser/chromeos/drive/drive_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 "chrome/browser/chromeos/drive/drive_cache.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 92 matching lines @@
 
   virtual void SetUp() OVERRIDE {
     profile_.reset(new TestingProfile);
 
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
-    cache_ = new DriveCache(
-        DriveCache::GetCacheRootPath(profile_.get()),
-        blocking_task_runner_,
-        fake_free_disk_space_getter_.get());
+    cache_.reset(new DriveCache(DriveCache::GetCacheRootPath(profile_.get()),
+                                blocking_task_runner_,
+                                fake_free_disk_space_getter_.get()));
 
     mock_cache_observer_.reset(new StrictMock<MockDriveCacheObserver>);
     cache_->AddObserver(mock_cache_observer_.get());
 
     bool initialization_success = false;
     cache_->RequestInitialize(
         base::Bind(&test_util::CopyResultFromInitializeCacheCallback,
                    &initialization_success));
     google_apis::test_util::RunBlockingPoolTask();
     ASSERT_TRUE(initialization_success);
   }
 
   virtual void TearDown() OVERRIDE {
-    test_util::DeleteDriveCache(cache_);
+    cache_.reset();
     profile_.reset(NULL);
   }
 
   void PrepareTestCacheResources() {
     fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cache_resources); ++i) {
       const struct TestCacheResource& resource = test_cache_resources[i];
       // Copy file from data dir to cache.
       if (!std::string(resource.source_file).empty()) {
@@ skipping 495 matching lines @@
     }
     return num_files_found;
   }
 
   MessageLoopForUI message_loop_;
   // The order of the test threads is important, do not change the order.
   // See also content/browser/browser_thread_imple.cc.
   content::TestBrowserThread ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<TestingProfile> profile_;
-  DriveCache* cache_;
+  scoped_ptr<DriveCache, test_util::DestroyHelperForTests> cache_;
   scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
   scoped_ptr<StrictMock<MockDriveCacheObserver> > mock_cache_observer_;
 
   DriveFileError expected_error_;
   int expected_cache_state_;
   DriveCache::CacheSubDirectoryType expected_sub_dir_type_;
   bool expected_success_;
   bool expect_outgoing_symlink_;
   std::string expected_file_extension_;
   int root_feed_changestamp_;
@@ skipping 680 matching lines @@
 // Don't use TEST_F, as we don't want SetUp() and TearDown() for this test.
 TEST(DriveCacheExtraTest, InitializationFailure) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
 
   scoped_refptr<base::SequencedWorkerPool> pool =
       content::BrowserThread::GetBlockingPool();
 
   // Set the cache root to a non existent path, so the initialization fails.
-  DriveCache* cache = new DriveCache(
+  scoped_ptr<DriveCache, test_util::DestroyHelperForTests> cache(new DriveCache(
       base::FilePath::FromUTF8Unsafe("/somewhere/nonexistent/blah/blah"),
       pool->GetSequencedTaskRunner(pool->GetSequenceToken()),
-      NULL /* free_disk_space_getter */);
+      NULL /* free_disk_space_getter */));
 
   bool success = false;
   cache->RequestInitialize(
       base::Bind(&test_util::CopyResultFromInitializeCacheCallback, &success));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_FALSE(success);
-
-  test_util::DeleteDriveCache(cache);
 }
 
 }   // namespace drive