[SyncFS] Replace leveldb classes with LevelDBWrapper

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.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/sync_file_system/drive_backend/metadata_database.h"
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #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"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #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"
@@ skipping 185 matching lines @@
     return status;
   }
 
   void DropDatabase() {
     metadata_database_.reset();
     message_loop_.RunUntilIdle();
   }
 
   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) {
       const TrackedFile* file = tracked_files[i];
       if (file->should_be_absent)
         continue;
       if (!file->tracker_only)
         EXPECT_TRUE(PutFileToDB(db.get(), file->metadata).ok());
       EXPECT_TRUE(PutTrackerToDB(db.get(), file->tracker).ok());
     }
@@ skipping 17 matching lines @@
         file.tracker.tracker_id(), NULL));
   }
 
   void VerifyTrackedFiles(const TrackedFile** tracked_files, int size) {
     for (int i = 0; i < size; ++i)
       VerifyTrackedFile(*tracked_files[i]);
   }
 
   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;
     options.max_open_files = 0;  // Use minimum.
     options.env = in_memory_env_.get();
     leveldb::Status status =
         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() {
     FileMetadata sync_root;
     sync_root.set_file_id(kSyncRootFolderID);
     FileDetails* details = sync_root.mutable_details();
     details->set_title(kSyncRootFolderTitle);
     details->set_file_kind(FILE_KIND_FOLDER);
     details->set_change_id(current_change_id_);
     return sync_root;
@@ skipping 151 matching lines @@
 
   void ApplyNoopChangeToMetadata(FileMetadata* file) {
     file->mutable_details()->set_change_id(++current_change_id_);
   }
 
   void PushToChangeList(scoped_ptr<google_apis::ChangeResource> change,
                         ScopedVector<google_apis::ChangeResource>* changes) {
     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() {
     scoped_ptr<MetadataDatabase> metadata_database_2;
     ASSERT_EQ(SYNC_STATUS_OK,
               MetadataDatabase::CreateForTesting(
                   metadata_database_->db_.Pass(),
                   &metadata_database_2));
     metadata_database_->db_ = metadata_database_2->db_.Pass();
 
@@ skipping 264 matching lines @@
 
   FileMetadata file(CreateFileMetadata(folder, "file"));
   FileTracker file_tracker(CreateTracker(folder_tracker, file));
 
   FileMetadata inactive_folder(CreateFolderMetadata(app_root, "folder"));
   FileTracker inactive_folder_tracker(CreateTracker(app_root_tracker,
                                                     inactive_folder));
   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());
     EXPECT_TRUE(PutTrackerToDB(db.get(), sync_root_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), app_root).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), app_root_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), folder).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), file).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), file_tracker).ok());
@@ skipping 32 matching lines @@
   FileTracker folder_tracker2(CreateTracker(folder_tracker1, folder2));
   FileMetadata file(CreateFileMetadata(folder2, "file"));
   FileTracker file_tracker(CreateTracker(folder_tracker2, file));
 
   FileMetadata inactive_folder(CreateFolderMetadata(app_root, "folder1"));
   FileTracker inactive_folder_tracker(CreateTracker(app_root_tracker,
                                                     inactive_folder));
   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());
     EXPECT_TRUE(PutTrackerToDB(db.get(), sync_root_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), app_root).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), app_root_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), folder1).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker1).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), folder2).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker2).ok());
@@ skipping 347 matching lines @@
   EXPECT_TRUE(file->HasKey("details"));
 
   ASSERT_TRUE(files->GetDictionary(1, &file));
   EXPECT_TRUE(file->GetString("title", &str) && str == "file_0");
   EXPECT_TRUE(file->GetString("type", &str) && str == "file");
   EXPECT_TRUE(file->HasKey("details"));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system