[SyncFS] Replace leveldb classes with LevelDBWrapper

chrome/browser/sync_file_system/drive_backend/metadata_database_index.cc

 // Copyright 2014 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/sync_file_system/drive_backend/metadata_database_index.h"
 
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
+#include "chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 // LevelDB database schema
 // =======================
 //
 // NOTE
@@ skipping 46 matching lines @@
 template <typename Container>
 typename Container::mapped_type FindItem(
     const Container& container,
     const typename Container::key_type& key) {
   typename Container::const_iterator found = container.find(key);
   if (found == container.end())
     return typename Container::mapped_type();
   return found->second;
 }
 
-void ReadDatabaseContents(leveldb::DB* db,
-                          DatabaseContents* contents) {
+void ReadDatabaseContents(LevelDBWrapper* db, DatabaseContents* contents) {
   DCHECK(db);
   DCHECK(contents);
 
-  scoped_ptr<leveldb::Iterator> itr(db->NewIterator(leveldb::ReadOptions()));
+  scoped_ptr<LevelDBWrapper::Iterator> itr(db->NewIterator());
   for (itr->SeekToFirst(); itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     std::string value = itr->value().ToString();
 
     std::string file_id;
     if (RemovePrefix(key, kFileMetadataKeyPrefix, &file_id)) {
       scoped_ptr<FileMetadata> metadata(new FileMetadata);
       if (!metadata->ParseFromString(itr->value().ToString())) {
         util::Log(logging::LOG_WARNING, FROM_HERE,
                   "Failed to parse a FileMetadata");
@@ skipping 20 matching lines @@
         continue;
       }
       contents->file_trackers.push_back(tracker.release());
       continue;
     }
   }
 }
 
 void RemoveUnreachableItems(DatabaseContents* contents,
                             int64 sync_root_tracker_id,
-                            leveldb::WriteBatch* batch) {
+                            LevelDBWrapper* db) {
   typedef std::map<int64, std::set<int64> > ChildTrackersByParent;
   ChildTrackersByParent trackers_by_parent;
 
   // Set up links from parent tracker to child trackers.
   for (size_t i = 0; i < contents->file_trackers.size(); ++i) {
     const FileTracker& tracker = *contents->file_trackers[i];
     int64 parent_tracker_id = tracker.parent_tracker_id();
     int64 tracker_id = tracker.tracker_id();
 
     trackers_by_parent[parent_tracker_id].insert(tracker_id);
@@ skipping 29 matching lines @@
   }
 
   // Delete all unreachable trackers.
   ScopedVector<FileTracker> reachable_trackers;
   for (size_t i = 0; i < contents->file_trackers.size(); ++i) {
     FileTracker* tracker = contents->file_trackers[i];
     if (ContainsKey(visited_trackers, tracker->tracker_id())) {
       reachable_trackers.push_back(tracker);
       contents->file_trackers[i] = NULL;
     } else {
-      PutFileTrackerDeletionToBatch(tracker->tracker_id(), batch);
+      PutFileTrackerDeletionToDB(tracker->tracker_id(), db);
     }
   }
   contents->file_trackers = reachable_trackers.Pass();
 
   // List all |file_id| referred by a tracker.
   base::hash_set<std::string> referred_file_ids;
   for (size_t i = 0; i < contents->file_trackers.size(); ++i)
     referred_file_ids.insert(contents->file_trackers[i]->file_id());
 
   // Delete all unreferred metadata.
   ScopedVector<FileMetadata> referred_file_metadata;
   for (size_t i = 0; i < contents->file_metadata.size(); ++i) {
     FileMetadata* metadata = contents->file_metadata[i];
     if (ContainsKey(referred_file_ids, metadata->file_id())) {
       referred_file_metadata.push_back(metadata);
       contents->file_metadata[i] = NULL;
     } else {
-      PutFileMetadataDeletionToBatch(metadata->file_id(), batch);
+      PutFileMetadataDeletionToDB(metadata->file_id(), db);
     }
   }
   contents->file_metadata = referred_file_metadata.Pass();
 }
 
 }  // namespace
 
 // static
 scoped_ptr<MetadataDatabaseIndex>
-MetadataDatabaseIndex::Create(leveldb::DB* db, leveldb::WriteBatch* batch) {
+MetadataDatabaseIndex::Create(LevelDBWrapper* db) {
   DCHECK(db);
-  DCHECK(batch);
 
   scoped_ptr<ServiceMetadata> service_metadata = InitializeServiceMetadata(db);
   DatabaseContents contents;
 
-  PutVersionToBatch(kCurrentDatabaseVersion, batch);
+  PutVersionToDB(kCurrentDatabaseVersion, db);
   ReadDatabaseContents(db, &contents);
   RemoveUnreachableItems(&contents,
                          service_metadata->sync_root_tracker_id(),
-                         batch);
+                         db);
 
-  scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex);
+  scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex(db));
   index->Initialize(service_metadata.Pass(), &contents);
   return index.Pass();
 }
 
 // static
 scoped_ptr<MetadataDatabaseIndex>
 MetadataDatabaseIndex::CreateForTesting(DatabaseContents* contents) {
-  scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex);
+  scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex(NULL));
   index->Initialize(make_scoped_ptr(new ServiceMetadata), contents);
   return index.Pass();
 }
 
 void MetadataDatabaseIndex::Initialize(
     scoped_ptr<ServiceMetadata> service_metadata,
     DatabaseContents* contents) {
   service_metadata_ = service_metadata.Pass();
 
   for (size_t i = 0; i < contents->file_metadata.size(); ++i)
-    StoreFileMetadata(make_scoped_ptr(contents->file_metadata[i]), NULL);
+    StoreFileMetadata(make_scoped_ptr(contents->file_metadata[i]));
   contents->file_metadata.weak_clear();
 
   for (size_t i = 0; i < contents->file_trackers.size(); ++i)
-    StoreFileTracker(make_scoped_ptr(contents->file_trackers[i]), NULL);
+    StoreFileTracker(make_scoped_ptr(contents->file_trackers[i]));
   contents->file_trackers.weak_clear();
 
   UMA_HISTOGRAM_COUNTS("SyncFileSystem.MetadataNumber", metadata_by_id_.size());
   UMA_HISTOGRAM_COUNTS("SyncFileSystem.TrackerNumber", tracker_by_id_.size());
   UMA_HISTOGRAM_COUNTS_100("SyncFileSystem.RegisteredAppNumber",
                            app_root_by_app_id_.size());
 }
 
-MetadataDatabaseIndex::MetadataDatabaseIndex() {}
+MetadataDatabaseIndex::MetadataDatabaseIndex(LevelDBWrapper* db) : db_(db) {}
 MetadataDatabaseIndex::~MetadataDatabaseIndex() {}
 
 bool MetadataDatabaseIndex::GetFileMetadata(
     const std::string& file_id, FileMetadata* metadata) const {
   FileMetadata* identified = metadata_by_id_.get(file_id);
   if (!identified)
     return false;
   if (metadata)
     metadata->CopyFrom(*identified);
   return true;
 }
 
 bool MetadataDatabaseIndex::GetFileTracker(
     int64 tracker_id, FileTracker* tracker) const {
   FileTracker* identified = tracker_by_id_.get(tracker_id);
   if (!identified)
     return false;
   if (tracker)
     tracker->CopyFrom(*identified);
   return true;
 }
 
 void MetadataDatabaseIndex::StoreFileMetadata(
-    scoped_ptr<FileMetadata> metadata, leveldb::WriteBatch* batch) {
-  PutFileMetadataToBatch(*metadata.get(), batch);
+    scoped_ptr<FileMetadata> metadata) {
+  PutFileMetadataToDB(*metadata.get(), db_);
   if (!metadata) {
     NOTREACHED();
     return;
   }
 
   std::string file_id = metadata->file_id();
   metadata_by_id_.set(file_id, metadata.Pass());
 }
 
-void MetadataDatabaseIndex::StoreFileTracker(scoped_ptr<FileTracker> tracker,
-                                             leveldb::WriteBatch* batch) {
-  PutFileTrackerToBatch(*tracker.get(), batch);
+void MetadataDatabaseIndex::StoreFileTracker(
+    scoped_ptr<FileTracker> tracker) {
+  PutFileTrackerToDB(*tracker.get(), db_);
   if (!tracker) {
     NOTREACHED();
     return;
   }
 
   int64 tracker_id = tracker->tracker_id();
   FileTracker* old_tracker = tracker_by_id_.get(tracker_id);
 
   if (!old_tracker) {
     DVLOG(3) << "Adding new tracker: " << tracker->tracker_id()
              << " " << GetTrackerTitle(*tracker);
 
     AddToAppIDIndex(*tracker);
     AddToPathIndexes(*tracker);
     AddToFileIDIndexes(*tracker);
     AddToDirtyTrackerIndexes(*tracker);
   } else {
     DVLOG(3) << "Updating tracker: " << tracker->tracker_id()
              << " " << GetTrackerTitle(*tracker);
 
     UpdateInAppIDIndex(*old_tracker, *tracker);
     UpdateInPathIndexes(*old_tracker, *tracker);
     UpdateInFileIDIndexes(*old_tracker, *tracker);
     UpdateInDirtyTrackerIndexes(*old_tracker, *tracker);
   }
 
   tracker_by_id_.set(tracker_id, tracker.Pass());
 }
 
-void MetadataDatabaseIndex::RemoveFileMetadata(const std::string& file_id,
-                                               leveldb::WriteBatch* batch) {
-  PutFileMetadataDeletionToBatch(file_id, batch);
+void MetadataDatabaseIndex::RemoveFileMetadata(const std::string& file_id) {
+  PutFileMetadataDeletionToDB(file_id, db_);
   metadata_by_id_.erase(file_id);
 }
 
-void MetadataDatabaseIndex::RemoveFileTracker(int64 tracker_id,
-                                              leveldb::WriteBatch* batch) {
-  PutFileTrackerDeletionToBatch(tracker_id, batch);
+void MetadataDatabaseIndex::RemoveFileTracker(int64 tracker_id) {
+  PutFileTrackerDeletionToDB(tracker_id, db_);
 
   FileTracker* tracker = tracker_by_id_.get(tracker_id);
   if (!tracker) {
     NOTREACHED();
     return;
   }
 
   DVLOG(3) << "Removing tracker: "
            << tracker->tracker_id() << " " << GetTrackerTitle(*tracker);
 
@@ skipping 52 matching lines @@
     return ParentIDAndTitle(kInvalidTrackerID, std::string());
   return *multi_backing_file_paths_.begin();
 }
 
 int64 MetadataDatabaseIndex::PickDirtyTracker() const {
   if (dirty_trackers_.empty())
     return kInvalidTrackerID;
   return *dirty_trackers_.begin();
 }
 
-void MetadataDatabaseIndex::DemoteDirtyTracker(
-    int64 tracker_id, leveldb::WriteBatch* /* unused_batch */) {
+void MetadataDatabaseIndex::DemoteDirtyTracker(int64 tracker_id) {
   if (dirty_trackers_.erase(tracker_id))
     demoted_dirty_trackers_.insert(tracker_id);
 }
 
 bool MetadataDatabaseIndex::HasDemotedDirtyTracker() const {
   return !demoted_dirty_trackers_.empty();
 }
 
-void MetadataDatabaseIndex::PromoteDemotedDirtyTrackers(
-    leveldb::WriteBatch* /* unused_batch */) {
+void MetadataDatabaseIndex::PromoteDemotedDirtyTrackers() {
   dirty_trackers_.insert(demoted_dirty_trackers_.begin(),
                          demoted_dirty_trackers_.end());
   demoted_dirty_trackers_.clear();
 }
 
 size_t MetadataDatabaseIndex::CountDirtyTracker() const {
   return dirty_trackers_.size() + demoted_dirty_trackers_.size();
 }
 
 size_t MetadataDatabaseIndex::CountFileMetadata() const {
   return metadata_by_id_.size();
 }
 
 size_t MetadataDatabaseIndex::CountFileTracker() const {
   return tracker_by_id_.size();
 }
 
 void MetadataDatabaseIndex::SetSyncRootTrackerID(
-    int64 sync_root_id, leveldb::WriteBatch* batch) const {
+    int64 sync_root_id) const {
   service_metadata_->set_sync_root_tracker_id(sync_root_id);
-  PutServiceMetadataToBatch(*service_metadata_, batch);
+  PutServiceMetadataToDB(*service_metadata_, db_);
 }
 
 void MetadataDatabaseIndex::SetLargestChangeID(
-    int64 largest_change_id, leveldb::WriteBatch* batch) const {
+    int64 largest_change_id) const {
   service_metadata_->set_largest_change_id(largest_change_id);
-  PutServiceMetadataToBatch(*service_metadata_, batch);
+  PutServiceMetadataToDB(*service_metadata_, db_);
 }
 
 void MetadataDatabaseIndex::SetNextTrackerID(
-    int64 next_tracker_id, leveldb::WriteBatch* batch) const {
+    int64 next_tracker_id) const {
   service_metadata_->set_next_tracker_id(next_tracker_id);
-  PutServiceMetadataToBatch(*service_metadata_, batch);
+  PutServiceMetadataToDB(*service_metadata_, db_);
 }
 
 int64 MetadataDatabaseIndex::GetSyncRootTrackerID() const {
   if (!service_metadata_->has_sync_root_tracker_id())
     return kInvalidTrackerID;
   return service_metadata_->sync_root_tracker_id();
 }
 
 int64 MetadataDatabaseIndex::GetLargestChangeID() const {
   if (!service_metadata_->has_largest_change_id())
@@ skipping 287 matching lines @@
 
     DVLOG(3) << "  Remove from dirty_trackers_: " << tracker_id;
     dirty_trackers_.erase(tracker_id);
 
     demoted_dirty_trackers_.erase(tracker_id);
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system