[SyncFS] Replace leveldb classes with LevelDBWrapper.

In most files under sync_file_system/drive_backend/,
leveldb::DB and leveldb::WriteBatch are replaced with
LevelDBWrapper to have a database transparent.

BUG=347425
TEST=./unit_tests --gtest_filter="MetadataDatabase*:DriveBackend*:LevelDBWrapper*"

Review URL: https://codereview.chromium.org/428063002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@287573 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc

@@ -11,65 +11,62 @@
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
+#include "chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/gdata_wapi_parser.h"
-#include "third_party/leveldatabase/src/include/leveldb/db.h"
-#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
+#include "third_party/leveldatabase/src/include/leveldb/status.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
-void PutVersionToBatch(int64 version, leveldb::WriteBatch* batch) {
-  if (batch)
-    batch->Put(kDatabaseVersionKey, base::Int64ToString(version));
+void PutVersionToDB(int64 version, LevelDBWrapper* db) {
+  if (db)
+    db->Put(kDatabaseVersionKey, base::Int64ToString(version));
 }
 
-void PutServiceMetadataToBatch(const ServiceMetadata& service_metadata,
-                               leveldb::WriteBatch* batch) {
-  if (!batch)
+void PutServiceMetadataToDB(const ServiceMetadata& service_metadata,
+                            LevelDBWrapper* db) {
+  if (!db)
     return;
 
   std::string value;
   bool success = service_metadata.SerializeToString(&value);
   DCHECK(success);
-  batch->Put(kServiceMetadataKey, value);
+  db->Put(kServiceMetadataKey, value);
 }
 
-void PutFileMetadataToBatch(const FileMetadata& file,
-                            leveldb::WriteBatch* batch) {
-  if (!batch)
+void PutFileMetadataToDB(const FileMetadata& file, LevelDBWrapper* db) {
+  if (!db)
     return;
 
   std::string value;
   bool success = file.SerializeToString(&value);
   DCHECK(success);
-  batch->Put(kFileMetadataKeyPrefix + file.file_id(), value);
+  db->Put(kFileMetadataKeyPrefix + file.file_id(), value);
 }
 
-void PutFileTrackerToBatch(const FileTracker& tracker,
-                           leveldb::WriteBatch* batch) {
-  if (!batch)
+void PutFileTrackerToDB(const FileTracker& tracker, LevelDBWrapper* db) {
+  if (!db)
     return;
 
   std::string value;
   bool success = tracker.SerializeToString(&value);
   DCHECK(success);
-  batch->Put(kFileTrackerKeyPrefix + base::Int64ToString(tracker.tracker_id()),
-             value);
+  db->Put(kFileTrackerKeyPrefix + base::Int64ToString(tracker.tracker_id()),
+          value);
 }
 
-void PutFileMetadataDeletionToBatch(const std::string& file_id,
-                                    leveldb::WriteBatch* batch) {
-  if (batch)
-    batch->Delete(kFileMetadataKeyPrefix + file_id);
+void PutFileMetadataDeletionToDB(const std::string& file_id,
+                                 LevelDBWrapper* db) {
+  if (db)
+    db->Delete(kFileMetadataKeyPrefix + file_id);
 }
 
-void PutFileTrackerDeletionToBatch(int64 tracker_id,
-                                   leveldb::WriteBatch* batch) {
-  if (batch)
-    batch->Delete(kFileTrackerKeyPrefix + base::Int64ToString(tracker_id));
+void PutFileTrackerDeletionToDB(int64 tracker_id, LevelDBWrapper* db) {
+  if (db)
+    db->Delete(kFileTrackerKeyPrefix + base::Int64ToString(tracker_id));
 }
 
 bool HasFileAsParent(const FileDetails& details, const std::string& file_id) {
@@ -171,14 +168,12 @@ bool RemovePrefix(const std::string& str, const std::string& prefix,
   return true;
 }
 
-scoped_ptr<ServiceMetadata> InitializeServiceMetadata(leveldb::DB* db) {
+scoped_ptr<ServiceMetadata> InitializeServiceMetadata(LevelDBWrapper* db) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(db);
 
   std::string value;
-  leveldb::Status status = db->Get(leveldb::ReadOptions(),
-                                   kServiceMetadataKey,
-                                   &value);
+  leveldb::Status status = db->Get(kServiceMetadataKey, &value);
 
   scoped_ptr<ServiceMetadata> service_metadata(new ServiceMetadata);
   if (!status.ok() || !service_metadata->ParseFromString(value))

chrome/browser/sync_file_system/drive_backend/drive_backend_util.h

@@ -22,27 +22,21 @@ class FileResource;
 class ResourceEntry;
 }
 
-namespace leveldb {
-class DB;
-class WriteBatch;
-}
-
 namespace sync_file_system {
 namespace drive_backend {
 
-void PutVersionToBatch(int64 version, leveldb::WriteBatch* batch);
+class LevelDBWrapper;
+
+void PutVersionToDB(int64 version, LevelDBWrapper* db);
 
-void PutServiceMetadataToBatch(const ServiceMetadata& service_metadata,
-                               leveldb::WriteBatch* batch);
-void PutFileMetadataToBatch(const FileMetadata& file,
-                            leveldb::WriteBatch* batch);
-void PutFileTrackerToBatch(const FileTracker& tracker,
-                           leveldb::WriteBatch* batch);
+void PutServiceMetadataToDB(const ServiceMetadata& service_metadata,
+                            LevelDBWrapper* db);
+void PutFileMetadataToDB(const FileMetadata& file, LevelDBWrapper* db);
+void PutFileTrackerToDB(const FileTracker& tracker, LevelDBWrapper* db);
 
-void PutFileMetadataDeletionToBatch(const std::string& file_id,
-                                    leveldb::WriteBatch* batch);
-void PutFileTrackerDeletionToBatch(int64 tracker_id,
-                                   leveldb::WriteBatch* batch);
+void PutFileMetadataDeletionToDB(const std::string& file_id,
+                                 LevelDBWrapper* db);
+void PutFileTrackerDeletionToDB(int64 tracker_id, LevelDBWrapper* db);
 
 bool HasFileAsParent(const FileDetails& details, const std::string& file_id);
 
@@ -58,7 +52,7 @@ SyncStatusCode GDataErrorCodeToSyncStatusCode(
 bool RemovePrefix(const std::string& str, const std::string& prefix,
                   std::string* out);
 
-scoped_ptr<ServiceMetadata> InitializeServiceMetadata(leveldb::DB* db);
+scoped_ptr<ServiceMetadata> InitializeServiceMetadata(LevelDBWrapper* db);
 
 template <typename Src, typename Dest>
 void AppendContents(const Src& src, Dest* dest) {

chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.cc

@@ -193,7 +193,7 @@ void LevelDBWrapper::Clear() {
   pending_.clear();
 }
 
-leveldb::DB* LevelDBWrapper::GetLevelDBForTesting() {
+leveldb::DB* LevelDBWrapper::GetLevelDB() {
   return db_.get();
 }
 

chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h

@@ -88,7 +88,10 @@ class LevelDBWrapper {
   // Clears pending transactions.
   void Clear();
 
-  leveldb::DB* GetLevelDBForTesting();
+  // TODO(peria): Rename this method to GetLevelDBForTesting, after removing
+  // usages of drive_backend::MigrateDatabaseFromVxToVy() under
+  // drive_backend_v1/.
+  leveldb::DB* GetLevelDB();
 
  private:
   scoped_ptr<leveldb::DB> db_;

chrome/browser/sync_file_system/drive_backend/leveldb_wrapper_unittest.cc

@@ -38,7 +38,7 @@ class LevelDBWrapperTest : public testing::Test {
   }
 
   void CreateDefaultDatabase() {
-    leveldb::DB* db = db_->GetLevelDBForTesting();
+    leveldb::DB* db = db_->GetLevelDB();
 
     // Expected contents are
     // {"a": "1", "ab": "0", "bb": "3", "d": "4"}

chrome/browser/sync_file_system/drive_backend/metadata_database.h

@@ -29,9 +29,7 @@ class SingleThreadTaskRunner;
 }
 
 namespace leveldb {
-class DB;
 class Env;
-class WriteBatch;
 }
 
 namespace google_apis {
@@ -50,6 +48,7 @@ namespace drive_backend {
 class FileDetails;
 class FileMetadata;
 class FileTracker;
+class LevelDBWrapper;
 class MetadataDatabaseIndexInterface;
 class ServiceMetadata;
 
@@ -138,7 +137,7 @@ class MetadataDatabase {
                      leveldb::Env* env_override,
                      const CreateCallback& callback);
   static SyncStatusCode CreateForTesting(
-      scoped_ptr<leveldb::DB> db,
+      scoped_ptr<LevelDBWrapper> db,
       scoped_ptr<MetadataDatabase>* metadata_database_out);
 
   ~MetadataDatabase();
@@ -358,27 +357,22 @@ class MetadataDatabase {
 
   // Database manipulation methods.
   void RegisterTrackerAsAppRoot(const std::string& app_id,
-                                int64 tracker_id,
-                                leveldb::WriteBatch* batch);
+                                int64 tracker_id);
 
   void CreateTrackerForParentAndFileID(const FileTracker& parent_tracker,
-                                       const std::string& file_id,
-                                       leveldb::WriteBatch* batch);
+                                       const std::string& file_id);
   void CreateTrackerForParentAndFileMetadata(const FileTracker& parent_tracker,
                                              const FileMetadata& file_metadata,
-                                             UpdateOption option,
-                                             leveldb::WriteBatch* batch);
+                                             UpdateOption option);
   void CreateTrackerInternal(const FileTracker& parent_tracker,
                              const std::string& file_id,
                              const FileDetails* details,
-                             UpdateOption option,
-                             leveldb::WriteBatch* batch);
+                             UpdateOption option);
 
   void MaybeAddTrackersForNewFile(const FileMetadata& file,
-                                  UpdateOption option,
-                                  leveldb::WriteBatch* batch);
+                                  UpdateOption option);
 
-  int64 IncrementTrackerID(leveldb::WriteBatch* batch);
+  int64 IncrementTrackerID();
 
   bool CanActivateTracker(const FileTracker& tracker);
   bool ShouldKeepDirty(const FileTracker& tracker) const;
@@ -388,37 +382,31 @@ class MetadataDatabase {
   bool HasActiveTrackerForPath(int64 parent_tracker,
                                const std::string& title) const;
 
-  void RemoveUnneededTrackersForMissingFile(const std::string& file_id,
-                                            leveldb::WriteBatch* batch);
+  void RemoveUnneededTrackersForMissingFile(const std::string& file_id);
   void UpdateByFileMetadata(const tracked_objects::Location& from_where,
                             scoped_ptr<FileMetadata> file,
-                            UpdateOption option,
-                            leveldb::WriteBatch* batch);
+                            UpdateOption option);
 
-  void WriteToDatabase(scoped_ptr<leveldb::WriteBatch> batch,
-                       const SyncStatusCallback& callback);
+  void WriteToDatabase(const SyncStatusCallback& callback);
 
   bool HasNewerFileMetadata(const std::string& file_id, int64 change_id);
 
   scoped_ptr<base::ListValue> DumpTrackers();
   scoped_ptr<base::ListValue> DumpMetadata();
 
-  void AttachSyncRoot(const google_apis::FileResource& sync_root_folder,
-                      leveldb::WriteBatch* batch);
-  void AttachInitialAppRoot(const google_apis::FileResource& app_root_folder,
-                            leveldb::WriteBatch* batch);
+  void AttachSyncRoot(const google_apis::FileResource& sync_root_folder);
+  void AttachInitialAppRoot(const google_apis::FileResource& app_root_folder);
 
   void ForceActivateTrackerByPath(int64 parent_tracker_id,
                                   const std::string& title,
-                                  const std::string& file_id,
-                                  leveldb::WriteBatch* batch);
+                                  const std::string& file_id);
 
   void DetachFromSequence();
 
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner_;
   base::FilePath database_path_;
   leveldb::Env* env_override_;
-  scoped_ptr<leveldb::DB> db_;
+  scoped_ptr<LevelDBWrapper> db_;
 
   int64 largest_known_change_id_;
 

chrome/browser/sync_file_system/drive_backend/metadata_database_index.cc

@@ -10,6 +10,7 @@
 #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"
@@ -76,12 +77,11 @@ typename Container::mapped_type FindItem(
   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();
@@ -122,7 +122,7 @@ void ReadDatabaseContents(leveldb::DB* db,
 
 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;
 
@@ -172,7 +172,7 @@ void RemoveUnreachableItems(DatabaseContents* contents,
       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();
@@ -190,7 +190,7 @@ void RemoveUnreachableItems(DatabaseContents* contents,
       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();
@@ -200,20 +200,19 @@ void RemoveUnreachableItems(DatabaseContents* contents,
 
 // 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();
 }
@@ -221,7 +220,7 @@ MetadataDatabaseIndex::Create(leveldb::DB* db, leveldb::WriteBatch* batch) {
 // 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();
 }
@@ -232,11 +231,11 @@ void MetadataDatabaseIndex::Initialize(
   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());
@@ -245,7 +244,7 @@ void MetadataDatabaseIndex::Initialize(
                            app_root_by_app_id_.size());
 }
 
-MetadataDatabaseIndex::MetadataDatabaseIndex() {}
+MetadataDatabaseIndex::MetadataDatabaseIndex(LevelDBWrapper* db) : db_(db) {}
 MetadataDatabaseIndex::~MetadataDatabaseIndex() {}
 
 bool MetadataDatabaseIndex::GetFileMetadata(
@@ -269,8 +268,8 @@ bool MetadataDatabaseIndex::GetFileTracker(
 }
 
 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;
@@ -280,9 +279,9 @@ void MetadataDatabaseIndex::StoreFileMetadata(
   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;
@@ -312,15 +311,13 @@ void MetadataDatabaseIndex::StoreFileTracker(scoped_ptr<FileTracker> 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) {
@@ -393,8 +390,7 @@ int64 MetadataDatabaseIndex::PickDirtyTracker() const {
   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);
 }
@@ -403,8 +399,7 @@ 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();
@@ -423,21 +418,21 @@ size_t MetadataDatabaseIndex::CountFileTracker() const {
 }
 
 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 {

chrome/browser/sync_file_system/drive_backend/metadata_database_index.h

@@ -16,16 +16,12 @@
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_interface.h"
 #include "chrome/browser/sync_file_system/drive_backend/tracker_id_set.h"
 
-namespace leveldb {
-class DB;
-class WriteBatch;
-}
-
 namespace sync_file_system {
 namespace drive_backend {
 
 class FileMetadata;
 class FileTracker;
+class LevelDBWrapper;
 class ServiceMetadata;
 
 }  // namespace drive_backend
@@ -64,8 +60,7 @@ class MetadataDatabaseIndex : public MetadataDatabaseIndexInterface {
  public:
   virtual ~MetadataDatabaseIndex();
 
-  static scoped_ptr<MetadataDatabaseIndex> Create(
-      leveldb::DB* db, leveldb::WriteBatch* batch);
+  static scoped_ptr<MetadataDatabaseIndex> Create(LevelDBWrapper* db);
   static scoped_ptr<MetadataDatabaseIndex> CreateForTesting(
       DatabaseContents* contents);
 
@@ -74,14 +69,10 @@ class MetadataDatabaseIndex : public MetadataDatabaseIndexInterface {
       const std::string& file_id, FileMetadata* metadata) const OVERRIDE;
   virtual bool GetFileTracker(
       int64 tracker_id, FileTracker* tracker) const OVERRIDE;
-  virtual void StoreFileMetadata(
-      scoped_ptr<FileMetadata> metadata, leveldb::WriteBatch* batch) OVERRIDE;
-  virtual void StoreFileTracker(
-      scoped_ptr<FileTracker> tracker, leveldb::WriteBatch* batch) OVERRIDE;
-  virtual void RemoveFileMetadata(
-      const std::string& file_id, leveldb::WriteBatch* batch) OVERRIDE;
-  virtual void RemoveFileTracker(
-      int64 tracker_id, leveldb::WriteBatch* batch) OVERRIDE;
+  virtual void StoreFileMetadata(scoped_ptr<FileMetadata> metadata) OVERRIDE;
+  virtual void StoreFileTracker(scoped_ptr<FileTracker> tracker) OVERRIDE;
+  virtual void RemoveFileMetadata(const std::string& file_id) OVERRIDE;
+  virtual void RemoveFileTracker(int64 tracker_id) OVERRIDE;
   virtual TrackerIDSet GetFileTrackerIDsByFileID(
       const std::string& file_id) const OVERRIDE;
   virtual int64 GetAppRootTracker(const std::string& app_id) const OVERRIDE;
@@ -93,19 +84,15 @@ class MetadataDatabaseIndex : public MetadataDatabaseIndexInterface {
   virtual std::string PickMultiTrackerFileID() const OVERRIDE;
   virtual ParentIDAndTitle PickMultiBackingFilePath() const OVERRIDE;
   virtual int64 PickDirtyTracker() const OVERRIDE;
-  virtual void DemoteDirtyTracker(
-      int64 tracker_id, leveldb::WriteBatch* batch) OVERRIDE;
+  virtual void DemoteDirtyTracker(int64 tracker_id) OVERRIDE;
   virtual bool HasDemotedDirtyTracker() const OVERRIDE;
-  virtual void PromoteDemotedDirtyTrackers(leveldb::WriteBatch* batch) OVERRIDE;
+  virtual void PromoteDemotedDirtyTrackers() OVERRIDE;
   virtual size_t CountDirtyTracker() const OVERRIDE;
   virtual size_t CountFileMetadata() const OVERRIDE;
   virtual size_t CountFileTracker() const OVERRIDE;
-  virtual void SetSyncRootTrackerID(int64 sync_root_id,
-                                    leveldb::WriteBatch* batch) const OVERRIDE;
-  virtual void SetLargestChangeID(int64 largest_change_id,
-                                  leveldb::WriteBatch* batch) const OVERRIDE;
-  virtual void SetNextTrackerID(int64 next_tracker_id,
-                                leveldb::WriteBatch* batch) const OVERRIDE;
+  virtual void SetSyncRootTrackerID(int64 sync_root_id) const OVERRIDE;
+  virtual void SetLargestChangeID(int64 largest_change_id) const OVERRIDE;
+  virtual void SetNextTrackerID(int64 next_tracker_id) const OVERRIDE;
   virtual int64 GetSyncRootTrackerID() const OVERRIDE;
   virtual int64 GetLargestChangeID() const OVERRIDE;
   virtual int64 GetNextTrackerID() const OVERRIDE;
@@ -126,7 +113,7 @@ class MetadataDatabaseIndex : public MetadataDatabaseIndexInterface {
 
   friend class MetadataDatabaseTest;
 
-  MetadataDatabaseIndex();
+  explicit MetadataDatabaseIndex(LevelDBWrapper* db);
   void Initialize(scoped_ptr<ServiceMetadata> service_metadata,
                   DatabaseContents* contents);
 
@@ -155,6 +142,7 @@ class MetadataDatabaseIndex : public MetadataDatabaseIndexInterface {
   void RemoveFromDirtyTrackerIndexes(const FileTracker& tracker);
 
   scoped_ptr<ServiceMetadata> service_metadata_;
+  LevelDBWrapper* db_;  // Not owned
 
   MetadataByID metadata_by_id_;
   TrackerByID tracker_by_id_;

chrome/browser/sync_file_system/drive_backend/metadata_database_index_interface.h

@@ -10,10 +10,6 @@
 
 #include "base/memory/scoped_ptr.h"
 
-namespace leveldb {
-class WriteBatch;
-}
-
 namespace sync_file_system {
 namespace drive_backend {
 
@@ -50,21 +46,17 @@ class MetadataDatabaseIndexInterface {
 
   // Stores |metadata| and updates indexes.
   // This overwrites existing FileMetadata for the same |file_id|.
-  virtual void StoreFileMetadata(
-      scoped_ptr<FileMetadata> metadata, leveldb::WriteBatch* batch) = 0;
+  virtual void StoreFileMetadata(scoped_ptr<FileMetadata> metadata) = 0;
 
   // Stores |tracker| and updates indexes.
   // This overwrites existing FileTracker for the same |tracker_id|.
-  virtual void StoreFileTracker(
-      scoped_ptr<FileTracker> tracker, leveldb::WriteBatch* batch) = 0;
+  virtual void StoreFileTracker(scoped_ptr<FileTracker> tracker) = 0;
 
   // Removes FileMetadata identified by |file_id| from indexes.
-  virtual void RemoveFileMetadata(
-      const std::string& file_id, leveldb::WriteBatch* batch) = 0;
+  virtual void RemoveFileMetadata(const std::string& file_id) = 0;
 
   // Removes FileTracker identified by |tracker_id| from indexes.
-  virtual void RemoveFileTracker(
-      int64 tracker_id, leveldb::WriteBatch* batch) = 0;
+  virtual void RemoveFileTracker(int64 tracker_id) = 0;
 
   // Returns a set of FileTracker that have |file_id| as its own.
   virtual TrackerIDSet GetFileTrackerIDsByFileID(
@@ -94,24 +86,20 @@ class MetadataDatabaseIndexInterface {
   virtual int64 PickDirtyTracker() const = 0;
 
   // Demotes a dirty tracker.
-  virtual void DemoteDirtyTracker(
-      int64 tracker_id, leveldb::WriteBatch* batch) = 0;
+  virtual void DemoteDirtyTracker(int64 tracker_id) = 0;
 
   virtual bool HasDemotedDirtyTracker() const = 0;
 
   // Promotes all demoted dirty trackers to normal dirty trackers.
-  virtual void PromoteDemotedDirtyTrackers(leveldb::WriteBatch* batch) = 0;
+  virtual void PromoteDemotedDirtyTrackers() = 0;
 
   virtual size_t CountDirtyTracker() const = 0;
   virtual size_t CountFileMetadata() const = 0;
   virtual size_t CountFileTracker() const = 0;
 
-  virtual void SetSyncRootTrackerID(int64 sync_root_id,
-                                    leveldb::WriteBatch* batch) const = 0;
-  virtual void SetLargestChangeID(int64 largest_change_id,
-                                  leveldb::WriteBatch* batch) const = 0;
-  virtual void SetNextTrackerID(int64 next_tracker_id,
-                                leveldb::WriteBatch* batch) const = 0;
+  virtual void SetSyncRootTrackerID(int64 sync_root_id) const = 0;
+  virtual void SetLargestChangeID(int64 largest_change_id) const = 0;
+  virtual void SetNextTrackerID(int64 next_tracker_id) const = 0;
   virtual int64 GetSyncRootTrackerID() const = 0;
   virtual int64 GetLargestChangeID() const = 0;
   virtual int64 GetNextTrackerID() const = 0;

chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.h

@@ -13,15 +13,12 @@
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_interface.h"
 #include "chrome/browser/sync_file_system/drive_backend/tracker_id_set.h"
 
-namespace leveldb {
-class DB;
-}
-
 namespace sync_file_system {
 namespace drive_backend {
 
 class FileMetadata;
 class FileTracker;
+class LevelDBWrapper;
 class ServiceMetadata;
 struct DatabaseContents;
 // TODO(peria): Migrate implementation of ParentIDAndTitle structure from
@@ -31,8 +28,7 @@ struct ParentIDAndTitle;
 // Maintains indexes of MetadataDatabase on disk.
 class MetadataDatabaseIndexOnDisk : public MetadataDatabaseIndexInterface {
  public:
-  static scoped_ptr<MetadataDatabaseIndexOnDisk>
-      Create(leveldb::DB* db, leveldb::WriteBatch* batch);
+  static scoped_ptr<MetadataDatabaseIndexOnDisk>  Create(LevelDBWrapper* db);
 
   virtual ~MetadataDatabaseIndexOnDisk();
 
@@ -41,14 +37,10 @@ class MetadataDatabaseIndexOnDisk : public MetadataDatabaseIndexInterface {
       const std::string& file_id, FileMetadata* metadata) const OVERRIDE;
   virtual bool GetFileTracker(
       int64 tracker_id, FileTracker* tracker) const OVERRIDE;
-  virtual void StoreFileMetadata(
-      scoped_ptr<FileMetadata> metadata, leveldb::WriteBatch* batch) OVERRIDE;
-  virtual void StoreFileTracker(
-      scoped_ptr<FileTracker> tracker, leveldb::WriteBatch* batch) OVERRIDE;
-  virtual void RemoveFileMetadata(
-      const std::string& file_id, leveldb::WriteBatch* batch) OVERRIDE;
-  virtual void RemoveFileTracker(
-      int64 tracker_id, leveldb::WriteBatch* batch) OVERRIDE;
+  virtual void StoreFileMetadata(scoped_ptr<FileMetadata> metadata) OVERRIDE;
+  virtual void StoreFileTracker(scoped_ptr<FileTracker> tracker) OVERRIDE;
+  virtual void RemoveFileMetadata(const std::string& file_id) OVERRIDE;
+  virtual void RemoveFileTracker(int64 tracker_id) OVERRIDE;
   virtual TrackerIDSet GetFileTrackerIDsByFileID(
       const std::string& file_id) const OVERRIDE;
   virtual int64 GetAppRootTracker(const std::string& app_id) const OVERRIDE;
@@ -59,19 +51,15 @@ class MetadataDatabaseIndexOnDisk : public MetadataDatabaseIndexInterface {
   virtual std::string PickMultiTrackerFileID() const OVERRIDE;
   virtual ParentIDAndTitle PickMultiBackingFilePath() const OVERRIDE;
   virtual int64 PickDirtyTracker() const OVERRIDE;
-  virtual void DemoteDirtyTracker(
-      int64 tracker_id, leveldb::WriteBatch* batch) OVERRIDE;
+  virtual void DemoteDirtyTracker(int64 tracker_id) OVERRIDE;
   virtual bool HasDemotedDirtyTracker() const OVERRIDE;
-  virtual void PromoteDemotedDirtyTrackers(leveldb::WriteBatch* batch) OVERRIDE;
+  virtual void PromoteDemotedDirtyTrackers() OVERRIDE;
   virtual size_t CountDirtyTracker() const OVERRIDE;
   virtual size_t CountFileMetadata() const OVERRIDE;
   virtual size_t CountFileTracker() const OVERRIDE;
-  virtual void SetSyncRootTrackerID(int64 sync_root_id,
-                                    leveldb::WriteBatch* batch) const OVERRIDE;
-  virtual void SetLargestChangeID(int64 largest_change_id,
-                                  leveldb::WriteBatch* batch) const OVERRIDE;
-  virtual void SetNextTrackerID(int64 next_tracker_id,
-                                leveldb::WriteBatch* batch) const OVERRIDE;
+  virtual void SetSyncRootTrackerID(int64 sync_root_id) const OVERRIDE;
+  virtual void SetLargestChangeID(int64 largest_change_id) const OVERRIDE;
+  virtual void SetNextTrackerID(int64 next_tracker_id) const OVERRIDE;
   virtual int64 GetSyncRootTrackerID() const OVERRIDE;
   virtual int64 GetLargestChangeID() const OVERRIDE;
   virtual int64 GetNextTrackerID() const OVERRIDE;
@@ -80,7 +68,7 @@ class MetadataDatabaseIndexOnDisk : public MetadataDatabaseIndexInterface {
   virtual std::vector<std::string> GetAllMetadataIDs() const OVERRIDE;
 
   // Builds on-disk indexes from FileTracker entries on disk.
-  void BuildTrackerIndexes(leveldb::WriteBatch* batch);
+  void BuildTrackerIndexes();
 
  private:
   enum NumEntries {
@@ -89,43 +77,31 @@ class MetadataDatabaseIndexOnDisk : public MetadataDatabaseIndexInterface {
     MULTIPLE,  // Two or more entires are found.
   };
 
-  explicit MetadataDatabaseIndexOnDisk(leveldb::DB* db);
+  explicit MetadataDatabaseIndexOnDisk(LevelDBWrapper* db);
 
   // Maintain indexes from AppIDs to tracker IDs.
-  void AddToAppIDIndex(const FileTracker& new_tracker,
-                       leveldb::WriteBatch* batch);
+  void AddToAppIDIndex(const FileTracker& new_tracker);
   void UpdateInAppIDIndex(const FileTracker& old_tracker,
-                          const FileTracker& new_tracker,
-                          leveldb::WriteBatch* batch);
-  void RemoveFromAppIDIndex(const FileTracker& tracker,
-                            leveldb::WriteBatch* batch);
+                          const FileTracker& new_tracker);
+  void RemoveFromAppIDIndex(const FileTracker& tracker);
 
   // Maintain indexes from remote file IDs to tracker ID sets.
-  void AddToFileIDIndexes(const FileTracker& new_tracker,
-                          leveldb::WriteBatch* batch);
+  void AddToFileIDIndexes(const FileTracker& new_tracker);
   void UpdateInFileIDIndexes(const FileTracker& old_tracker,
-                             const FileTracker& new_tracker,
-                             leveldb::WriteBatch* batch);
-  void RemoveFromFileIDIndexes(const FileTracker& tracker,
-                               leveldb::WriteBatch* batch);
+                             const FileTracker& new_tracker);
+  void RemoveFromFileIDIndexes(const FileTracker& tracker);
 
   // Maintain indexes from path indexes to tracker ID sets
-  void AddToPathIndexes(const FileTracker& new_tracker,
-                        leveldb::WriteBatch* batch);
+  void AddToPathIndexes(const FileTracker& new_tracker);
   void UpdateInPathIndexes(const FileTracker& old_tracker,
-                           const FileTracker& new_tracker,
-                           leveldb::WriteBatch* batch);
-  void RemoveFromPathIndexes(const FileTracker& tracker,
-                             leveldb::WriteBatch* batch);
+                           const FileTracker& new_tracker);
+  void RemoveFromPathIndexes(const FileTracker& tracker);
 
   // Maintain dirty tracker IDs.
-  void AddToDirtyTrackerIndexes(const FileTracker& new_tracker,
-                                leveldb::WriteBatch* batch);
+  void AddToDirtyTrackerIndexes(const FileTracker& new_tracker);
   void UpdateInDirtyTrackerIndexes(const FileTracker& old_tracker,
-                                   const FileTracker& new_tracker,
-                                   leveldb::WriteBatch* batch);
-  void RemoveFromDirtyTrackerIndexes(const FileTracker& tracker,
-                                     leveldb::WriteBatch* batch);
+                                   const FileTracker& new_tracker);
+  void RemoveFromDirtyTrackerIndexes(const FileTracker& tracker);
 
   // Returns a TrackerIDSet built from IDs which are found with given key
   // and key prefix.
@@ -141,32 +117,28 @@ class MetadataDatabaseIndexOnDisk : public MetadataDatabaseIndexInterface {
   void AddToTrackerIDSetWithPrefix(
       const std::string& active_tracker_key,
       const std::string& key_prefix,
-      const FileTracker& tracker,
-      leveldb::WriteBatch* batch);
+      const FileTracker& tracker);
 
   // Returns true if |tracker_id| is removed successfully.  If no other entries
   // are stored with |key_prefix|, the entry for |active_key| is also removed.
   bool EraseInTrackerIDSetWithPrefix(
       const std::string& active_tracker_key,
       const std::string& key_prefix,
-      int64 tracker_id,
-      leveldb::WriteBatch* batch);
+      int64 tracker_id);
 
   // Adds an entry for |active_key| on DB, if |tracker_id| has an entry with
   // |key_prefix|.
   void ActivateInTrackerIDSetWithPrefix(
       const std::string& active_tracker_key,
       const std::string& key_prefix,
-      int64 tracker_id,
-      leveldb::WriteBatch* batch);
+      int64 tracker_id);
 
   // Removes an entry for |active_key| on DB, if the value of |active_key| key
   // is |tracker_id|.
   void DeactivateInTrackerIDSetWithPrefix(
       const std::string& active_tracker_key,
       const std::string& key_prefix,
-      int64 tracker_id,
-      leveldb::WriteBatch* batch);
+      int64 tracker_id);
 
   // Checks if |db_| has an entry whose key is |key|.
   bool DBHasKey(const std::string& key);
@@ -175,7 +147,7 @@ class MetadataDatabaseIndexOnDisk : public MetadataDatabaseIndexInterface {
   // Entries for |ignored_id| are not counted in.
   NumEntries CountWithPrefix(const std::string& prefix, int64 ignored_id);
 
-  leveldb::DB* db_;  // Not owned.
+  LevelDBWrapper* db_;  // Not owned.
   scoped_ptr<ServiceMetadata> service_metadata_;
 
   DISALLOW_COPY_AND_ASSIGN(MetadataDatabaseIndexOnDisk);

chrome/browser/sync_file_system/drive_backend/metadata_database_index_unittest.cc

@@ -107,9 +107,9 @@ TEST(MetadataDatabaseIndexTest, UpdateTest) {
       MetadataDatabaseIndex::CreateForTesting(
           CreateTestDatabaseContents().get());
 
-  index->DemoteDirtyTracker(kPlaceholderTrackerID, NULL);
+  index->DemoteDirtyTracker(kPlaceholderTrackerID);
   EXPECT_EQ(kInvalidTrackerID, index->PickDirtyTracker());
-  index->PromoteDemotedDirtyTrackers(NULL);
+  index->PromoteDemotedDirtyTrackers();
   EXPECT_EQ(kPlaceholderTrackerID, index->PickDirtyTracker());
 
   FileMetadata metadata;
@@ -121,14 +121,14 @@ TEST(MetadataDatabaseIndexTest, UpdateTest) {
   scoped_ptr<FileTracker> new_tracker =
       test_util::CreateTracker(metadata, new_tracker_id, &app_root_tracker);
   new_tracker->set_active(false);
-  index->StoreFileTracker(new_tracker.Pass(), NULL);
+  index->StoreFileTracker(new_tracker.Pass());
 
   EXPECT_EQ("file_id", index->PickMultiTrackerFileID());
   EXPECT_EQ(ParentIDAndTitle(kAppRootTrackerID, std::string("file")),
             index->PickMultiBackingFilePath());
 
-  index->RemoveFileMetadata("file_id", NULL);
-  index->RemoveFileTracker(kFileTrackerID, NULL);
+  index->RemoveFileMetadata("file_id");
+  index->RemoveFileTracker(kFileTrackerID);
 
   EXPECT_FALSE(index->GetFileMetadata("file_id", NULL));
   EXPECT_FALSE(index->GetFileTracker(kFileTrackerID, NULL));

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc

@@ -12,6 +12,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.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.pb.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_interface.h"
@@ -216,7 +217,7 @@ class MetadataDatabaseTest : public testing::Test {
 
   void SetUpDatabaseByTrackedFiles(const TrackedFile** tracked_files,
                                    int size) {
-    scoped_ptr<leveldb::DB> db = InitializeLevelDB();
+    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
     ASSERT_TRUE(db);
 
     for (int i = 0; i < size; ++i) {
@@ -254,7 +255,7 @@ class MetadataDatabaseTest : public testing::Test {
 
   MetadataDatabase* metadata_database() { return metadata_database_.get(); }
 
-  scoped_ptr<leveldb::DB> InitializeLevelDB() {
+  scoped_ptr<LevelDBWrapper> InitializeLevelDB() {
     leveldb::DB* db = NULL;
     leveldb::Options options;
     options.create_if_missing = true;
@@ -264,22 +265,21 @@ class MetadataDatabaseTest : public testing::Test {
         leveldb::DB::Open(options, database_dir_.path().AsUTF8Unsafe(), &db);
     EXPECT_TRUE(status.ok());
 
-    db->Put(leveldb::WriteOptions(),
-            kDatabaseVersionKey,
-            base::Int64ToString(3));
-    SetUpServiceMetadata(db);
+    scoped_ptr<LevelDBWrapper> wrapper(new LevelDBWrapper(make_scoped_ptr(db)));
 
-    return make_scoped_ptr(db);
+    wrapper->Put(kDatabaseVersionKey, base::Int64ToString(3));
+    SetUpServiceMetadata(wrapper.get());
+
+    return wrapper.Pass();
   }
 
-  void SetUpServiceMetadata(leveldb::DB* db) {
+  void SetUpServiceMetadata(LevelDBWrapper* db) {
     ServiceMetadata service_metadata;
     service_metadata.set_largest_change_id(kInitialChangeID);
     service_metadata.set_sync_root_tracker_id(kSyncRootTrackerID);
     service_metadata.set_next_tracker_id(next_tracker_id_);
-    leveldb::WriteBatch batch;
-    PutServiceMetadataToBatch(service_metadata, &batch);
-    EXPECT_TRUE(db->Write(leveldb::WriteOptions(), &batch).ok());
+    PutServiceMetadataToDB(service_metadata, db);
+    EXPECT_TRUE(db->Commit().ok());
   }
 
   FileMetadata CreateSyncRootMetadata() {
@@ -451,17 +451,15 @@ class MetadataDatabaseTest : public testing::Test {
     changes->push_back(change.release());
   }
 
-  leveldb::Status PutFileToDB(leveldb::DB* db, const FileMetadata& file) {
-    leveldb::WriteBatch batch;
-    PutFileMetadataToBatch(file, &batch);
-    return db->Write(leveldb::WriteOptions(), &batch);
+  leveldb::Status PutFileToDB(LevelDBWrapper* db, const FileMetadata& file) {
+    PutFileMetadataToDB(file, db);
+    return db->Commit();
   }
 
-  leveldb::Status PutTrackerToDB(leveldb::DB* db,
+  leveldb::Status PutTrackerToDB(LevelDBWrapper* db,
                                  const FileTracker& tracker) {
-    leveldb::WriteBatch batch;
-    PutFileTrackerToBatch(tracker, &batch);
-    return db->Write(leveldb::WriteOptions(), &batch);
+    PutFileTrackerToDB(tracker, db);
+    return db->Commit();
   }
 
   void VerifyReloadConsistency() {
@@ -746,7 +744,7 @@ TEST_F(MetadataDatabaseTest, BuildPathTest) {
   inactive_folder_tracker.set_active(false);
 
   {
-    scoped_ptr<leveldb::DB> db = InitializeLevelDB();
+    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
     ASSERT_TRUE(db);
 
     EXPECT_TRUE(PutFileToDB(db.get(), sync_root).ok());
@@ -799,7 +797,7 @@ TEST_F(MetadataDatabaseTest, FindNearestActiveAncestorTest) {
   inactive_folder_tracker.set_active(false);
 
   {
-    scoped_ptr<leveldb::DB> db = InitializeLevelDB();
+    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
     ASSERT_TRUE(db);
 
     EXPECT_TRUE(PutFileToDB(db.get(), sync_root).ok());

chrome/browser/sync_file_system/drive_backend/register_app_task_unittest.cc

@@ -17,6 +17,7 @@
 #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/fake_drive_service_helper.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/drive_backend/sync_engine_context.h"
@@ -27,7 +28,6 @@
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
-#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 namespace sync_file_system {
 namespace drive_backend {
@@ -77,7 +77,7 @@ class RegisterAppTaskTest : public testing::Test {
   }
 
  protected:
-  scoped_ptr<leveldb::DB> OpenLevelDB() {
+  scoped_ptr<LevelDBWrapper> OpenLevelDB() {
     leveldb::DB* db = NULL;
     leveldb::Options options;
     options.create_if_missing = true;
@@ -85,10 +85,10 @@ class RegisterAppTaskTest : public testing::Test {
     leveldb::Status status =
         leveldb::DB::Open(options, database_dir_.path().AsUTF8Unsafe(), &db);
     EXPECT_TRUE(status.ok());
-    return make_scoped_ptr<leveldb::DB>(db);
+    return make_scoped_ptr(new LevelDBWrapper(make_scoped_ptr(db)));
   }
 
-  void SetUpInitialData(leveldb::DB* db) {
+  void SetUpInitialData(LevelDBWrapper* db) {
     ServiceMetadata service_metadata;
     service_metadata.set_largest_change_id(100);
     service_metadata.set_sync_root_tracker_id(kSyncRootTrackerID);
@@ -111,16 +111,15 @@ class RegisterAppTaskTest : public testing::Test {
     *sync_root_tracker.mutable_synced_details() = sync_root_details;
     sync_root_tracker.set_active(true);
 
-    leveldb::WriteBatch batch;
-    batch.Put(kDatabaseVersionKey,
-              base::Int64ToString(kCurrentDatabaseVersion));
-    PutServiceMetadataToBatch(service_metadata, &batch);
-    PutFileMetadataToBatch(sync_root_metadata, &batch);
-    PutFileTrackerToBatch(sync_root_tracker, &batch);
-    EXPECT_TRUE(db->Write(leveldb::WriteOptions(), &batch).ok());
+    db->Put(kDatabaseVersionKey,
+            base::Int64ToString(kCurrentDatabaseVersion));
+    PutServiceMetadataToDB(service_metadata, db);
+    PutFileMetadataToDB(sync_root_metadata, db);
+    PutFileTrackerToDB(sync_root_tracker, db);
+    EXPECT_TRUE(db->Commit().ok());
   }
 
-  void CreateMetadataDatabase(scoped_ptr<leveldb::DB> db) {
+  void CreateMetadataDatabase(scoped_ptr<LevelDBWrapper> db) {
     ASSERT_TRUE(db);
     ASSERT_FALSE(context_->GetMetadataDatabase());
     scoped_ptr<MetadataDatabase> metadata_db;
@@ -140,7 +139,7 @@ class RegisterAppTaskTest : public testing::Test {
 
   void SetUpRegisteredAppRoot(
       const std::string& app_id,
-      leveldb::DB* db) {
+      LevelDBWrapper* db) {
     FileDetails details;
     details.set_title(app_id);
     details.set_file_kind(FILE_KIND_FOLDER);
@@ -159,14 +158,13 @@ class RegisterAppTaskTest : public testing::Test {
     *tracker.mutable_synced_details() = details;
     tracker.set_active(true);
 
-    leveldb::WriteBatch batch;
-    PutFileMetadataToBatch(metadata, &batch);
-    PutFileTrackerToBatch(tracker, &batch);
-    EXPECT_TRUE(db->Write(leveldb::WriteOptions(), &batch).ok());
+    PutFileMetadataToDB(metadata, db);
+    PutFileTrackerToDB(tracker, db);
+    EXPECT_TRUE(db->Commit().ok());
   }
 
   void SetUpUnregisteredAppRoot(const std::string& app_id,
-                                leveldb::DB* db) {
+                                LevelDBWrapper* db) {
     FileDetails details;
     details.set_title(app_id);
     details.set_file_kind(FILE_KIND_FOLDER);
@@ -184,10 +182,9 @@ class RegisterAppTaskTest : public testing::Test {
     *tracker.mutable_synced_details() = details;
     tracker.set_active(false);
 
-    leveldb::WriteBatch batch;
-    PutFileMetadataToBatch(metadata, &batch);
-    PutFileTrackerToBatch(tracker, &batch);
-    EXPECT_TRUE(db->Write(leveldb::WriteOptions(), &batch).ok());
+    PutFileMetadataToDB(metadata, db);
+    PutFileTrackerToDB(tracker, db);
+    EXPECT_TRUE(db->Commit().ok());
   }
 
   size_t CountRegisteredAppRoot() {
@@ -253,7 +250,7 @@ class RegisterAppTaskTest : public testing::Test {
 };
 
 TEST_F(RegisterAppTaskTest, AlreadyRegistered) {
-  scoped_ptr<leveldb::DB> db(OpenLevelDB());
+  scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
@@ -268,7 +265,7 @@ TEST_F(RegisterAppTaskTest, AlreadyRegistered) {
 }
 
 TEST_F(RegisterAppTaskTest, CreateAppFolder) {
-  scoped_ptr<leveldb::DB> db(OpenLevelDB());
+  scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
@@ -284,7 +281,7 @@ TEST_F(RegisterAppTaskTest, CreateAppFolder) {
 }
 
 TEST_F(RegisterAppTaskTest, RegisterExistingFolder) {
-  scoped_ptr<leveldb::DB> db(OpenLevelDB());
+  scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
@@ -299,7 +296,7 @@ TEST_F(RegisterAppTaskTest, RegisterExistingFolder) {
 }
 
 TEST_F(RegisterAppTaskTest, RegisterExistingFolder_MultipleCandidate) {
-  scoped_ptr<leveldb::DB> db(OpenLevelDB());
+  scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());