drive: Drop "Drive" from FakeDriveFileSystem and MockDriveFileSystem

chrome/browser/chromeos/drive/fake_file_system_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/fake_drive_file_system.h"
+#include "chrome/browser/chromeos/drive/fake_file_system.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/google_apis/fake_drive_service.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace test_util {
 
-class FakeDriveFileSystemTest : public ::testing::Test {
+class FakeFileSystemTest : public ::testing::Test {
  protected:
-  FakeDriveFileSystemTest()
+  FakeFileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_) {
   }
 
   virtual void SetUp() OVERRIDE {
     // Initialize FakeDriveService.
     fake_drive_service_.reset(new google_apis::FakeDriveService);
     fake_drive_service_->LoadResourceListForWapi(
         "chromeos/gdata/root_feed.json");
     fake_drive_service_->LoadAccountMetadataForWapi(
         "chromeos/gdata/account_metadata.json");
     fake_drive_service_->LoadAppListForDriveApi("chromeos/drive/applist.json");
 
     // Create a testee instance.
-    fake_drive_file_system_.reset(
-        new FakeDriveFileSystem(fake_drive_service_.get()));
-    ASSERT_TRUE(fake_drive_file_system_->InitializeForTesting());
+    fake_file_system_.reset(
+        new FakeFileSystem(fake_drive_service_.get()));
+    ASSERT_TRUE(fake_file_system_->InitializeForTesting());
   }
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
 
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
-  scoped_ptr<FakeDriveFileSystem> fake_drive_file_system_;
+  scoped_ptr<FakeFileSystem> fake_file_system_;
 };
 
-TEST_F(FakeDriveFileSystemTest, GetEntryInfoByResourceId) {
+TEST_F(FakeFileSystemTest, GetEntryInfoByResourceId) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProto> entry;
   base::FilePath file_path;
 
-  fake_drive_file_system_->GetEntryInfoByResourceId(
+  fake_file_system_->GetEntryInfoByResourceId(
       "folder:sub_dir_folder_resource_id",
       google_apis::test_util::CreateCopyResultCallback(
           &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(
       util::GetDriveMyDriveRootPath().AppendASCII(
           "Directory 1/Sub Directory Folder"),
       file_path);
   EXPECT_TRUE(entry);  // Just make sure something is returned.
 }
 
-TEST_F(FakeDriveFileSystemTest,
+TEST_F(FakeFileSystemTest,
        GetEntryInfoByResourceId_PathCompatibleWithGetEntryInfoByPath) {
   const std::string document_resource_id = "document:5_document_resource_id";
 
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProto> entry;
   base::FilePath file_path;
 
   // Get entry info by resource id.
-  fake_drive_file_system_->GetEntryInfoByResourceId(
+  fake_file_system_->GetEntryInfoByResourceId(
       document_resource_id,
       google_apis::test_util::CreateCopyResultCallback(
           &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->file_specific_info().is_hosted_document());
 
   // Get entry info by path given by GetEntryInfoByResourceId.
   error = FILE_ERROR_FAILED;
   entry.reset();
-  fake_drive_file_system_->GetEntryInfoByPath(
+  fake_file_system_->GetEntryInfoByPath(
       file_path,
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_EQ(document_resource_id, entry->resource_id());
 }
 
-TEST_F(FakeDriveFileSystemTest, GetFileContentByPath) {
+TEST_F(FakeFileSystemTest, GetFileContentByPath) {
   FileError initialize_error = FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProto> entry_proto;
   base::FilePath cache_file_path;
   base::Closure cancel_download;
   google_apis::test_util::TestGetContentCallback get_content_callback;
   FileError completion_error = FILE_ERROR_FAILED;
 
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
 
   // For the first time, the file should be downloaded from the service.
-  fake_drive_file_system_->GetFileContentByPath(
+  fake_file_system_->GetFileContentByPath(
       kDriveFile,
       google_apis::test_util::CreateCopyResultCallback(
           &initialize_error, &entry_proto, &cache_file_path, &cancel_download),
       get_content_callback.callback(),
       google_apis::test_util::CreateCopyResultCallback(&completion_error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, initialize_error);
   EXPECT_TRUE(entry_proto);
 
   // No cache file is available yet.
   EXPECT_TRUE(cache_file_path.empty());
 
   // The download should be happened so the |get_content_callback|
   // should have the actual data.
   std::string content = get_content_callback.GetConcatenatedData();
   EXPECT_EQ(10U, content.size());
   EXPECT_EQ(FILE_ERROR_OK, completion_error);
 
   initialize_error = FILE_ERROR_FAILED;
   entry_proto.reset();
   get_content_callback.mutable_data()->clear();
   completion_error = FILE_ERROR_FAILED;
 
   // For the second time, the cache file should be found.
-  fake_drive_file_system_->GetFileContentByPath(
+  fake_file_system_->GetFileContentByPath(
       kDriveFile,
       google_apis::test_util::CreateCopyResultCallback(
           &initialize_error, &entry_proto, &cache_file_path, &cancel_download),
       get_content_callback.callback(),
       google_apis::test_util::CreateCopyResultCallback(&completion_error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, initialize_error);
   EXPECT_TRUE(entry_proto);
 
   // Cache file should be available.
   ASSERT_FALSE(cache_file_path.empty());
 
   // There should be a cache file so no data should be downloaded.
   EXPECT_TRUE(get_content_callback.data().empty());
   EXPECT_EQ(FILE_ERROR_OK, completion_error);
 
   // Make sure the cached file's content.
   std::string cache_file_content;
   ASSERT_TRUE(
       file_util::ReadFileToString(cache_file_path, &cache_file_content));
   EXPECT_EQ(content, cache_file_content);
 }
 
-TEST_F(FakeDriveFileSystemTest, GetFileContentByPath_Directory) {
+TEST_F(FakeFileSystemTest, GetFileContentByPath_Directory) {
   FileError initialize_error = FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProto> entry_proto;
   base::FilePath cache_file_path;
   google_apis::test_util::TestGetContentCallback get_content_callback;
   FileError completion_error = FILE_ERROR_FAILED;
   base::Closure cancel_download;
 
-  fake_drive_file_system_->GetFileContentByPath(
+  fake_file_system_->GetFileContentByPath(
       util::GetDriveMyDriveRootPath(),
       google_apis::test_util::CreateCopyResultCallback(
           &initialize_error, &entry_proto, &cache_file_path, &cancel_download),
       get_content_callback.callback(),
       google_apis::test_util::CreateCopyResultCallback(&completion_error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_NOT_A_FILE, completion_error);
 }
 
-TEST_F(FakeDriveFileSystemTest, GetEntryInfoByPath) {
+TEST_F(FakeFileSystemTest, GetEntryInfoByPath) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProto> entry;
-  fake_drive_file_system_->GetEntryInfoByPath(
+  fake_file_system_->GetEntryInfoByPath(
       util::GetDriveMyDriveRootPath().AppendASCII(
           "Directory 1/Sub Directory Folder"),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_EQ("folder:sub_dir_folder_resource_id", entry->resource_id());
 }
 
-TEST_F(FakeDriveFileSystemTest, GetEntryInfoByPath_Root) {
+TEST_F(FakeFileSystemTest, GetEntryInfoByPath_Root) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProto> entry;
-  fake_drive_file_system_->GetEntryInfoByPath(
+  fake_file_system_->GetEntryInfoByPath(
       util::GetDriveMyDriveRootPath(),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->file_info().is_directory());
   EXPECT_EQ(fake_drive_service_->GetRootResourceId(), entry->resource_id());
   EXPECT_EQ(util::kDriveMyDriveRootDirName, entry->title());
 }
 
-TEST_F(FakeDriveFileSystemTest, GetEntryInfoByPath_Invalid) {
+TEST_F(FakeFileSystemTest, GetEntryInfoByPath_Invalid) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProto> entry;
-  fake_drive_file_system_->GetEntryInfoByPath(
+  fake_file_system_->GetEntryInfoByPath(
       util::GetDriveMyDriveRootPath().AppendASCII("Invalid File Name"),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(FILE_ERROR_NOT_FOUND, error);
   ASSERT_FALSE(entry);
 }
 
 }  // namespace test_util
 }  // namespace drive