drive: Rename drive::DriveFileSystemTest to drive::FileSystemTest

chrome/browser/chromeos/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/file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 33 matching lines @@
 
 const int64 kLotsOfSpace = internal::kMinFreeSpace * 10;
 
 struct SearchResultPair {
   const char* path;
   const bool is_directory;
 };
 
 // Callback to FileSystem::Search used in ContentSearch tests.
 // Verifies returned vector of results and next feed url.
-void DriveSearchCallback(
+void VerifySearchResult(
     MessageLoop* message_loop,
     const SearchResultPair* expected_results,
     size_t expected_results_size,
     const GURL& expected_next_feed,
     FileError error,
     const GURL& next_feed,
     scoped_ptr<std::vector<SearchResultInfo> > results) {
   ASSERT_TRUE(results);
   ASSERT_EQ(expected_results_size, results->size());
 
@@ skipping 39 matching lines @@
 
 void AppendContent(std::vector<std::string>* buffer,
                    google_apis::GDataErrorCode error,
                    scoped_ptr<std::string> content) {
   DCHECK_EQ(error, google_apis::HTTP_SUCCESS);
   buffer->push_back(*content);
 }
 
 }  // namespace
 
-class DriveFileSystemTest : public testing::Test {
+class FileSystemTest : public testing::Test {
  protected:
-  DriveFileSystemTest()
+  FileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         // |root_feed_changestamp_| should be set to the largest changestamp in
         // about resource feed. But we fake it by some non-zero positive
         // increasing value.  See |LoadFeed()|.
         root_feed_changestamp_(1) {
   }
 
   virtual void SetUp() OVERRIDE {
     profile_.reset(new TestingProfile);
 
@@ skipping 317 matching lines @@
   scoped_ptr<JobScheduler> scheduler_;
   scoped_ptr<internal::ResourceMetadata, test_util::DestroyHelperForTests>
       resource_metadata_;
   scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
   scoped_ptr<StrictMock<MockCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   int root_feed_changestamp_;
 };
 
-TEST_F(DriveFileSystemTest, DuplicatedAsyncInitialization) {
+TEST_F(FileSystemTest, DuplicatedAsyncInitialization) {
   // "Fast fetch" will fire an OnirectoryChanged event.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   int counter = 0;
   const GetResourceEntryCallback& callback = base::Bind(
       &AsyncInitializationCallback, &counter, 2, &message_loop_);
 
   file_system_->GetResourceEntryByPath(
       base::FilePath(FILE_PATH_LITERAL("drive/root")), callback);
   file_system_->GetResourceEntryByPath(
       base::FilePath(FILE_PATH_LITERAL("drive/root")), callback);
   message_loop_.Run();  // Wait to get our result
   EXPECT_EQ(2, counter);
 
   // Although GetResourceEntryByPath() was called twice, the resource list
   // should only be loaded once. In the past, there was a bug that caused
   // it to be loaded twice.
   EXPECT_EQ(1, fake_drive_service_->resource_list_load_count());
   // See the comment in GetMyDriveRoot test case why this is 2.
   EXPECT_EQ(2, fake_drive_service_->about_resource_load_count());
 }
 
-TEST_F(DriveFileSystemTest, GetGrandRootEntry) {
+TEST_F(FileSystemTest, GetGrandRootEntry) {
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(util::kDriveGrandRootSpecialResourceId, entry->resource_id());
 
   // Getting the grand root entry should not cause the resource load to happen.
   EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
 }
 
-TEST_F(DriveFileSystemTest, GetOtherDirEntry) {
+TEST_F(FileSystemTest, GetOtherDirEntry) {
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/other"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(util::kDriveOtherDirSpecialResourceId, entry->resource_id());
 
   // Getting the "other" directory entry should not cause the resource load to
   // happen.
   EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
 }
 
-TEST_F(DriveFileSystemTest, GetMyDriveRoot) {
+TEST_F(FileSystemTest, GetMyDriveRoot) {
   // "Fast fetch" will fire an OnirectoryChanged event.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(fake_drive_service_->GetRootResourceId(), entry->resource_id());
 
   // Absence of "drive/root" in the local metadata triggers the "fast fetch"
   // of "drive" directory. Fetch of "drive" grand root directory has a special
   // implementation. Instead of normal GetResourceListInDirectory(), it is
   // emulated by calling GetAboutResource() so that the resource_id of
   // "drive/root" is listed.
   // Together with the normal GetAboutResource() call to retrieve the largest
   // changestamp, the method is called twice.
   EXPECT_EQ(2, fake_drive_service_->about_resource_load_count());
 
   // After "fast fetch" is done, full resource list is fetched.
   EXPECT_EQ(1, fake_drive_service_->resource_list_load_count());
 }
 
-TEST_F(DriveFileSystemTest, GetExistingFile) {
+TEST_F(FileSystemTest, GetExistingFile) {
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ("file:2_file_resource_id", entry->resource_id());
 
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(1, fake_drive_service_->resource_list_load_count());
 }
 
-TEST_F(DriveFileSystemTest, GetExistingDocument) {
+TEST_F(FileSystemTest, GetExistingDocument) {
   const base::FilePath kFilePath(
       FILE_PATH_LITERAL("drive/root/Document 1 excludeDir-test.gdoc"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ("document:5_document_resource_id", entry->resource_id());
 }
 
-TEST_F(DriveFileSystemTest, GetNonExistingFile) {
+TEST_F(FileSystemTest, GetNonExistingFile) {
   const base::FilePath kFilePath(
       FILE_PATH_LITERAL("drive/root/nonexisting.file"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   EXPECT_FALSE(entry);
 }
 
-TEST_F(DriveFileSystemTest, GetEncodedFileNames) {
+TEST_F(FileSystemTest, GetEncodedFileNames) {
   const base::FilePath kFilePath1(
       FILE_PATH_LITERAL("drive/root/Slash / in file 1.txt"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath1);
   ASSERT_FALSE(entry);
 
   const base::FilePath kFilePath2 = base::FilePath::FromUTF8Unsafe(
       "drive/root/Slash \xE2\x88\x95 in file 1.txt");
   entry = GetResourceEntryByPathSync(kFilePath2);
   ASSERT_TRUE(entry);
   EXPECT_EQ("file:slash_file_resource_id", entry->resource_id());
 
   const base::FilePath kFilePath3 = base::FilePath::FromUTF8Unsafe(
       "drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = GetResourceEntryByPathSync(kFilePath3);
   ASSERT_TRUE(entry);
   EXPECT_EQ("file:slash_subdir_file", entry->resource_id());
 }
 
-TEST_F(DriveFileSystemTest, GetDuplicateNames) {
+TEST_F(FileSystemTest, GetDuplicateNames) {
   const base::FilePath kFilePath1(
       FILE_PATH_LITERAL("drive/root/Duplicate Name.txt"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath1);
   ASSERT_TRUE(entry);
   const std::string resource_id1 = entry->resource_id();
 
   const base::FilePath kFilePath2(
       FILE_PATH_LITERAL("drive/root/Duplicate Name (2).txt"));
   entry = GetResourceEntryByPathSync(kFilePath2);
   ASSERT_TRUE(entry);
   const std::string resource_id2 = entry->resource_id();
 
   // The entries are de-duped non-deterministically, so we shouldn't rely on the
   // names matching specific resource ids.
   const std::string file3_resource_id = "file:3_file_resource_id";
   const std::string file4_resource_id = "file:4_file_resource_id";
   EXPECT_TRUE(file3_resource_id == resource_id1 ||
               file3_resource_id == resource_id2);
   EXPECT_TRUE(file4_resource_id == resource_id1 ||
               file4_resource_id == resource_id2);
 }
 
-TEST_F(DriveFileSystemTest, GetExistingDirectory) {
+TEST_F(FileSystemTest, GetExistingDirectory) {
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/Directory 1"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   ASSERT_EQ("folder:1_folder_resource_id", entry->resource_id());
 
   // The changestamp should be propagated to the directory.
   EXPECT_EQ(fake_drive_service_->largest_changestamp(),
             entry->directory_specific_info().changestamp());
 }
 
-TEST_F(DriveFileSystemTest, GetInSubSubdir) {
+TEST_F(FileSystemTest, GetInSubSubdir) {
   const base::FilePath kFilePath(
       FILE_PATH_LITERAL("drive/root/Directory 1/Sub Directory Folder/"
                         "Sub Sub Directory Folder"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   ASSERT_EQ("folder:sub_sub_directory_folder_id", entry->resource_id());
 }
 
-TEST_F(DriveFileSystemTest, GetOrphanFile) {
+TEST_F(FileSystemTest, GetOrphanFile) {
   const base::FilePath kFilePath(
       FILE_PATH_LITERAL("drive/other/Orphan File 1.txt"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ("file:1_orphanfile_resource_id", entry->resource_id());
 }
 
-TEST_F(DriveFileSystemTest, ReadDirectoryByPath_Root) {
+TEST_F(FileSystemTest, ReadDirectoryByPath_Root) {
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   // ReadDirectoryByPath() should kick off the resource list loading.
   scoped_ptr<ResourceEntryVector> entries(
       ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive")));
   // The root directory should be read correctly.
   ASSERT_TRUE(entries);
   ASSERT_EQ(2U, entries->size());
 
   // The found two directories should be /drive/root and /drive/other.
   bool found_other = false;
   bool found_my_drive = false;
   for (size_t i = 0; i < entries->size(); ++i) {
     const base::FilePath title =
         base::FilePath::FromUTF8Unsafe((*entries)[i].title());
     if (title == base::FilePath(util::kDriveOtherDirName)) {
       found_other = true;
     } else if (title == base::FilePath(util::kDriveMyDriveRootDirName)) {
       found_my_drive = true;
     }
   }
 
   EXPECT_TRUE(found_other);
   EXPECT_TRUE(found_my_drive);
 }
 
-TEST_F(DriveFileSystemTest, ReadDirectoryByPath_NonRootDirectory) {
+TEST_F(FileSystemTest, ReadDirectoryByPath_NonRootDirectory) {
   // ReadDirectoryByPath() should kick off the resource list loading.
   scoped_ptr<ResourceEntryVector> entries(
       ReadDirectoryByPathSync(
           base::FilePath::FromUTF8Unsafe("drive/root/Directory 1")));
   // The non root directory should also be read correctly.
   // There was a bug (crbug.com/181487), which broke this behavior.
   // Make sure this is fixed.
   ASSERT_TRUE(entries);
   EXPECT_EQ(3U, entries->size());
 }
 
-TEST_F(DriveFileSystemTest, ChangeFeed_AddAndDeleteFileInRoot) {
+TEST_F(FileSystemTest, ChangeFeed_AddAndDeleteFileInRoot) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(2);
 
   ASSERT_TRUE(LoadChangeFeed("chromeos/gdata/delta_file_added_in_root.json"));
   EXPECT_TRUE(EntryExists(
       base::FilePath(FILE_PATH_LITERAL("drive/root/Added file.gdoc"))));
 
   ASSERT_TRUE(LoadChangeFeed("chromeos/gdata/delta_file_deleted_in_root.json"));
   EXPECT_FALSE(EntryExists(
       base::FilePath(FILE_PATH_LITERAL("drive/root/Added file.gdoc"))));
 }
 
-TEST_F(DriveFileSystemTest, ChangeFeed_AddAndDeleteFileFromExistingDirectory) {
+TEST_F(FileSystemTest, ChangeFeed_AddAndDeleteFileFromExistingDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(
       EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1"))));
 
   // Add file to an existing directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
       .Times(1);
   ASSERT_TRUE(
       LoadChangeFeed("chromeos/gdata/delta_file_added_in_directory.json"));
   EXPECT_TRUE(EntryExists(base::FilePath(
       FILE_PATH_LITERAL("drive/root/Directory 1/Added file.gdoc"))));
 
   // Remove that file from the directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
       .Times(1);
   ASSERT_TRUE(
       LoadChangeFeed("chromeos/gdata/delta_file_deleted_in_directory.json"));
   EXPECT_TRUE(
       EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1"))));
   EXPECT_FALSE(EntryExists(base::FilePath(
       FILE_PATH_LITERAL("drive/root/Directory 1/Added file.gdoc"))));
 }
 
-TEST_F(DriveFileSystemTest, ChangeFeed_AddFileToNewDirectory) {
+TEST_F(FileSystemTest, ChangeFeed_AddFileToNewDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
   // Add file to a new directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/New Directory")))))
       .Times(1);
 
   ASSERT_TRUE(
       LoadChangeFeed("chromeos/gdata/delta_file_added_in_new_directory.json"));
 
   EXPECT_TRUE(
       EntryExists(base::FilePath(
           FILE_PATH_LITERAL("drive/root/New Directory"))));
   EXPECT_TRUE(EntryExists(base::FilePath(
       FILE_PATH_LITERAL("drive/root/New Directory/File in new dir.gdoc"))));
 }
 
-TEST_F(DriveFileSystemTest, ChangeFeed_AddFileToNewButDeletedDirectory) {
+TEST_F(FileSystemTest, ChangeFeed_AddFileToNewButDeletedDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // This feed contains the following updates:
   // 1) A new PDF file is added to a new directory
   // 2) but the new directory is marked "deleted" (i.e. moved to Trash)
   // Hence, the PDF file should be just ignored.
   ASSERT_TRUE(LoadChangeFeed(
       "chromeos/gdata/delta_file_added_in_new_but_deleted_directory.json"));
 }
 
-TEST_F(DriveFileSystemTest, ChangeFeed_DirectoryMovedFromRootToDirectory) {
+TEST_F(FileSystemTest, ChangeFeed_DirectoryMovedFromRootToDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 2 excludeDir-test"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/Sub Directory Folder"))));
@@ skipping 27 matching lines @@
       "drive/root/Directory 2 excludeDir-test/Directory 1/"
       "SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 2 excludeDir-test/Directory 1/"
       "Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 2 excludeDir-test/Directory 1/Sub Directory Folder/"
       "Sub Sub Directory Folder"))));
 }
 
-TEST_F(DriveFileSystemTest, ChangeFeed_FileMovedFromDirectoryToRoot) {
+TEST_F(FileSystemTest, ChangeFeed_FileMovedFromDirectoryToRoot) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/Sub Directory Folder/"
       "Sub Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
@@ skipping 13 matching lines @@
       "drive/root/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/Sub Directory Folder/"
       "Sub Sub Directory Folder"))));
   EXPECT_FALSE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/SubDirectory File 1.txt"))));
 }
 
-TEST_F(DriveFileSystemTest, ChangeFeed_FileRenamedInDirectory) {
+TEST_F(FileSystemTest, ChangeFeed_FileRenamedInDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/SubDirectory File 1.txt"))));
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
       .Times(1);
   ASSERT_TRUE(LoadChangeFeed(
       "chromeos/gdata/delta_file_renamed_in_directory.json"));
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1"))));
   EXPECT_FALSE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/New SubDirectory File 1.txt"))));
 }
 
-TEST_F(DriveFileSystemTest, CachedFeedLoadingThenServerFeedLoading) {
+TEST_F(FileSystemTest, CachedFeedLoadingThenServerFeedLoading) {
   ASSERT_TRUE(SetUpTestFileSystem(USE_SERVER_TIMESTAMP));
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(ReadDirectoryByPathSync(util::GetDriveMyDriveRootPath()));
 
   // SetUpTestFileSystem and "account_metadata.json" have the same changestamp,
   // so no request for new feeds (i.e., call to GetResourceList) should happen.
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
 
   // Since the file system has verified that it holds the latest snapshot,
   // it should change its state to "loaded", which admits periodic refresh.
   // To test it, call CheckForUpdates and verify it does try to check updates.
   file_system_->CheckForUpdates();
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(2, fake_drive_service_->about_resource_load_count());
 }
 
-TEST_F(DriveFileSystemTest, OfflineCachedFeedLoading) {
+TEST_F(FileSystemTest, OfflineCachedFeedLoading) {
   ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
 
   // Make GetResourceList fail for simulating offline situation. This will leave
   // the file system "loaded from cache, but not synced with server" state.
   fake_drive_service_->set_offline(true);
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(ReadDirectoryByPathSync(util::GetDriveMyDriveRootPath()));
   // Loading of about resource should not happen as it's offline.
   EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
@@ skipping 18 matching lines @@
 
   file_system_->CheckForUpdates();
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(_))
       .Times(AtLeast(1));
 
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(1, fake_drive_service_->change_list_load_count());
 }
 
-TEST_F(DriveFileSystemTest, ReadDirectoryWhileRefreshing) {
+TEST_F(FileSystemTest, ReadDirectoryWhileRefreshing) {
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(_))
       .Times(AtLeast(1));
 
   // Enter the "refreshing" state so the fast fetch will be performed.
   ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
   file_system_->CheckForUpdates();
 
   // The list of resources in "drive/root/Dir1" should be fetched.
   EXPECT_TRUE(ReadDirectoryByPathSync(base::FilePath(
       FILE_PATH_LITERAL("drive/root/Dir1"))));
   EXPECT_EQ(1, fake_drive_service_->directory_load_count());
 }
 
-TEST_F(DriveFileSystemTest, GetResourceEntryExistingWhileRefreshing) {
+TEST_F(FileSystemTest, GetResourceEntryExistingWhileRefreshing) {
   // Enter the "refreshing" state.
   ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
   file_system_->CheckForUpdates();
 
   // If an entry is already found in local metadata, no directory fetch happens.
   EXPECT_TRUE(GetResourceEntryByPathSync(base::FilePath(
       FILE_PATH_LITERAL("drive/root/Dir1/File2"))));
   EXPECT_EQ(0, fake_drive_service_->directory_load_count());
 }
 
-TEST_F(DriveFileSystemTest, GetResourceEntryNonExistentWhileRefreshing) {
+TEST_F(FileSystemTest, GetResourceEntryNonExistentWhileRefreshing) {
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(_))
       .Times(AtLeast(1));
 
   // Enter the "refreshing" state so the fast fetch will be performed.
   ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
   file_system_->CheckForUpdates();
 
   // If an entry is not found, parent directory's resource list is fetched.
   EXPECT_FALSE(GetResourceEntryByPathSync(base::FilePath(
       FILE_PATH_LITERAL("drive/root/Dir1/NonExistentFile"))));
   EXPECT_EQ(1, fake_drive_service_->directory_load_count());
 }
 
-TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
+TEST_F(FileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // We'll add a file to the Drive root directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   // Prepare a local file.
   base::ScopedTempDir temp_dir;
@@ skipping 24 matching lines @@
       remote_dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
-TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_HostedDocument) {
+TEST_F(FileSystemTest, TransferFileFromLocalToRemote_HostedDocument) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // Prepare a local file, which is a json file of a hosted document, which
   // matches "Document 1" in root_feed.json.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   const base::FilePath local_src_file_path =
       temp_dir.path().AppendASCII("local.gdoc");
   const std::string kEditUrl =
       "https://3_document_self_link/document:5_document_resource_id";
@@ skipping 22 matching lines @@
       remote_dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
-TEST_F(DriveFileSystemTest, TransferFileFromRemoteToLocal_RegularFile) {
+TEST_F(FileSystemTest, TransferFileFromRemoteToLocal_RegularFile) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath local_dest_file_path =
@@ skipping 31 matching lines @@
   std::string cache_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(cache_file_path, &cache_file_data));
   EXPECT_EQ(kExpectedContent, cache_file_data);
 
   std::string local_dest_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(local_dest_file_path,
                                           &local_dest_file_data));
   EXPECT_EQ(kExpectedContent, local_dest_file_data);
 }
 
-TEST_F(DriveFileSystemTest, TransferFileFromRemoteToLocal_HostedDocument) {
+TEST_F(FileSystemTest, TransferFileFromRemoteToLocal_HostedDocument) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath local_dest_file_path =
       temp_dir.path().AppendASCII("local_copy.txt");
   base::FilePath remote_src_file_path(
       FILE_PATH_LITERAL("drive/root/Document 1 excludeDir-test.gdoc"));
   FileError error = FILE_ERROR_FAILED;
   file_system_->TransferFileFromRemoteToLocal(
       remote_src_file_path,
       local_dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   scoped_ptr<ResourceEntry> entry = GetResourceEntryByPathSync(
       remote_src_file_path);
   ASSERT_TRUE(entry);
   VerifyHostedDocumentJSONFile(*entry, local_dest_file_path);
 }
 
-TEST_F(DriveFileSystemTest, CopyNotExistingFile) {
+TEST_F(FileSystemTest, CopyNotExistingFile) {
   base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/Dummy file.txt"));
   base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_FALSE(EntryExists(src_file_path));
 
   FileError error = FILE_ERROR_OK;
   file_system_->Copy(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
-TEST_F(DriveFileSystemTest, CopyFileToNonExistingDirectory) {
+TEST_F(FileSystemTest, CopyFileToNonExistingDirectory) {
   base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/root/Dummy"));
   base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Dummy/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<ResourceEntry> src_entry = GetResourceEntryByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry);
   std::string src_file_path_resource_id = src_entry->resource_id();
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
 
   FileError error = FILE_ERROR_OK;
   file_system_->Copy(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 // Test the case where the parent of |dest_file_path| is an existing file,
 // not a directory.
-TEST_F(DriveFileSystemTest, CopyFileToInvalidPath) {
+TEST_F(FileSystemTest, CopyFileToInvalidPath) {
   base::FilePath src_file_path(FILE_PATH_LITERAL(
       "drive/root/Document 1 excludeDir-test.gdoc"));
   base::FilePath dest_parent_path(
       FILE_PATH_LITERAL("drive/root/Duplicate Name.txt"));
   base::FilePath dest_file_path(FILE_PATH_LITERAL(
       "drive/root/Duplicate Name.txt/Document 1 excludeDir-test.gdoc"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
@@ skipping 15 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_NOT_A_DIRECTORY, error);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
 
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
-TEST_F(DriveFileSystemTest, RemoveEntries) {
+TEST_F(FileSystemTest, RemoveEntries) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath nonexisting_file(
       FILE_PATH_LITERAL("drive/root/Dummy file.txt"));
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   base::FilePath dir_in_root(FILE_PATH_LITERAL("drive/root/Directory 1"));
   base::FilePath file_in_subdir(
       FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
 
   ASSERT_TRUE(EntryExists(file_in_root));
@@ skipping 34 matching lines @@
   // Try removing non-existing file.
   EXPECT_FALSE(RemoveEntry(nonexisting_file));
 
   // Try removing root file element.
   EXPECT_FALSE(RemoveEntry(base::FilePath(FILE_PATH_LITERAL("drive/root"))));
 
   // Need this to ensure OnDirectoryChanged() is run.
   google_apis::test_util::RunBlockingPoolTask();
 }
 
-TEST_F(DriveFileSystemTest, CreateDirectory) {
+TEST_F(FileSystemTest, CreateDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   // Create directory in root.
   base::FilePath dir_path(FILE_PATH_LITERAL("drive/root/New Folder 1"));
   EXPECT_FALSE(EntryExists(dir_path));
   EXPECT_EQ(FILE_ERROR_OK, AddDirectory(dir_path));
   EXPECT_TRUE(EntryExists(dir_path));
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/New Folder 1")))))
       .Times(1);
 
   // Create directory in a sub directory.
   base::FilePath subdir_path(
       FILE_PATH_LITERAL("drive/root/New Folder 1/New Folder 2"));
   EXPECT_FALSE(EntryExists(subdir_path));
   EXPECT_EQ(FILE_ERROR_OK, AddDirectory(subdir_path));
   EXPECT_TRUE(EntryExists(subdir_path));
 }
 
-TEST_F(DriveFileSystemTest, CreateDirectoryByImplicitLoad) {
+TEST_F(FileSystemTest, CreateDirectoryByImplicitLoad) {
   // Intentionally *not* calling LoadRootFeedDocument(), for testing that
   // CreateDirectory ensures feed loading before it runs.
 
   base::FilePath existing_directory(
       FILE_PATH_LITERAL("drive/root/Directory 1"));
   FileError error = FILE_ERROR_FAILED;
   file_system_->CreateDirectory(
       existing_directory,
       true,  // is_exclusive
       false,  // is_recursive
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // It should fail because is_exclusive is set to true.
   EXPECT_EQ(FILE_ERROR_EXISTS, error);
 }
 
-TEST_F(DriveFileSystemTest, PinAndUnpin) {
+TEST_F(FileSystemTest, PinAndUnpin) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
 
   // Get the file info.
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_path));
   ASSERT_TRUE(entry);
 
   // Pin the file.
   FileError error = FILE_ERROR_FAILED;
   EXPECT_CALL(*mock_cache_observer_,
               OnCachePinned(entry->resource_id(),
                             entry->file_specific_info().file_md5())).Times(1);
   file_system_->Pin(file_path,
                     google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Unpin the file.
   error = FILE_ERROR_FAILED;
   EXPECT_CALL(*mock_cache_observer_,
               OnCacheUnpinned(entry->resource_id(),
                               entry->file_specific_info().file_md5())).Times(1);
   file_system_->Unpin(file_path,
                       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 }
 
-TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
+TEST_F(FileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
   const int64 file_size = entry->file_info().size();
@@ skipping 16 matching lines @@
 
   // Verify that readable permission is set.
   int permission = 0;
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_path, &permission));
   EXPECT_EQ(file_util::FILE_PERMISSION_READ_BY_USER |
             file_util::FILE_PERMISSION_WRITE_BY_USER |
             file_util::FILE_PERMISSION_READ_BY_GROUP |
             file_util::FILE_PERMISSION_READ_BY_OTHERS, permission);
 }
 
-TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
+TEST_F(FileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
 
   // Pretend we have no space at all.
   fake_free_disk_space_getter_->set_fake_free_disk_space(0);
 
   FileError error = FILE_ERROR_OK;
   base::FilePath file_path;
   scoped_ptr<ResourceEntry> entry;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_NO_SPACE, error);
 }
 
-TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
+TEST_F(FileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
   const int64 file_size = entry->file_info().size();
@@ skipping 34 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 
   // The cache entry should be removed in order to free up space.
   ASSERT_FALSE(CacheEntryExists("<resource_id>", "<md5>"));
 }
 
-TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpaceButBecomeFull) {
+TEST_F(FileSystemTest, GetFileByPath_FromGData_EnoughSpaceButBecomeFull) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
   const int64 file_size = entry->file_info().size();
 
   // Pretend we have enough space first (checked before downloading a file),
   // but then start reporting we have not enough space. This is to emulate that
   // the disk space becomes full after the file is downloaded for some reason
   // (ex. the actual file was larger than the expected size).
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       file_size + internal::kMinFreeSpace);
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       internal::kMinFreeSpace - 1);
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       internal::kMinFreeSpace - 1);
 
   FileError error = FILE_ERROR_OK;
   base::FilePath file_path;
   entry.reset();
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_NO_SPACE, error);
 }
 
-TEST_F(DriveFileSystemTest, GetFileByPath_FromCache) {
+TEST_F(FileSystemTest, GetFileByPath_FromCache) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
 
   // Store something as cached version of this file.
   FileError error = FILE_ERROR_OK;
   cache_->StoreOnUIThread(
@@ skipping 10 matching lines @@
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 }
 
-TEST_F(DriveFileSystemTest, GetFileByPath_HostedDocument) {
+TEST_F(FileSystemTest, GetFileByPath_HostedDocument) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL(
       "drive/root/Document 1 excludeDir-test.gdoc"));
   scoped_ptr<ResourceEntry> src_entry =
       GetResourceEntryByPathSync(file_in_root);
   ASSERT_TRUE(src_entry);
 
   FileError error = FILE_ERROR_FAILED;
   base::FilePath file_path;
   scoped_ptr<ResourceEntry> entry;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->file_specific_info().is_hosted_document());
   EXPECT_FALSE(file_path.empty());
 
   ASSERT_TRUE(src_entry);
   VerifyHostedDocumentJSONFile(*src_entry, file_path);
 }
 
-TEST_F(DriveFileSystemTest, GetFileByResourceId) {
+TEST_F(FileSystemTest, GetFileByResourceId) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
   std::string resource_id = entry->resource_id();
 
   FileError error = FILE_ERROR_OK;
   base::FilePath file_path;
   entry.reset();
   file_system_->GetFileByResourceId(
       resource_id,
       DriveClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(
           &error, &file_path, &entry),
       google_apis::GetContentCallback());
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 }
 
-TEST_F(DriveFileSystemTest, GetFileContentByPath) {
+TEST_F(FileSystemTest, GetFileContentByPath) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
@@ skipping 58 matching lines @@
     EXPECT_TRUE(cancel_download.is_null());
     // The content is available from the cache file.
     EXPECT_TRUE(content_buffer.empty());
     int64 local_file_size = 0;
     file_util::GetFileSize(local_path, &local_file_size);
     EXPECT_EQ(entry->file_info().size(), local_file_size);
     EXPECT_EQ(FILE_ERROR_OK, completion_error);
   }
 }
 
-TEST_F(DriveFileSystemTest, GetFileByResourceId_FromCache) {
+TEST_F(FileSystemTest, GetFileByResourceId_FromCache) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
 
   // Store something as cached version of this file.
   FileError error = FILE_ERROR_FAILED;
   cache_->StoreOnUIThread(
@@ skipping 18 matching lines @@
       google_apis::test_util::CreateCopyResultCallback(
           &error, &file_path, &entry),
       google_apis::GetContentCallback());
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_FALSE(entry->file_specific_info().is_hosted_document());
 }
 
-TEST_F(DriveFileSystemTest, UpdateFileByResourceId_PersistentFile) {
+TEST_F(FileSystemTest, UpdateFileByResourceId_PersistentFile) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // This is a file defined in root_feed.json.
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   const std::string kResourceId("file:2_file_resource_id");
   const std::string kMd5("3b4382ebefec6e743578c76bbd0575ce");
 
   // Pin the file so it'll be store in "persistent" directory.
@@ skipping 51 matching lines @@
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Make sure that the number of files did not change (i.e. we updated an
   // existing file, rather than adding a new file. The number of files
   // increases if we don't handle the file update right).
   EXPECT_EQ(num_files_in_root, CountFiles(*root_directory_entries));
 }
 
-TEST_F(DriveFileSystemTest, UpdateFileByResourceId_NonexistentFile) {
+TEST_F(FileSystemTest, UpdateFileByResourceId_NonexistentFile) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // This is nonexistent in root_feed.json.
   const base::FilePath kFilePath(
       FILE_PATH_LITERAL("drive/root/Nonexistent.txt"));
   const std::string kResourceId("file:nonexistent_resource_id");
   const std::string kMd5("nonexistent_md5");
 
   // The callback will be called upon completion of
   // UpdateFileByResourceId().
   FileError error = FILE_ERROR_OK;
   file_system_->UpdateFileByResourceId(
       kResourceId,
       DriveClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
 }
 
-TEST_F(DriveFileSystemTest, ContentSearch) {
+TEST_F(FileSystemTest, ContentSearch) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const SearchResultPair kExpectedResults[] = {
     { "drive/root/Directory 1/Sub Directory Folder/Sub Sub Directory Folder",
       true },
     { "drive/root/Directory 1/Sub Directory Folder", true },
     { "drive/root/Directory 1/SubDirectory File 1.txt", false },
     { "drive/root/Directory 1", true },
     { "drive/root/Directory 2 excludeDir-test", true },
   };
 
   SearchCallback callback = base::Bind(
-      &DriveSearchCallback,
+      &VerifySearchResult,
       &message_loop_,
       kExpectedResults, ARRAYSIZE_UNSAFE(kExpectedResults),
       GURL());
 
   file_system_->Search("Directory", GURL(), callback);
   google_apis::test_util::RunBlockingPoolTask();
 }
 
-TEST_F(DriveFileSystemTest, ContentSearchWithNewEntry) {
+TEST_F(FileSystemTest, ContentSearchWithNewEntry) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // Create a new directory in the drive service.
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceEntry> resource_entry;
   fake_drive_service_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),  // Add to the root directory.
       "New Directory 1!",
       google_apis::test_util::CreateCopyResultCallback(
           &error, &resource_entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   // As the result of the first Search(), only entries in the current file
   // system snapshot are expected to be returned (i.e. "New Directory 1!"
   // shouldn't be included in the search result even though it matches
   // "Directory 1".
   const SearchResultPair kExpectedResults[] = {
       { "drive/root/Directory 1", true }
   };
 
   SearchCallback callback = base::Bind(
-      &DriveSearchCallback,
+      &VerifySearchResult,
       &message_loop_,
       kExpectedResults, ARRAYSIZE_UNSAFE(kExpectedResults),
       GURL());
 
   file_system_->Search("\"Directory 1\"", GURL(), callback);
   google_apis::test_util::RunBlockingPoolTask();
 }
 
-TEST_F(DriveFileSystemTest, ContentSearchEmptyResult) {
+TEST_F(FileSystemTest, ContentSearchEmptyResult) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const SearchResultPair* expected_results = NULL;
 
   SearchCallback callback = base::Bind(
-      &DriveSearchCallback,
+      &VerifySearchResult,
       &message_loop_,
       expected_results,
       0u,
       GURL());
 
   file_system_->Search("\"no-match query\"", GURL(), callback);
   google_apis::test_util::RunBlockingPoolTask();
 }
 
-TEST_F(DriveFileSystemTest, GetAvailableSpace) {
+TEST_F(FileSystemTest, GetAvailableSpace) {
   FileError error = FILE_ERROR_OK;
   int64 bytes_total;
   int64 bytes_used;
   file_system_->GetAvailableSpace(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &bytes_total, &bytes_used));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(GG_LONGLONG(6789012345), bytes_used);
   EXPECT_EQ(GG_LONGLONG(9876543210), bytes_total);
 }
 
-TEST_F(DriveFileSystemTest, RefreshDirectory) {
+TEST_F(FileSystemTest, RefreshDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // We'll notify the directory change to the observer.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(util::GetDriveMyDriveRootPath()))).Times(1);
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->RefreshDirectory(
       util::GetDriveMyDriveRootPath(),
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 }
 
-TEST_F(DriveFileSystemTest, OpenAndCloseFile) {
+TEST_F(FileSystemTest, OpenAndCloseFile) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   const base::FilePath kFileInRoot(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(kFileInRoot));
   const int64 file_size = entry->file_info().size();
@@ skipping 70 matching lines @@
   // Try to close the same file twice.
   file_system_->CloseFile(
       kFileInRoot,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // It must fail.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
 }
 
-TEST_F(DriveFileSystemTest, MarkCacheFileAsMountedAndUnmounted) {
+TEST_F(FileSystemTest, MarkCacheFileAsMountedAndUnmounted) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
   ASSERT_TRUE(entry);
 
   // Write to cache.
   FileError error = FILE_ERROR_FAILED;
   cache_->StoreOnUIThread(
@@ skipping 38 matching lines @@
       entry->resource_id(),
       entry->file_specific_info().file_md5(),
       google_apis::test_util::CreateCopyResultCallback(&success, &cache_entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_TRUE(success);
   EXPECT_FALSE(cache_entry.is_mounted());
 }
 
 }   // namespace drive