Replace GDataDirectory::TakeEntry with GDataDirectoryService::AddEntryToDirectory.

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 1049 matching lines @@
 
   documents_service_->CopyDocument(resource_id, new_name,
       base::Bind(&GDataFileSystem::OnCopyDocumentCompleted,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
 void GDataFileSystem::Rename(const FilePath& file_path,
                              const FilePath::StringType& new_name,
-                             const FilePathUpdateCallback& callback) {
+                             const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // It is a no-op if the file is renamed to the same name.
   if (file_path.BaseName().value() == new_name) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(callback, GDATA_FILE_OK, file_path));
     }
     return;
   }
 
   // Get the edit URL of an entry at |file_path|.
   directory_service_->GetEntryInfoByPath(
       file_path,
       base::Bind(
           &GDataFileSystem::RenameAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path,
           new_name,
           callback));
 }
 
 void GDataFileSystem::RenameAfterGetEntryInfo(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
-    const FilePathUpdateCallback& callback,
+    const FileMoveCallback& callback,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, file_path);
     return;
   }
   DCHECK(entry_proto.get());
 
   // Drop the .g<something> extension from |new_name| if the file being
   // renamed is a hosted document and |new_name| has the same .g<something>
   // extension as the file.
   FilePath::StringType file_name = new_name;
   if (entry_proto->has_file_specific_info() &&
       entry_proto->file_specific_info().is_hosted_document()) {
     FilePath new_file(file_name);
     if (new_file.Extension() ==
         entry_proto->file_specific_info().document_extension()) {
       file_name = new_file.RemoveExtension().value();
     }
   }
 
   documents_service_->RenameResource(
       GURL(entry_proto->edit_url()),
       file_name,
-      base::Bind(&GDataFileSystem::OnRenameResourceCompleted,
+      base::Bind(&GDataFileSystem::RenameFileOnFileSystem,
                  ui_weak_ptr_,
                  file_path,
                  file_name,
                  callback));
 }
 
 void GDataFileSystem::Move(const FilePath& src_file_path,
                            const FilePath& dest_file_path,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
@@ skipping 26 matching lines @@
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(FROM_HERE,
                                        base::Bind(callback, error));
     }
     return;
   }
 
   // If the file/directory is moved to the same directory, just rename it.
   if (src_file_path.DirName() == dest_parent_path) {
-    FilePathUpdateCallback final_file_path_update_callback =
+    FileMoveCallback final_file_path_update_callback =
         base::Bind(&GDataFileSystem::OnFilePathUpdated,
                    ui_weak_ptr_,
                    callback);
 
     Rename(src_file_path, dest_file_path.BaseName().value(),
            final_file_path_update_callback);
     return;
   }
 
   // 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|.
-  FilePathUpdateCallback add_file_to_directory_callback =
+  FileMoveCallback add_file_to_directory_callback =
       base::Bind(&GDataFileSystem::AddEntryToDirectory,
                  ui_weak_ptr_,
                  dest_file_path.DirName(),
                  callback);
 
-  FilePathUpdateCallback remove_file_from_directory_callback =
+  FileMoveCallback remove_file_from_directory_callback =
       base::Bind(&GDataFileSystem::RemoveEntryFromDirectory,
                  ui_weak_ptr_,
                  src_file_path.DirName(),
                  add_file_to_directory_callback);
 
   Rename(src_file_path, dest_file_path.BaseName().value(),
          remove_file_from_directory_callback);
 }
 
 void GDataFileSystem::AddEntryToDirectory(
@@ skipping 28 matching lines @@
       entry->edit_url(),
       base::Bind(&GDataFileSystem::OnAddEntryToDirectoryCompleted,
                  ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
 void GDataFileSystem::RemoveEntryFromDirectory(
     const FilePath& dir_path,
-    const FilePathUpdateCallback& callback,
+    const FileMoveCallback& callback,
     GDataFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
   GDataEntry* dir = directory_service_->FindEntryByPathSync(dir_path);
   if (error == GDATA_FILE_OK) {
     if (!entry || !dir) {
       error = GDATA_FILE_ERROR_NOT_FOUND;
     } else {
       if (!dir->AsGDataDirectory())
         error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
     }
   }
 
   // Returns if there is an error or |dir_path| is the root directory.
   if (error != GDATA_FILE_OK ||
       dir->resource_id() == kGDataRootDirectoryResourceId) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(callback, error, file_path));
     }
     return;
   }
 
   documents_service_->RemoveResourceFromDirectory(
       dir->content_url(),
       entry->edit_url(),
       entry->resource_id(),
-      base::Bind(&GDataFileSystem::OnRemoveEntryFromDirectoryCompleted,
+      base::Bind(&GDataFileSystem::RemoveEntryFromDirectoryOnFileSystem,
                  ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
 void GDataFileSystem::Remove(const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
@@ skipping 710 matching lines @@
     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.
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer,
-                    observers_, OnDirectoryChanged(directory_path));
+  OnDirectoryChanged(directory_path);
   DVLOG(1) << "Directory refreshed: " << directory_path.value();
 }
 
 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,
@@ skipping 370 matching lines @@
     int root_feed_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return feed_loader_->UpdateFromFeed(feed_list,
                                       start_changestamp,
                                       root_feed_changestamp);
 }
 
 void GDataFileSystem::OnFilePathUpdated(const FileOperationCallback& callback,
                                         GDataFileError error,
-                                        const FilePath& file_path) {
+                                        const FilePath& /* file_path */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     callback.Run(error);
 }
 
-void GDataFileSystem::OnRenameResourceCompleted(
-    const FilePath& file_path,
-    const FilePath::StringType& new_name,
-    const FilePathUpdateCallback& callback,
-    GDataErrorCode status,
-    const GURL& document_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  FilePath updated_file_path;
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error == GDATA_FILE_OK)
-    error = RenameFileOnFilesystem(file_path, new_name, &updated_file_path);
-
-  if (!callback.is_null())
-    callback.Run(error, updated_file_path);
-}
-
 void GDataFileSystem::OnCopyDocumentCompleted(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
 
     return;
   }
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
   if (!doc_entry.get()) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_ERROR_FAILED);
 
     return;
   }
 
   GDataEntry* entry = GDataEntry::FromDocumentEntry(
-      directory_service_->root(), doc_entry.get(), directory_service_.get());
+      NULL, doc_entry.get(), directory_service_.get());
   if (!entry) {
     if (!callback.is_null())
       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 AddEntryToDirectory().
   directory_service_->root()->AddEntry(entry);
   AddEntryToDirectory(dir_path, callback, GDATA_FILE_OK, entry->GetFilePath());
 }
 
 void GDataFileSystem::OnAddEntryToDirectoryCompleted(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   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());
-      error = AddEntryToDirectoryOnFilesystem(entry, dir_path);
+      directory_service_->MoveEntryToDirectory(dir_path, entry,
+          base::Bind(
+              &GDataFileSystem::OnMoveEntryToDirectoryWithFileOperationCallback,
+              ui_weak_ptr_,
+              callback));
+      return;
     } else {
       error = GDATA_FILE_ERROR_NOT_FOUND;
     }
   }
 
   if (!callback.is_null())
     callback.Run(error);
 }
 
-void GDataFileSystem::OnRemoveEntryFromDirectoryCompleted(
-    const FilePathUpdateCallback& callback,
-    const FilePath& file_path,
-    const FilePath& dir_path,
-    GDataErrorCode status,
-    const GURL& document_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  FilePath updated_file_path = file_path;
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error == GDATA_FILE_OK)
-    error = RemoveEntryFromDirectoryOnFilesystem(file_path, dir_path,
-                                                 &updated_file_path);
-
-  if (!callback.is_null())
-    callback.Run(error, updated_file_path);
-}
-
 void GDataFileSystem::OnRemovedDocument(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = util::GDataToGDataFileError(status);
 
   if (error == GDATA_FILE_OK)
@@ skipping 103 matching lines @@
   }
 }
 
 void GDataFileSystem::OnDownloadStoredToCache(GDataFileError error,
                                               const std::string& resource_id,
                                               const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Nothing much to do here for now.
 }
 
-GDataFileError GDataFileSystem::RenameFileOnFilesystem(
+void GDataFileSystem::RenameFileOnFileSystem(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
-    FilePath* updated_file_path) {
+    const FileMoveCallback& callback,
+    GDataErrorCode status,
+    const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(updated_file_path);
+
+  const GDataFileError error = util::GDataToGDataFileError(status);
+  if (error != GDATA_FILE_OK) {
+    if (!callback.is_null())
+      callback.Run(error, FilePath());
+    return;
+  }
 
   GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
-  if (!entry)
-    return GDATA_FILE_ERROR_NOT_FOUND;
+  if (!entry) {
+    if (!callback.is_null())
+      callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
+    return;
+  }
 
   DCHECK(entry->parent());
   entry->set_title(new_name);
-  // After changing the title of the entry, call TakeFile() to remove the
-  // entry from its parent directory and then add it back in order to go
-  // through the file name de-duplication.
+  // After changing the title of the entry, call MoveEntryToDirectory() to
+  // remove the entry from its parent directory and then add it back in order to
+  // go through the file name de-duplication.
   // TODO(achuith/satorux/zel): This code is fragile. The title has been
-  // changed, but not the file_name. TakeEntry removes the child based on the
-  // old file_name, and then re-adds the child by first assigning the new title
-  // to file_name. http://crbug.com/30157
-  if (!entry->parent()->TakeEntry(entry))
-    return GDATA_FILE_ERROR_FAILED;
-
-  *updated_file_path = entry->GetFilePath();
-
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
-                    OnDirectoryChanged(updated_file_path->DirName()));
-  return GDATA_FILE_OK;
+  // changed, but not the file_name. MoveEntryToDirectory calls RemoveChild to
+  // remove the child based on the old file_name, and then re-adds the child by
+  // first assigning the new title to file_name. http://crbug.com/30157
+  directory_service_->MoveEntryToDirectory(
+      entry->parent()->GetFilePath(),
+      entry,
+      base::Bind(&GDataFileSystem::OnMoveEntryToDirectoryWithFileMoveCallback,
+                 ui_weak_ptr_,
+                 callback));
 }
 
-GDataFileError GDataFileSystem::AddEntryToDirectoryOnFilesystem(
-    GDataEntry* entry, const FilePath& dir_path) {
+void GDataFileSystem::RemoveEntryFromDirectoryOnFileSystem(
+    const FileMoveCallback& callback,
+    const FilePath& file_path,
+    const FilePath& dir_path,
+    GDataErrorCode status,
+    const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(entry);
 
-  GDataEntry* dir_entry = directory_service_->FindEntryByPathSync(dir_path);
-  if (!dir_entry)
-    return GDATA_FILE_ERROR_NOT_FOUND;
+  const GDataFileError error = util::GDataToGDataFileError(status);
+  if (error != GDATA_FILE_OK) {
+    if (!callback.is_null())
+      callback.Run(error, FilePath());
+    return;
+  }
 
-  GDataDirectory* dir = dir_entry->AsGDataDirectory();
-  if (!dir)
-    return GDATA_FILE_ERROR_NOT_A_DIRECTORY;
+  GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
+  if (!entry) {
+    if (!callback.is_null())
+      callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
+    return;
+  }
 
-  if (!dir->TakeEntry(entry))
-    return GDATA_FILE_ERROR_FAILED;
-
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
-                    OnDirectoryChanged(dir_path));
-  return GDATA_FILE_OK;
+  directory_service_->MoveEntryToDirectory(
+      directory_service_->root()->GetFilePath(),
+      entry,
+      base::Bind(&GDataFileSystem::OnMoveEntryToDirectoryWithFileMoveCallback,
+                 ui_weak_ptr_,
+                 callback));
 }
 
-GDataFileError GDataFileSystem::RemoveEntryFromDirectoryOnFilesystem(
-    const FilePath& file_path, const FilePath& dir_path,
-    FilePath* updated_file_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(updated_file_path);
+void GDataFileSystem::OnMoveEntryToDirectoryWithFileMoveCallback(
+    const FileMoveCallback& callback,
+    GDataFileError error,
+    const FilePath& moved_file_path) {
+  if (error == GDATA_FILE_OK)
+    OnDirectoryChanged(moved_file_path.DirName());
 
-  GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
-  if (!entry)
-    return GDATA_FILE_ERROR_NOT_FOUND;
+  if (!callback.is_null())
+    callback.Run(error, moved_file_path);
+}
 
-  GDataEntry* dir = directory_service_->FindEntryByPathSync(dir_path);

[satorux1, 2012/08/10 21:04:16]

The two callers of FindEntryByPathSync() were removed. This is nice!

-  if (!dir)
-    return GDATA_FILE_ERROR_NOT_FOUND;
+void GDataFileSystem::OnMoveEntryToDirectoryWithFileOperationCallback(
+    const FileOperationCallback& callback,
+    GDataFileError error,
+    const FilePath& moved_file_path) {
+  if (error == GDATA_FILE_OK)
+    OnDirectoryChanged(moved_file_path.DirName());
 
-  if (!dir->AsGDataDirectory())
-    return GDATA_FILE_ERROR_NOT_A_DIRECTORY;
-
-  DCHECK_EQ(dir->AsGDataDirectory(), entry->parent());
-
-  if (!directory_service_->root()->TakeEntry(entry))
-    return GDATA_FILE_ERROR_FAILED;
-
-  *updated_file_path = entry->GetFilePath();
-
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
-                    OnDirectoryChanged(updated_file_path->DirName()));
-  return GDATA_FILE_OK;
+  if (!callback.is_null())
+    callback.Run(error);
 }
 
 GDataFileError GDataFileSystem::RemoveEntryFromFileSystem(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string resource_id;
   GDataFileError error = RemoveEntryFromGData(file_path, &resource_id);
   if (error != GDATA_FILE_OK)
     return error;
@@ skipping 70 matching lines @@
     return GDATA_FILE_ERROR_FAILED;
 
   // Check if parent is a directory since in theory since this is a callback
   // something could in the meantime have nuked the parent dir and created a
   // file with the exact same name.
   GDataDirectory* parent_dir = entry->AsGDataDirectory();
   if (!parent_dir)
     return GDATA_FILE_ERROR_FAILED;
 
   GDataEntry* new_entry = GDataEntry::FromDocumentEntry(
-      parent_dir, doc_entry.get(), directory_service_.get());
+      NULL, doc_entry.get(), directory_service_.get());
   if (!new_entry)
     return GDATA_FILE_ERROR_FAILED;
 
   parent_dir->AddEntry(new_entry);
 
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
-                    OnDirectoryChanged(directory_path));
+  OnDirectoryChanged(directory_path);
   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 40 matching lines @@
     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);
 
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
-                    OnDirectoryChanged(parent_dir->GetFilePath()));
+  OnDirectoryChanged(parent_dir->GetFilePath());
   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 35 matching lines @@
       virtual_dir_path);
   if (!dir_entry)
     return;
 
   GDataDirectory* parent_dir  = dir_entry->AsGDataDirectory();
   if (!parent_dir)
     return;
 
   scoped_ptr<GDataEntry> new_entry(
       GDataEntry::FromDocumentEntry(
-          parent_dir, entry.get(), directory_service_.get()));
+          NULL, entry.get(), directory_service_.get()));
   if (!new_entry.get())
     return;
 
   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());
 
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
-                    OnDirectoryChanged(virtual_dir_path));
+  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) {
@@ skipping 467 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata