Rename DocumentsServiceInterface to DriveServiceInterface.

chrome/browser/chromeos/gdata/gdata_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_api_parser.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.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_gdata_cache_observer.h"
-#include "chrome/browser/chromeos/gdata/mock_documents_service.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"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AtLeast;
 using ::testing::Eq;
 using ::testing::NotNull;
@@ skipping 29 matching lines @@
     EXPECT_EQ(FilePath(expected_results[i].path),
               results->at(i).path);
     EXPECT_EQ(expected_results[i].is_directory,
               results->at(i).is_directory);
   }
 
   message_loop->Quit();
 }
 
 // Action used to set mock expectations for
-// DocumentsService::GetDocumentEntry().
+// DriveServiceInterface::GetDocumentEntry().
 ACTION_P2(MockGetDocumentEntry, status, value) {
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(arg1, status, base::Passed(value)));
 }
 
 // Action used to set mock expectations for
 // GDataUploaderInterface::UploadExistingFile().
 ACTION_P4(MockUploadExistingFile,
           error, gdata_path, local_file_path, document_entry) {
   scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo);
@@ skipping 108 matching lines @@
   MOCK_METHOD1(UpdateFromApplicationList, void(const AppList& applist));
 };
 
 class GDataFileSystemTest : public testing::Test {
  protected:
   GDataFileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
         cache_(NULL),
         file_system_(NULL),
-        mock_doc_service_(NULL),
+        mock_drive_service_(NULL),
         mock_webapps_registry_(NULL),
         num_callback_invocations_(0),
         expected_error_(GDATA_FILE_OK),
         expected_cache_state_(0),
         expected_sub_dir_type_(GDataCache::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.
-    mock_doc_service_ = new StrictMock<MockDocumentsService>;
+    mock_drive_service_ = new StrictMock<MockDriveService>;
 
-    EXPECT_CALL(*mock_doc_service_, Initialize(profile_.get())).Times(1);
+    EXPECT_CALL(*mock_drive_service_, Initialize(profile_.get())).Times(1);
 
     // Likewise, this will be owned by GDataFileSystem.
     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_ = GDataCache::CreateGDataCacheOnUIThread(
         GDataCache::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(),
                                        cache_,
-                                       mock_doc_service_,
+                                       mock_drive_service_,
                                        mock_uploader_.get(),
                                        mock_webapps_registry_.get(),
                                        blocking_task_runner_);
 
     mock_cache_observer_.reset(new StrictMock<MockGDataCacheObserver>);
     cache_->AddObserver(mock_cache_observer_.get());
 
     mock_directory_observer_.reset(new StrictMock<MockDirectoryChangeObserver>);
     file_system_->AddObserver(mock_directory_observer_.get());
 
     file_system_->Initialize();
     cache_->RequestInitializeOnUIThreadForTesting();
     test_util::RunBlockingPoolTask();
   }
 
   virtual void TearDown() OVERRIDE {
     ASSERT_TRUE(file_system_);
-    EXPECT_CALL(*mock_doc_service_, CancelAll()).Times(1);
+    EXPECT_CALL(*mock_drive_service_, CancelAll()).Times(1);
     delete file_system_;
     file_system_ = NULL;
-    delete mock_doc_service_;
-    mock_doc_service_ = NULL;
+    delete mock_drive_service_;
+    mock_drive_service_ = NULL;
     SetFreeDiskSpaceGetterForTesting(NULL);
     cache_->DestroyOnUIThread();
     // The cache destruction requires to post a task to the blocking pool.
     test_util::RunBlockingPoolTask();
 
     profile_.reset(NULL);
     chromeos::CrosLibrary::Shutdown();
   }
 
   // Loads test json file as root ("/drive") element.
@@ skipping 352 matching lines @@
       EXPECT_TRUE(target_path.value() != kSymLinkToDevNull);
       if (test_util::ToCacheEntry(expected_cache_state_).is_present())
         EXPECT_EQ(dest_path, target_path);
     } else {
       EXPECT_FALSE(exists);
     }
   }
 
   void SetExpectationsForGetDocumentEntry(scoped_ptr<base::Value>* document,
                                           const std::string& resource_id) {
-    EXPECT_CALL(*mock_doc_service_, GetDocumentEntry(resource_id, _))
+    EXPECT_CALL(*mock_drive_service_, GetDocumentEntry(resource_id, _))
         .WillOnce(MockGetDocumentEntry(gdata::HTTP_SUCCESS, document));
   }
 
   // Loads serialized proto file from GCache, and makes sure the root
   // filesystem has a root at 'drive'
   void TestLoadMetadataFromCache() {
     file_system_->LoadRootFeedFromCacheForTesting();
     test_util::RunBlockingPoolTask();
   }
 
@@ skipping 181 matching lines @@
   // 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_;
   GDataCache* cache_;
   scoped_ptr<StrictMock<MockGDataUploader> > mock_uploader_;
   GDataFileSystem* file_system_;
-  StrictMock<MockDocumentsService>* mock_doc_service_;
+  StrictMock<MockDriveService>* mock_drive_service_;
   scoped_ptr<StrictMock<MockDriveWebAppsRegistry> > mock_webapps_registry_;
   StrictMock<MockFreeDiskSpaceGetter>* mock_free_disk_space_checker_;
   scoped_ptr<StrictMock<MockGDataCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   int num_callback_invocations_;
   GDataFileError expected_error_;
   int expected_cache_state_;
   GDataCache::CacheSubDirectoryType expected_sub_dir_type_;
   bool expected_success_;
@@ skipping 24 matching lines @@
 
 TEST_F(GDataFileSystemTest, DuplicatedAsyncInitialization) {
   int counter = 0;
   GetEntryInfoCallback callback = base::Bind(
       &AsyncInitializationCallback,
       &counter,
       2,
       FilePath(FILE_PATH_LITERAL("drive")),
       &message_loop_);
 
-  EXPECT_CALL(*mock_doc_service_, GetAccountMetadata(_)).Times(1);
-  EXPECT_CALL(*mock_doc_service_,
+  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);
@@ skipping 316 matching lines @@
   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) {
   SaveTestFileSystem();
 
   // SaveTestFileSystem and "account_metadata.json" have the same changestamp,
   // so no request for new feeds (i.e., call to GetDocuments) should happen.
-  mock_doc_service_->set_account_metadata(
+  mock_drive_service_->set_account_metadata(
       LoadJSONFile("account_metadata.json"));
-  EXPECT_CALL(*mock_doc_service_, GetAccountMetadata(_)).Times(1);
+  EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
-  EXPECT_CALL(*mock_doc_service_, GetDocuments(_, _, _, _, _)).Times(0);
+  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_doc_service_->set_account_metadata(
+  mock_drive_service_->set_account_metadata(
       LoadJSONFile("account_metadata.json"));
-  EXPECT_CALL(*mock_doc_service_, GetAccountMetadata(_)).Times(1);
+  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) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
@@ skipping 50 matching lines @@
       FILE_PATH_LITERAL("drive/Directory 1/Document 1.gdoc"));
   EXPECT_FALSE(EntryExists(remote_dest_file_path));
 
   // We'll add a file to "Directory 1" directory on Drive.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   // We'll copy a hosted document using CopyDocument.
   // ".gdoc" suffix should be stripped when copying.
   scoped_ptr<base::Value> document(LoadJSONFile("uploaded_document.json"));
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               CopyDocument(kResourceId,
                            FILE_PATH_LITERAL("Document 1"),
                            _))
       .WillOnce(MockCopyDocument(gdata::HTTP_SUCCESS, &document));
   // We'll then add the hosted document to the destination directory.
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               AddResourceToDirectory(_, _, _)).Times(1);
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Transfer the local file to Drive.
   file_system_->TransferFileFromLocalToRemote(
       local_src_file_path, remote_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
@@ skipping 21 matching lines @@
   FilePath cache_file = GetCachePathForFile(
       file->resource_id(),
       file->file_specific_info().file_md5());
   const int64 file_size = file->file_info().size();
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   const std::string remote_src_file_data = "Test file data";
-  mock_doc_service_->set_file_data(new std::string(remote_src_file_data));
+  mock_drive_service_->set_file_data(new std::string(remote_src_file_data));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
-  // The file is obtained with the mock DocumentsService.
-  EXPECT_CALL(*mock_doc_service_,
+  // The file is obtained with the mock DriveService.
+  EXPECT_CALL(*mock_drive_service_,
               DownloadFile(remote_src_file_path,
                            cache_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->TransferFileFromRemoteToLocal(
       remote_src_file_path, local_dest_file_path, callback);
   test_util::RunBlockingPoolTask();
 
@@ skipping 130 matching lines @@
 
   LoadRootFeedDocument("root_feed.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<GDataEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
 
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              FILE_PATH_LITERAL("Test.log"), _));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
@@ skipping 21 matching lines @@
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   ASSERT_TRUE(EntryExists(dest_parent_path));
   scoped_ptr<GDataEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_parent_proto.get());
   ASSERT_TRUE(dest_parent_proto->file_info().is_directory());
   EXPECT_FALSE(dest_parent_proto->content_url().empty());
 
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              FILE_PATH_LITERAL("Test.log"), _));
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               AddResourceToDirectory(
                   GURL(dest_parent_proto->content_url()),
                   GURL(src_entry_proto->edit_url()), _));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Expect notification for both source and destination directories.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
@@ skipping 26 matching lines @@
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   ASSERT_TRUE(EntryExists(src_parent_path));
   scoped_ptr<GDataEntryProto> src_parent_proto = GetEntryInfoByPathSync(
       src_parent_path);
   ASSERT_TRUE(src_parent_proto.get());
   ASSERT_TRUE(src_parent_proto->file_info().is_directory());
   EXPECT_FALSE(src_parent_proto->content_url().empty());
 
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              FILE_PATH_LITERAL("Test.log"), _));
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               RemoveResourceFromDirectory(
                   GURL(src_parent_proto->content_url()),
                   GURL(src_entry_proto->edit_url()),
                   src_file_resource_id, _));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Expect notification for both source and destination directories.
@@ skipping 43 matching lines @@
 
   ASSERT_TRUE(EntryExists(dest_parent_path));
   scoped_ptr<GDataEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_parent_proto.get());
   ASSERT_TRUE(dest_parent_proto->file_info().is_directory());
   EXPECT_FALSE(dest_parent_proto->content_url().empty());
 
   EXPECT_FALSE(EntryExists(interim_file_path));
 
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               RenameResource(GURL(src_entry_proto->edit_url()),
                              FILE_PATH_LITERAL("Test.log"), _));
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               RemoveResourceFromDirectory(
                   GURL(src_parent_proto->content_url()),
                   GURL(src_entry_proto->edit_url()),
                   src_file_resource_id, _));
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               AddResourceToDirectory(
                   GURL(dest_parent_proto->content_url()),
                   GURL(src_entry_proto->edit_url()),
                   _));
 
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
   // Expect notification for both source and destination directories plus
@@ skipping 232 matching lines @@
       GDataFileSystem::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) {
   LoadRootFeedDocument("root_feed.json");
-  EXPECT_CALL(*mock_doc_service_,
+  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<GDataFileError>(1);
   file_system_->CreateDirectory(
       FilePath(FILE_PATH_LITERAL("drive/Sample Directory Title")),
       false,  // is_exclusive
       true,  // is_recursive
@@ skipping 21 matching lines @@
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
-  // The file is obtained with the mock DocumentsService.
-  EXPECT_CALL(*mock_doc_service_,
+  // The file is obtained with the mock DriveService.
+  EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
@@ skipping 18 matching lines @@
 
   // Pretend we have no space at all.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(0));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
-  // The file is not obtained with the mock DocumentsService, because of no
-  // space.
-  EXPECT_CALL(*mock_doc_service_,
+  // The file is not obtained with the mock DriveService, because of no space.
+  EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(0);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
@@ skipping 32 matching lines @@
                    test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   ASSERT_TRUE(CacheEntryExists("<resource_id>", "<md5>"));
   ASSERT_TRUE(CacheFileExists("<resource_id>", "<md5>"));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
-  // The file is obtained with the mock DocumentsService, because of we freed
-  // up the space.
-  EXPECT_CALL(*mock_doc_service_,
+  // The file is obtained with the mock DriveService, because of we freed up the
+  // space.
+  EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
@@ skipping 29 matching lines @@
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .WillOnce(Return(file_size + kMinFreeSpace))
       .WillOnce(Return(kMinFreeSpace - 1))
       .WillOnce(Return(kMinFreeSpace - 1));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
-  // The file is obtained with the mock DocumentsService.
-  EXPECT_CALL(*mock_doc_service_,
+  // The file is obtained with the mock DriveService.
+  EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
@@ skipping 19 matching lines @@
 
   // Store something as cached version of this file.
   TestStoreToCache(entry_proto->resource_id(),
                    entry_proto->file_specific_info().file_md5(),
                    GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Make sure we don't fetch metadata for downloading file.
-  EXPECT_CALL(*mock_doc_service_, GetDocumentEntry(_, _)).Times(0);
+  EXPECT_CALL(*mock_drive_service_, GetDocumentEntry(_, _)).Times(0);
 
   // Make sure we don't call downloads at all.
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(0);
 
   file_system_->GetFileByPath(file_in_root, callback,
                               GetContentCallback());
   test_util::RunBlockingPoolTask();
 
@@ skipping 40 matching lines @@
   scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
-  // The file is obtained with the mock DocumentsService, because it's not
-  // stored in the cache.
-  EXPECT_CALL(*mock_doc_service_,
+  // The file is obtained with the mock DriveService, because it's not stored in
+  // the cache.
+  EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   file_system_->GetFileByResourceId(entry_proto->resource_id(),
                                     callback,
                                     GetContentCallback());
   test_util::RunBlockingPoolTask();
@@ skipping 22 matching lines @@
   // Store something as cached version of this file.
   TestStoreToCache(entry_proto->resource_id(),
                    entry_proto->file_specific_info().file_md5(),
                    GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // The file is obtained from the cache.
   // Make sure we don't call downloads at all.
-  EXPECT_CALL(*mock_doc_service_, DownloadFile(_, _, _, _, _))
+  EXPECT_CALL(*mock_drive_service_, DownloadFile(_, _, _, _, _))
       .Times(0);
 
   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());
@@ skipping 158 matching lines @@
                  callback_helper_.get());
 
   file_system_->UpdateFileByResourceId(kResourceId, callback);
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 TEST_F(GDataFileSystemTest, ContentSearch) {
   LoadRootFeedDocument("root_feed.json");
 
-  mock_doc_service_->set_search_result("search_result_feed.json");
+  mock_drive_service_->set_search_result("search_result_feed.json");
 
-  EXPECT_CALL(*mock_doc_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
+  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) {
   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_doc_service_->set_search_result(
+  mock_drive_service_->set_search_result(
       "search_result_with_new_entry_feed.json");
 
-  EXPECT_CALL(*mock_doc_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
+  EXPECT_CALL(*mock_drive_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
       .Times(1);
 
   // As the result of the first Search(), only entries in the current file
   // system snapshot are expected to be returned.
   const SearchResultPair kExpectedResults[] = {
     { "drive/Directory 1", true }
   };
 
   // At the same time, unknown entry should trigger delta feed request.
   // This will cause notification to observers (e.g., File Browser) so that
   // they can request search again.
-  EXPECT_CALL(*mock_doc_service_, GetAccountMetadata(_)).Times(1);
-  EXPECT_CALL(*mock_doc_service_, GetDocuments(Eq(GURL()), _, "", _, _))
+  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);
 
   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) {
   LoadRootFeedDocument("root_feed.json");
 
-  mock_doc_service_->set_search_result("empty_feed.json");
+  mock_drive_service_->set_search_result("empty_feed.json");
 
-  EXPECT_CALL(*mock_doc_service_, GetDocuments(Eq(GURL()), _, "foo", _, _))
+  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) {
   GetAvailableSpaceCallback callback =
       base::Bind(&CallbackHelper::GetAvailableSpaceCallback,
                  callback_helper_.get());
 
-  EXPECT_CALL(*mock_doc_service_, GetAccountMetadata(_));
+  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) {
   LoadRootFeedDocument("root_feed.json");
 
   // We'll fetch documents in the root directory with its resource ID.
-  EXPECT_CALL(*mock_doc_service_,
+  EXPECT_CALL(*mock_drive_service_,
               GetDocuments(Eq(GURL()), _, _, kGDataRootDirectoryResourceId, _))
       .Times(1);
   // We'll notify the directory change to the observer.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(FilePath(kGDataRootDirectory)))).Times(1);
 
   file_system_->RequestDirectoryRefresh(FilePath(kGDataRootDirectory));
   test_util::RunBlockingPoolTask();
 }
 
@@ skipping 19 matching lines @@
 
   // A dirty file is created on close.
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(file_resource_id))
       .Times(1);
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   const std::string kExpectedFileData = "test file data";
-  mock_doc_service_->set_file_data(new std::string(kExpectedFileData));
+  mock_drive_service_->set_file_data(new std::string(kExpectedFileData));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
   scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
-  // The file is obtained with the mock DocumentsService.
-  EXPECT_CALL(*mock_doc_service_,
+  // The file is obtained with the mock DriveService.
+  EXPECT_CALL(*mock_drive_service_,
               DownloadFile(kFileInRoot,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
   // Open kFileInRoot ("drive/File 1.txt").
   file_system_->OpenFile(kFileInRoot, callback);
   message_loop_.Run();
   const FilePath opened_file_path = callback_helper_->opened_file_path_;
@@ skipping 33 matching lines @@
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace gdata