chromeos: Destruct DriveResourceMetadata on the blocking pool

chrome/browser/chromeos/drive/drive_file_system_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_file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 198 matching lines @@
     fake_drive_service_->LoadAppListForDriveApi("chromeos/drive/applist.json");
 
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
 
     // Likewise, this will be owned by DriveFileSystem.
-    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()));
 
     fake_uploader_.reset(new FakeDriveUploader);
     drive_webapps_registry_.reset(new DriveWebAppsRegistry);
 
     ASSERT_FALSE(file_system_);
     file_system_ = new DriveFileSystem(profile_.get(),
-                                       cache_,
+                                       cache_.get(),
                                        fake_drive_service_,
                                        fake_uploader_.get(),
                                        drive_webapps_registry_.get(),
                                        blocking_task_runner_);
 
     mock_cache_observer_.reset(new StrictMock<MockDriveCacheObserver>);
     cache_->AddObserver(mock_cache_observer_.get());
 
     mock_directory_observer_.reset(new StrictMock<MockDirectoryChangeObserver>);
     file_system_->AddObserver(mock_directory_observer_.get());
 
     file_system_->Initialize();
     cache_->RequestInitializeForTesting();
     google_apis::test_util::RunBlockingPoolTask();
   }
 
   virtual void TearDown() OVERRIDE {
     ASSERT_TRUE(file_system_);
     delete file_system_;
     file_system_ = NULL;
     delete fake_drive_service_;
     fake_drive_service_ = NULL;
-    test_util::DeleteDriveCache(cache_);
+    cache_.reset();
     profile_.reset(NULL);
   }
 
   // Loads test json file as root ("/drive") element.
   bool LoadRootFeedDocument() {
     DriveFileError error = DRIVE_FILE_ERROR_FAILED;
     file_system_->change_list_loader()->LoadFromServerIfNeeded(
         DirectoryFetchInfo(),
         base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback,
                    &error));
@@ skipping 139 matching lines @@
   // Saves a file representing a filesystem with directories:
   // drive, drive/Dir1, drive/Dir1/SubDir2
   // and files
   // drive/File1, drive/Dir1/File2, drive/Dir1/SubDir2/File3.
   // If |use_up_to_date_timestamp| is true, sets the changestamp to 654321,
   // equal to that of "account_metadata.json" test data, indicating the cache is
   // holding the latest file system info.
   bool SaveTestFileSystem(SaveTestFileSystemParam param) {
     const std::string root_resource_id =
         fake_drive_service_->GetRootResourceId();
-    DriveResourceMetadata resource_metadata(root_resource_id,
-                                            blocking_task_runner_);
+    scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
+        resource_metadata(new DriveResourceMetadata(root_resource_id,
+                                                    blocking_task_runner_));
 
     DriveFileError error = DRIVE_FILE_ERROR_FAILED;
-    resource_metadata.SetLargestChangestamp(
+    resource_metadata->SetLargestChangestamp(
         param == USE_SERVER_TIMESTAMP ? 654321 : 1,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
     // drive/File1
     DriveEntryProto file1;
     file1.set_title("File1");
     file1.set_resource_id("resource_id:File1");
     file1.set_parent_resource_id(root_resource_id);
     file1.set_upload_url("http://resumable-edit-media/1");
     file1.mutable_file_specific_info()->set_file_md5("md5");
     file1.mutable_file_info()->set_is_directory(false);
     file1.mutable_file_info()->set_size(1048576);
     base::FilePath file_path;
-    resource_metadata.AddEntry(
+    resource_metadata->AddEntry(
         file1,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
     // drive/Dir1
     DriveEntryProto dir1;
     dir1.set_title("Dir1");
     dir1.set_resource_id("resource_id:Dir1");
     dir1.set_parent_resource_id(root_resource_id);
     dir1.set_upload_url("http://resumable-create-media/2");
     dir1.mutable_file_info()->set_is_directory(true);
-    resource_metadata.AddEntry(
+    resource_metadata->AddEntry(
         dir1,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
     // drive/Dir1/File2
     DriveEntryProto file2;
     file2.set_title("File2");
     file2.set_resource_id("resource_id:File2");
     file2.set_parent_resource_id(dir1.resource_id());
     file2.set_upload_url("http://resumable-edit-media/2");
     file2.mutable_file_specific_info()->set_file_md5("md5");
     file2.mutable_file_info()->set_is_directory(false);
     file2.mutable_file_info()->set_size(555);
-    resource_metadata.AddEntry(
+    resource_metadata->AddEntry(
         file2,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
     // drive/Dir1/SubDir2
     DriveEntryProto dir2;
     dir2.set_title("SubDir2");
     dir2.set_resource_id("resource_id:SubDir2");
     dir2.set_parent_resource_id(dir1.resource_id());
     dir2.set_upload_url("http://resumable-create-media/3");
     dir2.mutable_file_info()->set_is_directory(true);
-    resource_metadata.AddEntry(
+    resource_metadata->AddEntry(
         dir2,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
     // drive/Dir1/SubDir2/File3
     DriveEntryProto file3;
     file3.set_title("File3");
     file3.set_resource_id("resource_id:File3");
     file3.set_parent_resource_id(dir2.resource_id());
     file3.set_upload_url("http://resumable-edit-media/3");
     file3.mutable_file_specific_info()->set_file_md5("md5");
     file3.mutable_file_info()->set_is_directory(false);
     file3.mutable_file_info()->set_size(12345);
-    resource_metadata.AddEntry(
+    resource_metadata->AddEntry(
         file3,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
     // Write resource metadata.
     base::FilePath cache_dir_path =
         cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_META);
     if (!file_util::CreateDirectory(cache_dir_path))
       return false;
-    resource_metadata.MaybeSave(cache_dir_path);
+    resource_metadata->MaybeSave(cache_dir_path);
     google_apis::test_util::RunBlockingPoolTask();
 
     return true;
   }
 
   // Verifies that |file_path| is a valid JSON file for the hosted document
   // associated with |entry| (i.e. |url| and |resource_id| match).
   void VerifyHostedDocumentJSONFile(const DriveEntryProto& entry_proto,
                                     const base::FilePath& file_path) {
     std::string error;
@@ skipping 12 matching lines @@
               edit_url);
     EXPECT_EQ(entry_proto.resource_id(), resource_id);
   }
 
   MessageLoopForUI message_loop_;
   // The order of the test threads is important, do not change the order.
   // See also content/browser/browser_thread_impl.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<FakeDriveUploader> fake_uploader_;
   DriveFileSystem* file_system_;
   google_apis::FakeDriveService* fake_drive_service_;
   scoped_ptr<DriveWebAppsRegistry> drive_webapps_registry_;
   scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
   scoped_ptr<StrictMock<MockDriveCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   bool expected_success_;
   std::string expected_file_extension_;
@@ skipping 1653 matching lines @@
 
   // An app for foo.exe should now be found, as the registry was loaded.
   drive_webapps_registry_->GetWebAppsForFile(
       base::FilePath(FILE_PATH_LITERAL("foo.exe")),
       "" /* mime_type */,
       &apps);
   EXPECT_EQ(1U, apps.size());
 }
 
 }   // namespace drive