gdata: Fix bad function names in GDataFileSystem

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 1111 matching lines @@
     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::RenameFileOnFileSystem,
+      base::Bind(&GDataFileSystem::RenameEntryLocally,
                  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 67 matching lines @@
   // 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 =
       base::Bind(&GDataFileSystem::MoveEntryFromRootDirectory,
                  ui_weak_ptr_,
                  dest_file_path.DirName(),
                  callback);
 
   FileMoveCallback remove_file_from_directory_callback =
-      base::Bind(&GDataFileSystem::RemoveEntryFromDirectory,
+      base::Bind(&GDataFileSystem::RemoveEntryFromNonRootDirectory,
                  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::MoveEntryFromRootDirectory(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
     GDataFileError error,
@@ skipping 45 matching lines @@
   documents_service_->AddResourceToDirectory(
       GURL(dir_proto->content_url()),
       GURL(src_proto->edit_url()),
       base::Bind(&GDataFileSystem::OnMoveEntryFromRootDirectoryCompleted,
                  ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
-void GDataFileSystem::RemoveEntryFromDirectory(
-    const FilePath& dir_path,
+void GDataFileSystem::RemoveEntryFromNonRootDirectory(
     const FileMoveCallback& callback,
     GDataFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
+  const FilePath dir_path = file_path.DirName();
   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));
-    }
+    callback.Run(error, file_path);
     return;
   }
 
   documents_service_->RemoveResourceFromDirectory(
       dir->content_url(),
       entry->edit_url(),
       entry->resource_id(),
-      base::Bind(&GDataFileSystem::RemoveEntryFromDirectoryOnFileSystem,
+      base::Bind(&GDataFileSystem::MoveEntryToRootDirectoryLocally,
                  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 1193 matching lines @@
   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,
           base::Bind(
-              &GDataFileSystem::OnMoveEntryToDirectoryWithFileOperationCallback,
+              &GDataFileSystem::NotifyAndRunFileOperationCallback,
               ui_weak_ptr_,
               callback));
       return;
     } else {
       error = GDATA_FILE_ERROR_NOT_FOUND;
     }
   }
 
   callback.Run(error);
 }
 
 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)
-    error = RemoveEntryFromFileSystem(file_path);
+    error = RemoveEntryAndCacheLocally(file_path);
 
   if (!callback.is_null()) {
     callback.Run(error);
   }
 }
 
 void GDataFileSystem::OnFileDownloaded(
     const GetFileFromCacheParams& params,
     GDataErrorCode status,
     const GURL& content_url,
@@ skipping 92 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.
 }
 
-void GDataFileSystem::RenameFileOnFileSystem(
+void GDataFileSystem::RenameEntryLocally(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FileMoveCallback& callback,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
@@ skipping 13 matching lines @@
   // 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. 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,
+      base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::RemoveEntryFromDirectoryOnFileSystem(
+void GDataFileSystem::MoveEntryToRootDirectoryLocally(
     const FileMoveCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   const GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
-    if (!callback.is_null())
-      callback.Run(error, FilePath());
+    callback.Run(error, FilePath());
     return;
   }
 
   GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
   if (!entry) {
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
+    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
     return;
   }
 
   directory_service_->MoveEntryToDirectory(
       directory_service_->root()->GetFilePath(),
       entry,
-      base::Bind(&GDataFileSystem::OnMoveEntryToDirectoryWithFileMoveCallback,
+      base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::OnMoveEntryToDirectoryWithFileMoveCallback(
+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);
+  callback.Run(error, moved_file_path);
 }
 
-void GDataFileSystem::OnMoveEntryToDirectoryWithFileOperationCallback(
+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);
 }
 
-GDataFileError GDataFileSystem::RemoveEntryFromFileSystem(
+GDataFileError GDataFileSystem::RemoveEntryAndCacheLocally(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string resource_id;
-  GDataFileError error = RemoveEntryFromGData(file_path, &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;
 }
 
@@ skipping 105 matching lines @@
         return FOUND_INVALID;
       }
     } else {
       *first_missing_parent_path = current_path;
       return FOUND_MISSING;
     }
   }
   return DIRECTORY_ALREADY_PRESENT;
 }
 
-GDataFileError GDataFileSystem::RemoveEntryFromGData(
+GDataFileError GDataFileSystem::RemoveEntryLocally(
     const FilePath& file_path, std::string* resource_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   resource_id->clear();
 
   // Find directory element within the cached file system snapshot.
   GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
 
   if (!entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
@@ skipping 563 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