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 290 matching lines @@
     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) {

[satorux1, 2013/05/07 06:29:45]

This looks like a misnomer. I think this function was named when we were saving
a giant serialized proto file.

Maybe: SetUpTestFileSystem() ?

[hashimoto, 2013/05/07 06:49:01]

Done.

     // 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(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 356 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.

[satorux1, 2013/05/07 06:29:45]

Enter the "refreshing" state so the fast fetch will be performed.

[hashimoto, 2013/05/07 06:49:01]

Done for ReadDirectoryWhileRefreshing and
GetEntryInfoNonExistentWhileRefreshing.

+  ASSERT_TRUE(SaveTestFileSystem(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(SaveTestFileSystem(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.
+  ASSERT_TRUE(SaveTestFileSystem(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 1393 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