Try fast-fetch rather than full fetch if drive::FileSystem::GetEntryInfo failed.

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 278 matching lines @@
   }
 
   // Returns true if the cache entry exists for the given resource ID and MD5.
   bool CacheEntryExists(const std::string& resource_id,
                         const std::string& md5) {
     FileCacheEntry cache_entry;
     return GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
   }
 
   // Flag for specifying the timestamp of the test filesystem cache.
-  enum SaveTestFileSystemParam {
+  enum SetUpTestFileSystemParam {
     USE_OLD_TIMESTAMP,
     USE_SERVER_TIMESTAMP,
   };
 
-  // Saves a file representing a filesystem with directories:
-  // drive/root, drive/root/Dir1, drive/root/Dir1/SubDir2
-  // and files
-  // drive/root/File1, drive/root/Dir1/File2, drive/root/Dir1/SubDir2/File3.
-  // If |use_up_to_date_timestamp| is true, sets the changestamp to 654321,
-  // equal to that of "account_metadata.json" test data, indicating the cache is
-  // holding the latest file system info.
-  bool SaveTestFileSystem(SaveTestFileSystemParam param) {
+  // Sets up a filesystem with directories: drive/root, drive/root/Dir1,
+  // drive/root/Dir1/SubDir2 and files drive/root/File1, drive/root/Dir1/File2,
+  // drive/root/Dir1/SubDir2/File3. If |use_up_to_date_timestamp| is true, sets
+  // the changestamp to 654321, equal to that of "account_metadata.json" test
+  // data, indicating the cache is holding the latest file system info.
+  bool SetUpTestFileSystem(SetUpTestFileSystemParam param) {
     // Destroy the existing resource metadata to close DB.
     resource_metadata_.reset();
 
     const std::string root_resource_id =
         fake_drive_service_->GetRootResourceId();
     scoped_ptr<internal::ResourceMetadata, test_util::DestroyHelperForTests>
         resource_metadata(new internal::ResourceMetadata(
             cache_->GetCacheDirectoryPath(internal::FileCache::CACHE_TYPE_META),
             blocking_task_runner_));
 
@@ skipping 132 matching lines @@
   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(DriveFileSystemTest, 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 GetEntryInfoCallback& callback = base::Bind(
       &AsyncInitializationCallback, &counter, 2, &message_loop_);
 
   file_system_->GetEntryInfoByPath(
       base::FilePath(FILE_PATH_LITERAL("drive/root")), callback);
   file_system_->GetEntryInfoByPath(
       base::FilePath(FILE_PATH_LITERAL("drive/root")), callback);
   message_loop_.Run();  // Wait to get our result
   EXPECT_EQ(2, counter);
 
   // Although GetEntryInfoByPath() was called twice, the account metadata
   // should only be loaded once. In the past, there was a bug that caused
   // it to be loaded twice.
-  EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(1, fake_drive_service_->resource_list_load_count());
+  // See the comment in GetMyDriveRoot test case why this is 2.
+  EXPECT_EQ(2, fake_drive_service_->about_resource_load_count());
 }
 
 TEST_F(DriveFileSystemTest, GetGrandRootEntry) {
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive"));
   scoped_ptr<ResourceEntry> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(util::kDriveGrandRootSpecialResourceId, entry->resource_id());
 
   // Getting the grand root entry should not cause the resource load to happen.
   EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
 }
 
 TEST_F(DriveFileSystemTest, GetOtherDirEntry) {
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/other"));
   scoped_ptr<ResourceEntry> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(util::kDriveOtherDirSpecialResourceId, entry->resource_id());
 
   // Getting the "other" directory entry should not cause the resource load to
   // happen.
   EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
 }
 
 TEST_F(DriveFileSystemTest, GetMyDriveRoot) {
+  // "Fast fetch" will fire an OnirectoryChanged event.
+  EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root"));
   scoped_ptr<ResourceEntry> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(fake_drive_service_->GetRootResourceId(), entry->resource_id());
 
-  // The changestamp should be propagated to the root directory.
-  EXPECT_EQ(fake_drive_service_->largest_changestamp(),
-            entry->directory_specific_info().changestamp());
+  // Absence of "drive/root" in the local metadata triggers the "fast fetch"
+  // of "drive" directory. Fetch of "drive" grand root directory has a special
+  // implementation. Instead of normal GetResourceListInDirectory(), it is
+  // emulated by calling GetAboutResource() so that the resource_id of
+  // "drive/root" is listed.
+  // Together with the normal GetAboutResource() call to retrieve the largest
+  // changestamp, the method is called twice.
+  EXPECT_EQ(2, fake_drive_service_->about_resource_load_count());
 
-  // The resource load should happen because "My Drive"'s root is not the grand
-  // root entry and hence does not present until the initial loading.
-  EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
+  // After "fast fetch" is done, full resource list is fetched.
   EXPECT_EQ(1, fake_drive_service_->resource_list_load_count());
 }
 
 TEST_F(DriveFileSystemTest, GetExistingFile) {
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ("file:2_file_resource_id", entry->resource_id());
 
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
@@ skipping 299 matching lines @@
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1"))));
   EXPECT_FALSE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
       "drive/root/Directory 1/New SubDirectory File 1.txt"))));
 }
 
 TEST_F(DriveFileSystemTest, CachedFeedLoadingThenServerFeedLoading) {
-  ASSERT_TRUE(SaveTestFileSystem(USE_SERVER_TIMESTAMP));
+  ASSERT_TRUE(SetUpTestFileSystem(USE_SERVER_TIMESTAMP));
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(ReadDirectoryByPathSync(util::GetDriveMyDriveRootPath()));
 
-  // SaveTestFileSystem and "account_metadata.json" have the same changestamp,
+  // SetUpTestFileSystem and "account_metadata.json" have the same changestamp,
   // so no request for new feeds (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(DriveFileSystemTest, OfflineCachedFeedLoading) {
-  ASSERT_TRUE(SaveTestFileSystem(USE_OLD_TIMESTAMP));
+  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.
   fake_drive_service_->set_offline(true);
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(ReadDirectoryByPathSync(util::GetDriveMyDriveRootPath()));
   // Loading of account metadata should not happen as it's offline.
   EXPECT_EQ(0, fake_drive_service_->account_metadata_load_count());
 
@@ skipping 17 matching lines @@
 
   file_system_->CheckForUpdates();
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(_))
       .Times(AtLeast(1));
 
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(1, fake_drive_service_->change_list_load_count());
 }
 
+TEST_F(DriveFileSystemTest, ReadDirectoryWhileRefreshing) {
+  EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(_))
+      .Times(AtLeast(1));
+
+  // Enter the "refreshing" state so the fast fetch will be performed.
+  ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
+  file_system_->CheckForUpdates();
+
+  // The list of resources in "drive/root/Dir1" should be fetched.
+  EXPECT_TRUE(ReadDirectoryByPathSync(base::FilePath(
+      FILE_PATH_LITERAL("drive/root/Dir1"))));
+  EXPECT_EQ(1, fake_drive_service_->directory_load_count());
+}
+
+TEST_F(DriveFileSystemTest, GetEntryInfoExistingWhileRefreshing) {
+  // Enter the "refreshing" state.
+  ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
+  file_system_->CheckForUpdates();
+
+  // If an entry is already found in local metadata, no directory fetch happens.
+  EXPECT_TRUE(GetEntryInfoByPathSync(base::FilePath(
+      FILE_PATH_LITERAL("drive/root/Dir1/File2"))));
+  EXPECT_EQ(0, fake_drive_service_->directory_load_count());
+}
+
+TEST_F(DriveFileSystemTest, GetEntryInfoNonExistentWhileRefreshing) {
+  EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(_))
+      .Times(AtLeast(1));
+
+  // Enter the "refreshing" state so the fast fetch will be performed.
+  ASSERT_TRUE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
+  file_system_->CheckForUpdates();
+
+  // If an entry is not found, parent directory's resource list is fetched.
+  EXPECT_FALSE(GetEntryInfoByPathSync(base::FilePath(
+      FILE_PATH_LITERAL("drive/root/Dir1/NonExistentFile"))));
+  EXPECT_EQ(1, fake_drive_service_->directory_load_count());
+}
+
 TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // We'll add a file to the Drive root directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   // Prepare a local file.
@@ skipping 1263 matching lines @@
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // It must fail.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
 }
 
 // TODO(satorux): Testing if WebAppsRegistry is loaded here is awkward. We
 // should move this to change_list_loader_unittest.cc. crbug.com/161703
 TEST_F(DriveFileSystemTest, WebAppsRegistryIsLoaded) {
-  ASSERT_TRUE(SaveTestFileSystem(USE_SERVER_TIMESTAMP));
+  ASSERT_TRUE(SetUpTestFileSystem(USE_SERVER_TIMESTAMP));
 
   // No apps should be found as the webapps registry is empty.
   ScopedVector<DriveWebAppInfo> apps;
   drive_webapps_registry_->GetWebAppsForFile(
       base::FilePath::FromUTF8Unsafe("foo.exe"),
       "" /* mime_type */,
       &apps);
   EXPECT_TRUE(apps.empty());
 
   // Kicks loading of cached file system and query for server update. This
@@ skipping 120 matching lines @@
 
   // Create fails if the parent directory does not exist.
   file_system_->CreateFile(
       kFileInNonExistingDirectory, false,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_NOT_A_DIRECTORY, error);
 }
 
 }   // namespace drive