chromeos: Destruct DriveResourceMetadata on the blocking pool

chrome/browser/chromeos/drive/drive_resource_metadata_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_resource_metadata.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 85 matching lines @@
 
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
     resource_metadata_.reset(new DriveResourceMetadata(kTestRootResourceId,
                                                        blocking_task_runner_));
     Init(resource_metadata_.get());
   }
 
+  virtual void TearDown() OVERRIDE {
+    resource_metadata_.reset();
+  }
+
   // Gets the entry info by path synchronously. Returns NULL on failure.
   scoped_ptr<DriveEntryProto> GetEntryInfoByPathSync(
       const base::FilePath& file_path) {
     DriveFileError error = DRIVE_FILE_OK;
     scoped_ptr<DriveEntryProto> entry_proto;
     resource_metadata_->GetEntryInfoByPath(
         file_path,
         base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                    &error, &entry_proto));
     google_apis::test_util::RunBlockingPoolTask();
@@ skipping 16 matching lines @@
     return entries.Pass();
   }
 
   bool ParseMetadataFromString(DriveResourceMetadata* resource_metadata,
                                const std::string& serialized_proto) {
     return resource_metadata->ParseFromString(serialized_proto);
   }
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
-  scoped_ptr<DriveResourceMetadata> resource_metadata_;
+  scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
+      resource_metadata_;
 
  private:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
 };
 
 // static
 void DriveResourceMetadataTest::Init(DriveResourceMetadata* resource_metadata) {
   int sequence_id = 1;
   ASSERT_TRUE(AddDriveEntryProto(
@@ skipping 80 matching lines @@
 TEST_F(DriveResourceMetadataTest, VersionCheck) {
   // Set up the root directory.
   DriveRootDirectoryProto proto;
   DriveEntryProto* mutable_entry =
       proto.mutable_drive_directory()->mutable_drive_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_resource_id(kTestRootResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
   mutable_entry->set_title("drive");
 
-  DriveResourceMetadata resource_metadata(kTestRootResourceId,
-                                          blocking_task_runner_);
+  scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
+      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
+                                                  blocking_task_runner_));
 
   std::string serialized_proto;
   EXPECT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is empty.
-  EXPECT_FALSE(ParseMetadataFromString(&resource_metadata, serialized_proto));
+  EXPECT_FALSE(ParseMetadataFromString(resource_metadata.get(),
+                                       serialized_proto));
 
   // Set an older version, and serialize.
   proto.set_version(kProtoVersion - 1);
   EXPECT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is older.
-  EXPECT_FALSE(ParseMetadataFromString(&resource_metadata, serialized_proto));
+  EXPECT_FALSE(ParseMetadataFromString(resource_metadata.get(),
+                                       serialized_proto));
 
   // Set the current version, and serialize.
   proto.set_version(kProtoVersion);
   EXPECT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should succeed as the version matches the current number.
-  EXPECT_TRUE(ParseMetadataFromString(&resource_metadata, serialized_proto));
+  EXPECT_TRUE(ParseMetadataFromString(resource_metadata.get(),
+                                      serialized_proto));
 
   // Set a newer version, and serialize.
   proto.set_version(kProtoVersion + 1);
   EXPECT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is newer.
-  EXPECT_FALSE(ParseMetadataFromString(&resource_metadata, serialized_proto));
+  EXPECT_FALSE(ParseMetadataFromString(resource_metadata.get(),
+                                       serialized_proto));
 }
 
 TEST_F(DriveResourceMetadataTest, LargestChangestamp) {
-  DriveResourceMetadata resource_metadata(kTestRootResourceId,
-                                          blocking_task_runner_);
+  scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
+      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
+                                                  blocking_task_runner_));
 
   int64 in_changestamp = 123456;
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
-  resource_metadata.SetLargestChangestamp(
+  resource_metadata->SetLargestChangestamp(
       in_changestamp,
       base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback,
                  &error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   int64 out_changestamp = 0;
-  resource_metadata.GetLargestChangestamp(
+  resource_metadata->GetLargestChangestamp(
       base::Bind(&CopyResultFromGetChangestampCallback,
                  &out_changestamp));
   google_apis::test_util::RunBlockingPoolTask();
   DCHECK_EQ(in_changestamp, out_changestamp);
 }
 
 TEST_F(DriveResourceMetadataTest, GetEntryInfoByResourceId_RootDirectory) {
-  DriveResourceMetadata resource_metadata(kTestRootResourceId,
-                                          blocking_task_runner_);
+  scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
+      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
+                                                  blocking_task_runner_));
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   base::FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
   // Look up the root directory by its resource ID.
-  resource_metadata.GetEntryInfoByResourceId(
+  resource_metadata->GetEntryInfoByResourceId(
       kTestRootResourceId,
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe("drive"), drive_file_path);
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("drive", entry_proto->base_name());
 }
 
@@ skipping 872 matching lines @@
   // root should have no children.
   entries = ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive"));
   ASSERT_TRUE(entries.get());
   EXPECT_TRUE(entries->empty());
 }
 
 TEST_F(DriveResourceMetadataTest, PerDirectoryChangestamp) {
   const int kNewChangestamp = kTestChangestamp + 1;
   const char kSubDirectoryResourceId[] = "sub-directory-id";
 
-  DriveResourceMetadata resource_metadata_original(kTestRootResourceId,
-                                                   blocking_task_runner_);
+  scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
+      resource_metadata_original(new DriveResourceMetadata(
+          kTestRootResourceId, blocking_task_runner_));
+
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
-  resource_metadata_original.SetLargestChangestamp(
+  resource_metadata_original->SetLargestChangestamp(
       kNewChangestamp,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Add a sub directory.
   DriveEntryProto directory_entry;
   directory_entry.mutable_file_info()->set_is_directory(true);
   directory_entry.set_resource_id(kSubDirectoryResourceId);
   directory_entry.set_parent_resource_id(kTestRootResourceId);
   directory_entry.set_title("directory");
   base::FilePath file_path;
-  resource_metadata_original.AddEntry(
+  resource_metadata_original->AddEntry(
       directory_entry,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
   // At this point, both the root and the sub directory do not contain the
   // per-directory changestamp.
-  resource_metadata_original.MaybeSave(temp_dir_.path());
+  resource_metadata_original->MaybeSave(temp_dir_.path());
   google_apis::test_util::RunBlockingPoolTask();
 
-  DriveResourceMetadata resource_metadata(kTestRootResourceId,
-                                          blocking_task_runner_);
+  scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
+      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
+                                                  blocking_task_runner_));
 
   // Load. This should propagate the largest changestamp to every directory.
-  resource_metadata.Load(
+  resource_metadata->Load(
       temp_dir_.path(),
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Confirm that the root directory contains the changestamp.
   scoped_ptr<DriveEntryProto> entry_proto;
-  resource_metadata.GetEntryInfoByPath(
+  resource_metadata->GetEntryInfoByPath(
       base::FilePath::FromUTF8Unsafe("drive"),
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(kNewChangestamp,
             entry_proto->directory_specific_info().changestamp());
 
   // Confirm that the sub directory contains the changestamp.
-  resource_metadata.GetEntryInfoByPath(
+  resource_metadata->GetEntryInfoByPath(
       base::FilePath::FromUTF8Unsafe("drive/directory"),
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(kNewChangestamp,
             entry_proto->directory_specific_info().changestamp());
 }
 
 TEST_F(DriveResourceMetadataTest, SaveAndLoad) {
@@ skipping 14 matching lines @@
   // Try to get some data.
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(
       base::FilePath::FromUTF8Unsafe("drive/dir1/dir3/file9"));
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file9", entry->base_name());
   ASSERT_TRUE(!entry->file_info().is_directory());
   EXPECT_EQ("md5:file9", entry->file_specific_info().file_md5());
 }
 
 }  // namespace drive