Rename GDataFileSystem* to DriveFileSystem*

chrome/browser/chromeos/gdata/gdata_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/gdata/gdata_sync_client.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.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/test/test_timeouts.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/mock_network_library.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_test_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
-#include "chrome/browser/chromeos/gdata/mock_gdata_file_system.h"
+#include "chrome/browser/chromeos/gdata/mock_drive_file_system.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.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::AnyNumber;
 using ::testing::DoAll;
@@ skipping 19 matching lines @@
   entry_proto->mutable_file_specific_info()->set_file_md5(md5);
   arg1.Run(error, FilePath(), entry_proto.Pass());
 }
 
 class GDataSyncClientTest : public testing::Test {
  public:
   GDataSyncClientTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
         profile_(new TestingProfile),
-        mock_file_system_(new StrictMock<MockGDataFileSystem>),
+        mock_file_system_(new StrictMock<MockDriveFileSystem>),
         mock_network_library_(NULL) {
   }
 
   virtual void SetUp() OVERRIDE {
     chromeos::CrosLibrary::Initialize(true /* use_stub */);
 
     // CrosLibrary takes ownership of MockNetworkLibrary.
     mock_network_library_ = new chromeos::MockNetworkLibrary;
     chromeos::CrosLibrary::Get()->GetTestApi()->SetNetworkLibrary(
         mock_network_library_, true);
@@ skipping 135 matching lines @@
         file_util::CreateSymbolicLink(
             dirty_file_path,
             outgoing_dir.AppendASCII("resource_id_dirty")));
     // Create a symlink in the pinned directory to the dirty file.
     ASSERT_TRUE(
         file_util::CreateSymbolicLink(
             dirty_file_path,
             pinned_dir.AppendASCII("resource_id_dirty")));
   }
 
-  // Sets the expectation for MockGDataFileSystem::GetFileByResourceId(),
+  // Sets the expectation for MockDriveFileSystem::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(
             DRIVE_FILE_OK,
             FilePath::FromUTF8Unsafe("local_path_does_not_matter"),
             std::string("mime_type_does_not_matter"),
             REGULAR_FILE));
   }
 
-  // Sets the expectation for MockGDataFileSystem::UpdateFileByResourceId(),
+  // Sets the expectation for MockDriveFileSystem::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(DRIVE_FILE_OK));
   }
 
-  // Sets the expectation for MockGDataFileSystem::GetFileInfoByResourceId(),
+  // Sets the expectation for MockDriveFileSystem::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 24 matching lines @@
     sync_client_->AddResourceIdForTesting(GDataSyncClient::UPLOAD,
                                           resource_id);
   }
 
  protected:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
   ScopedTempDir temp_dir_;
   scoped_ptr<TestingProfile> profile_;
-  scoped_ptr<StrictMock<MockGDataFileSystem> > mock_file_system_;
+  scoped_ptr<StrictMock<MockDriveFileSystem> > mock_file_system_;
   DriveCache* cache_;
   scoped_ptr<GDataSyncClient> sync_client_;
   chromeos::MockNetworkLibrary* mock_network_library_;
   scoped_ptr<chromeos::Network> active_network_;
 };
 
 TEST_F(GDataSyncClientTest, StartInitialScan) {
   SetUpTestFiles();
   // Connect to no network, so the sync loop won't spin.
   ConnectToNone();
@@ skipping 26 matching lines @@
 
 TEST_F(GDataSyncClientTest, StartSyncLoop) {
   SetUpTestFiles();
   ConnectToWifi();
 
   AddResourceIdToFetch("resource_id_not_fetched_foo");
   AddResourceIdToFetch("resource_id_not_fetched_bar");
   AddResourceIdToFetch("resource_id_not_fetched_baz");
   AddResourceIdToUpload("resource_id_dirty");
 
-  // These files will be fetched or uploaded by GDataFileSystem, once
+  // These files will be fetched or uploaded by DriveFileSystem, once
   // StartSyncLoop() starts.
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_foo");
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_bar");
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_baz");
   SetExpectationForUpdateFileByResourceId("resource_id_dirty");
 
   sync_client_->StartSyncLoop();
 }
 
 TEST_F(GDataSyncClientTest, StartSyncLoop_Offline) {
   SetUpTestFiles();
   ConnectToNone();
 
   AddResourceIdToFetch("resource_id_not_fetched_foo");
   AddResourceIdToFetch("resource_id_not_fetched_bar");
   AddResourceIdToFetch("resource_id_not_fetched_baz");
   AddResourceIdToUpload("resource_id_dirty");
 
-  // These files will be neither fetched nor uploaded not by GDataFileSystem,
+  // These files will be neither fetched nor uploaded not by DriveFileSystem,
   // as network is not connected.
 
   sync_client_->StartSyncLoop();
 }
 
 TEST_F(GDataSyncClientTest, StartSyncLoop_ResumedConnection) {
   const std::string resource_id("resource_id_not_fetched_foo");
   const FilePath file_path(
       FilePath::FromUTF8Unsafe("local_path_does_not_matter"));
   const std::string mime_type("mime_type_does_not_matter");
@@ skipping 22 matching lines @@
 
 TEST_F(GDataSyncClientTest, StartSyncLoop_CelluarDisabled) {
   SetUpTestFiles();
   ConnectToWifi();  // First connect to Wifi.
 
   AddResourceIdToFetch("resource_id_not_fetched_foo");
   AddResourceIdToFetch("resource_id_not_fetched_bar");
   AddResourceIdToFetch("resource_id_not_fetched_baz");
   AddResourceIdToUpload("resource_id_dirty");
 
-  // These files will be neither fetched nor uploaded not by GDataFileSystem,
+  // These files will be neither fetched nor uploaded not by DriveFileSystem,
   // as fetching over cellular network is disabled by default.
 
   // Then connect to cellular. This will kick off StartSyncLoop().
   ConnectToCellular();
 }
 
 TEST_F(GDataSyncClientTest, StartSyncLoop_CelluarEnabled) {
   SetUpTestFiles();
   ConnectToWifi();  // First connect to Wifi.
 
   // Enable fetching over cellular network.
   profile_->GetPrefs()->SetBoolean(prefs::kDisableGDataOverCellular, false);
 
   AddResourceIdToFetch("resource_id_not_fetched_foo");
   AddResourceIdToFetch("resource_id_not_fetched_bar");
   AddResourceIdToFetch("resource_id_not_fetched_baz");
   AddResourceIdToUpload("resource_id_dirty");
 
-  // These files will be fetched or uploaded by GDataFileSystem, as syncing
+  // These files will be fetched or uploaded by DriveFileSystem, as syncing
   // over cellular network is explicitly enabled.
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_foo");
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_bar");
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_baz");
   SetExpectationForUpdateFileByResourceId("resource_id_dirty");
 
   // Then connect to cellular. This will kick off StartSyncLoop().
   ConnectToCellular();
 }
 
 TEST_F(GDataSyncClientTest, StartSyncLoop_WimaxDisabled) {
   SetUpTestFiles();
   ConnectToWifi();  // First connect to Wifi.
 
   AddResourceIdToFetch("resource_id_not_fetched_foo");
   AddResourceIdToFetch("resource_id_not_fetched_bar");
   AddResourceIdToFetch("resource_id_not_fetched_baz");
   AddResourceIdToUpload("resource_id_dirty");
 
-  // These files will be neither fetched nor uploaded not by GDataFileSystem,
+  // These files will be neither fetched nor uploaded not by DriveFileSystem,
   // as syncing over wimax network is disabled by default.
 
   // Then connect to wimax. This will kick off StartSyncLoop().
   ConnectToWimax();
 }
 
 TEST_F(GDataSyncClientTest, StartSyncLoop_CelluarEnabledWithWimax) {
   SetUpTestFiles();
   ConnectToWifi();  // First connect to Wifi.
 
   // Enable fetching over cellular network. This includes wimax.
   profile_->GetPrefs()->SetBoolean(prefs::kDisableGDataOverCellular, false);
 
   AddResourceIdToFetch("resource_id_not_fetched_foo");
   AddResourceIdToFetch("resource_id_not_fetched_bar");
   AddResourceIdToFetch("resource_id_not_fetched_baz");
   AddResourceIdToUpload("resource_id_dirty");
 
-  // These files will be fetched or uploaded by GDataFileSystem, as syncing
+  // These files will be fetched or uploaded by DriveFileSystem, as syncing
   // over cellular network, which includes wimax, is explicitly enabled.
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_foo");
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_bar");
   SetExpectationForGetFileByResourceId("resource_id_not_fetched_baz");
   SetExpectationForUpdateFileByResourceId("resource_id_dirty");
 
   // Then connect to wimax. This will kick off StartSyncLoop().
   ConnectToWimax();
 }
 
 TEST_F(GDataSyncClientTest, StartSyncLoop_GDataDisabled) {
   SetUpTestFiles();
   ConnectToWifi();
 
   // Disable the GData feature.
   profile_->GetPrefs()->SetBoolean(prefs::kDisableGData, true);
 
   AddResourceIdToFetch("resource_id_not_fetched_foo");
   AddResourceIdToFetch("resource_id_not_fetched_bar");
   AddResourceIdToFetch("resource_id_not_fetched_baz");
   AddResourceIdToUpload("resource_id_dirty");
 
-  // These files will be neither fetched nor uploaded not by GDataFileSystem,
+  // These files will be neither fetched nor uploaded not by DriveFileSystem,
   // as the GData feature is disabled.
 
   sync_client_->StartSyncLoop();
 }
 
 TEST_F(GDataSyncClientTest, OnCachePinned) {
   SetUpTestFiles();
   ConnectToWifi();
 
   // This file will be fetched by GetFileByResourceId() as OnCachePinned()
@@ skipping 47 matching lines @@
 
 TEST_F(GDataSyncClientTest, ExistingPinnedFiles) {
   SetUpTestFiles();
   // Connect to no network, so the sync loop won't spin.
   ConnectToNone();
 
   // Kick off the cache initialization. This will scan the contents in the
   // test cache directory.
   cache_->RequestInitializeOnUIThread();
 
-  // Set the expectation so that the MockGDataFileSystem returns "new_md5"
+  // Set the expectation so that the MockDriveFileSystem 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 cach file is stale).
   SetExpectationForGetFileInfoByResourceId("resource_id_fetched",
                                            "new_md5");
-  // Set the expectation so that the MockGDataFileSystem returns "some_md5"
+  // Set the expectation so that the MockDriveFileSystem 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();
   test_util::RunBlockingPoolTask();
 
   // Check the contents of the queue for fetching.
   std::vector<std::string> resource_ids =
       GetResourceIdsToBeFetched();
   ASSERT_EQ(1U, resource_ids.size());
   EXPECT_EQ("resource_id_fetched", resource_ids[0]);
   // resource_id_dirty is not collected in the queue.
 
   // Check the contents of the queue for uploading.
   resource_ids = GetResourceIdsToBeUploaded();
   ASSERT_TRUE(resource_ids.empty());
 }
 
 }  // namespace gdata