Rename GDataFileSystem* to DriveFileSystem*

chrome/browser/chromeos/gdata/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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_api_parser.h"
+#include "chrome/browser/chromeos/gdata/drive_file_system.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
-#include "chrome/browser/chromeos/gdata/gdata_file_system.h"
 #include "chrome/browser/chromeos/gdata/gdata_test_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/mock_directory_change_observer.h"
 #include "chrome/browser/chromeos/gdata/mock_drive_cache_observer.h"
 #include "chrome/browser/chromeos/gdata/mock_drive_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
@@ skipping 12 matching lines @@
 
 const char kSymLinkToDevNull[] = "/dev/null";
 
 const int64 kLotsOfSpace = kMinFreeSpace * 10;
 
 struct SearchResultPair {
   const char* path;
   const bool is_directory;
 };
 
-// Callback to GDataFileSystem::Search used in ContentSearch tests.
+// Callback to DriveFileSystem::Search used in ContentSearch tests.
 // Verifies returned vector of results.
 void DriveSearchCallback(
     MessageLoop* message_loop,
     const SearchResultPair* expected_results,
     size_t expected_results_size,
     DriveFileError error,
     const GURL& next_feed,
     scoped_ptr<std::vector<SearchResultInfo> > results) {
   ASSERT_TRUE(results.get());
   ASSERT_EQ(expected_results_size, results->size());
@@ skipping 24 matching lines @@
   upload_file_info->file_path = local_file_path;
   upload_file_info->entry.reset(document_entry);
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(arg5, error, base::Passed(&upload_file_info)));
 
   const int kUploadId = 123;
   return kUploadId;
 }
 
 // Action used to set mock expectations for
-// GDataFileSystem::CopyDocument().
+// DriveFileSystem::CopyDocument().
 ACTION_P2(MockCopyDocument, status, value) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(arg2, status, base::Passed(value)));
 }
 
 // Returns the absolute path for a test file stored under
 // chrome/test/data/chromeos/gdata.
 FilePath GetTestFilePath(const FilePath::StringType& base_name) {
   FilePath path;
@@ skipping 83 matching lines @@
 
   MOCK_METHOD3(GetWebAppsForFile, void(const FilePath& file,
                                        const std::string& mime_type,
                                        ScopedVector<DriveWebAppInfo>* apps));
   MOCK_METHOD1(GetExtensionsForWebStoreApp,
                std::set<std::string>(const std::string& web_store_id));
   MOCK_METHOD1(UpdateFromFeed, void(const AccountMetadataFeed& metadata));
   MOCK_METHOD1(UpdateFromApplicationList, void(const AppList& applist));
 };
 
-class GDataFileSystemTest : public testing::Test {
+class DriveFileSystemTest : public testing::Test {
  protected:
-  GDataFileSystemTest()
+  DriveFileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
         cache_(NULL),
         file_system_(NULL),
         mock_drive_service_(NULL),
         mock_webapps_registry_(NULL),
         num_callback_invocations_(0),
         expected_error_(DRIVE_FILE_OK),
         expected_cache_state_(0),
         expected_sub_dir_type_(DriveCache::CACHE_TYPE_META),
         expected_success_(true),
         expect_outgoing_symlink_(false),
         root_feed_changestamp_(0) {
   }
 
   virtual void SetUp() OVERRIDE {
     chromeos::CrosLibrary::Initialize(true /* use_stub */);
     io_thread_.StartIOThread();
 
     profile_.reset(new TestingProfile);
 
     callback_helper_ = new CallbackHelper;
 
     // Allocate and keep a pointer to the mock, and inject it into the
-    // GDataFileSystem object, which will own the mock object.
+    // DriveFileSystem object, which will own the mock object.
     mock_drive_service_ = new StrictMock<MockDriveService>;
 
     EXPECT_CALL(*mock_drive_service_, Initialize(profile_.get())).Times(1);
 
-    // Likewise, this will be owned by GDataFileSystem.
+    // Likewise, this will be owned by DriveFileSystem.
     mock_free_disk_space_checker_ = new StrictMock<MockFreeDiskSpaceGetter>;
     SetFreeDiskSpaceGetterForTesting(mock_free_disk_space_checker_);
 
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
 
     cache_ = DriveCache::CreateDriveCacheOnUIThread(
         DriveCache::GetCacheRootPath(profile_.get()), blocking_task_runner_);
 
     mock_uploader_.reset(new StrictMock<MockGDataUploader>);
     mock_webapps_registry_.reset(new StrictMock<MockDriveWebAppsRegistry>);
 
     ASSERT_FALSE(file_system_);
-    file_system_ = new GDataFileSystem(profile_.get(),
+    file_system_ = new DriveFileSystem(profile_.get(),
                                        cache_,
                                        mock_drive_service_,
                                        mock_uploader_.get(),
                                        mock_webapps_registry_.get(),
                                        blocking_task_runner_);
 
     mock_cache_observer_.reset(new StrictMock<MockDriveCacheObserver>);
     cache_->AddObserver(mock_cache_observer_.get());
 
     mock_directory_observer_.reset(new StrictMock<MockDirectoryChangeObserver>);
@@ skipping 131 matching lines @@
       return "";
   }
 
   // Helper function to call GetCacheEntry from origin thread.
   bool GetCacheEntryFromOriginThread(const std::string& resource_id,
                                      const std::string& md5,
                                      DriveCacheEntry* cache_entry) {
     bool result = false;
     blocking_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&GDataFileSystemTest::GetCacheEntryFromOriginThreadInternal,
+        base::Bind(&DriveFileSystemTest::GetCacheEntryFromOriginThreadInternal,
                    base::Unretained(this),
                    resource_id,
                    md5,
                    cache_entry,
                    &result));
     test_util::RunBlockingPoolTask();
     return result;
   }
 
   // Used to implement GetCacheEntry.
@@ skipping 30 matching lines @@
       DriveFileError expected_error,
       int expected_cache_state,
       DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
 
     cache_->StoreOnUIThread(
         resource_id, md5, source_path,
         DriveCache::FILE_OPERATION_COPY,
-        base::Bind(&GDataFileSystemTest::VerifyCacheFileState,
+        base::Bind(&DriveFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void TestPin(
       const std::string& resource_id,
       const std::string& md5,
       DriveFileError expected_error,
       int expected_cache_state,
       DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
 
     cache_->PinOnUIThread(
         resource_id, md5,
-        base::Bind(&GDataFileSystemTest::VerifyCacheFileState,
+        base::Bind(&DriveFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void TestMarkDirty(
       const std::string& resource_id,
       const std::string& md5,
       DriveFileError expected_error,
       int expected_cache_state,
       DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
     expect_outgoing_symlink_ = false;
 
     cache_->MarkDirtyOnUIThread(
         resource_id, md5,
-        base::Bind(&GDataFileSystemTest::VerifyMarkDirty,
+        base::Bind(&DriveFileSystemTest::VerifyMarkDirty,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void VerifyMarkDirty(DriveFileError error,
                        const std::string& resource_id,
                        const std::string& md5,
                        const FilePath& cache_file_path) {
     VerifyCacheFileState(error, resource_id, md5);
@@ skipping 16 matching lines @@
       DriveFileError expected_error,
       int expected_cache_state,
       DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
     expect_outgoing_symlink_ = true;
 
     cache_->CommitDirtyOnUIThread(
         resource_id, md5,
-        base::Bind(&GDataFileSystemTest::VerifyCacheFileState,
+        base::Bind(&DriveFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   // Verify the file identified by |resource_id| and |md5| is in the expected
   // cache state after |OpenFile|, that is, marked dirty and has no outgoing
   // symlink, etc.
   void VerifyCacheStateAfterOpenFile(DriveFileError error,
                                      const std::string& resource_id,
@@ skipping 300 matching lines @@
   MessageLoopForUI message_loop_;
   // The order of the test threads is important, do not change the order.
   // See also content/browser/browser_thread_impl.cc.
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<TestingProfile> profile_;
   scoped_refptr<CallbackHelper> callback_helper_;
   DriveCache* cache_;
   scoped_ptr<StrictMock<MockGDataUploader> > mock_uploader_;
-  GDataFileSystem* file_system_;
+  DriveFileSystem* file_system_;
   StrictMock<MockDriveService>* mock_drive_service_;
   scoped_ptr<StrictMock<MockDriveWebAppsRegistry> > mock_webapps_registry_;
   StrictMock<MockFreeDiskSpaceGetter>* mock_free_disk_space_checker_;
   scoped_ptr<StrictMock<MockDriveCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   int num_callback_invocations_;
   DriveFileError expected_error_;
   int expected_cache_state_;
   DriveCache::CacheSubDirectoryType expected_sub_dir_type_;
   bool expected_success_;
   bool expect_outgoing_symlink_;
   std::string expected_file_extension_;
   int root_feed_changestamp_;
   static bool cros_initialized_;
 };
 
-bool GDataFileSystemTest::cros_initialized_ = false;
+bool DriveFileSystemTest::cros_initialized_ = false;
 
 void AsyncInitializationCallback(
     int* counter,
     int expected_counter,
     const FilePath& expected_file_path,
     MessageLoop* message_loop,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   ASSERT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entry_proto.get());
   ASSERT_TRUE(entry_proto->file_info().is_directory());
   EXPECT_EQ(expected_file_path.value(), entry_proto->base_name());
 
   (*counter)++;
   if (*counter >= expected_counter)
     message_loop->Quit();
 }
 
-TEST_F(GDataFileSystemTest, DuplicatedAsyncInitialization) {
+TEST_F(DriveFileSystemTest, DuplicatedAsyncInitialization) {
   int counter = 0;
   GetEntryInfoCallback callback = base::Bind(
       &AsyncInitializationCallback,
       &counter,
       2,
       FilePath(FILE_PATH_LITERAL("drive")),
       &message_loop_);
 
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
   EXPECT_CALL(*mock_drive_service_,
               GetDocuments(Eq(GURL()), _, _, _, _)).Times(1);
 
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
 
   file_system_->GetEntryInfoByPath(
       FilePath(FILE_PATH_LITERAL("drive")), callback);
   file_system_->GetEntryInfoByPath(
       FilePath(FILE_PATH_LITERAL("drive")), callback);
   message_loop_.Run();  // Wait to get our result
   EXPECT_EQ(2, counter);
 }
 
-TEST_F(GDataFileSystemTest, SearchRootDirectory) {
+TEST_F(DriveFileSystemTest, SearchRootDirectory) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(FILE_PATH_LITERAL("drive"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(
       FilePath(FILE_PATH_LITERAL(kFilePath)));
   ASSERT_TRUE(entry.get());
   EXPECT_EQ(kDriveRootDirectoryResourceId, entry->resource_id());
 }
 
-TEST_F(GDataFileSystemTest, SearchExistingFile) {
+TEST_F(DriveFileSystemTest, SearchExistingFile) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:2_file_resource_id", entry->resource_id());
 }
 
-TEST_F(GDataFileSystemTest, SearchExistingDocument) {
+TEST_F(DriveFileSystemTest, SearchExistingDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/Document 1.gdoc"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("document:5_document_resource_id", entry->resource_id());
 }
 
-TEST_F(GDataFileSystemTest, SearchNonExistingFile) {
+TEST_F(DriveFileSystemTest, SearchNonExistingFile) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/nonexisting.file"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_FALSE(entry.get());
 }
 
-TEST_F(GDataFileSystemTest, SearchEncodedFileNames) {
+TEST_F(DriveFileSystemTest, SearchEncodedFileNames) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("drive/Slash / in file 1.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_FALSE(entry.get());
 
   const FilePath kFilePath2 = FilePath::FromUTF8Unsafe(
       "drive/Slash \xE2\x88\x95 in file 1.txt");
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_file_resource_id", entry->resource_id());
 
   const FilePath kFilePath3 = FilePath::FromUTF8Unsafe(
       "drive/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = GetEntryInfoByPathSync(kFilePath3);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_subdir_file", entry->resource_id());
 }
 
-TEST_F(GDataFileSystemTest, SearchEncodedFileNamesLoadingRoot) {
+TEST_F(DriveFileSystemTest, SearchEncodedFileNamesLoadingRoot) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("drive/Slash / in file 1.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_FALSE(entry.get());
 
   const FilePath kFilePath2 = FilePath::FromUTF8Unsafe(
       "drive/Slash \xE2\x88\x95 in file 1.txt");
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_file_resource_id", entry->resource_id());
 
   const FilePath kFilePath3 = FilePath::FromUTF8Unsafe(
       "drive/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = GetEntryInfoByPathSync(kFilePath3);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_subdir_file", entry->resource_id());
 }
 
-TEST_F(GDataFileSystemTest, SearchDuplicateNames) {
+TEST_F(DriveFileSystemTest, SearchDuplicateNames) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:3_file_resource_id", entry->resource_id());
 
   const FilePath kFilePath2 = FilePath(
       FILE_PATH_LITERAL("drive/Duplicate Name (2).txt"));
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:4_file_resource_id", entry->resource_id());
 }
 
-TEST_F(GDataFileSystemTest, SearchExistingDirectory) {
+TEST_F(DriveFileSystemTest, SearchExistingDirectory) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/Directory 1"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("folder:1_folder_resource_id", entry->resource_id());
 }
 
-TEST_F(GDataFileSystemTest, SearchInSubdir) {
+TEST_F(DriveFileSystemTest, SearchInSubdir) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("file:subdirectory_file_1_id", entry->resource_id());
 }
 
 // Check the reconstruction of the directory structure from only the root feed.
-TEST_F(GDataFileSystemTest, SearchInSubSubdir) {
+TEST_F(DriveFileSystemTest, SearchInSubSubdir) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("drive/Directory 1/Sub Directory Folder/"
                         "Sub Sub Directory Folder"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("folder:sub_sub_directory_folder_id", entry->resource_id());
 }
 
-TEST_F(GDataFileSystemTest, FilePathTests) {
+TEST_F(DriveFileSystemTest, FilePathTests) {
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/File 1.txt"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))));
   EXPECT_TRUE(EntryExists(
       FilePath(
           FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"))));
 }
 
-TEST_F(GDataFileSystemTest, ChangeFeed_AddAndDeleteFileInRoot) {
+TEST_F(DriveFileSystemTest, ChangeFeed_AddAndDeleteFileInRoot) {
   int latest_changelog = 0;
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(2);
 
   LoadChangeFeed("delta_file_added_in_root.json", ++latest_changelog);
   EXPECT_TRUE(
       EntryExists(FilePath(FILE_PATH_LITERAL("drive/Added file.gdoc"))));
 
   LoadChangeFeed("delta_file_deleted_in_root.json", ++latest_changelog);
   EXPECT_FALSE(
       EntryExists(FilePath(FILE_PATH_LITERAL("drive/Added file.gdoc"))));
 }
 
 
-TEST_F(GDataFileSystemTest, ChangeFeed_AddAndDeleteFileFromExistingDirectory) {
+TEST_F(DriveFileSystemTest, ChangeFeed_AddAndDeleteFileFromExistingDirectory) {
   int latest_changelog = 0;
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_TRUE(EntryExists(FilePath(
       FILE_PATH_LITERAL("drive/Directory 1"))));
 
   // Add file to an existing directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
   LoadChangeFeed("delta_file_added_in_directory.json", ++latest_changelog);
   EXPECT_TRUE(EntryExists(FilePath(
       FILE_PATH_LITERAL("drive/Directory 1/Added file.gdoc"))));
 
   // Remove that file from the directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
   LoadChangeFeed("delta_file_deleted_in_directory.json", ++latest_changelog);
   EXPECT_TRUE(EntryExists(FilePath(
       FILE_PATH_LITERAL("drive/Directory 1"))));
   EXPECT_FALSE(EntryExists(FilePath(
       FILE_PATH_LITERAL("drive/Directory 1/Added file.gdoc"))));
 }
 
-TEST_F(GDataFileSystemTest, ChangeFeed_AddFileToNewDirectory) {
+TEST_F(DriveFileSystemTest, ChangeFeed_AddFileToNewDirectory) {
   int latest_changelog = 0;
   LoadRootFeedDocument("root_feed.json");
   // Add file to a new directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/New Directory"))))).Times(1);
 
   LoadChangeFeed("delta_file_added_in_new_directory.json", ++latest_changelog);
 
   EXPECT_TRUE(EntryExists(FilePath(
       FILE_PATH_LITERAL("drive/New Directory"))));
   EXPECT_TRUE(EntryExists(FilePath(
       FILE_PATH_LITERAL("drive/New Directory/File in new dir.gdoc"))));
 }
 
-TEST_F(GDataFileSystemTest, ChangeFeed_AddFileToNewButDeletedDirectory) {
+TEST_F(DriveFileSystemTest, ChangeFeed_AddFileToNewButDeletedDirectory) {
   int latest_changelog = 0;
   LoadRootFeedDocument("root_feed.json");
 
   // This feed contains thw 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.
   LoadChangeFeed("delta_file_added_in_new_but_deleted_directory.json",
                  ++latest_changelog);
 }
 
-TEST_F(GDataFileSystemTest, ChangeFeed_DirectoryMovedFromRootToDirectory) {
+TEST_F(DriveFileSystemTest, ChangeFeed_DirectoryMovedFromRootToDirectory) {
   int latest_changelog = 0;
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 2"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
@@ skipping 19 matching lines @@
       "drive/Directory 2/Directory 1"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 2/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 2/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 2/Directory 1/Sub Directory Folder/"
       "Sub Sub Directory Folder"))));
 }
 
-TEST_F(GDataFileSystemTest, ChangeFeed_FileMovedFromDirectoryToRoot) {
+TEST_F(DriveFileSystemTest, ChangeFeed_FileMovedFromDirectoryToRoot) {
   int latest_changelog = 0;
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/Sub Directory Folder/Sub Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
@@ skipping 11 matching lines @@
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/Sub Directory Folder/Sub Sub Directory Folder"))));
   EXPECT_FALSE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/SubDirectory File 1.txt"))));
 }
 
-TEST_F(GDataFileSystemTest, ChangeFeed_FileRenamedInDirectory) {
+TEST_F(DriveFileSystemTest, ChangeFeed_FileRenamedInDirectory) {
   int latest_changelog = 0;
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/SubDirectory File 1.txt"))));
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
   LoadChangeFeed("delta_file_renamed_in_directory.json",
                  ++latest_changelog);
 
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1"))));
   EXPECT_FALSE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL(
       "drive/Directory 1/New SubDirectory File 1.txt"))));
 }
 
-TEST_F(GDataFileSystemTest, CachedFeedLoading) {
+TEST_F(DriveFileSystemTest, CachedFeedLoading) {
   SaveTestFileSystem();
   TestLoadMetadataFromCache();
 
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/File1"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/Dir1"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/Dir1/File2"))));
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/Dir1/SubDir2"))));
   EXPECT_TRUE(EntryExists(
       FilePath(FILE_PATH_LITERAL("drive/Dir1/SubDir2/File3"))));
 }
 
-TEST_F(GDataFileSystemTest, CachedFeadLoadingThenServerFeedLoading) {
+TEST_F(DriveFileSystemTest, CachedFeadLoadingThenServerFeedLoading) {
   SaveTestFileSystem();
 
   // SaveTestFileSystem and "account_metadata.json" have the same changestamp,
   // so no request for new feeds (i.e., call to GetDocuments) should happen.
   mock_drive_service_->set_account_metadata(
       LoadJSONFile("account_metadata.json"));
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
   EXPECT_CALL(*mock_drive_service_, GetDocuments(_, _, _, _, _)).Times(0);
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/File1"))));
 
   // Since the file system has verified that it holds the latest snapshot,
   // it should change its state to FROM_SERVER, which admits periodic refresh.
   // To test it, call CheckForUpdates and verify it does try to check updates.
   mock_drive_service_->set_account_metadata(
       LoadJSONFile("account_metadata.json"));
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
 
   file_system_->CheckForUpdates();
   test_util::RunBlockingPoolTask();
 }
 
-TEST_F(GDataFileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
+TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   // We'll add a file to the Drive root directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   FileOperationCallback callback =
@@ skipping 15 matching lines @@
   file_system_->TransferFileFromLocalToRemote(
       local_src_file_path, remote_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, TransferFileFromLocalToRemote_HostedDocument) {
+TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_HostedDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   // Prepare a local file, which is a json file of a hosted document, which
   // matches "Document 1" in root_feed.json.
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   const FilePath local_src_file_path = temp_dir.path().Append("local.gdoc");
   const std::string kEditUrl =
       "https://3_document_self_link/document:5_document_resource_id";
   const std::string kResourceId = "document:5_document_resource_id";
@@ skipping 31 matching lines @@
   file_system_->TransferFileFromLocalToRemote(
       local_src_file_path, remote_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, TransferFileFromRemoteToLocal_RegularFile) {
+TEST_F(DriveFileSystemTest, TransferFileFromRemoteToLocal_RegularFile) {
   LoadRootFeedDocument("root_feed.json");
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath local_dest_file_path = temp_dir.path().Append("local_copy.txt");
 
@@ skipping 34 matching lines @@
   std::string cache_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(cache_file, &cache_file_data));
   EXPECT_EQ(remote_src_file_data, cache_file_data);
 
   std::string local_dest_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(local_dest_file_path,
                                           &local_dest_file_data));
   EXPECT_EQ(remote_src_file_data, local_dest_file_data);
 }
 
-TEST_F(GDataFileSystemTest, TransferFileFromRemoteToLocal_HostedDocument) {
+TEST_F(DriveFileSystemTest, TransferFileFromRemoteToLocal_HostedDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath local_dest_file_path = temp_dir.path().Append("local_copy.txt");
   FilePath remote_src_file_path(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
   file_system_->TransferFileFromRemoteToLocal(
       remote_src_file_path, local_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   scoped_ptr<DriveEntryProto> entry_proto = GetEntryInfoByPathSync(
       remote_src_file_path);
   ASSERT_TRUE(entry_proto.get());
   VerifyHostedDocumentJSONFile(*entry_proto, local_dest_file_path);
 }
 
-TEST_F(GDataFileSystemTest, CopyNotExistingFile) {
+TEST_F(DriveFileSystemTest, CopyNotExistingFile) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_FALSE(EntryExists(src_file_path));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Copy(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, CopyFileToNonExistingDirectory) {
+TEST_F(DriveFileSystemTest, CopyFileToNonExistingDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Dummy"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Dummy/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
@@ skipping 11 matching lines @@
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_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(GDataFileSystemTest, CopyFileToInvalidPath) {
+TEST_F(DriveFileSystemTest, CopyFileToInvalidPath) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL(
       "drive/Duplicate Name.txt/Document 1.gdoc"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
@@ skipping 16 matching lines @@
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY,
             callback_helper_->last_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(GDataFileSystemTest, RenameFile) {
+TEST_F(DriveFileSystemTest, RenameFile) {
   const FilePath src_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
   const FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   const FilePath dest_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
@@ skipping 15 matching lines @@
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, MoveFileFromRootToSubDirectory) {
+TEST_F(DriveFileSystemTest, MoveFileFromRootToSubDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Directory 1/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
@@ skipping 28 matching lines @@
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, MoveFileFromSubDirectoryToRoot) {
+TEST_F(DriveFileSystemTest, MoveFileFromSubDirectoryToRoot) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
@@ skipping 30 matching lines @@
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   ASSERT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, MoveFileBetweenSubDirectories) {
+TEST_F(DriveFileSystemTest, MoveFileBetweenSubDirectories) {
   FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath src_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/New Folder 1"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/New Folder 1/Test.log"));
   FilePath interim_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
@@ skipping 57 matching lines @@
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(interim_file_path));
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, MoveNotExistingFile) {
+TEST_F(DriveFileSystemTest, MoveNotExistingFile) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_FALSE(EntryExists(src_file_path));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, MoveFileToNonExistingDirectory) {
+TEST_F(DriveFileSystemTest, MoveFileToNonExistingDirectory) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Dummy"));
   FilePath dest_file_path(FILE_PATH_LITERAL("drive/Dummy/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
@@ skipping 11 matching lines @@
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 // Test the case where the parent of |dest_file_path| is a existing file,
 // not a directory.
-TEST_F(GDataFileSystemTest, MoveFileToInvalidPath) {
+TEST_F(DriveFileSystemTest, MoveFileToInvalidPath) {
   FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
   FilePath dest_file_path(FILE_PATH_LITERAL(
       "drive/Duplicate Name.txt/Test.log"));
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
@@ skipping 14 matching lines @@
   file_system_->Move(src_file_path, dest_file_path, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY,
             callback_helper_->last_error_);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
-TEST_F(GDataFileSystemTest, RemoveEntries) {
+TEST_F(DriveFileSystemTest, RemoveEntries) {
   LoadRootFeedDocument("root_feed.json");
 
   FilePath nonexisting_file(FILE_PATH_LITERAL("drive/Dummy file.txt"));
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   FilePath dir_in_root(FILE_PATH_LITERAL("drive/Directory 1"));
   FilePath file_in_subdir(
       FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
 
   ASSERT_TRUE(EntryExists(file_in_root));
   scoped_ptr<DriveEntryProto> file_in_root_proto = GetEntryInfoByPathSync(
@@ skipping 33 matching lines @@
   // Try removing non-existing file.
   EXPECT_FALSE(RemoveEntry(nonexisting_file));
 
   // Try removing root file element.
   EXPECT_FALSE(RemoveEntry(FilePath(FILE_PATH_LITERAL("drive"))));
 
   // Need this to ensure OnDirectoryChanged() is run.
   test_util::RunBlockingPoolTask();
 }
 
-TEST_F(GDataFileSystemTest, CreateDirectory) {
+TEST_F(DriveFileSystemTest, CreateDirectory) {
   LoadRootFeedDocument("root_feed.json");
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   // Create directory in root.
   FilePath dir_path(FILE_PATH_LITERAL("drive/New Folder 1"));
   EXPECT_FALSE(EntryExists(dir_path));
   AddDirectoryFromFile(dir_path, "directory_entry_atom.json");
   EXPECT_TRUE(EntryExists(dir_path));
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/New Folder 1"))))).Times(1);
 
   // Create directory in a sub directory.
   FilePath subdir_path(FILE_PATH_LITERAL("drive/New Folder 1/New Folder 2"));
   EXPECT_FALSE(EntryExists(subdir_path));
   AddDirectoryFromFile(subdir_path, "directory_entry_atom2.json");
   EXPECT_TRUE(EntryExists(subdir_path));
 }
 
-TEST_F(GDataFileSystemTest, FindFirstMissingParentDirectory) {
+TEST_F(DriveFileSystemTest, FindFirstMissingParentDirectory) {
   LoadRootFeedDocument("root_feed.json");
 
   GURL last_dir_content_url;
   FilePath first_missing_parent_path;
 
   // Create directory in root.
   FilePath dir_path(FILE_PATH_LITERAL("drive/New Folder 1"));
   EXPECT_EQ(
-      GDataFileSystem::FOUND_MISSING,
+      DriveFileSystem::FOUND_MISSING,
       file_system_->FindFirstMissingParentDirectory(dir_path,
           &last_dir_content_url,
           &first_missing_parent_path));
   EXPECT_EQ(FilePath(FILE_PATH_LITERAL("drive/New Folder 1")),
             first_missing_parent_path);
   EXPECT_TRUE(last_dir_content_url.is_empty());    // root directory.
 
   // Missing folders in subdir of an existing folder.
   FilePath dir_path2(FILE_PATH_LITERAL("drive/Directory 1/New Folder 2"));
   EXPECT_EQ(
-      GDataFileSystem::FOUND_MISSING,
+      DriveFileSystem::FOUND_MISSING,
       file_system_->FindFirstMissingParentDirectory(dir_path2,
           &last_dir_content_url,
           &first_missing_parent_path));
   EXPECT_EQ(FilePath(FILE_PATH_LITERAL("drive/Directory 1/New Folder 2")),
             first_missing_parent_path);
   EXPECT_FALSE(last_dir_content_url.is_empty());    // non-root directory.
 
   // Missing two folders on the path.
   FilePath dir_path3 = dir_path2.Append(FILE_PATH_LITERAL("Another Folder"));
   EXPECT_EQ(
-      GDataFileSystem::FOUND_MISSING,
+      DriveFileSystem::FOUND_MISSING,
       file_system_->FindFirstMissingParentDirectory(dir_path3,
           &last_dir_content_url,
           &first_missing_parent_path));
   EXPECT_EQ(FilePath(FILE_PATH_LITERAL("drive/Directory 1/New Folder 2")),
             first_missing_parent_path);
   EXPECT_FALSE(last_dir_content_url.is_empty());    // non-root directory.
 
   // Folders on top of an existing file.
   EXPECT_EQ(
-      GDataFileSystem::FOUND_INVALID,
+      DriveFileSystem::FOUND_INVALID,
       file_system_->FindFirstMissingParentDirectory(
           FilePath(FILE_PATH_LITERAL("drive/File 1.txt/BadDir")),
           &last_dir_content_url,
           &first_missing_parent_path));
 
   // Existing folder.
   EXPECT_EQ(
-      GDataFileSystem::DIRECTORY_ALREADY_PRESENT,
+      DriveFileSystem::DIRECTORY_ALREADY_PRESENT,
       file_system_->FindFirstMissingParentDirectory(
           FilePath(FILE_PATH_LITERAL("drive/Directory 1")),
           &last_dir_content_url,
           &first_missing_parent_path));
 }
 
 // Create a directory through the document service
-TEST_F(GDataFileSystemTest, CreateDirectoryWithService) {
+TEST_F(DriveFileSystemTest, CreateDirectoryWithService) {
   LoadRootFeedDocument("root_feed.json");
   EXPECT_CALL(*mock_drive_service_,
               CreateDirectory(_, "Sample Directory Title", _)).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   // Set last error so it's not a valid error code.
   callback_helper_->last_error_ = static_cast<DriveFileError>(1);
   file_system_->CreateDirectory(
       FilePath(FILE_PATH_LITERAL("drive/Sample Directory Title")),
       false,  // is_exclusive
       true,  // is_recursive
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get()));
   test_util::RunBlockingPoolTask();
   // TODO(gspencer): Uncomment this when we get a blob that
   // works that can be returned from the mock.
   // EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 }
 
-TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
+TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
@@ skipping 20 matching lines @@
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 }
 
-TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
+TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
@@ skipping 17 matching lines @@
       .Times(0);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_ERROR_NO_SPACE,
             callback_helper_->last_error_);
 }
 
-TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
+TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
@@ skipping 41 matching lines @@
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 
   // The file should be removed in order to free up space, and the cache
   // entry should also be removed.
   ASSERT_FALSE(CacheEntryExists("<resource_id>", "<md5>"));
   ASSERT_FALSE(CacheFileExists("<resource_id>", "<md5>"));
 }
 
-TEST_F(GDataFileSystemTest, GetFileByPath_FromGData_EnoughSpaceButBecomeFull) {
+TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpaceButBecomeFull) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
@@ skipping 23 matching lines @@
       .Times(1);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_ERROR_NO_SPACE,
             callback_helper_->last_error_);
 }
 
-TEST_F(GDataFileSystemTest, GetFileByPath_FromCache) {
+TEST_F(DriveFileSystemTest, GetFileByPath_FromCache) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
@@ skipping 23 matching lines @@
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 }
 
-TEST_F(GDataFileSystemTest, GetFileByPath_HostedDocument) {
+TEST_F(DriveFileSystemTest, GetFileByPath_HostedDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
   scoped_ptr<DriveEntryProto> src_entry_proto =
       GetEntryInfoByPathSync(file_in_root);
   ASSERT_TRUE(src_entry_proto.get());
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(HOSTED_DOCUMENT, callback_helper_->file_type_);
   EXPECT_FALSE(callback_helper_->download_path_.empty());
 
   ASSERT_TRUE(src_entry_proto.get());
   VerifyHostedDocumentJSONFile(*src_entry_proto,
                                callback_helper_->download_path_);
 }
 
-TEST_F(GDataFileSystemTest, GetFileByResourceId) {
+TEST_F(DriveFileSystemTest, GetFileByResourceId) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
@@ skipping 19 matching lines @@
   file_system_->GetFileByResourceId(entry_proto->resource_id(),
                                     callback,
                                     GetContentCallback());
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 }
 
-TEST_F(GDataFileSystemTest, GetFileByResourceId_FromCache) {
+TEST_F(DriveFileSystemTest, GetFileByResourceId_FromCache) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
@@ skipping 18 matching lines @@
   file_system_->GetFileByResourceId(entry_proto->resource_id(),
                                     callback,
                                     GetContentCallback());
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
   EXPECT_EQ(downloaded_file.value(),
             callback_helper_->download_path_.value());
 }
 
-TEST_F(GDataFileSystemTest, UpdateFileByResourceId_PersistentFile) {
+TEST_F(DriveFileSystemTest, UpdateFileByResourceId_PersistentFile) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   LoadRootFeedDocument("root_feed.json");
 
   // This is a file defined in root_feed.json.
   const FilePath kFilePath(FILE_PATH_LITERAL("drive/File 1.txt"));
   const std::string kResourceId("file:2_file_resource_id");
   const std::string kMd5("3b4382ebefec6e743578c76bbd0575ce");
 
@@ skipping 123 matching lines @@
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_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));
   // After the file is updated, the dirty bit is cleared, hence the symlink
   // should be gone.
   ASSERT_FALSE(file_util::PathExists(outgoing_symlink_path));
 }
 
-TEST_F(GDataFileSystemTest, UpdateFileByResourceId_NonexistentFile) {
+TEST_F(DriveFileSystemTest, UpdateFileByResourceId_NonexistentFile) {
   LoadRootFeedDocument("root_feed.json");
 
   // This is nonexistent in root_feed.json.
   const FilePath kFilePath(FILE_PATH_LITERAL("drive/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().
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   file_system_->UpdateFileByResourceId(kResourceId, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
-TEST_F(GDataFileSystemTest, ContentSearch) {
+TEST_F(DriveFileSystemTest, ContentSearch) {
   LoadRootFeedDocument("root_feed.json");
 
   mock_drive_service_->set_search_result("search_result_feed.json");
 
   EXPECT_CALL(*mock_drive_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
       .Times(1);
 
   const SearchResultPair kExpectedResults[] = {
     { "drive/Directory 1/SubDirectory File 1.txt", false },
     { "drive/Directory 1", true }
   };
 
   SearchCallback callback = base::Bind(&DriveSearchCallback,
       &message_loop_, kExpectedResults, ARRAYSIZE_UNSAFE(kExpectedResults));
 
   file_system_->Search("foo", GURL(), callback);
   message_loop_.Run();  // Wait to get our result.
 }
 
-TEST_F(GDataFileSystemTest, ContentSearchWithNewEntry) {
+TEST_F(DriveFileSystemTest, ContentSearchWithNewEntry) {
   LoadRootFeedDocument("root_feed.json");
 
   // Search result returning two entries "Directory 1/" and
   // "Directory 1/SubDirectory Newly Added File.txt". The latter is not
   // contained in the root feed.
   mock_drive_service_->set_search_result(
       "search_result_with_new_entry_feed.json");
 
   EXPECT_CALL(*mock_drive_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
       .Times(1);
@@ skipping 12 matching lines @@
       .Times(1);
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
 
   SearchCallback callback = base::Bind(&DriveSearchCallback,
       &message_loop_, kExpectedResults, ARRAYSIZE_UNSAFE(kExpectedResults));
 
   file_system_->Search("foo", GURL(), callback);
   message_loop_.Run();  // Wait to get our result.
 }
 
-TEST_F(GDataFileSystemTest, ContentSearchEmptyResult) {
+TEST_F(DriveFileSystemTest, ContentSearchEmptyResult) {
   LoadRootFeedDocument("root_feed.json");
 
   mock_drive_service_->set_search_result("empty_feed.json");
 
   EXPECT_CALL(*mock_drive_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
       .Times(1);
 
   const SearchResultPair* expected_results = NULL;
 
   SearchCallback callback = base::Bind(&DriveSearchCallback,
       &message_loop_, expected_results, 0u);
 
   file_system_->Search("foo", GURL(), callback);
   message_loop_.Run();  // Wait to get our result.
 }
 
-TEST_F(GDataFileSystemTest, GetAvailableSpace) {
+TEST_F(DriveFileSystemTest, GetAvailableSpace) {
   GetAvailableSpaceCallback callback =
       base::Bind(&CallbackHelper::GetAvailableSpaceCallback,
                  callback_helper_.get());
 
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_));
 
   file_system_->GetAvailableSpace(callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GG_LONGLONG(6789012345), callback_helper_->quota_bytes_used_);
   EXPECT_EQ(GG_LONGLONG(9876543210), callback_helper_->quota_bytes_total_);
 }
 
-TEST_F(GDataFileSystemTest, RequestDirectoryRefresh) {
+TEST_F(DriveFileSystemTest, RequestDirectoryRefresh) {
   LoadRootFeedDocument("root_feed.json");
 
   // We'll fetch documents in the root directory with its resource ID.
   EXPECT_CALL(*mock_drive_service_,
               GetDocuments(Eq(GURL()), _, _, kDriveRootDirectoryResourceId, _))
       .Times(1);
   // We'll notify the directory change to the observer.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(FilePath(kDriveRootDirectory)))).Times(1);
 
   file_system_->RequestDirectoryRefresh(FilePath(kDriveRootDirectory));
   test_util::RunBlockingPoolTask();
 }
 
-TEST_F(GDataFileSystemTest, OpenAndCloseFile) {
+TEST_F(DriveFileSystemTest, OpenAndCloseFile) {
   LoadRootFeedDocument("root_feed.json");
 
   OpenFileCallback callback =
       base::Bind(&CallbackHelper::OpenFileCallback,
                  callback_helper_.get());
   FileOperationCallback close_file_callback =
       base::Bind(&CallbackHelper::CloseFileCallback,
                  callback_helper_.get());
 
   const FilePath kFileInRoot(FILE_PATH_LITERAL("drive/File 1.txt"));
@@ skipping 70 matching lines @@
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace gdata