[chrome/browser/chromeos/drive] Avoid use of MessageLoopProxy by use of TTRH

chrome/browser/chromeos/drive/resource_metadata_storage_unittest.cc

 // Copyright 2013 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/resource_metadata_storage.h"
 
 #include <algorithm>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_split.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 namespace drive {
 namespace internal {
 
 class ResourceMetadataStorageTest : public testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     storage_.reset(new ResourceMetadataStorage(
-        temp_dir_.path(), base::MessageLoopProxy::current().get()));
+        temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
     ASSERT_TRUE(storage_->Initialize());
   }
 
   // Overwrites |storage_|'s version.
   void SetDBVersion(int version) {
     ResourceMetadataHeader header;
     ASSERT_EQ(FILE_ERROR_OK, storage_->GetHeader(&header));
     header.set_version(version);
     EXPECT_EQ(FILE_ERROR_OK, storage_->PutHeader(header));
   }
@@ skipping 218 matching lines @@
   entry2.set_local_id(child_id1);
   entry2.set_parent_local_id(parent_id1);
   entry2.set_base_name(child_name1);
 
   // Put some data.
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry1));
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry2));
 
   // Close DB and reopen.
   storage_.reset(new ResourceMetadataStorage(
-      temp_dir_.path(), base::MessageLoopProxy::current().get()));
+      temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Can read data.
   ResourceEntry result;
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetEntry(parent_id1, &result));
 
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetEntry(child_id1, &result));
   EXPECT_EQ(parent_id1, result.parent_local_id());
   EXPECT_EQ(child_name1, result.base_name());
 
@@ skipping 25 matching lines @@
   FileCacheEntry cache_entry;
   EXPECT_TRUE(cache_entry.SerializeToString(&serialized_entry));
   batch.Put(std::string("file:abcd") + '\0' + "CACHE", serialized_entry);
 
   EXPECT_TRUE(resource_map()->Write(leveldb::WriteOptions(), &batch).ok());
 
   // Upgrade and reopen.
   storage_.reset();
   EXPECT_TRUE(ResourceMetadataStorage::UpgradeOldDB(temp_dir_.path()));
   storage_.reset(new ResourceMetadataStorage(
-      temp_dir_.path(), base::MessageLoopProxy::current().get()));
+      temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Resource-ID-to-local-ID mapping is added.
   std::string id;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetIdByResourceId("abcd", &id));  // "file:" is dropped.
 
   // Data is erased, except cache entries.
   int64 largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
@@ skipping 31 matching lines @@
   batch.Put(local_id + '\0' + "CACHE", serialized_entry);
 
   batch.Put('\0' + std::string("ID") + '\0' + resource_id, local_id);
 
   EXPECT_TRUE(resource_map()->Write(leveldb::WriteOptions(), &batch).ok());
 
   // Upgrade and reopen.
   storage_.reset();
   EXPECT_TRUE(ResourceMetadataStorage::UpgradeOldDB(temp_dir_.path()));
   storage_.reset(new ResourceMetadataStorage(
-      temp_dir_.path(), base::MessageLoopProxy::current().get()));
+      temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Data is erased, except cache and id mapping entries.
   std::string id;
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetIdByResourceId(resource_id, &id));
   EXPECT_EQ(local_id, id);
   int64 largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetLargestChangestamp(&largest_changestamp));
   EXPECT_EQ(0, largest_changestamp);
@@ skipping 40 matching lines @@
   EXPECT_TRUE(cache_entry.SerializeToString(&serialized_entry));
   batch.Put(local_id2 + '\0' + "CACHE", serialized_entry);
   batch.Put('\0' + std::string("ID") + '\0' + resource_id2, local_id2);
 
   EXPECT_TRUE(resource_map()->Write(leveldb::WriteOptions(), &batch).ok());
 
   // Upgrade and reopen.
   storage_.reset();
   EXPECT_TRUE(ResourceMetadataStorage::UpgradeOldDB(temp_dir_.path()));
   storage_.reset(new ResourceMetadataStorage(
-      temp_dir_.path(), base::MessageLoopProxy::current().get()));
+      temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // No data is lost.
   int64 largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetLargestChangestamp(&largest_changestamp));
   EXPECT_EQ(kLargestChangestamp, largest_changestamp);
 
   std::string id;
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetIdByResourceId(resource_id, &id));
@@ skipping 17 matching lines @@
             storage_->SetLargestChangestamp(kLargestChangestamp));
   ResourceEntry entry;
   entry.set_local_id(key1);
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
 
   // Set newer version, upgrade and reopen DB.
   SetDBVersion(ResourceMetadataStorage::kDBVersion + 1);
   storage_.reset();
   EXPECT_FALSE(ResourceMetadataStorage::UpgradeOldDB(temp_dir_.path()));
   storage_.reset(new ResourceMetadataStorage(
-      temp_dir_.path(), base::MessageLoopProxy::current().get()));
+      temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Data is erased because of the incompatible version.
   int64 largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetLargestChangestamp(&largest_changestamp));
   EXPECT_EQ(0, largest_changestamp);
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, storage_->GetEntry(key1, &entry));
 }
 
@@ skipping 12 matching lines @@
 
   // Put an ID entry without any corresponding entries.
   batch.Put('\0' + std::string("ID") + '\0' + "resource_id2", "id3");
 
   EXPECT_TRUE(resource_map()->Write(leveldb::WriteOptions(), &batch).ok());
 
   // Upgrade and reopen.
   storage_.reset();
   EXPECT_TRUE(ResourceMetadataStorage::UpgradeOldDB(temp_dir_.path()));
   storage_.reset(new ResourceMetadataStorage(
-      temp_dir_.path(), base::MessageLoopProxy::current().get()));
+      temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Only the unused entry is deleted.
   std::string id;
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetIdByResourceId("resource_id1", &id));
   EXPECT_EQ("id1", id);
   EXPECT_EQ(FILE_ERROR_NOT_FOUND,
             storage_->GetIdByResourceId("resource_id2", &id));
 }
 
 TEST_F(ResourceMetadataStorageTest, WrongPath) {
   // Create a file.
   base::FilePath path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &path));
 
   storage_.reset(new ResourceMetadataStorage(
-      path, base::MessageLoopProxy::current().get()));
+      path, base::ThreadTaskRunnerHandle::Get().get()));
   // Cannot initialize DB beacause the path does not point a directory.
   ASSERT_FALSE(storage_->Initialize());
 }
 
 TEST_F(ResourceMetadataStorageTest, RecoverCacheEntriesFromTrashedResourceMap) {
   // Put entry with id_foo.
   ResourceEntry entry;
   entry.set_local_id("id_foo");
   entry.set_base_name("foo");
   entry.set_title("foo");
   entry.mutable_file_specific_info()->mutable_cache_state()->set_md5("md5_foo");
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
 
   // Put entry with id_bar as a id_foo's child.
   entry.set_local_id("id_bar");
   entry.set_parent_local_id("id_foo");
   entry.set_base_name("bar");
   entry.set_title("bar");
   entry.mutable_file_specific_info()->mutable_cache_state()->set_md5("md5_bar");
   entry.mutable_file_specific_info()->mutable_cache_state()->set_is_dirty(true);
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
 
   // Remove parent-child relationship to make the DB invalid.
   RemoveChild("id_foo", "bar");
   EXPECT_FALSE(CheckValidity());
 
   // Reopen. This should result in trashing the DB.
   storage_.reset(new ResourceMetadataStorage(
-      temp_dir_.path(), base::MessageLoopProxy::current().get()));
+      temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Recover cache entries from the trashed DB.
   ResourceMetadataStorage::RecoveredCacheInfoMap recovered_cache_info;
   storage_->RecoverCacheInfoFromTrashedResourceMap(&recovered_cache_info);
   EXPECT_EQ(2U, recovered_cache_info.size());
   EXPECT_FALSE(recovered_cache_info["id_foo"].is_dirty);
   EXPECT_EQ("md5_foo", recovered_cache_info["id_foo"].md5);
   EXPECT_EQ("foo", recovered_cache_info["id_foo"].title);
   EXPECT_TRUE(recovered_cache_info["id_bar"].is_dirty);
@@ skipping 68 matching lines @@
   EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveEntry(key3));
   EXPECT_TRUE(CheckValidity());
 
   // Remove key1.
   EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveEntry(key1));
   EXPECT_TRUE(CheckValidity());
 }
 
 }  // namespace internal
 }  // namespace drive