GDataFileSystem is no longer a friend of GDataDirectory.

chrome/browser/chromeos/gdata/gdata_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/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 484 matching lines @@
                         const FileOperationCallback& in_callback)
       : local_file_path(in_local_file_path),
         remote_file_path(in_remote_file_path),
         callback(in_callback) {}
 
   const FilePath local_file_path;
   const FilePath remote_file_path;
   const FileOperationCallback callback;
 };
 
+// GDataFileSystem::AddUploadedFileParams implementation.
+struct GDataFileSystem::AddUploadedFileParams {
+  AddUploadedFileParams(UploadMode upload_mode,
+                        GDataDirectory* parent_dir,
+                        scoped_ptr<GDataEntry> new_entry,
+                        const FilePath& file_content_path,
+                        GDataCache::FileOperationType cache_operation,
+                        const base::Closure& callback)
+  : upload_mode(upload_mode),
+    parent_dir(parent_dir),
+    new_entry(new_entry.Pass()),
+    file_content_path(file_content_path),
+    cache_operation(cache_operation),
+    callback(callback) {
+  }
+
+  UploadMode upload_mode;
+  GDataDirectory* parent_dir;
+  scoped_ptr<GDataEntry> new_entry;
+  FilePath file_content_path;
+  GDataCache::FileOperationType cache_operation;
+  base::Closure callback;
+  std::string resource_id;
+  std::string md5;
+};
+
+
 // GDataFileSystem class implementation.
 
 GDataFileSystem::GDataFileSystem(
     Profile* profile,
     GDataCache* cache,
     DocumentsServiceInterface* documents_service,
     GDataUploaderInterface* uploader,
     DriveWebAppsRegistryInterface* webapps_registry,
     base::SequencedTaskRunner* blocking_task_runner)
     : profile_(profile),
@@ skipping 695 matching lines @@
 
   // Otherwise, the move operation involves three steps:
   // 1. Renames the file at |src_file_path| to basename(|dest_file_path|)
   //    within the same directory. The rename operation is a no-op if
   //    basename(|src_file_path|) equals to basename(|dest_file_path|).
   // 2. Removes the file from its parent directory (the file is not deleted),
   //    which effectively moves the file to the root directory.
   // 3. Adds the file to the parent directory of |dest_file_path|, which
   //    effectively moves the file from the root directory to the parent
   //    directory of |dest_file_path|.
-  FileMoveCallback add_file_to_directory_callback =
+  const FileMoveCallback add_file_to_directory_callback =
       base::Bind(&GDataFileSystem::MoveEntryFromRootDirectory,
                  ui_weak_ptr_,
                  dest_file_path.DirName(),
                  callback);
 
-  FileMoveCallback remove_file_from_directory_callback =
+  const FileMoveCallback remove_file_from_directory_callback =
       base::Bind(&GDataFileSystem::RemoveEntryFromNonRootDirectory,
                  ui_weak_ptr_,
                  add_file_to_directory_callback);
 
   Rename(src_file_path, dest_file_path.BaseName().value(),
          remove_file_from_directory_callback);
 }
 
 void GDataFileSystem::MoveEntryFromRootDirectory(
     const FilePath& dir_path,
@@ skipping 799 matching lines @@
       *params->feed_list,
       &file_map,
       &unused_delta_feed_changestamp,
       &unused_uma_stats);
   if (error != GDATA_FILE_OK) {
     LOG(ERROR) << "Failed to convert feed: " << directory_path.value()
                << ": " << error;
     return;
   }
 
-  directory_service_->GetEntryByResourceIdAsync(params->directory_resource_id,
-      base::Bind(&GDataFileSystem::RequestDirectoryRefreshByEntry,
-                 ui_weak_ptr_,
-                 directory_path,
-                 params->directory_resource_id,
-                 file_map));
-}
-
-void GDataFileSystem::RequestDirectoryRefreshByEntry(
-    const FilePath& directory_path,
-    const std::string& directory_resource_id,
-    const FileResourceIdMap& file_map,
-    GDataEntry* directory_entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!directory_entry || !directory_entry->AsGDataDirectory()) {
-    LOG(ERROR) << "Directory entry is gone: " << directory_path.value()
-               << ": " << directory_resource_id;
-    return;
-  }
-  GDataDirectory* directory = directory_entry->AsGDataDirectory();
-
-  // Remove the existing files.
-  directory->RemoveChildFiles();
-  // Go through all entries generated by the feed and add files.
-  for (FileResourceIdMap::const_iterator it = file_map.begin();
-       it != file_map.end(); ++it) {
-    scoped_ptr<GDataEntry> entry(it->second);
-    // Skip if it's not a file (i.e. directory).
-    if (!entry->AsGDataFile())
-      continue;
-    directory->AddEntry(entry.release());
-  }
-
-  // Note that there may be no change in the directory, but it's expensive to
-  // check if the new metadata matches the existing one, so we just always
-  // notify that the directory is changed.
-  OnDirectoryChanged(directory_path);
-  DVLOG(1) << "Directory refreshed: " << directory_path.value();
+  directory_service_->RefreshDirectory(
+      params->directory_resource_id,
+      file_map,
+      base::Bind(&GDataFileSystem::OnDirectoryChangeFileMoveCallback,
+                 ui_weak_ptr_));
 }
 
 void GDataFileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::UpdateFileByResourceIdOnUIThread,
                  ui_weak_ptr_,
@@ skipping 440 matching lines @@
 
   GDataEntry* entry = directory_service_->FromDocumentEntry(doc_entry.get());
   if (!entry) {
     callback.Run(GDATA_FILE_ERROR_FAILED);
     return;
   }
 
   // |entry| was added in the root directory on the server, so we should
   // first add it to |root_| to mirror the state and then move it to the
   // destination directory by MoveEntryFromRootDirectory().
-  directory_service_->root()->AddEntry(entry);
-  MoveEntryFromRootDirectory(dir_path,
-                             callback,
-                             GDATA_FILE_OK,
-                             entry->GetFilePath());
+  directory_service_->AddEntryToDirectory(
+      directory_service_->root(),
+      entry,
+      base::Bind(&GDataFileSystem::MoveEntryFromRootDirectory,
+                 ui_weak_ptr_,
+                 dir_path,
+                 callback));
 }
 
 void GDataFileSystem::OnMoveEntryFromRootDirectoryCompleted(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   GDataFileError error = util::GDataToGDataFileError(status);
   if (error == GDATA_FILE_OK) {
     GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
     if (entry) {
       DCHECK_EQ(directory_service_->root(), entry->parent());
-      directory_service_->MoveEntryToDirectory(dir_path, entry,
+      directory_service_->MoveEntryToDirectory(
+          dir_path,
+          entry,
           base::Bind(
               &GDataFileSystem::NotifyAndRunFileOperationCallback,
               ui_weak_ptr_,
               callback));
       return;
     } else {
       error = GDATA_FILE_ERROR_NOT_FOUND;
     }
   }
 
@@ skipping 189 matching lines @@
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::NotifyAndRunFileMoveCallback(
     const FileMoveCallback& callback,
     GDataFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
 
   if (error == GDATA_FILE_OK)
     OnDirectoryChanged(moved_file_path.DirName());
 
+  if (!callback.is_null())
   callback.Run(error, moved_file_path);
 }
 
 void GDataFileSystem::NotifyAndRunFileOperationCallback(
     const FileOperationCallback& callback,
     GDataFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error == GDATA_FILE_OK)
     OnDirectoryChanged(moved_file_path.DirName());
 
   callback.Run(error);
 }
 
+void GDataFileSystem::OnDirectoryChangeFileMoveCallback(
+    GDataFileError error,
+    const FilePath& directory_path) {
+  if (error == GDATA_FILE_OK)
+    OnDirectoryChanged(directory_path);
+}
+
 GDataFileError GDataFileSystem::RemoveEntryAndCacheLocally(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string resource_id;
   GDataFileError error = RemoveEntryLocally(file_path, &resource_id);
   if (error != GDATA_FILE_OK)
     return error;
 
   // If resource_id is not empty, remove its corresponding file from cache.
   if (!resource_id.empty())
     cache_->RemoveOnUIThread(resource_id, CacheOperationCallback());
 
   return GDATA_FILE_OK;
 }
 
-// static
-void GDataFileSystem::RemoveStaleEntryOnUpload(const std::string& resource_id,
-                                               GDataDirectory* parent_dir,
-                                               GDataEntry* existing_entry) {
+void GDataFileSystem::RemoveStaleEntryOnUpload(
+    const std::string& resource_id,
+    GDataDirectory* parent_dir,
+    const FileMoveCallback& callback,
+    GDataEntry* existing_entry) {
   if (existing_entry &&
       // This should always match, but just in case.
       existing_entry->parent() == parent_dir) {
-    parent_dir->RemoveEntry(existing_entry);
+    directory_service_->RemoveEntryFromParent(existing_entry, callback);
   } else {
+    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
     LOG(ERROR) << "Entry for the existing file not found: " << resource_id;
   }
 }
 
 void GDataFileSystem::NotifyFileSystemMounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "File System is mounted";
   // Notify the observers that the file system is mounted.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
@@ skipping 47 matching lines @@
   // file with the exact same name.
   GDataDirectory* parent_dir = entry->AsGDataDirectory();
   if (!parent_dir)
     return GDATA_FILE_ERROR_FAILED;
 
   GDataEntry* new_entry =
       directory_service_->FromDocumentEntry(doc_entry.get());
   if (!new_entry)
     return GDATA_FILE_ERROR_FAILED;
 
-  parent_dir->AddEntry(new_entry);
-
-  OnDirectoryChanged(directory_path);
+  directory_service_->AddEntryToDirectory(
+      parent_dir,
+      new_entry,
+      base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
+                 ui_weak_ptr_,
+                 FileMoveCallback()));
   return GDATA_FILE_OK;
 }
 
 GDataFileSystem::FindMissingDirectoryResult
 GDataFileSystem::FindFirstMissingParentDirectory(
     const FilePath& directory_path,
     GURL* last_dir_content_url,
     FilePath* first_missing_parent_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 37 matching lines @@
 
   // You can't remove root element.
   if (!entry->parent())
     return GDATA_FILE_ERROR_ACCESS_DENIED;
 
   // If it's a file (only files have resource id), get its resource id so that
   // we can remove it after releasing the auto lock.
   if (entry->AsGDataFile())
     *resource_id = entry->AsGDataFile()->resource_id();
 
-  GDataDirectory* parent_dir = entry->parent();
-  parent_dir->RemoveEntry(entry);
-
-  OnDirectoryChanged(parent_dir->GetFilePath());
+  directory_service_->RemoveEntryFromParent(
+      entry,
+      base::Bind(&GDataFileSystem::OnDirectoryChangeFileMoveCallback,
+                 ui_weak_ptr_));
   return GDATA_FILE_OK;
 }
 
 void GDataFileSystem::AddUploadedFile(
     UploadMode upload_mode,
     const FilePath& virtual_dir_path,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
     GDataCache::FileOperationType cache_operation,
     const base::Closure& callback) {
@@ skipping 38 matching lines @@
 
   GDataDirectory* parent_dir  = dir_entry->AsGDataDirectory();
   if (!parent_dir)
     return;
 
   scoped_ptr<GDataEntry> new_entry(
       directory_service_->FromDocumentEntry(entry.get()));
   if (!new_entry.get())
     return;
 
+  const std::string& resource_id = new_entry->resource_id();
+  AddUploadedFileParams* params =
+      new AddUploadedFileParams(upload_mode,
+                                parent_dir,
+                                new_entry.Pass(),
+                                file_content_path,
+                                cache_operation,
+                                callback_runner.Release());
+
+  const FileMoveCallback file_move_callback =
+      base::Bind(&GDataFileSystem::ContinueAddUploadedFile,
+                 ui_weak_ptr_, params);
+
   if (upload_mode == UPLOAD_EXISTING_FILE) {
     // Remove an existing entry, which should be present.
-    const std::string& resource_id = new_entry->resource_id();
-    directory_service_->GetEntryByResourceIdAsync(resource_id,
-        base::Bind(&RemoveStaleEntryOnUpload, resource_id, parent_dir));
-  }
-
-  GDataFile* file = new_entry->AsGDataFile();
-  DCHECK(file);
-  const std::string& resource_id = file->resource_id();
-  const std::string& md5 = file->file_md5();
-  parent_dir->AddEntry(new_entry.release());
-
-  OnDirectoryChanged(virtual_dir_path);
-
-  if (upload_mode == UPLOAD_NEW_FILE) {
-    // Add the file to the cache if we have uploaded a new file.
-    cache_->StoreOnUIThread(resource_id,
-                            md5,
-                            file_content_path,
-                            cache_operation,
-                            base::Bind(&OnCacheUpdatedForAddUploadedFile,
-                                       callback_runner.Release()));
-  } else if (upload_mode == UPLOAD_EXISTING_FILE) {
-    // Clear the dirty bit if we have updated an existing file.
-    cache_->ClearDirtyOnUIThread(resource_id,
-                                 md5,
-                                 base::Bind(&OnCacheUpdatedForAddUploadedFile,
-                                            callback_runner.Release()));
+    directory_service_->GetEntryByResourceIdAsync(
+        resource_id,
+        base::Bind(&GDataFileSystem::RemoveStaleEntryOnUpload,
+                   ui_weak_ptr_,
+                   resource_id,
+                   parent_dir,
+                   file_move_callback));
   } else {
-    NOTREACHED() << "Unexpected upload mode: " << upload_mode;
+    file_move_callback.Run(GDATA_FILE_OK, FilePath());
   }
 }
 
+void GDataFileSystem::ContinueAddUploadedFile(
+    AddUploadedFileParams* params,
+    GDataFileError error,
+    const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_EQ(GDATA_FILE_OK, error);
+  DCHECK(params->new_entry.get());
+  GDataFile* file = params->new_entry->AsGDataFile();
+  DCHECK(file);
+
+  params->resource_id = file->resource_id();
+  params->md5 = file->file_md5();
+  directory_service_->AddEntryToDirectory(
+      params->parent_dir,
+      params->new_entry.release(),
+      base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
+                 ui_weak_ptr_,
+                 base::Bind(&GDataFileSystem::AddUploadedFileToCache,
+                            ui_weak_ptr_,
+                            base::Owned(params))));
+}
+
+void GDataFileSystem::AddUploadedFileToCache(
+    AddUploadedFileParams* params,
+    GDataFileError error,
+    const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (params->upload_mode == UPLOAD_NEW_FILE) {
+    // Add the file to the cache if we have uploaded a new file.
+    cache_->StoreOnUIThread(params->resource_id,
+                            params->md5,
+                            params->file_content_path,
+                            params->cache_operation,
+                            base::Bind(&OnCacheUpdatedForAddUploadedFile,
+                                       params->callback));
+  } else if (params->upload_mode == UPLOAD_EXISTING_FILE) {
+    // Clear the dirty bit if we have updated an existing file.
+    cache_->ClearDirtyOnUIThread(params->resource_id,
+                                 params->md5,
+                                 base::Bind(&OnCacheUpdatedForAddUploadedFile,
+                                            params->callback));
+  } else {
+    NOTREACHED() << "Unexpected upload mode: " << params->upload_mode;
+  }
+  params->callback.Run();
+}
+
 void GDataFileSystem::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     PrefService* pref_service = profile_->GetPrefs();
     std::string* pref_name = content::Details<std::string>(details).ptr();
     if (*pref_name == prefs::kDisableGDataHostedFiles) {
       SetHideHostedDocuments(
@@ skipping 351 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata