chromeos: Rewrite DriveResourceMetadata::MoveEntryToDirectory with RefreshEntry

chrome/browser/chromeos/drive/drive_resource_metadata.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/drive_resource_metadata.h"
 
 #include "base/file_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
@@ skipping 33 matching lines @@
 }
 
 // Returns true if enough disk space is avilable for DB operation.
 // TODO(hashimoto): Merge this with DriveCache's FreeDiskSpaceGetterInterface.
 bool EnoughDiskSpaceIsAvailableForDBOperation(const base::FilePath& path) {
   const int64 kRequiredDiskSpaceInMB = 128;  // 128 MB seems to be large enough.
   return base::SysInfo::AmountOfFreeDiskSpace(path) >=
       kRequiredDiskSpaceInMB * (1 << 20);
 }
 
+// Runs |callback| with arguments.
+void RunGetEntryInfoWithFilePathCallback(
+    const GetEntryInfoWithFilePathCallback& callback,
+    base::FilePath* path,
+    scoped_ptr<DriveEntryProto> entry,
+    FileError error) {
+  DCHECK(!callback.is_null());
+
+  if (error != FILE_ERROR_OK)
+    entry.reset();
+  callback.Run(error, *path, entry.Pass());
+}
+
 }  // namespace
 
 std::string DirectoryFetchInfo::ToString() const {
   return ("resource_id: " + resource_id_ +
           ", changestamp: " + base::Int64ToString(changestamp_));
 }
 
 EntryInfoResult::EntryInfoResult() : error(FILE_ERROR_FAILED) {
 }
 
@@ skipping 42 matching lines @@
                                     scoped_ptr<GetEntryInfoResult> result) {
     DCHECK(!callback.is_null());
     DCHECK(result);
     callback.Run(result->error, result->entry.Pass());
   }
 
   FileError error;
   scoped_ptr<DriveEntryProto> entry;
 };
 
-// Struct to hold result values passed to GetEntryInfoWithFilePathCallback.
-struct DriveResourceMetadata::GetEntryInfoWithFilePathResult {
-  GetEntryInfoWithFilePathResult(FileError error,
-                                 const base::FilePath& path,
-                                 scoped_ptr<DriveEntryProto> entry)
-      : error(error),
-        path(path),
-        entry(entry.Pass()) {}
-
-  explicit GetEntryInfoWithFilePathResult(FileError error)
-      : error(error) {}
-
-  // Runs GetEntryInfoWithFilePathCallback with the values stored in |result|.
-  static void RunCallbackWithResult(
-      const GetEntryInfoWithFilePathCallback& callback,
-      scoped_ptr<GetEntryInfoWithFilePathResult> result) {
-    DCHECK(!callback.is_null());
-    DCHECK(result);
-    callback.Run(result->error, result->path, result->entry.Pass());
-  }
-
-  FileError error;
-  base::FilePath path;
-  scoped_ptr<DriveEntryProto> entry;
-};
-
 // Struct to hold result values passed to ReadDirectoryCallback.
 struct DriveResourceMetadata::ReadDirectoryResult {
   ReadDirectoryResult(FileError error,
                       scoped_ptr<DriveEntryProtoVector> entries)
       : error(error),
         entries(entries.Pass()) {}
 
   // Runs ReadDirectoryCallback with the values stored in |result|.
   static void RunCallbackWithResult(const ReadDirectoryCallback& callback,
                                     scoped_ptr<ReadDirectoryResult> result) {
@@ skipping 190 matching lines @@
                  resource_id),
       base::Bind(&FileMoveResult::RunCallbackWithResult,
                  callback));
 }
 
 void DriveResourceMetadata::GetEntryInfoByResourceId(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
+
+  base::FilePath* file_path = new base::FilePath;
+  scoped_ptr<DriveEntryProto> entry(new DriveEntryProto);
+  DriveEntryProto* entry_ptr = entry.get();
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&DriveResourceMetadata::GetEntryInfoByResourceIdOnBlockingPool,
                  base::Unretained(this),
-                 resource_id),
-      base::Bind(&GetEntryInfoWithFilePathResult::RunCallbackWithResult,
-                 callback));
+                 resource_id,
+                 file_path,
+                 entry_ptr),
+      base::Bind(&RunGetEntryInfoWithFilePathCallback,
+                 callback,
+                 base::Owned(file_path),
+                 base::Passed(&entry)));
 }
 
 void DriveResourceMetadata::GetEntryInfoByPath(
     const base::FilePath& file_path,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
@@ skipping 17 matching lines @@
                  file_path),
       base::Bind(&ReadDirectoryResult::RunCallbackWithResult,
                  callback));
 }
 
 void DriveResourceMetadata::RefreshEntry(
     const DriveEntryProto& entry_proto,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
+
+  base::FilePath* file_path = new base::FilePath;
+  scoped_ptr<DriveEntryProto> entry(new DriveEntryProto);
+  DriveEntryProto* entry_ptr = entry.get();
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&DriveResourceMetadata::RefreshEntryOnBlockingPool,
                  base::Unretained(this),
-                 entry_proto),
-      base::Bind(&GetEntryInfoWithFilePathResult::RunCallbackWithResult,
-                 callback));
+                 entry_proto,
+                 file_path,
+                 entry_ptr),
+      base::Bind(&RunGetEntryInfoWithFilePathCallback,
+                 callback,
+                 base::Owned(file_path),
+                 base::Passed(&entry)));
 }
 
 void DriveResourceMetadata::RefreshDirectory(
     const DirectoryFetchInfo& directory_fetch_info,
     const DriveEntryProtoMap& entry_proto_map,
     const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
@@ skipping 67 matching lines @@
     const base::FilePath& file_path,
     const base::FilePath& directory_path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!directory_path.empty());
   DCHECK(!file_path.empty());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
     return FileMoveResult(FILE_ERROR_NO_SPACE);
 
   scoped_ptr<DriveEntryProto> entry = FindEntryByPathSync(file_path);
-  if (!entry)
+  scoped_ptr<DriveEntryProto> destination = FindEntryByPathSync(directory_path);
+  if (!entry || !destination)
     return FileMoveResult(FILE_ERROR_NOT_FOUND);
+  if (!destination->file_info().is_directory())
+    return FileMoveResult(FILE_ERROR_NOT_A_DIRECTORY);
 
-  // Cannot move an entry without its parent. (i.e. the root)
-  if (entry->parent_resource_id().empty())
-    return FileMoveResult(FILE_ERROR_INVALID_OPERATION);
+  entry->set_parent_resource_id(destination->resource_id());
 
-  scoped_ptr<DriveEntryProto> destination = FindEntryByPathSync(directory_path);
-  base::FilePath moved_file_path;
-  FileError error = FILE_ERROR_FAILED;
-  if (!destination) {
-    error = FILE_ERROR_NOT_FOUND;
-  } else if (!destination->file_info().is_directory()) {
-    error = FILE_ERROR_NOT_A_DIRECTORY;
-  } else {
-    DetachEntryFromDirectory(entry->resource_id());
-    entry->set_parent_resource_id(destination->resource_id());
-    AddEntryToDirectory(*entry);
-    moved_file_path = GetFilePath(entry->resource_id());
-    error = FILE_ERROR_OK;
-  }
-  DVLOG(1) << "MoveEntryToDirectory " << moved_file_path.value();
-  return FileMoveResult(error, moved_file_path);
+  base::FilePath result_file_path;
+  FileError error = RefreshEntryOnBlockingPool(*entry, &result_file_path, NULL);
+  return FileMoveResult(error, result_file_path);
 }
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::RenameEntryOnBlockingPool(
     const base::FilePath& file_path,
     const std::string& new_name) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!file_path.empty());
   DCHECK(!new_name.empty());
 
   DVLOG(1) << "RenameEntry " << file_path.value() << " to " << new_name;
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
     return FileMoveResult(FILE_ERROR_NO_SPACE);
 
   scoped_ptr<DriveEntryProto> entry = FindEntryByPathSync(file_path);
   if (!entry)
     return FileMoveResult(FILE_ERROR_NOT_FOUND);
 
   if (base::FilePath::FromUTF8Unsafe(new_name) == file_path.BaseName())
     return FileMoveResult(FILE_ERROR_EXISTS);
 
   entry->set_title(new_name);
-  scoped_ptr<GetEntryInfoWithFilePathResult> result =
-      RefreshEntryOnBlockingPool(*entry);
-  return FileMoveResult(result->error, result->path);
+  base::FilePath result_file_path;
+  FileError error = RefreshEntryOnBlockingPool(*entry, &result_file_path, NULL);
+  return FileMoveResult(error, result_file_path);
 }
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::RemoveEntryOnBlockingPool(
     const std::string& resource_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
     return FileMoveResult(FILE_ERROR_NO_SPACE);
 
@@ skipping 35 matching lines @@
     if (resource_id.empty())
       return scoped_ptr<DriveEntryProto>();
 
     entry = storage_->GetEntry(resource_id);
     DCHECK(entry);
     DCHECK_EQ(entry->base_name(), component);
   }
   return entry.Pass();
 }
 
-scoped_ptr<DriveResourceMetadata::GetEntryInfoWithFilePathResult>
-DriveResourceMetadata::GetEntryInfoByResourceIdOnBlockingPool(
-    const std::string& resource_id) {
+FileError DriveResourceMetadata::GetEntryInfoByResourceIdOnBlockingPool(
+    const std::string& resource_id,
+    base::FilePath* out_file_path,
+    DriveEntryProto* out_entry) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!resource_id.empty());
 
   scoped_ptr<DriveEntryProto> entry = storage_->GetEntry(resource_id);
-  FileError error = FILE_ERROR_FAILED;
-  base::FilePath drive_file_path;
-  if (entry) {
-    error = FILE_ERROR_OK;
-    drive_file_path = GetFilePath(resource_id);
-  } else {
-    error = FILE_ERROR_NOT_FOUND;
-  }
+  if (!entry)
+    return FILE_ERROR_NOT_FOUND;
 
-  return make_scoped_ptr(
-      new GetEntryInfoWithFilePathResult(error, drive_file_path, entry.Pass()));
+  if (out_file_path)
+    *out_file_path = GetFilePath(resource_id);
+  if (out_entry)
+    *out_entry = *entry;
+
+  return FILE_ERROR_OK;
 }
 
 scoped_ptr<DriveResourceMetadata::GetEntryInfoResult>
 DriveResourceMetadata::GetEntryInfoByPathOnBlockingPool(
     const base::FilePath& path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<DriveEntryProto> entry = FindEntryByPathSync(path);
   FileError error = entry ? FILE_ERROR_OK : FILE_ERROR_NOT_FOUND;
 
@@ skipping 31 matching lines @@
   // Get the first entry.
   GetEntryInfoByPath(
       first_path,
       base::Bind(&DriveResourceMetadata::GetEntryInfoPairByPathsAfterGetFirst,
                  weak_ptr_factory_.GetWeakPtr(),
                  first_path,
                  second_path,
                  callback));
 }
 
-scoped_ptr<DriveResourceMetadata::GetEntryInfoWithFilePathResult>
-DriveResourceMetadata::RefreshEntryOnBlockingPool(
-    const DriveEntryProto& entry_proto) {
+FileError DriveResourceMetadata::RefreshEntryOnBlockingPool(
+    const DriveEntryProto& entry,
+    base::FilePath* out_file_path,
+    DriveEntryProto* out_entry) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_)) {
-    return make_scoped_ptr(
-        new GetEntryInfoWithFilePathResult(FILE_ERROR_NO_SPACE));
-  }
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    return FILE_ERROR_NO_SPACE;
 
-  scoped_ptr<DriveEntryProto> entry =
-      storage_->GetEntry(entry_proto.resource_id());
-  if (!entry) {
-    return make_scoped_ptr(
-        new GetEntryInfoWithFilePathResult(FILE_ERROR_NOT_FOUND));
-  }
+  scoped_ptr<DriveEntryProto> old_entry =
+      storage_->GetEntry(entry.resource_id());
+  if (!old_entry)
+    return FILE_ERROR_NOT_FOUND;
 
-  if (entry->parent_resource_id().empty() ||  // Rejct root.
-      entry->file_info().is_directory() !=  // Reject incompatible input.
-      entry_proto.file_info().is_directory()) {
-    return make_scoped_ptr(
-        new GetEntryInfoWithFilePathResult(FILE_ERROR_INVALID_OPERATION));
-  }
+  if (old_entry->parent_resource_id().empty() ||  // Rejct root.
+      old_entry->file_info().is_directory() !=  // Reject incompatible input.
+      entry.file_info().is_directory())
+    return FILE_ERROR_INVALID_OPERATION;
 
   // Update data.
   scoped_ptr<DriveEntryProto> new_parent =
-      GetDirectory(entry_proto.parent_resource_id());
+      GetDirectory(entry.parent_resource_id());
 
-  if (!new_parent) {
-    return make_scoped_ptr(
-        new GetEntryInfoWithFilePathResult(FILE_ERROR_NOT_FOUND));
-  }
+  if (!new_parent)
+    return FILE_ERROR_NOT_FOUND;
 
   // Remove from the old parent and add it to the new parent with the new data.
-  DetachEntryFromDirectory(entry->resource_id());
-  AddEntryToDirectory(CreateEntryWithProperBaseName(entry_proto));
+  DetachEntryFromDirectory(old_entry->resource_id());
+  AddEntryToDirectory(CreateEntryWithProperBaseName(entry));
 
-  // Note that base_name is not the same for the new entry and entry_proto.
-  scoped_ptr<DriveEntryProto> result_entry_proto =
-      storage_->GetEntry(entry->resource_id());
-  return make_scoped_ptr(
-      new GetEntryInfoWithFilePathResult(FILE_ERROR_OK,
-                                         GetFilePath(entry->resource_id()),
-                                         result_entry_proto.Pass()));
+  if (out_file_path)
+    *out_file_path = GetFilePath(entry.resource_id());
+
+  if (out_entry) {
+    // Note that base_name is not the same for the new entry and entry_proto.
+    scoped_ptr<DriveEntryProto> result_entry_proto =
+        storage_->GetEntry(entry.resource_id());
+    DCHECK(result_entry_proto);
+    *out_entry = *result_entry_proto;
+  }
+  return FILE_ERROR_OK;
 }
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::RefreshDirectoryOnBlockingPool(
     const DirectoryFetchInfo& directory_fetch_info,
     const DriveEntryProtoMap& entry_proto_map) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!directory_fetch_info.empty());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
@@ skipping 280 matching lines @@
   storage_->GetChildren(directory_resource_id, &children);
   for (size_t i = 0; i < children.size(); ++i) {
     scoped_ptr<DriveEntryProto> child = storage_->GetEntry(children[i]);
     DCHECK(child);
     entries->push_back(*child);
   }
   return entries.Pass();
 }
 
 }  // namespace drive