chromeos: Use WriteBatch to update DriveResourceMetadata DB

chrome/browser/chromeos/drive/drive_resource_metadata_storage.cc

 // Copyright 2013 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_storage.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
+#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 namespace drive {
 
 namespace {
 
 const base::FilePath::CharType kResourceMapDBName[] =
     FILE_PATH_LITERAL("resource_metadata_resource_map.db");
 const base::FilePath::CharType kChildMapDBName[] =
     FILE_PATH_LITERAL("resource_metadata_child_map.db");
 
 // Meant to be a character which never happen to be in real resource IDs.
 const char kDBKeyDelimeter = '\0';
 
 // Returns a string to be used as the key for the header.
 std::string GetHeaderDBKey() {
   std::string key;
   key.push_back(kDBKeyDelimeter);
   key.append("HEADER");
   return key;
 }
 
-// Returns a string to be used as a key for child entry.
-std::string GetChildEntryKey(const std::string& parent_resource_id,
-                             const std::string& child_name) {
-  std::string key = parent_resource_id;
-  key.push_back(kDBKeyDelimeter);
-  key.append(child_name);
-  key.push_back(kDBKeyDelimeter);
-  return key;
-}
-
 // Returns true if |key| is a key for a child entry.
 bool IsChildEntryKey(const leveldb::Slice& key) {
   return !key.empty() && key[key.size() - 1] == kDBKeyDelimeter;
 }
 
 }  // namespace
 
 DriveResourceMetadataStorage::DriveResourceMetadataStorage(
     const base::FilePath& directory_path)
     : directory_path_(directory_path) {
@@ skipping 71 matching lines @@
   PutHeader(*header);
 }
 
 int64 DriveResourceMetadataStorage::GetLargestChangestamp() {
   base::ThreadRestrictions::AssertIOAllowed();
   scoped_ptr<DriveResourceMetadataHeader> header = GetHeader();
   DCHECK(header);
   return header->largest_changestamp();
 }
 
-void DriveResourceMetadataStorage::PutEntry(const DriveEntryProto& entry) {
+bool DriveResourceMetadataStorage::PutEntry(const DriveEntryProto& entry) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!entry.resource_id().empty());
 
   std::string serialized_entry;
   if (!entry.SerializeToString(&serialized_entry)) {
     DLOG(ERROR) << "Failed to serialize the entry: " << entry.resource_id();
-    return;
+    return false;
   }
 
-  const leveldb::Status status = resource_map_->Put(
-      leveldb::WriteOptions(),
-      leveldb::Slice(entry.resource_id()),
-      leveldb::Slice(serialized_entry));
-  DCHECK(status.ok());
+  leveldb::WriteBatch batch;
+
+  // Remove from the old parent.
+  scoped_ptr<DriveEntryProto> old_entry = GetEntry(entry.resource_id());
+  if (old_entry && !old_entry->parent_resource_id().empty()) {
+    batch.Delete(GetChildEntryKey(old_entry->parent_resource_id(),
+                                  old_entry->base_name()));
+  }
+
+  // Add to the new parent.
+  if (!entry.parent_resource_id().empty()) {
+    batch.Put(GetChildEntryKey(entry.parent_resource_id(), entry.base_name()),
+              entry.resource_id());
+  }
+
+  // Put the entry itself.
+  batch.Put(entry.resource_id(), serialized_entry);
+
+  const leveldb::Status status = resource_map_->Write(leveldb::WriteOptions(),
+                                                      &batch);
+  return status.ok();
 }
 
 scoped_ptr<DriveEntryProto> DriveResourceMetadataStorage::GetEntry(
     const std::string& resource_id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!resource_id.empty());
 
   std::string serialized_entry;
   const leveldb::Status status = resource_map_->Get(leveldb::ReadOptions(),
                                                     leveldb::Slice(resource_id),
                                                     &serialized_entry);
   if (!status.ok())
     return scoped_ptr<DriveEntryProto>();
 
   scoped_ptr<DriveEntryProto> entry(new DriveEntryProto);
   if (!entry->ParseFromString(serialized_entry))
     return scoped_ptr<DriveEntryProto>();
   return entry.Pass();
 }
 
-void DriveResourceMetadataStorage::RemoveEntry(const std::string& resource_id) {
+bool DriveResourceMetadataStorage::RemoveEntry(const std::string& resource_id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!resource_id.empty());
 
-  const leveldb::Status status = resource_map_->Delete(
-      leveldb::WriteOptions(),
-      leveldb::Slice(resource_id));
-  DCHECK(status.ok());
+  scoped_ptr<DriveEntryProto> entry = GetEntry(resource_id);
+  if (!entry)
+    return false;
+
+  leveldb::WriteBatch batch;
+
+  // Remove from the parent.
+  if (!entry->parent_resource_id().empty()) {
+    batch.Delete(GetChildEntryKey(entry->parent_resource_id(),
+                                  entry->base_name()));
+  }
+  // Remove the entry itself.
+  batch.Delete(resource_id);
+
+  const leveldb::Status status = resource_map_->Write(leveldb::WriteOptions(),
+                                                      &batch);
+  return status.ok();
 }
 
 void DriveResourceMetadataStorage::Iterate(const IterateCallback& callback) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!callback.is_null());
 
   scoped_ptr<leveldb::Iterator> it(
       resource_map_->NewIterator(leveldb::ReadOptions()));
 
   // Skip the header entry.
   // Note: The header entry comes before all other entries because its key
   // starts with kDBKeyDelimeter. (i.e. '\0')
   it->Seek(leveldb::Slice(GetHeaderDBKey()));
   it->Next();
 
   DriveEntryProto entry;
   for (; it->Valid(); it->Next()) {
     if (!IsChildEntryKey(it->key()) &&
         entry.ParseFromArray(it->value().data(), it->value().size()))
       callback.Run(entry);
   }
 }
 
-void DriveResourceMetadataStorage::PutChild(
-    const std::string& parent_resource_id,
-    const std::string& child_name,
-    const std::string& child_resource_id) {
-  base::ThreadRestrictions::AssertIOAllowed();
-
-  const leveldb::Status status = resource_map_->Put(
-      leveldb::WriteOptions(),
-      leveldb::Slice(GetChildEntryKey(parent_resource_id, child_name)),
-      leveldb::Slice(child_resource_id));
-  DCHECK(status.ok());
-}
-
 std::string DriveResourceMetadataStorage::GetChild(
     const std::string& parent_resource_id,
     const std::string& child_name) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   std::string child_resource_id;
   resource_map_->Get(
       leveldb::ReadOptions(),
       leveldb::Slice(GetChildEntryKey(parent_resource_id, child_name)),
       &child_resource_id);
@@ skipping 10 matching lines @@
       resource_map_->NewIterator(leveldb::ReadOptions()));
   for (it->Seek(parent_resource_id);
        it->Valid() && it->key().starts_with(leveldb::Slice(parent_resource_id));
        it->Next()) {
     if (IsChildEntryKey(it->key()))
       children->push_back(it->value().ToString());
   }
   DCHECK(it->status().ok());
 }
 
-void DriveResourceMetadataStorage::RemoveChild(
+// static
+std::string DriveResourceMetadataStorage::GetChildEntryKey(
     const std::string& parent_resource_id,
     const std::string& child_name) {
-  base::ThreadRestrictions::AssertIOAllowed();
-
-  const leveldb::Status status = resource_map_->Delete(
-      leveldb::WriteOptions(),
-      leveldb::Slice(GetChildEntryKey(parent_resource_id, child_name)));
-  DCHECK(status.ok());
+  std::string key = parent_resource_id;
+  key.push_back(kDBKeyDelimeter);
+  key.append(child_name);
+  key.push_back(kDBKeyDelimeter);
+  return key;
 }
 
 void DriveResourceMetadataStorage::PutHeader(
     const DriveResourceMetadataHeader& header) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   std::string serialized_header;
   if (!header.SerializeToString(&serialized_header)) {
     DLOG(ERROR) << "Failed to serialize the header";
     return;
@@ skipping 91 matching lines @@
   }
   if (!it->status().ok() || num_child_entries != num_entries_with_parent) {
     DLOG(ERROR) << "Error during checking resource map. status = "
                 << it->status().ToString();
     return false;
   }
   return true;
 }
 
 }  // namespace drive