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

chrome/browser/chromeos/drive/file_system.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 "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
@@ skipping 645 matching lines @@
     FileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error == FILE_ERROR_OK) {
     CheckLocalModificationAndRun(entry_proto.Pass(), callback);
     return;
   }
 
-  // Start loading if needed. Note that directory_fetch_info is empty here,
-  // as we don't need to fetch the contents of a directory when we just need
-  // to get an entry of the directory.
-  change_list_loader_->LoadIfNeeded(
-      DirectoryFetchInfo(),
+  // If the information about the path is not in the local ResourceMetadata,
+  // try fetching information of the directory and retry.
+  LoadDirectoryIfNeeded(
+      file_path.DirName(),
       base::Bind(&FileSystem::GetEntryInfoByPathAfterLoad,
                  weak_ptr_factory_.GetWeakPtr(),
                  file_path,
                  callback));
 }
 
 void FileSystem::GetEntryInfoByPathAfterLoad(
     const base::FilePath& file_path,
     const GetEntryInfoCallback& callback,
     FileError error) {
@@ skipping 27 matching lines @@
 
   CheckLocalModificationAndRun(entry_proto.Pass(), callback);
 }
 
 void FileSystem::ReadDirectoryByPath(
     const base::FilePath& directory_path,
     const ReadDirectoryWithSettingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  LoadDirectoryIfNeeded(
+      directory_path,
+      base::Bind(&FileSystem::ReadDirectoryByPathAfterLoad,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 directory_path,
+                 callback));
+}
+
+void FileSystem::LoadDirectoryIfNeeded(const base::FilePath& directory_path,
+                                       const FileOperationCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
   // As described in GetEntryInfoByPath(), ResourceMetadata may know
   // about the entry even if the file system is not yet fully loaded, hence we
   // should just ask ResourceMetadata first.
   resource_metadata_->GetEntryInfoByPath(
       directory_path,
-      base::Bind(&FileSystem::ReadDirectoryByPathAfterGetEntry,
+      base::Bind(&FileSystem::LoadDirectoryIfNeededAfterGetEntry,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_path,
                  callback));
 }
 
-void FileSystem::ReadDirectoryByPathAfterGetEntry(
+void FileSystem::LoadDirectoryIfNeededAfterGetEntry(
     const base::FilePath& directory_path,
-    const ReadDirectoryWithSettingCallback& callback,
+    const FileOperationCallback& callback,
     FileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
-    // If we don't know about the directory, start loading.
-    change_list_loader_->LoadIfNeeded(
-        DirectoryFetchInfo(),
-        base::Bind(&FileSystem::ReadDirectoryByPathAfterLoad,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   directory_path,
-                   callback));
+    // If we don't know about the directory, start loading full feed.

[satorux1, 2013/05/02 04:42:38]

full feed -> full resource list.

[kinaba, 2013/05/02 11:32:11]

Done.

+    change_list_loader_->LoadIfNeeded(DirectoryFetchInfo(), callback);
     return;
   }
 
   if (!entry_proto->file_info().is_directory()) {
-    callback.Run(FILE_ERROR_NOT_A_DIRECTORY,
-                 hide_hosted_docs_,
-                 scoped_ptr<DriveEntryProtoVector>());
+    callback.Run(FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   // Pass the directory fetch info so we can fetch the contents of the
   // directory before loading change lists.
   DirectoryFetchInfo directory_fetch_info(
       entry_proto->resource_id(),
       entry_proto->directory_specific_info().changestamp());
-  change_list_loader_->LoadIfNeeded(
-      directory_fetch_info,
-      base::Bind(&FileSystem::ReadDirectoryByPathAfterLoad,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 directory_path,
-                 callback));
+  change_list_loader_->LoadIfNeeded(directory_fetch_info, callback);
 }
 
 void FileSystem::ReadDirectoryByPathAfterLoad(
     const base::FilePath& directory_path,
     const ReadDirectoryWithSettingCallback& callback,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
@@ skipping 1015 matching lines @@
   util::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(FILE_ERROR_OK, entry_proto.Pass());
 }
 
 void FileSystem::CancelJobInScheduler(JobID id) {
   scheduler_->CancelJob(id);
 }
 
 }  // namespace drive