[SyncFS] Replace leveldb classes with LevelDBWrapper

chrome/browser/sync_file_system/drive_backend/metadata_database.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 <algorithm>
 #include <stack>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/scoped_vector.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #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/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/drive_backend/metadata_db_migration_util.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "google_apis/drive/drive_api_parser.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/status.h"
@@ skipping 148 matching lines @@
   return app_root_tracker.Pass();
 }
 
 scoped_ptr<FileTracker> CloneFileTracker(const FileTracker* obj) {
   if (!obj)
     return scoped_ptr<FileTracker>();
   return scoped_ptr<FileTracker>(new FileTracker(*obj));
 }
 
 // Returns true if |db| has no content.
-bool IsDatabaseEmpty(leveldb::DB* db) {
+bool IsDatabaseEmpty(LevelDBWrapper* db) {
   DCHECK(db);
-  scoped_ptr<leveldb::Iterator> itr(db->NewIterator(leveldb::ReadOptions()));
+  scoped_ptr<LevelDBWrapper::Iterator> itr(db->NewIterator());
   itr->SeekToFirst();
   return !itr->Valid();
 }
 
 SyncStatusCode OpenDatabase(const base::FilePath& path,
                             leveldb::Env* env_override,
-                            scoped_ptr<leveldb::DB>* db_out,
+                            scoped_ptr<LevelDBWrapper>* db_out,
                             bool* created) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(db_out);
   DCHECK(created);
   DCHECK(path.IsAbsolute());
 
   leveldb::Options options;
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = true;
   if (env_override)
     options.env = env_override;
   leveldb::DB* db = NULL;
   leveldb::Status db_status =
       leveldb::DB::Open(options, path.AsUTF8Unsafe(), &db);
   SyncStatusCode status = LevelDBStatusToSyncStatusCode(db_status);
   if (status != SYNC_STATUS_OK) {
     delete db;
     return status;
   }
 
-  *created = IsDatabaseEmpty(db);
-  db_out->reset(db);
+  db_out->reset(new LevelDBWrapper(make_scoped_ptr(db)));
+  *created = IsDatabaseEmpty(db_out->get());
   return status;
 }
 
-SyncStatusCode MigrateDatabaseIfNeeded(leveldb::DB* db) {
+SyncStatusCode MigrateDatabaseIfNeeded(LevelDBWrapper* db) {
   // See metadata_database_index.cc for the database schema.
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(db);
   std::string value;
-  leveldb::Status status =
-      db->Get(leveldb::ReadOptions(), kDatabaseVersionKey, &value);
+  leveldb::Status status = db->Get(kDatabaseVersionKey, &value);
   int64 version = 0;
   if (status.ok()) {
     if (!base::StringToInt64(value, &version))
       return SYNC_DATABASE_ERROR_FAILED;
   } else {
     if (!status.IsNotFound())
       return SYNC_DATABASE_ERROR_FAILED;
   }
 
   switch (version) {
     case 0:
-      drive_backend::MigrateDatabaseFromV0ToV1(db);
+      drive_backend::MigrateDatabaseFromV0ToV1(db->GetLevelDB());
       // fall-through
     case 1:
-      drive_backend::MigrateDatabaseFromV1ToV2(db);
+      drive_backend::MigrateDatabaseFromV1ToV2(db->GetLevelDB());
       // fall-through
     case 2:
       // TODO(tzik): Migrate database from version 2 to 3.
       //   * Add sync-root folder as active, dirty and needs_folder_listing
       //     folder.
       //   * Add app-root folders for each origins.  Each app-root folder for
       //     an enabled origin should be a active, dirty and
       //     needs_folder_listing folder.  And Each app-root folder for a
       //     disabled origin should be an inactive, dirty and
       //     non-needs_folder_listing folder.
       //   * Add a file metadata for each file in previous version.
       NOTIMPLEMENTED();
       return SYNC_DATABASE_ERROR_FAILED;
       // fall-through
     case 3:
       DCHECK_EQ(3, kCurrentDatabaseVersion);
       return SYNC_STATUS_OK;
     default:
       return SYNC_DATABASE_ERROR_FAILED;
   }
 }
 
 bool HasInvalidTitle(const std::string& title) {
   return title.empty() ||
       title.find('/') != std::string::npos ||
       title.find('\\') != std::string::npos;
 }
 
 void MarkTrackerSetDirty(const TrackerIDSet& trackers,
-                         MetadataDatabaseIndexInterface* index,
-                         leveldb::WriteBatch* batch) {
+                         MetadataDatabaseIndexInterface* index) {
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
     scoped_ptr<FileTracker> tracker(new FileTracker);
     index->GetFileTracker(*itr, tracker.get());
     if (tracker->dirty())
       continue;
     tracker->set_dirty(true);
-    index->StoreFileTracker(tracker.Pass(), batch);
+    index->StoreFileTracker(tracker.Pass());
   }
 }
 
 void MarkTrackersDirtyByPath(int64 parent_tracker_id,
                              const std::string& title,
-                             MetadataDatabaseIndexInterface* index,
-                             leveldb::WriteBatch* batch) {
+                             MetadataDatabaseIndexInterface* index) {
   if (parent_tracker_id == kInvalidTrackerID || title.empty())
     return;
   MarkTrackerSetDirty(
       index->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title),
-      index, batch);
+      index);
 }
 
 void MarkTrackersDirtyByFileID(const std::string& file_id,
-                               MetadataDatabaseIndexInterface* index,
-                               leveldb::WriteBatch* batch) {
-  MarkTrackerSetDirty(index->GetFileTrackerIDsByFileID(file_id),
-                      index, batch);
+                               MetadataDatabaseIndexInterface* index) {
+  MarkTrackerSetDirty(index->GetFileTrackerIDsByFileID(file_id), index);
 }
 
 void MarkTrackersDirtyRecursively(int64 root_tracker_id,
-                                  MetadataDatabaseIndexInterface* index,
-                                  leveldb::WriteBatch* batch) {
+                                  MetadataDatabaseIndexInterface* index) {
   std::vector<int64> stack;
   stack.push_back(root_tracker_id);
   while (!stack.empty()) {
     int64 tracker_id = stack.back();
     stack.pop_back();
     AppendContents(index->GetFileTrackerIDsByParent(tracker_id), &stack);
 
     scoped_ptr<FileTracker> tracker(new FileTracker);
     index->GetFileTracker(tracker_id, tracker.get());
     tracker->set_dirty(true);
 
-    index->StoreFileTracker(tracker.Pass(), batch);
+    index->StoreFileTracker(tracker.Pass());
   }
 }
 
 void RemoveAllDescendantTrackers(int64 root_tracker_id,
-                                 MetadataDatabaseIndexInterface* index,
-                                 leveldb::WriteBatch* batch) {
+                                 MetadataDatabaseIndexInterface* index) {
   std::vector<int64> pending_trackers;
   AppendContents(index->GetFileTrackerIDsByParent(root_tracker_id),
                  &pending_trackers);
 
   std::vector<int64> to_be_removed;
 
   // List trackers to remove.
   while (!pending_trackers.empty()) {
     int64 tracker_id = pending_trackers.back();
     pending_trackers.pop_back();
     AppendContents(index->GetFileTrackerIDsByParent(tracker_id),
                    &pending_trackers);
     to_be_removed.push_back(tracker_id);
   }
 
   // Remove trackers in the reversed order.
   base::hash_set<std::string> affected_file_ids;
   for (std::vector<int64>::reverse_iterator itr = to_be_removed.rbegin();
        itr != to_be_removed.rend(); ++itr) {
     FileTracker tracker;
     index->GetFileTracker(*itr, &tracker);
     affected_file_ids.insert(tracker.file_id());
-    index->RemoveFileTracker(*itr, batch);
+    index->RemoveFileTracker(*itr);
   }
 
   for (base::hash_set<std::string>::iterator itr = affected_file_ids.begin();
        itr != affected_file_ids.end(); ++itr) {
     TrackerIDSet trackers = index->GetFileTrackerIDsByFileID(*itr);
     if (trackers.empty()) {
       // Remove metadata that no longer has any tracker.
-      index->RemoveFileMetadata(*itr, batch);
+      index->RemoveFileMetadata(*itr);
     } else {
-      MarkTrackerSetDirty(trackers, index, batch);
+      MarkTrackerSetDirty(trackers, index);
     }
   }
 }
 
 bool FilterFileTrackersByParent(
     const MetadataDatabaseIndexInterface* index,
     const TrackerIDSet& trackers,
     int64 parent_tracker_id,
     FileTracker* tracker_out) {
   FileTracker tracker;
@@ skipping 73 matching lines @@
 
 enum DirtyingOption {
   MARK_NOTHING_DIRTY = 0,
   MARK_ITSELF_DIRTY = 1 << 0,
   MARK_SAME_FILE_ID_TRACKERS_DIRTY = 1 << 1,
   MARK_SAME_PATH_TRACKERS_DIRTY = 1 << 2,
 };
 
 void ActivateFileTracker(int64 tracker_id,
                          int dirtying_options,
-                         MetadataDatabaseIndexInterface* index,
-                         leveldb::WriteBatch* batch) {
+                         MetadataDatabaseIndexInterface* index) {
   DCHECK(dirtying_options == MARK_NOTHING_DIRTY ||
          dirtying_options == MARK_ITSELF_DIRTY);
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   index->GetFileTracker(tracker_id, tracker.get());
   tracker->set_active(true);
   if (dirtying_options & MARK_ITSELF_DIRTY) {
     tracker->set_dirty(true);
     tracker->set_needs_folder_listing(
         tracker->has_synced_details() &&
         tracker->synced_details().file_kind() == FILE_KIND_FOLDER);
   } else {
     tracker->set_dirty(false);
     tracker->set_needs_folder_listing(false);
   }
 
-  index->StoreFileTracker(tracker.Pass(), batch);
+  index->StoreFileTracker(tracker.Pass());
 }
 
 void DeactivateFileTracker(int64 tracker_id,
                            int dirtying_options,
-                           MetadataDatabaseIndexInterface* index,
-                           leveldb::WriteBatch* batch) {
-  RemoveAllDescendantTrackers(tracker_id, index, batch);
+                           MetadataDatabaseIndexInterface* index) {
+  RemoveAllDescendantTrackers(tracker_id, index);
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   index->GetFileTracker(tracker_id, tracker.get());
 
   if (dirtying_options & MARK_SAME_FILE_ID_TRACKERS_DIRTY)
-    MarkTrackersDirtyByFileID(tracker->file_id(), index, batch);
+    MarkTrackersDirtyByFileID(tracker->file_id(), index);
   if (dirtying_options & MARK_SAME_PATH_TRACKERS_DIRTY) {
     MarkTrackersDirtyByPath(tracker->parent_tracker_id(),
-                            GetTrackerTitle(*tracker),
-                            index, batch);
+                            GetTrackerTitle(*tracker), index);
   }
 
   tracker->set_dirty(dirtying_options & MARK_ITSELF_DIRTY);
   tracker->set_active(false);
-  index->StoreFileTracker(tracker.Pass(), batch);
+  index->StoreFileTracker(tracker.Pass());
 }
 
 void RemoveFileTracker(int64 tracker_id,
                        int dirtying_options,
-                       MetadataDatabaseIndexInterface* index,
-                       leveldb::WriteBatch* batch) {
+                       MetadataDatabaseIndexInterface* index) {
   DCHECK(!(dirtying_options & MARK_ITSELF_DIRTY));
 
   FileTracker tracker;
   if (!index->GetFileTracker(tracker_id, &tracker))
     return;
 
   std::string file_id = tracker.file_id();
   int64 parent_tracker_id = tracker.parent_tracker_id();
   std::string title = GetTrackerTitle(tracker);
 
-  RemoveAllDescendantTrackers(tracker_id, index, batch);
-  index->RemoveFileTracker(tracker_id, batch);
+  RemoveAllDescendantTrackers(tracker_id, index);
+  index->RemoveFileTracker(tracker_id);
 
   if (dirtying_options & MARK_SAME_FILE_ID_TRACKERS_DIRTY)
-    MarkTrackersDirtyByFileID(file_id, index, batch);
+    MarkTrackersDirtyByFileID(file_id, index);
   if (dirtying_options & MARK_SAME_PATH_TRACKERS_DIRTY)
-    MarkTrackersDirtyByPath(parent_tracker_id, title, index, batch);
+    MarkTrackersDirtyByPath(parent_tracker_id, title, index);
 
   if (index->GetFileTrackerIDsByFileID(file_id).empty()) {
-    index->RemoveFileMetadata(file_id, batch);
+    index->RemoveFileMetadata(file_id);
   }
 }
 
 }  // namespace
 
 struct MetadataDatabase::CreateParam {
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner;
   base::FilePath database_path;
   leveldb::Env* env_override;
 
@@ skipping 15 matching lines @@
       &MetadataDatabase::CreateOnWorkerTaskRunner,
       base::Passed(make_scoped_ptr(new CreateParam(
           worker_task_runner,
           database_path,
           env_override))),
       callback));
 }
 
 // static
 SyncStatusCode MetadataDatabase::CreateForTesting(
-    scoped_ptr<leveldb::DB> db,
+    scoped_ptr<LevelDBWrapper> db,
     scoped_ptr<MetadataDatabase>* metadata_database_out) {
   scoped_ptr<MetadataDatabase> metadata_database(
       new MetadataDatabase(base::ThreadTaskRunnerHandle::Get(),
                            base::FilePath(), NULL));
   metadata_database->db_ = db.Pass();
   SyncStatusCode status = metadata_database->Initialize();
   if (status == SYNC_STATUS_OK)
     *metadata_database_out = metadata_database.Pass();
   return status;
 }
@@ skipping 45 matching lines @@
   return index_->GetSyncRootTrackerID() != kInvalidTrackerID;
 }
 
 void MetadataDatabase::PopulateInitialData(
     int64 largest_change_id,
     const google_apis::FileResource& sync_root_folder,
     const ScopedVector<google_apis::FileResource>& app_root_folders,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-  index_->SetLargestChangeID(largest_change_id, batch.get());
+  index_->SetLargestChangeID(largest_change_id);
   UpdateLargestKnownChangeID(largest_change_id);
 
-  AttachSyncRoot(sync_root_folder, batch.get());
+  AttachSyncRoot(sync_root_folder);
   for (size_t i = 0; i < app_root_folders.size(); ++i)
-    AttachInitialAppRoot(*app_root_folders[i], batch.get());
+    AttachInitialAppRoot(*app_root_folders[i]);
 
-  WriteToDatabase(batch.Pass(), callback);
+  WriteToDatabase(callback);
 }
 
 bool MetadataDatabase::IsAppEnabled(const std::string& app_id) const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   if (tracker_id == kInvalidTrackerID)
     return false;
 
   FileTracker tracker;
@@ skipping 45 matching lines @@
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!FilterFileTrackersByParent(index_.get(), trackers,
                                   sync_root_tracker_id, tracker.get())) {
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
     return;
   }
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   tracker->set_app_id(app_id);
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   tracker->set_active(true);
   tracker->set_needs_folder_listing(true);
   tracker->set_dirty(true);
 
-  index_->StoreFileTracker(tracker.Pass(), batch.get());
-  WriteToDatabase(batch.Pass(), callback);
+  index_->StoreFileTracker(tracker.Pass());
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::DisableApp(const std::string& app_id,
                                   const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
     return;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   DCHECK_EQ(TRACKER_KIND_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-
   // Keep the app-root tracker active (but change the tracker_kind) so that
   // other conflicting trackers won't become active.
   tracker->set_tracker_kind(TRACKER_KIND_DISABLED_APP_ROOT);
 
-  index_->StoreFileTracker(tracker.Pass(), batch.get());
-  WriteToDatabase(batch.Pass(), callback);
+  index_->StoreFileTracker(tracker.Pass());
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::EnableApp(const std::string& app_id,
                                  const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
     return;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_APP_ROOT) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   DCHECK_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
+  tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
+  index_->StoreFileTracker(tracker.Pass());
 
-  tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
-  index_->StoreFileTracker(tracker.Pass(), batch.get());
-
-  MarkTrackersDirtyRecursively(tracker_id, index_.get(), batch.get());
-  WriteToDatabase(batch.Pass(), callback);
+  MarkTrackersDirtyRecursively(tracker_id, index_.get());
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UnregisterApp(const std::string& app_id,
                                      const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get()) ||
       tracker->tracker_kind() == TRACKER_KIND_REGULAR) {
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_STATUS_OK));
     return;
   }
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-  RemoveAllDescendantTrackers(tracker_id, index_.get(), batch.get());
+  RemoveAllDescendantTrackers(tracker_id, index_.get());
 
   tracker->clear_app_id();
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_active(false);
   tracker->set_dirty(true);
 
-  index_->StoreFileTracker(tracker.Pass(), batch.get());
-  WriteToDatabase(batch.Pass(), callback);
+  index_->StoreFileTracker(tracker.Pass());
+  WriteToDatabase(callback);
 }
 
 bool MetadataDatabase::FindAppRootTracker(const std::string& app_id,
                                           FileTracker* tracker_out) const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   int64 app_root_tracker_id = index_->GetAppRootTracker(app_id);
   if (!app_root_tracker_id)
     return false;
 
@@ skipping 136 matching lines @@
   return true;
 }
 
 void MetadataDatabase::UpdateByChangeList(
     int64 largest_change_id,
     ScopedVector<google_apis::ChangeResource> changes,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK_LE(index_->GetLargestChangeID(), largest_change_id);
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-
   for (size_t i = 0; i < changes.size(); ++i) {
     const google_apis::ChangeResource& change = *changes[i];
     if (HasNewerFileMetadata(change.file_id(), change.change_id()))
       continue;
 
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromChangeResource(change));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
-                         UPDATE_TRACKER_FOR_UNSYNCED_FILE,
-                         batch.get());
+                         UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
 
   UpdateLargestKnownChangeID(largest_change_id);
-  index_->SetLargestChangeID(largest_change_id, batch.get());
-  WriteToDatabase(batch.Pass(), callback);
+  index_->SetLargestChangeID(largest_change_id);
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateByFileResource(
     const google_apis::FileResource& resource,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-
   scoped_ptr<FileMetadata> metadata(
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), resource));
   UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
-                       UPDATE_TRACKER_FOR_UNSYNCED_FILE,
-                       batch.get());
-  WriteToDatabase(batch.Pass(), callback);
+                       UPDATE_TRACKER_FOR_UNSYNCED_FILE);
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateByFileResourceList(
     ScopedVector<google_apis::FileResource> resources,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-
   for (size_t i = 0; i < resources.size(); ++i) {
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromFileResource(
             GetLargestKnownChangeID(), *resources[i]));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
-                         UPDATE_TRACKER_FOR_UNSYNCED_FILE,
-                         batch.get());
+                         UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
-  WriteToDatabase(batch.Pass(), callback);
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateByDeletedRemoteFile(
     const std::string& file_id,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   scoped_ptr<FileMetadata> metadata(
       CreateDeletedFileMetadata(GetLargestKnownChangeID(), file_id));
   UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
-                       UPDATE_TRACKER_FOR_UNSYNCED_FILE,
-                       batch.get());
-  WriteToDatabase(batch.Pass(), callback);
+                       UPDATE_TRACKER_FOR_UNSYNCED_FILE);
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateByDeletedRemoteFileList(
     const FileIDList& file_ids,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   for (FileIDList::const_iterator itr = file_ids.begin();
        itr != file_ids.end(); ++itr) {
     scoped_ptr<FileMetadata> metadata(
         CreateDeletedFileMetadata(GetLargestKnownChangeID(), *itr));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
-                         UPDATE_TRACKER_FOR_UNSYNCED_FILE,
-                         batch.get());
+                         UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
-  WriteToDatabase(batch.Pass(), callback);
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::ReplaceActiveTrackerWithNewResource(
     int64 parent_tracker_id,
     const google_apis::FileResource& resource,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   DCHECK(!index_->GetFileMetadata(resource.file_id(), NULL));
   DCHECK(index_->GetFileTracker(parent_tracker_id, NULL));
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   UpdateByFileMetadata(
       FROM_HERE,
       CreateFileMetadataFromFileResource(GetLargestKnownChangeID(), resource),
-      UPDATE_TRACKER_FOR_SYNCED_FILE,
-      batch.get());
+      UPDATE_TRACKER_FOR_SYNCED_FILE);
 
   DCHECK(index_->GetFileMetadata(resource.file_id(), NULL));
   DCHECK(!index_->GetFileTrackerIDsByFileID(resource.file_id()).has_active());
 
   TrackerIDSet same_path_trackers =
       index_->GetFileTrackerIDsByParentAndTitle(
           parent_tracker_id, resource.title());
   FileTracker to_be_activated;
   if (!FilterFileTrackersByFileID(index_.get(), same_path_trackers,
                                   resource.file_id(), &to_be_activated)) {
     NOTREACHED();
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_STATUS_FAILED));
     return;
   }
 
   int64 tracker_id = to_be_activated.tracker_id();
   if (same_path_trackers.has_active()) {
     DeactivateFileTracker(same_path_trackers.active_tracker(),
                           MARK_ITSELF_DIRTY |
                           MARK_SAME_FILE_ID_TRACKERS_DIRTY,
-                          index_.get(), batch.get());
+                          index_.get());
   }
 
-  ActivateFileTracker(tracker_id, MARK_NOTHING_DIRTY,
-                      index_.get(), batch.get());
-  WriteToDatabase(batch.Pass(), callback);
+  ActivateFileTracker(tracker_id, MARK_NOTHING_DIRTY, index_.get());
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::PopulateFolderByChildList(
     const std::string& folder_id,
     const FileIDList& child_file_ids,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(folder_id);
   if (!trackers.has_active()) {
@@ skipping 22 matching lines @@
       index_->GetFileTrackerIDsByParent(folder_tracker->tracker_id());
   for (size_t i = 0; i < known_children.size(); ++i) {
     FileTracker tracker;
     if (!index_->GetFileTracker(known_children[i], &tracker)) {
       NOTREACHED();
       continue;
     }
     children.erase(tracker.file_id());
   }
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   for (base::hash_set<std::string>::const_iterator itr = children.begin();
        itr != children.end(); ++itr)
-    CreateTrackerForParentAndFileID(*folder_tracker, *itr, batch.get());
+    CreateTrackerForParentAndFileID(*folder_tracker, *itr);
   folder_tracker->set_needs_folder_listing(false);
   if (folder_tracker->dirty() && !ShouldKeepDirty(*folder_tracker))
     folder_tracker->set_dirty(false);
-  index_->StoreFileTracker(folder_tracker.Pass(), batch.get());
+  index_->StoreFileTracker(folder_tracker.Pass());
 
-  WriteToDatabase(batch.Pass(), callback);
+  WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateTracker(int64 tracker_id,
                                      const FileDetails& updated_details,
                                      const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   FileTracker tracker;
   if (!index_->GetFileTracker(tracker_id, &tracker)) {
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
     return;
   }
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-
   // Check if the tracker is to be deleted.
   if (updated_details.missing()) {
     FileMetadata metadata;
     if (!index_->GetFileMetadata(tracker.file_id(), &metadata) ||
         metadata.details().missing()) {
       // Both the tracker and metadata have the missing flag, now it's safe to
       // delete the |tracker|.
       RemoveFileTracker(tracker_id,
                         MARK_SAME_FILE_ID_TRACKERS_DIRTY |
                         MARK_SAME_PATH_TRACKERS_DIRTY,
-                        index_.get(), batch.get());
-      WriteToDatabase(batch.Pass(), callback);
+                        index_.get());
+      WriteToDatabase(callback);
       return;
     }
   }
 
   // Sync-root deletion should be handled separately by SyncEngine.
   DCHECK(tracker_id != GetSyncRootTrackerID() ||
          (tracker.has_synced_details() &&
           tracker.synced_details().title() == updated_details.title() &&
           !updated_details.missing()));
 
   if (tracker_id != GetSyncRootTrackerID()) {
     // Check if the tracker's parent is still in |parent_tracker_ids|.
     // If not, there should exist another tracker for the new parent, so delete
     // old tracker.
     FileTracker parent_tracker;
     index_->GetFileTracker(tracker.parent_tracker_id(), &parent_tracker);
 
     if (!HasFileAsParent(updated_details, parent_tracker.file_id())) {
       RemoveFileTracker(tracker.tracker_id(),
                         MARK_SAME_PATH_TRACKERS_DIRTY,
-                        index_.get(), batch.get());
-      WriteToDatabase(batch.Pass(), callback);
+                        index_.get());
+      WriteToDatabase(callback);
       return;
     }
 
     if (tracker.has_synced_details()) {
       // Check if the tracker was retitled.  If it was, there should exist
       // another tracker for the new title, so delete the tracker being updated.
       if (tracker.synced_details().title() != updated_details.title()) {
         RemoveFileTracker(tracker.tracker_id(),
                           MARK_SAME_FILE_ID_TRACKERS_DIRTY,
-                          index_.get(), batch.get());
-        WriteToDatabase(batch.Pass(), callback);
+                          index_.get());
+        WriteToDatabase(callback);
         return;
       }
     } else {
       // Check if any other tracker exists has the same parent, title and
       // file_id to the updated tracker.  If it exists, delete the tracker being
       // updated.
       if (FilterFileTrackersByFileID(
               index_.get(),
               index_->GetFileTrackerIDsByParentAndTitle(
                   parent_tracker.tracker_id(),
                   updated_details.title()),
               tracker.file_id(),
               NULL)) {
         RemoveFileTracker(tracker.tracker_id(),
                           MARK_NOTHING_DIRTY,
-                          index_.get(), batch.get());
-        WriteToDatabase(batch.Pass(), callback);
+                          index_.get());
+        WriteToDatabase(callback);
         return;
       }
     }
   }
 
   scoped_ptr<FileTracker> updated_tracker = CloneFileTracker(&tracker);
   *updated_tracker->mutable_synced_details() = updated_details;
 
   // Activate the tracker if:
   //   - There is no active tracker that tracks |tracker->file_id()|.
   //   - There is no active tracker that has the same |parent| and |title|.
   if (!tracker.active() && CanActivateTracker(tracker)) {
     updated_tracker->set_active(true);
     updated_tracker->set_dirty(true);
     updated_tracker->set_needs_folder_listing(
         tracker.synced_details().file_kind() == FILE_KIND_FOLDER);
   } else if (tracker.dirty() && !ShouldKeepDirty(tracker)) {
     updated_tracker->set_dirty(false);
   }
-  index_->StoreFileTracker(updated_tracker.Pass(), batch.get());
+  index_->StoreFileTracker(updated_tracker.Pass());
 
-  WriteToDatabase(batch.Pass(), callback);
+  WriteToDatabase(callback);
 }
 
 MetadataDatabase::ActivationStatus MetadataDatabase::TryActivateTracker(
     int64 parent_tracker_id,
     const std::string& file_id,
     const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata)) {
@@ skipping 12 matching lines @@
   FilterFileTrackersByParentAndTitle(
       index_.get(), same_file_id_trackers, parent_tracker_id,
       title, tracker_to_be_activated.get());
 
   // Check if there is another active tracker that tracks |file_id|.
   // This can happen when the tracked file has multiple parents.
   // In this case, report the failure to the caller.
   if (!tracker_to_be_activated->active() && same_file_id_trackers.has_active())
     return ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER;
 
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-
   if (!tracker_to_be_activated->active()) {
     // Check if there exists another active tracker that has the same path to
     // the tracker.  If there is, deactivate it, assuming the caller already
     // overrides local file with newly added file,
     TrackerIDSet same_title_trackers =
         index_->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title);
     if (same_title_trackers.has_active()) {
       RemoveAllDescendantTrackers(same_title_trackers.active_tracker(),
-                                  index_.get(), batch.get());
+                                  index_.get());
 
       scoped_ptr<FileTracker> tracker_to_be_deactivated(new FileTracker);
       if (index_->GetFileTracker(same_title_trackers.active_tracker(),
                                  tracker_to_be_deactivated.get())) {
         const std::string file_id = tracker_to_be_deactivated->file_id();
         tracker_to_be_deactivated->set_active(false);
-        index_->StoreFileTracker(tracker_to_be_deactivated.Pass(), batch.get());
+        index_->StoreFileTracker(tracker_to_be_deactivated.Pass());
 
-        MarkTrackersDirtyByFileID(file_id, index_.get(), batch.get());
+        MarkTrackersDirtyByFileID(file_id, index_.get());
       } else {
         NOTREACHED();
       }
     }
   }
 
   tracker_to_be_activated->set_dirty(false);
   tracker_to_be_activated->set_active(true);
   *tracker_to_be_activated->mutable_synced_details() = metadata.details();
   if (tracker_to_be_activated->synced_details().file_kind() ==
       FILE_KIND_FOLDER) {
     tracker_to_be_activated->set_needs_folder_listing(true);
   }
   tracker_to_be_activated->set_dirty(false);
 
-  index_->StoreFileTracker(tracker_to_be_activated.Pass(), batch.get());
+  index_->StoreFileTracker(tracker_to_be_activated.Pass());
 
-  WriteToDatabase(batch.Pass(), callback);
+  WriteToDatabase(callback);
   return ACTIVATION_PENDING;
 }
 
 void MetadataDatabase::LowerTrackerPriority(int64 tracker_id) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-  index_->DemoteDirtyTracker(tracker_id, batch.get());
-  WriteToDatabase(batch.Pass(), base::Bind(&EmptyStatusCallback));
+  index_->DemoteDirtyTracker(tracker_id);
+  WriteToDatabase(base::Bind(&EmptyStatusCallback));
 }
 
 void MetadataDatabase::PromoteLowerPriorityTrackersToNormal() {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
-  index_->PromoteDemotedDirtyTrackers(batch.get());
-  WriteToDatabase(batch.Pass(), base::Bind(&EmptyStatusCallback));
+  index_->PromoteDemotedDirtyTrackers();
+  WriteToDatabase(base::Bind(&EmptyStatusCallback));
 }
 
 bool MetadataDatabase::GetNormalPriorityDirtyTracker(
     FileTracker* tracker_out) const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   int64 dirty_tracker_id = index_->PickDirtyTracker();
   if (!dirty_tracker_id)
     return false;
 
@@ skipping 122 matching lines @@
     if (status != SYNC_STATUS_OK)
       return status;
   }
 
   if (!created) {
     status = MigrateDatabaseIfNeeded(db_.get());
     if (status != SYNC_STATUS_OK)
       return status;
   }
 
-  leveldb::WriteBatch batch;
-  index_ = MetadataDatabaseIndex::Create(db_.get(), &batch);
+  index_ = MetadataDatabaseIndex::Create(db_.get());
 
-  status = LevelDBStatusToSyncStatusCode(
-      db_->Write(leveldb::WriteOptions(), &batch));
+  status = LevelDBStatusToSyncStatusCode(db_->Commit());
   if (status != SYNC_STATUS_OK)
     return status;
 
   UpdateLargestKnownChangeID(index_->GetLargestChangeID());
 
   return status;
 }
 
 void MetadataDatabase::CreateTrackerForParentAndFileID(
     const FileTracker& parent_tracker,
-    const std::string& file_id,
-    leveldb::WriteBatch* batch) {
+    const std::string& file_id) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   CreateTrackerInternal(parent_tracker, file_id, NULL,
-                        UPDATE_TRACKER_FOR_UNSYNCED_FILE,
-                        batch);
+                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
 }
 
 void MetadataDatabase::CreateTrackerForParentAndFileMetadata(
     const FileTracker& parent_tracker,
     const FileMetadata& file_metadata,
-    UpdateOption option,
-    leveldb::WriteBatch* batch) {
+    UpdateOption option) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(file_metadata.has_details());
   CreateTrackerInternal(parent_tracker,
                         file_metadata.file_id(),
                         &file_metadata.details(),
-                        option,
-                        batch);
+                        option);
 }
 
 void MetadataDatabase::CreateTrackerInternal(const FileTracker& parent_tracker,
                                              const std::string& file_id,
                                              const FileDetails* details,
-                                             UpdateOption option,
-                                             leveldb::WriteBatch* batch) {
+                                             UpdateOption option) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
-  int64 tracker_id = IncrementTrackerID(batch);
+  int64 tracker_id = IncrementTrackerID();
   scoped_ptr<FileTracker> tracker(new FileTracker);
   tracker->set_tracker_id(tracker_id);
   tracker->set_parent_tracker_id(parent_tracker.tracker_id());
   tracker->set_file_id(file_id);
   tracker->set_app_id(parent_tracker.app_id());
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_dirty(true);
   tracker->set_active(false);
   tracker->set_needs_folder_listing(false);
   if (details) {
     *tracker->mutable_synced_details() = *details;
     if (option == UPDATE_TRACKER_FOR_UNSYNCED_FILE) {
       tracker->mutable_synced_details()->set_missing(true);
       tracker->mutable_synced_details()->clear_md5();
     }
   }
-  index_->StoreFileTracker(tracker.Pass(), batch);
+  index_->StoreFileTracker(tracker.Pass());
 }
 
 void MetadataDatabase::MaybeAddTrackersForNewFile(
     const FileMetadata& metadata,
-    UpdateOption option,
-    leveldb::WriteBatch* batch) {
+    UpdateOption option) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   std::set<int64> parents_to_exclude;
   TrackerIDSet existing_trackers =
       index_->GetFileTrackerIDsByFileID(metadata.file_id());
   for (TrackerIDSet::const_iterator itr = existing_trackers.begin();
        itr != existing_trackers.end(); ++itr) {
     FileTracker tracker;
     if (!index_->GetFileTracker(*itr, &tracker)) {
       NOTREACHED();
@@ skipping 20 matching lines @@
          itr != parent_trackers.end(); ++itr) {
       FileTracker parent_tracker;
       index_->GetFileTracker(*itr, &parent_tracker);
       if (!parent_tracker.active())
         continue;
 
       if (ContainsKey(parents_to_exclude, parent_tracker.tracker_id()))
         continue;
 
       CreateTrackerForParentAndFileMetadata(
-          parent_tracker, metadata, option, batch);
+          parent_tracker, metadata, option);
     }
   }
 }
 
-int64 MetadataDatabase::IncrementTrackerID(leveldb::WriteBatch* batch) {
+int64 MetadataDatabase::IncrementTrackerID() {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   int64 tracker_id = index_->GetNextTrackerID();
-  index_->SetNextTrackerID(tracker_id + 1, batch);
+  index_->SetNextTrackerID(tracker_id + 1);
   DCHECK_GT(tracker_id, 0);
   return tracker_id;
 }
 
 bool MetadataDatabase::CanActivateTracker(const FileTracker& tracker) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!tracker.active());
   DCHECK_NE(index_->GetSyncRootTrackerID(), tracker.tracker_id());
 
   if (HasActiveTrackerForFileID(tracker.file_id()))
@@ skipping 71 matching lines @@
 }
 
 bool MetadataDatabase::HasActiveTrackerForPath(int64 parent_tracker_id,
                                                const std::string& title) const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title)
       .has_active();
 }
 
 void MetadataDatabase::RemoveUnneededTrackersForMissingFile(
-    const std::string& file_id,
-    leveldb::WriteBatch* batch) {
+    const std::string& file_id) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
     FileTracker tracker;
     if (!index_->GetFileTracker(*itr, &tracker)) {
       NOTREACHED();
       continue;
     }
 
     if (!tracker.has_synced_details() || tracker.synced_details().missing()) {
-      RemoveFileTracker(*itr, MARK_NOTHING_DIRTY, index_.get(), batch);
+      RemoveFileTracker(*itr, MARK_NOTHING_DIRTY, index_.get());
     }
   }
 }
 
 void MetadataDatabase::UpdateByFileMetadata(
     const tracked_objects::Location& from_where,
     scoped_ptr<FileMetadata> metadata,
-    UpdateOption option,
-    leveldb::WriteBatch* batch) {
+    UpdateOption option) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(metadata);
   DCHECK(metadata->has_details());
 
   DVLOG(1) << from_where.function_name() << ": "
            << metadata->file_id() << " ("
            << metadata->details().title() << ")"
            << (metadata->details().missing() ? " deleted" : "");
 
   std::string file_id = metadata->file_id();
   if (metadata->details().missing())
-    RemoveUnneededTrackersForMissingFile(file_id, batch);
+    RemoveUnneededTrackersForMissingFile(file_id);
   else
-    MaybeAddTrackersForNewFile(*metadata, option, batch);
+    MaybeAddTrackersForNewFile(*metadata, option);
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (!trackers.empty()) {
-    index_->StoreFileMetadata(metadata.Pass(), batch);
+    index_->StoreFileMetadata(metadata.Pass());
 
     if (option != UPDATE_TRACKER_FOR_SYNCED_FILE)
-      MarkTrackerSetDirty(trackers, index_.get(), batch);
+      MarkTrackerSetDirty(trackers, index_.get());
   }
 }
 
-void MetadataDatabase::WriteToDatabase(scoped_ptr<leveldb::WriteBatch> batch,
-                                       const SyncStatusCallback& callback) {
+void MetadataDatabase::WriteToDatabase(const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
-  if (!batch) {
-    callback.Run(SYNC_STATUS_OK);
-    return;
-  }
-
-  leveldb::Status status = db_->Write(leveldb::WriteOptions(), batch.get());
+  leveldb::Status status = db_->Commit();
   callback.Run(LevelDBStatusToSyncStatusCode(status));
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
     const std::string& app_id) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   scoped_ptr<base::ListValue> files(new base::ListValue);
 
   FileTracker app_root_tracker;
@@ skipping 166 matching lines @@
       for (int i = 0; i < details.parent_folder_ids_size(); ++i)
         parents.push_back(details.parent_folder_ids(i));
       dict->SetString("parents", JoinString(parents, ","));
     }
     files->Append(dict);
   }
   return files.Pass();
 }
 
 void MetadataDatabase::AttachSyncRoot(
-    const google_apis::FileResource& sync_root_folder,
-    leveldb::WriteBatch* batch) {
+    const google_apis::FileResource& sync_root_folder) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   scoped_ptr<FileMetadata> sync_root_metadata =
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), sync_root_folder);
   scoped_ptr<FileTracker> sync_root_tracker =
-      CreateSyncRootTracker(IncrementTrackerID(batch), *sync_root_metadata);
+      CreateSyncRootTracker(IncrementTrackerID(), *sync_root_metadata);
 
-  index_->SetSyncRootTrackerID(sync_root_tracker->tracker_id(), batch);
-  index_->StoreFileMetadata(sync_root_metadata.Pass(), batch);
-  index_->StoreFileTracker(sync_root_tracker.Pass(), batch);
+  index_->SetSyncRootTrackerID(sync_root_tracker->tracker_id());
+  index_->StoreFileMetadata(sync_root_metadata.Pass());
+  index_->StoreFileTracker(sync_root_tracker.Pass());
 }
 
 void MetadataDatabase::AttachInitialAppRoot(
-    const google_apis::FileResource& app_root_folder,
-    leveldb::WriteBatch* batch) {
+    const google_apis::FileResource& app_root_folder) {
   scoped_ptr<FileMetadata> app_root_metadata =
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), app_root_folder);
   scoped_ptr<FileTracker> app_root_tracker =
-      CreateInitialAppRootTracker(IncrementTrackerID(batch),
+      CreateInitialAppRootTracker(IncrementTrackerID(),
                                   GetSyncRootTrackerID(),
                                   *app_root_metadata);
 
-  index_->StoreFileMetadata(app_root_metadata.Pass(), batch);
-  index_->StoreFileTracker(app_root_tracker.Pass(), batch);
+  index_->StoreFileMetadata(app_root_metadata.Pass());
+  index_->StoreFileTracker(app_root_tracker.Pass());
 }
 
 void MetadataDatabase::DetachFromSequence() {
   worker_sequence_checker_.DetachFromSequence();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system