drive: Drop "Drive" from FakeDriveFileSystem and MockDriveFileSystem

chrome/browser/chromeos/drive/sync_client_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/drive/sync_client.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
-#include "chrome/browser/chromeos/drive/mock_drive_file_system.h"
+#include "chrome/browser/chromeos/drive/mock_file_system.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/google_apis/test_util.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::StrictMock;
 using ::testing::_;
 
 namespace drive {
@@ skipping 16 matching lines @@
   entry_proto->mutable_file_specific_info()->set_file_md5(md5);
   arg1.Run(error, base::FilePath(), entry_proto.Pass());
 }
 
 }  // namespace
 
 class SyncClientTest : public testing::Test {
  public:
   SyncClientTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
-        mock_file_system_(new StrictMock<MockDriveFileSystem>) {
+        mock_file_system_(new StrictMock<MockFileSystem>) {
   }
 
   virtual void SetUp() OVERRIDE {
     // Create a temporary directory.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     // Initialize the cache.
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     cache_.reset(new FileCache(
@@ skipping 78 matching lines @@
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     EXPECT_EQ(FILE_ERROR_OK, error);
     cache_->CommitDirty(
         resource_id_dirty, md5_dirty,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     EXPECT_EQ(FILE_ERROR_OK, error);
   }
 
-  // Sets the expectation for MockDriveFileSystem::GetFileByResourceId(),
+  // Sets the expectation for MockFileSystem::GetFileByResourceId(),
   // that simulates successful retrieval of a file for the given resource ID.
   void SetExpectationForGetFileByResourceId(const std::string& resource_id) {
     EXPECT_CALL(*mock_file_system_,
                 GetFileByResourceId(resource_id, _, _, _))
         .WillOnce(
             MockGetFileByResourceId(
                 FILE_ERROR_OK,
                 base::FilePath::FromUTF8Unsafe("local_path_does_not_matter"),
                 std::string("mime_type_does_not_matter"),
                 REGULAR_FILE));
   }
 
-  // Sets the expectation for MockDriveFileSystem::UpdateFileByResourceId(),
+  // Sets the expectation for MockFileSystem::UpdateFileByResourceId(),
   // that simulates successful uploading of a file for the given resource ID.
   void SetExpectationForUpdateFileByResourceId(
       const std::string& resource_id) {
     EXPECT_CALL(*mock_file_system_,
                 UpdateFileByResourceId(resource_id, _, _))
         .WillOnce(MockUpdateFileByResourceId(FILE_ERROR_OK));
   }
 
-  // Sets the expectation for MockDriveFileSystem::GetFileInfoByResourceId(),
+  // Sets the expectation for MockFileSystem::GetFileInfoByResourceId(),
   // that simulates successful retrieval of file info for the given resource
   // ID.
   //
   // This is used for testing StartCheckingExistingPinnedFiles(), hence we
   // are only interested in the MD5 value in DriveEntryProto.
   void SetExpectationForGetFileInfoByResourceId(
       const std::string& resource_id,
       const std::string& new_md5) {
     EXPECT_CALL(*mock_file_system_,
                 GetEntryInfoByResourceId(resource_id, _))
@@ skipping 19 matching lines @@
 
   // Adds a resource ID of a file to upload.
   void AddResourceIdToUpload(const std::string& resource_id) {
     sync_client_->AddResourceIdForTesting(SyncClient::UPLOAD, resource_id);
   }
 
  protected:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   base::ScopedTempDir temp_dir_;
-  scoped_ptr<StrictMock<MockDriveFileSystem> > mock_file_system_;
+  scoped_ptr<StrictMock<MockFileSystem> > mock_file_system_;
   scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
   scoped_ptr<SyncClient> sync_client_;
 };
 
 TEST_F(SyncClientTest, StartInitialScan) {
   // Start processing the files in the backlog. This will collect the
   // resource IDs of these files.
   sync_client_->StartProcessingBacklog();
 
   // Check the contents of the queue for fetching.
@@ skipping 38 matching lines @@
   // Set the delay so that DoSyncLoop() is delayed.
   sync_client_->set_delay_for_testing(TestTimeouts::action_max_timeout());
   // Raise OnCachePinned() event. This shouldn't result in adding the second
   // task, as tasks are de-duplicated.
   sync_client_->OnCachePinned("resource_id_not_fetched_foo", "md5");
 
   ASSERT_EQ(1U, GetResourceIdsToBeFetched().size());
 }
 
 TEST_F(SyncClientTest, ExistingPinnedFiles) {
-  // Set the expectation so that the MockDriveFileSystem returns "new_md5"
+  // Set the expectation so that the MockFileSystem returns "new_md5"
   // for "resource_id_fetched". This simulates that the file is updated on
   // the server side, and the new MD5 is obtained from the server (i.e. the
   // local cache file is stale).
   SetExpectationForGetFileInfoByResourceId("resource_id_fetched",
                                            "new_md5");
-  // Set the expectation so that the MockDriveFileSystem returns "some_md5"
+  // Set the expectation so that the MockFileSystem returns "some_md5"
   // for "resource_id_dirty". The MD5 on the server is always different from
   // the MD5 of a dirty file, which is set to "local". We should not collect
   // this by StartCheckingExistingPinnedFiles().
   SetExpectationForGetFileInfoByResourceId("resource_id_dirty",
                                            "some_md5");
 
   // Start checking the existing pinned files. This will collect the resource
   // IDs of pinned files, with stale local cache files.
   sync_client_->StartCheckingExistingPinnedFiles();
 
   SetExpectationForGetFileByResourceId("resource_id_fetched");
 
   google_apis::test_util::RunBlockingPoolTask();
 }
 
 }  // namespace drive