drive: Change the return type of ResourceMetadata's methods to FileError

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/platform_file.h"
 #include "base/prefs/pref_service.h"
@@ skipping 161 matching lines @@
                               bool success) {
   DCHECK(!callback.is_null());
   callback.Run(success, *cache_entry);
 }
 
 // Callback for ResourceMetadata::GetLargestChangestamp.
 // |callback| must not be null.
 void OnGetLargestChangestamp(
     FileSystemMetadata metadata,  // Will be modified.
     const GetFilesystemMetadataCallback& callback,
-    int64 largest_changestamp) {
+    const int64* largest_changestamp,
+    FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  metadata.largest_changestamp = largest_changestamp;
+  metadata.largest_changestamp = *largest_changestamp;
   callback.Run(metadata);
 }
 
 // Thin adapter to map GetFileCallback to FileOperationCallback.
 void GetFileCallbackToFileOperationCallbackAdapter(
     const FileOperationCallback& callback,
     FileError error,
     const base::FilePath& unused_file_path,
     scoped_ptr<ResourceEntry> unused_entry) {
   callback.Run(error);
@@ skipping 11 matching lines @@
 // Part of GetPathFromResourceId().
 // Obtains |file_path| from |resource_id|. The function should be run on the
 // blocking pool.
 FileError GetPathFromResourceIdOnBlockingPool(
     internal::ResourceMetadata* resource_metadata,
     const std::string& resource_id,
     base::FilePath* file_path) {
   std::string local_id;
   const FileError error =
       resource_metadata->GetIdByResourceId(resource_id, &local_id);
-  *file_path = error == FILE_ERROR_OK ?
-      resource_metadata->GetFilePath(local_id) : base::FilePath();
-  return error;
+  if (error != FILE_ERROR_OK)
+    return error;
+  return resource_metadata->GetFilePath(local_id, file_path);
 }
 
 // Part of GetPathFromResourceId().
 // Called when GetPathFromResourceIdInBlockingPool is complete.
 void GetPathFromResourceIdAfterGetPath(base::FilePath* file_path,
                                        const GetFilePathCallback& callback,
                                        FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   callback.Run(error, *file_path);
 }
@@ skipping 582 matching lines @@
     const base::FilePath& directory_path) {
   OnDirectoryChanged(directory_path);
 }
 
 void FileSystem::OnEntryUpdatedByOperation(const std::string& local_id) {
   sync_client_->AddUpdateTask(ClientContext(USER_INITIATED), local_id);
 }
 
 void FileSystem::OnDriveSyncError(file_system::DriveSyncErrorType type,
                                   const std::string& local_id) {
+  base::FilePath* file_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&internal::ResourceMetadata::GetFilePath,
                  base::Unretained(resource_metadata_),
-                 local_id),
+                 local_id,
+                 file_path),
       base::Bind(&FileSystem::OnDriveSyncErrorAfterGetFilePath,
                  weak_ptr_factory_.GetWeakPtr(),
-                 type));
+                 type,
+                 base::Owned(file_path)));
 }
 
 void FileSystem::OnDriveSyncErrorAfterGetFilePath(
     file_system::DriveSyncErrorType type,
-    const base::FilePath& path) {
-  if (path.empty())
+    const base::FilePath* file_path,
+    FileError error) {
+  if (error != FILE_ERROR_OK)
     return;
   FOR_EACH_OBSERVER(FileSystemObserver,
                     observers_,
-                    OnDriveSyncError(type, path));
+                    OnDriveSyncError(type, *file_path));
 }
 
 void FileSystem::OnDirectoryChanged(const base::FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(FileSystemObserver, observers_,
                     OnDirectoryChanged(directory_path));
 }
 
 void FileSystem::OnLoadFromServerComplete() {
@@ skipping 17 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   FileSystemMetadata metadata;
   metadata.refreshing = change_list_loader_->IsRefreshing();
 
   // Metadata related to delta update.
   metadata.last_update_check_time = last_update_check_time_;
   metadata.last_update_check_error = last_update_check_error_;
 
+  int64* largest_changestamp = new int64(0);
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&internal::ResourceMetadata::GetLargestChangestamp,
-                 base::Unretained(resource_metadata_)),
-      base::Bind(&OnGetLargestChangestamp, metadata, callback));
+                 base::Unretained(resource_metadata_), largest_changestamp),
+      base::Bind(&OnGetLargestChangestamp, metadata, callback,
+                 base::Owned(largest_changestamp)));
 }
 
 void FileSystem::MarkCacheFileAsMounted(
     const base::FilePath& drive_file_path,
     const MarkMountedCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::FilePath* cache_file_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
@@ skipping 114 matching lines @@
       FROM_HERE,
       base::Bind(&GetPathFromResourceIdOnBlockingPool,
                  resource_metadata_,
                  resource_id,
                  file_path),
       base::Bind(&GetPathFromResourceIdAfterGetPath,
                  base::Owned(file_path),
                  callback));
 }
 }  // namespace drive