gdata: Get rid of callback from GDataDirectoryService::FindEntryByPath()

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 553 matching lines @@
 };
 
 // Returns callback which runs the given |callback| on the current thread.
 template<typename CallbackType>
 CallbackType CreateRelayCallback(const CallbackType& callback) {
   return base::Bind(&RelayCallback<CallbackType>::Run,
                     base::MessageLoopProxy::current(),
                     callback);
 }
 
-// Callback used to find a directory element for file system updates.
-void ReadOnlyFindEntryCallback(GDataEntry** out,
-                               GDataFileError error,
-                               GDataEntry* entry) {
-  if (error == GDATA_FILE_OK)
-    *out = entry;
-}
-
 // Wrapper around BrowserThread::PostTask to post a task to the blocking
 // pool with the given sequence token.
 void PostBlockingPoolSequencedTask(
     const tracked_objects::Location& from_here,
     base::SequencedTaskRunner* blocking_task_runner,
     const base::Closure& task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const bool posted = blocking_task_runner->PostTask(from_here, task);
   DCHECK(posted);
@@ skipping 375 matching lines @@
                  ui_weak_ptr_,
                  search_file_path,
                  callback));
 }
 
 void GDataFileSystem::FindEntryByPathSyncOnUIThread(
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  directory_service_->FindEntryByPath(search_file_path, callback);
+  GDataEntry* entry = directory_service_->FindEntryByPathSync(
+      search_file_path);
+  if (entry)

[achuithb, 2012/07/30 21:54:40]

Alternatively, you could do:
callback.Run(entry ? GDATA_FILE_OK : GDATA_FILE_ERROR_NOT_FOUND, entry);
or you could pull error out if you think that's too cryptic:
const GDataErrorCode error = entry ? GDATA_FILE_OK : GDATA_FILE_ERROR_NOT_FOUND;
callback.Run(error, entry);

[satorux1, 2012/07/30 22:10:40]

Done.

+    callback.Run(GDATA_FILE_OK, entry);
+  else
+    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, entry);
 }
 
 void GDataFileSystem::ReloadFeedFromServerIfNeeded(
     ContentOrigin initial_origin,
     int local_changestamp,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // First fetch the latest changestamp to see if there were any new changes
@@ skipping 392 matching lines @@
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = GDATA_FILE_OK;
   FilePath dest_parent_path = dest_file_path.DirName();
 
   std::string src_file_resource_id;
   bool src_file_is_hosted_document = false;
 
-  GDataEntry* src_entry = GetGDataEntryByPath(src_file_path);
-  GDataEntry* dest_parent = GetGDataEntryByPath(dest_parent_path);
+  GDataEntry* src_entry = directory_service_->FindEntryByPathSync(
+      src_file_path);
+  GDataEntry* dest_parent = directory_service_->FindEntryByPathSync(
+      dest_parent_path);
   if (!src_entry || !dest_parent) {
     error = GDATA_FILE_ERROR_NOT_FOUND;
   } else if (!dest_parent->AsGDataDirectory()) {
     error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
   } else if (!src_entry->AsGDataFile()) {
     // TODO(benchan): Implement copy for directories. In the interim,
     // we handle recursive directory copy in the file manager.
     error = GDATA_FILE_ERROR_INVALID_OPERATION;
   } else {
     src_file_resource_id = src_entry->resource_id();
@@ skipping 184 matching lines @@
 }
 
 void GDataFileSystem::MoveOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = GDATA_FILE_OK;
   FilePath dest_parent_path = dest_file_path.DirName();
 
-  GDataEntry* src_entry = GetGDataEntryByPath(src_file_path);
-  GDataEntry* dest_parent = GetGDataEntryByPath(dest_parent_path);
+  GDataEntry* src_entry = directory_service_->FindEntryByPathSync(
+      src_file_path);
+  GDataEntry* dest_parent = directory_service_->FindEntryByPathSync(
+      dest_parent_path);
   if (!src_entry || !dest_parent) {
     error = GDATA_FILE_ERROR_NOT_FOUND;
   } else if (!dest_parent->AsGDataDirectory()) {
     error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
   }
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(FROM_HERE,
                                        base::Bind(callback, error));
@@ skipping 38 matching lines @@
          remove_file_from_directory_callback);
 }
 
 void GDataFileSystem::AddEntryToDirectory(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataEntry* entry = GetGDataEntryByPath(file_path);
-  GDataEntry* dir_entry = GetGDataEntryByPath(dir_path);
+  GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
+  GDataEntry* dir_entry = directory_service_->FindEntryByPathSync(dir_path);
   if (error == GDATA_FILE_OK) {
     if (!entry || !dir_entry) {
       error = GDATA_FILE_ERROR_NOT_FOUND;
     } else {
       if (!dir_entry->AsGDataDirectory())
         error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
     }
   }
 
   // Returns if there is an error or |dir_path| is the root directory.
@@ skipping 15 matching lines @@
                  dir_path));
 }
 
 void GDataFileSystem::RemoveEntryFromDirectory(
     const FilePath& dir_path,
     const FilePathUpdateCallback& callback,
     GDataFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataEntry* entry = GetGDataEntryByPath(file_path);
-  GDataEntry* dir = GetGDataEntryByPath(dir_path);
+  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.
@@ skipping 746 matching lines @@
     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.
   NotifyDirectoryChanged(directory_path);
   DVLOG(1) << "Directory refreshed: " << directory_path.value();
 }
 
-GDataEntry* GDataFileSystem::GetGDataEntryByPath(
-    const FilePath& file_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // Find directory element within the cached file system snapshot.
-  GDataEntry* entry = NULL;
-  directory_service_->FindEntryByPath(file_path,
-      base::Bind(&ReadOnlyFindEntryCallback, &entry));
-  return entry;
-}
-
 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_,
                  resource_id,
                  CreateRelayCallback(callback)));
@@ skipping 592 matching lines @@
 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 = GDataToGDataFileError(status);
   if (error == GDATA_FILE_OK) {
-    GDataEntry* entry = GetGDataEntryByPath(file_path);
+    GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
     if (entry) {
       DCHECK_EQ(directory_service_->root(), entry->parent());
       error = AddEntryToDirectoryOnFilesystem(entry, dir_path);
     } else {
       error = GDATA_FILE_ERROR_NOT_FOUND;
     }
   }
 
   if (!callback.is_null())
     callback.Run(error);
@@ skipping 140 matching lines @@
   // Nothing much to do here for now.
 }
 
 GDataFileError GDataFileSystem::RenameFileOnFilesystem(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     FilePath* updated_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(updated_file_path);
 
-  GDataEntry* entry = GetGDataEntryByPath(file_path);
+  GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
   if (!entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   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.
   // 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();
 
   NotifyDirectoryChanged(updated_file_path->DirName());
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::AddEntryToDirectoryOnFilesystem(
     GDataEntry* entry, const FilePath& dir_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry);
 
-  GDataEntry* dir_entry = GetGDataEntryByPath(dir_path);
+  GDataEntry* dir_entry = directory_service_->FindEntryByPathSync(dir_path);
   if (!dir_entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   GDataDirectory* dir = dir_entry->AsGDataDirectory();
   if (!dir)
     return GDATA_FILE_ERROR_NOT_A_DIRECTORY;
 
   if (!dir->TakeEntry(entry))
     return GDATA_FILE_ERROR_FAILED;
 
   NotifyDirectoryChanged(dir_path);
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::RemoveEntryFromDirectoryOnFilesystem(
     const FilePath& file_path, const FilePath& dir_path,
     FilePath* updated_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(updated_file_path);
 
-  GDataEntry* entry = GetGDataEntryByPath(file_path);
+  GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
   if (!entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
-  GDataEntry* dir = GetGDataEntryByPath(dir_path);
+  GDataEntry* dir = directory_service_->FindEntryByPathSync(dir_path);
   if (!dir)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   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;
@@ skipping 328 matching lines @@
 
   if (!entry_value)
     return GDATA_FILE_ERROR_FAILED;
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::CreateFrom(*entry_value));
 
   if (!doc_entry.get())
     return GDATA_FILE_ERROR_FAILED;
 
   // Find parent directory element within the cached file system snapshot.
-  GDataEntry* entry = GetGDataEntryByPath(directory_path);
+  GDataEntry* entry = directory_service_->FindEntryByPathSync(directory_path);
   if (!entry)
     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;
 
@@ skipping 18 matching lines @@
   // Let's find which how deep is the existing directory structure and
   // get the first element that's missing.
   std::vector<FilePath::StringType> path_parts;
   directory_path.GetComponents(&path_parts);
   FilePath current_path;
 
   for (std::vector<FilePath::StringType>::const_iterator iter =
           path_parts.begin();
        iter != path_parts.end(); ++iter) {
     current_path = current_path.Append(*iter);
-    GDataEntry* entry = GetGDataEntryByPath(current_path);
+    GDataEntry* entry = directory_service_->FindEntryByPathSync(current_path);
     if (entry) {
       if (entry->file_info().is_directory) {
         *last_dir_content_url = entry->content_url();
       } else {
         // Huh, the segment found is a file not a directory?
         return FOUND_INVALID;
       }
     } else {
       *first_missing_parent_path = current_path;
       return FOUND_MISSING;
     }
   }
   return DIRECTORY_ALREADY_PRESENT;
 }
 
 GDataFileError GDataFileSystem::RemoveEntryFromGData(
     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 = GetGDataEntryByPath(file_path);
+  GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
 
   if (!entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   // 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.
@@ skipping 40 matching lines @@
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (!entry.get()) {
     NOTREACHED();
     callback.Run();
     return;
   }
 
-  GDataEntry* dir_entry = GetGDataEntryByPath(virtual_dir_path);
+  GDataEntry* dir_entry = directory_service_->FindEntryByPathSync(
+      virtual_dir_path);
   if (!dir_entry) {
     callback.Run();
     return;
   }
 
   GDataDirectory* parent_dir  = dir_entry->AsGDataDirectory();
   if (!parent_dir) {
     callback.Run();
     return;
   }
@@ skipping 499 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