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

chrome/browser/chromeos/drive/search_metadata_unittest.cc

 // Copyright (c) 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/search_metadata.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/i18n/string_search.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/drive/fake_free_disk_space_getter.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace internal {
@@ skipping 15 matching lines @@
 
 }  // namespace
 
 class SearchMetadataTest : public testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
     metadata_storage_.reset(new ResourceMetadataStorage(
-        temp_dir_.path(), base::MessageLoopProxy::current().get()));
+        temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
     ASSERT_TRUE(metadata_storage_->Initialize());
 
     cache_.reset(new FileCache(metadata_storage_.get(),
                                temp_dir_.path(),
-                               base::MessageLoopProxy::current().get(),
+                               base::ThreadTaskRunnerHandle::Get().get(),
                                fake_free_disk_space_getter_.get()));
     ASSERT_TRUE(cache_->Initialize());
 
     resource_metadata_.reset(
         new ResourceMetadata(metadata_storage_.get(),
                              cache_.get(),
-                             base::MessageLoopProxy::current()));
+                             base::ThreadTaskRunnerHandle::Get().get()));
     ASSERT_EQ(FILE_ERROR_OK, resource_metadata_->Initialize());
 
     AddEntriesToMetadata();
   }
 
   void AddEntriesToMetadata() {
     base::FilePath temp_file;
     EXPECT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file));
     const std::string temp_file_md5 = "md5";
 
@@ skipping 85 matching lines @@
   scoped_ptr<ResourceMetadata, test_util::DestroyHelperForTests>
       resource_metadata_;
   scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
 };
 
 TEST_F(SearchMetadataTest, SearchMetadata_ZeroMatches) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(),
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "NonExistent", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(0U, result->size());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_RegularFile) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(),
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "SubDirectory File 1.txt", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 // This test checks if |FindAndHighlightWrapper| does case-insensitive search.
 // Tricker test cases for |FindAndHighlightWrapper| can be found below.
 TEST_F(SearchMetadataTest, SearchMetadata_CaseInsensitiveSearch) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   // The query is all in lower case.
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(),
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "subdirectory file 1.txt", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_RegularFiles) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(), "SubDir",
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "SubDir",
       base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(2U, result->size());
 
   // All base names should contain "File". The results should be sorted by the
   // last accessed time in descending order.
   EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt",
             result->at(0).path.AsUTF8Unsafe());
   EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
             result->at(1).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_AtMostOneFile) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   // There are two files matching "SubDir" but only one file should be
   // returned.
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(), "SubDir",
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "SubDir",
       base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       1,  // at_most_num_matches
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_Directory) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(),
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "Directory 1", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Directory 1", result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_HostedDocument) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(), "Document",
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "Document",
       base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
 
   EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeHostedDocument) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(), "Document",
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "Document",
       base::Bind(&MatchesType, SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(0U, result->size());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_SharedWithMe) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(), "",
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "",
       base::Bind(&MatchesType, SEARCH_METADATA_SHARED_WITH_ME),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Directory 1/Shared To The Account Owner.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_FileAndDirectory) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(),
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "excludeDir-test", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(2U, result->size());
 
   EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc",
             result->at(0).path.AsUTF8Unsafe());
   EXPECT_EQ("drive/root/Directory 2 excludeDir-test",
             result->at(1).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeDirectory) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(),
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "excludeDir-test",
       base::Bind(&MatchesType, SEARCH_METADATA_EXCLUDE_DIRECTORIES),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
 
   EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 // "drive", "drive/root", "drive/other" should be excluded.
 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeSpecialDirectories) {
   const char* const kQueries[] = { "drive", "root", "other" };
   for (size_t i = 0; i < arraysize(kQueries); ++i) {
     FileError error = FILE_ERROR_FAILED;
     scoped_ptr<MetadataSearchResultVector> result;
 
     const std::string query = kQueries[i];
     SearchMetadata(
-        base::MessageLoopProxy::current(), resource_metadata_.get(), query,
+        base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), query,
         base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches,
         google_apis::test_util::CreateCopyResultCallback(&error, &result));
 
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(FILE_ERROR_OK, error);
     ASSERT_TRUE(result);
     ASSERT_TRUE(result->empty()) << ": " << query << " should not match";
   }
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_Offline) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
-      base::MessageLoopProxy::current(), resource_metadata_.get(), "",
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "",
       base::Bind(&MatchesType, SEARCH_METADATA_OFFLINE),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_EQ(3U, result->size());
 
   // This is not included in the cache but is a hosted document.
   EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc",
             result->at(0).path.AsUTF8Unsafe());
@@ skipping 95 matching lines @@
 }
 
 TEST(SearchMetadataSimpleTest, FindAndHighlight_MoreMetaChars) {
   std::string highlighted_text;
   EXPECT_TRUE(FindAndHighlightWrapper("a&b&c&d", "b&c", &highlighted_text));
   EXPECT_EQ("a&amp;<b>b&amp;c</b>&amp;d", highlighted_text);
 }
 
 }  // namespace internal
 }  // namespace drive