drive: Enable recursive fast-fetch.

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/message_loop_proxy.h"
 #include "base/platform_file.h"
@@ skipping 39 matching lines @@
 namespace {
 
 // Gets a ResourceEntry from the metadata, and overwrites its file info when the
 // cached file is dirty.
 FileError GetLocallyStoredResourceEntry(
     internal::ResourceMetadata* resource_metadata,
     internal::FileCache* cache,
     const base::FilePath& file_path,
     ResourceEntry* entry) {
   std::string local_id;
-  FileError error =
-      resource_metadata->GetIdByPath(file_path, &local_id);
+  FileError error = resource_metadata->GetIdByPath(file_path, &local_id);
   if (error != FILE_ERROR_OK)
     return error;
 
   error = resource_metadata->GetResourceEntryById(local_id, entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   // For entries that will never be cached, use the original resource entry
   // as is.
   if (!entry->has_file_specific_info() ||
@@ skipping 568 matching lines @@
 }
 
 void FileSystem::GetResourceEntryByPathAfterGetEntry(
     const base::FilePath& file_path,
     const GetResourceEntryCallback& callback,
     scoped_ptr<ResourceEntry> entry,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error == FILE_ERROR_OK) {
-    callback.Run(error, entry.Pass());
-    return;
+  if (error == FILE_ERROR_NOT_FOUND) {
+    // If the information about the path is not in the local ResourceMetadata,
+    // try fetching information of the directory and retry.
+    //
+    // Note: this forms mutual recursion between GetResourceEntryByPath and
+    // LoadDirectoryIfNeeded, because directory loading requires the existence
+    // of directory entry itself. The recursion terminates because we always go
+    // up the hierarchy by .DirName() bounded under the Drive root path.
+    if (util::GetDriveGrandRootPath().IsParent(file_path)) {
+      LoadDirectoryIfNeeded(
+          file_path.DirName(),
+          base::Bind(&FileSystem::GetResourceEntryByPathAfterLoad,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     file_path,
+                     callback));
+      return;
+    }
   }
 
-  // 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::GetResourceEntryByPathAfterLoad,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 file_path,
-                 callback));
+  callback.Run(error, entry.Pass());
 }
 
 void FileSystem::GetResourceEntryByPathAfterLoad(
     const base::FilePath& file_path,
     const GetResourceEntryCallback& callback,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
@@ skipping 28 matching lines @@
                  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());
 
-  // ResourceMetadata may know about the entry even if the resource
-  // metadata is not yet fully loaded.
-  resource_metadata_->GetResourceEntryByPathOnUIThread(
+  GetResourceEntryByPath(
       directory_path,
       base::Bind(&FileSystem::LoadDirectoryIfNeededAfterGetEntry,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_path,
                  callback));
 }
 
 void FileSystem::LoadDirectoryIfNeededAfterGetEntry(
     const base::FilePath& directory_path,
     const FileOperationCallback& callback,
     FileError error,
     scoped_ptr<ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != FILE_ERROR_OK ||
-      entry->resource_id() == util::kDriveOtherDirSpecialResourceId) {
-    // If we don't know about the directory, or it is the "drive/other"
-    // directory that has to gather all orphan entries, start loading full
-    // resource list.
-    change_list_loader_->LoadIfNeeded(internal::DirectoryFetchInfo(), callback);
+  if (error != FILE_ERROR_OK) {
+    callback.Run(error);
     return;
   }
 
   if (!entry->file_info().is_directory()) {
     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.
@@ skipping 344 matching lines @@
   if (util::IsSpecialResourceId(id))
     return;
 
   util::Log(logging::LOG_INFO,
             "Thumbnail refresh for %s", directory_path.AsUTF8Unsafe().c_str());
   change_list_loader_->LoadDirectoryFromServer(
       id, base::Bind(&util::EmptyFileOperationCallback));
 }
 
 }  // namespace drive