chromeos: Use WriteBatch to update DriveResourceMetadata DB

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 529 matching lines @@
     return FileMoveResult(FILE_ERROR_NO_SPACE);
 
   // Disallow deletion of special entries "/drive" and "/drive/other".
   if (util::IsSpecialResourceId(resource_id))
     return FileMoveResult(FILE_ERROR_ACCESS_DENIED);
 
   scoped_ptr<DriveEntryProto> entry = storage_->GetEntry(resource_id);
   if (!entry)
     return FileMoveResult(FILE_ERROR_NOT_FOUND);
 
-  RemoveDirectoryChild(entry->resource_id());
+  if (!RemoveEntryRecursively(entry->resource_id()))
+    return FileMoveResult(FILE_ERROR_FAILED);
+
   return FileMoveResult(FILE_ERROR_OK,
                         GetFilePath(entry->parent_resource_id()));
 }
 
 scoped_ptr<DriveEntryProto> DriveResourceMetadata::FindEntryByPathSync(
     const base::FilePath& file_path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   // Start from the root.
   scoped_ptr<DriveEntryProto> entry =
@@ skipping 111 matching lines @@
     return FILE_ERROR_INVALID_OPERATION;
 
   // Update data.
   scoped_ptr<DriveEntryProto> new_parent =
       GetDirectory(entry.parent_resource_id());
 
   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(old_entry->resource_id());
-  AddEntryToDirectory(CreateEntryWithProperBaseName(entry));
+  if (!AddEntryToDirectory(CreateEntryWithProperBaseName(entry)))
+    return FILE_ERROR_FAILED;
 
   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;
@@ skipping 38 matching lines @@
     // have a parent resource ID which does not match the target directory's.
     //
     // TODO(satorux): Move the filtering logic to somewhere more appropriate.
     // crbug.com/193525.
     if (entry_proto.parent_resource_id() !=
         directory_fetch_info.resource_id()) {
       DVLOG(1) << "Wrong-parent entry rejected: " << entry_proto.resource_id();
       continue;
     }
 
-    scoped_ptr<DriveEntryProto> existing_entry =
-        storage_->GetEntry(entry_proto.resource_id());
-    if (existing_entry)
-      DetachEntryFromDirectory(entry_proto.resource_id());
-
-    AddEntryToDirectory(CreateEntryWithProperBaseName(entry_proto));
+    if (!AddEntryToDirectory(CreateEntryWithProperBaseName(entry_proto)))
+      return FileMoveResult(FILE_ERROR_FAILED);
   }
 
   // Go through the existing entries and remove deleted entries.
   scoped_ptr<DriveEntryProtoVector> entries =
       DirectoryChildrenToProtoVector(directory->resource_id());
   for (size_t i = 0; i < entries->size(); ++i) {
     if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
       return FileMoveResult(FILE_ERROR_NO_SPACE);
 
     const DriveEntryProto& entry_proto = entries->at(i);
-    if (entry_proto_map.count(entry_proto.resource_id()) == 0)
-      RemoveDirectoryChild(entry_proto.resource_id());
+    if (entry_proto_map.count(entry_proto.resource_id()) == 0) {
+      if (!RemoveEntryRecursively(entry_proto.resource_id()))
+        return FileMoveResult(FILE_ERROR_FAILED);
+    }
   }
 
   return FileMoveResult(FILE_ERROR_OK, GetFilePath(directory->resource_id()));
 }
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::AddEntryOnBlockingPool(
     const DriveEntryProto& entry_proto) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
     return FileMoveResult(FILE_ERROR_NO_SPACE);
 
   scoped_ptr<DriveEntryProto> existing_entry =
       storage_->GetEntry(entry_proto.resource_id());
   if (existing_entry)
     return FileMoveResult(FILE_ERROR_EXISTS);
 
   scoped_ptr<DriveEntryProto> parent =
       GetDirectory(entry_proto.parent_resource_id());
   if (!parent)
     return FileMoveResult(FILE_ERROR_NOT_FOUND);
 
-  AddEntryToDirectory(entry_proto);
+  if (!AddEntryToDirectory(entry_proto))
+    return FileMoveResult(FILE_ERROR_FAILED);
+
   return FileMoveResult(FILE_ERROR_OK, GetFilePath(entry_proto.resource_id()));
 }
 
 scoped_ptr<DriveEntryProto> DriveResourceMetadata::GetDirectory(
     const std::string& resource_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!resource_id.empty());
 
   scoped_ptr<DriveEntryProto> entry = storage_->GetEntry(resource_id);
   return entry && entry->file_info().is_directory() ?
@@ skipping 46 matching lines @@
 
 void DriveResourceMetadata::RemoveAllOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   // TODO(hashimoto): Return FILE_ERROR_NO_SPACE here.
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_)) {
     LOG(ERROR) << "Required disk space not available.";
     return;
   }
 
-  RemoveDirectoryChildren(util::kDriveGrandRootSpecialResourceId);
+  RemoveEntryRecursively(util::kDriveGrandRootSpecialResourceId);
   SetUpDefaultEntries();
 }
 
 void DriveResourceMetadata::IterateEntriesOnBlockingPool(
     const IterateCallback& callback) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!callback.is_null());
 
   storage_->Iterate(callback);
 }
@@ skipping 38 matching lines @@
   DCHECK(!callback.is_null());
   DCHECK(result.get());
 
   result->second.path = second_path;
   result->second.error = error;
   result->second.proto = entry_proto.Pass();
 
   callback.Run(result.Pass());
 }
 
-void DriveResourceMetadata::AddEntryToDirectory(const DriveEntryProto& entry) {
+bool DriveResourceMetadata::AddEntryToDirectory(const DriveEntryProto& entry) {

[hidehiko, 2013/04/24 07:29:45]

AddEntryToDirectory sounds weird because this doesn't just add an entry to its
parent directory, but it also removes the entry from its old parent now.

[hashimoto, 2013/04/24 08:05:56]

Renamed to PutEntryUnderDirectory.

   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   DriveEntryProto updated_entry(entry);
 
   // The entry name may have been changed due to prior name de-duplication.
   // We need to first restore the file name based on the title before going
   // through name de-duplication again when it is added to another directory.
   SetBaseNameFromTitle(&updated_entry);
 
-  // Do file name de-duplication - find files with the same name and
-  // append a name modifier to the name.
+  // Do file name de-duplication - Keep changing |entry|'s name until there is
+  // no other entry with the same name under the parent.
   int modifier = 1;
   std::string new_base_name = updated_entry.base_name();
-  while (!storage_->GetChild(entry.parent_resource_id(),
-                             new_base_name).empty()) {
+  while (true) {
+    const std::string existing_entry_id =
+        storage_->GetChild(entry.parent_resource_id(), new_base_name);
+    if (existing_entry_id.empty() || existing_entry_id == entry.resource_id())
+      break;
+
     base::FilePath new_path =
         base::FilePath::FromUTF8Unsafe(updated_entry.base_name());
     new_path =
         new_path.InsertBeforeExtension(base::StringPrintf(" (%d)", ++modifier));
     new_base_name = new_path.AsUTF8Unsafe();
   }
   updated_entry.set_base_name(new_base_name);
 
-  // Setup child and parent links.
-  storage_->PutChild(entry.parent_resource_id(),
-                     updated_entry.base_name(),
-                     updated_entry.resource_id());
-
   // Add the entry to resource map.
-  storage_->PutEntry(updated_entry);
+  return storage_->PutEntry(updated_entry);
 }
 
-void DriveResourceMetadata::RemoveDirectoryChild(
-    const std::string& child_resource_id) {
+bool DriveResourceMetadata::RemoveEntryRecursively(
+    const std::string& resource_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  scoped_ptr<DriveEntryProto> entry = storage_->GetEntry(child_resource_id);
-  DCHECK(entry);
-  DetachEntryFromDirectory(child_resource_id);
-  storage_->RemoveEntry(entry->resource_id());
-  if (entry->file_info().is_directory())
-    RemoveDirectoryChildren(child_resource_id);
-}
-
-void DriveResourceMetadata::DetachEntryFromDirectory(
-    const std::string& child_resource_id) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
-
-  scoped_ptr<DriveEntryProto> entry = storage_->GetEntry(child_resource_id);
+  scoped_ptr<DriveEntryProto> entry = storage_->GetEntry(resource_id);
   DCHECK(entry);
 
-  // entry must be present in this directory.
-  DCHECK_EQ(entry->resource_id(),
-            storage_->GetChild(entry->parent_resource_id(),
-                               entry->base_name()));
-
-  storage_->RemoveChild(entry->parent_resource_id(), entry->base_name());
-}
-
-void DriveResourceMetadata::RemoveDirectoryChildren(
-    const std::string& directory_resource_id) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
-
-  std::vector<std::string> children;
-  storage_->GetChildren(directory_resource_id, &children);
-  for (size_t i = 0; i < children.size(); ++i)
-    RemoveDirectoryChild(children[i]);
+  if (entry->file_info().is_directory()) {
+    std::vector<std::string> children;
+    storage_->GetChildren(resource_id, &children);
+    for (size_t i = 0; i < children.size(); ++i) {
+      if (!RemoveEntryRecursively(children[i]))
+        return false;
+    }
+  }
+  return storage_->RemoveEntry(resource_id);
 }
 
 scoped_ptr<DriveEntryProtoVector>
 DriveResourceMetadata::DirectoryChildrenToProtoVector(
     const std::string& directory_resource_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<DriveEntryProtoVector> entries(new DriveEntryProtoVector);
   std::vector<std::string> children;
   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