drive: Remove the remaining mentions of "feed"

chrome/browser/chromeos/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 "chrome/browser/chromeos/drive/file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
   (*counter)++;
   if (*counter >= expected_counter)
     message_loop->Quit();
 }
 
 }  // namespace
 
 class FileSystemTest : public testing::Test {
  protected:
   FileSystemTest()
-      : ui_thread_(content::BrowserThread::UI, &message_loop_),
-        // |root_feed_changestamp_| should be set to the largest changestamp in
-        // about resource feed. But we fake it by some non-zero positive
-        // increasing value.  See |LoadFeed()|.
-        root_feed_changestamp_(1) {
+      : ui_thread_(content::BrowserThread::UI, &message_loop_) {
   }
 
   virtual void SetUp() OVERRIDE {
     profile_.reset(new TestingProfile);
 
     // The fake object will be manually deleted in TearDown().
     fake_drive_service_.reset(new google_apis::FakeDriveService);
     fake_drive_service_->LoadResourceListForWapi(
         "chromeos/gdata/root_feed.json");
     fake_drive_service_->LoadAccountMetadataForWapi(
@@ skipping 47 matching lines @@
 
   virtual void TearDown() OVERRIDE {
     ASSERT_TRUE(file_system_);
     file_system_.reset();
     scheduler_.reset();
     fake_drive_service_.reset();
     cache_.reset();
     profile_.reset(NULL);
   }
 
-  // Loads test json file as root ("/drive") element.
-  bool LoadRootFeedDocument() {
+  // Loads the full resource list via FakeDriveService.
+  bool LoadFullResourceList() {
     FileError error = FILE_ERROR_FAILED;
     file_system_->change_list_loader()->LoadIfNeeded(
         DirectoryFetchInfo(),
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     return error == FILE_ERROR_OK;
   }
 
   // Gets resource entry by path synchronously.
   scoped_ptr<ResourceEntry> GetResourceEntryByPathSync(
@@ skipping 181 matching lines @@
 
   scoped_ptr<internal::FileCache, test_util::DestroyHelperForTests> cache_;
   scoped_ptr<FileSystem> file_system_;
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
   scoped_ptr<JobScheduler> scheduler_;
   scoped_ptr<internal::ResourceMetadata, test_util::DestroyHelperForTests>
       resource_metadata_;
   scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
   scoped_ptr<StrictMock<MockCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
-
-  int root_feed_changestamp_;
 };
 
 TEST_F(FileSystemTest, DuplicatedAsyncInitialization) {
   // "Fast fetch" will fire an OnirectoryChanged event.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
 
   int counter = 0;
   const GetResourceEntryCallback& callback = base::Bind(
       &AsyncInitializationCallback, &counter, 2, &message_loop_);
@@ skipping 187 matching lines @@
   scoped_ptr<ResourceEntryVector> entries(
       ReadDirectoryByPathSync(
           base::FilePath::FromUTF8Unsafe("drive/root/Directory 1")));
   // The non root directory should also be read correctly.
   // There was a bug (crbug.com/181487), which broke this behavior.
   // Make sure this is fixed.
   ASSERT_TRUE(entries);
   EXPECT_EQ(3U, entries->size());
 }
 
-TEST_F(FileSystemTest, CachedFeedLoadingThenServerFeedLoading) {
+TEST_F(FileSystemTest, LoadFileSystemFromUpToDateCache) {
   ASSERT_TRUE(SetUpTestFileSystem(USE_SERVER_TIMESTAMP));
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(ReadDirectoryByPathSync(util::GetDriveMyDriveRootPath()));
 
-  // SetUpTestFileSystem and "account_metadata.json" have the same changestamp,
-  // so no request for new feeds (i.e., call to GetResourceList) should happen.
+  // SetUpTestFileSystem and "account_metadata.json" have the same
+  // changestamp (i.e. the local metadata is up-to-date), so no request for
+  // new resource list (i.e., call to GetResourceList) should happen.
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
 
   // Since the file system has verified that it holds the latest snapshot,
   // it should change its state to "loaded", which admits periodic refresh.
   // To test it, call CheckForUpdates and verify it does try to check updates.
   file_system_->CheckForUpdates();
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(2, fake_drive_service_->about_resource_load_count());
 }
 
-TEST_F(FileSystemTest, OfflineCachedFeedLoading) {
+TEST_F(FileSystemTest, LoadFileSystemFromCacheWhileOffline) {
   ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
 
-  // Make GetResourceList fail for simulating offline situation. This will leave
-  // the file system "loaded from cache, but not synced with server" state.
+  // Make GetResourceList fail for simulating offline situation. This will
+  // leave the file system "loaded from cache, but not synced with server"
+  // state.
   fake_drive_service_->set_offline(true);
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(ReadDirectoryByPathSync(util::GetDriveMyDriveRootPath()));
   // Loading of about resource should not happen as it's offline.
   EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
 
   // Tests that cached data can be loaded even if the server is not reachable.
   EXPECT_TRUE(EntryExists(base::FilePath(
       FILE_PATH_LITERAL("drive/root/File1"))));
@@ skipping 54 matching lines @@
   ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
   file_system_->CheckForUpdates();
 
   // If an entry is not found, parent directory's resource list is fetched.
   EXPECT_FALSE(GetResourceEntryByPathSync(base::FilePath(
       FILE_PATH_LITERAL("drive/root/Dir1/NonExistentFile"))));
   EXPECT_EQ(1, fake_drive_service_->directory_load_count());
 }
 
 TEST_F(FileSystemTest, CreateDirectoryByImplicitLoad) {
-  // Intentionally *not* calling LoadRootFeedDocument(), for testing that
-  // CreateDirectory ensures feed loading before it runs.
+  // Intentionally *not* calling LoadFullResourceList(), for testing that
+  // CreateDirectory ensures the resource list is loaded before it runs.
 
   base::FilePath existing_directory(
       FILE_PATH_LITERAL("drive/root/Directory 1"));
   FileError error = FILE_ERROR_FAILED;
   file_system_->CreateDirectory(
       existing_directory,
       true,  // is_exclusive
       false,  // is_recursive
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // It should fail because is_exclusive is set to true.
   EXPECT_EQ(FILE_ERROR_EXISTS, error);
 }
 
 TEST_F(FileSystemTest, PinAndUnpin) {
-  ASSERT_TRUE(LoadRootFeedDocument());
+  ASSERT_TRUE(LoadFullResourceList());
 
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
 
   // Get the file info.
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_path));
   ASSERT_TRUE(entry);
 
   // Pin the file.
   FileError error = FILE_ERROR_FAILED;
   EXPECT_CALL(*mock_cache_observer_,
@@ skipping 21 matching lines @@
   int64 bytes_used;
   file_system_->GetAvailableSpace(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &bytes_total, &bytes_used));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(GG_LONGLONG(6789012345), bytes_used);
   EXPECT_EQ(GG_LONGLONG(9876543210), bytes_total);
 }
 
 TEST_F(FileSystemTest, RefreshDirectory) {
-  ASSERT_TRUE(LoadRootFeedDocument());
+  ASSERT_TRUE(LoadFullResourceList());
 
   // We'll notify the directory change to the observer.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(util::GetDriveMyDriveRootPath()))).Times(1);
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->RefreshDirectory(
       util::GetDriveMyDriveRootPath(),
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 }
 
 TEST_F(FileSystemTest, OpenAndCloseFile) {
-  ASSERT_TRUE(LoadRootFeedDocument());
+  ASSERT_TRUE(LoadFullResourceList());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   const base::FilePath kFileInRoot(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(kFileInRoot));
   const int64 file_size = entry->file_info().size();
   const std::string& file_resource_id =
@@ skipping 71 matching lines @@
       kFileInRoot,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // It must fail.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
 }
 
 TEST_F(FileSystemTest, MarkCacheFileAsMountedAndUnmounted) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
-  ASSERT_TRUE(LoadRootFeedDocument());
+  ASSERT_TRUE(LoadFullResourceList());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_in_root));
   ASSERT_TRUE(entry);
 
   // Write to cache.
   FileError error = FILE_ERROR_FAILED;
   cache_->StoreOnUIThread(
       entry->resource_id(),
       entry->file_specific_info().file_md5(),
@@ skipping 36 matching lines @@
       entry->resource_id(),
       entry->file_specific_info().file_md5(),
       google_apis::test_util::CreateCopyResultCallback(&success, &cache_entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_TRUE(success);
   EXPECT_FALSE(cache_entry.is_mounted());
 }
 
 }   // namespace drive