Deprecate DriveMetadataStore.batch_sync_origins

chrome/browser/sync_file_system/drive_metadata_store.cc

 // Copyright (c) 2012 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_metadata_store.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 92 matching lines @@
 
   found->second = resource_id;
   return true;
 }
 
 }  // namespace
 
 class DriveMetadataDB {
  public:
   enum OriginSyncType {
-    BATCH_SYNC_ORIGIN,
     INCREMENTAL_SYNC_ORIGIN,
     DISABLED_ORIGIN
   };
 
   typedef DriveMetadataStore::MetadataMap MetadataMap;
 
   DriveMetadataDB(const base::FilePath& base_dir,
                   base::SequencedTaskRunner* task_runner);
   ~DriveMetadataDB();
 
@@ skipping 20 matching lines @@
   SyncStatusCode UpdateOriginAsBatchSync(const GURL& origin,
                                          const std::string& resource_id);
   SyncStatusCode UpdateOriginAsIncrementalSync(const GURL& origin,
                                                const std::string& resource_id);
   SyncStatusCode EnableOrigin(const GURL& origin,
                               const std::string& resource_id);
   SyncStatusCode DisableOrigin(const GURL& origin,
                                const std::string& resource_id);
   SyncStatusCode RemoveOrigin(const GURL& origin);
 
-  SyncStatusCode GetOrigins(ResourceIdByOrigin* batch_sync_origins,
-                            ResourceIdByOrigin* incremental_sync_origins,
+  SyncStatusCode GetOrigins(ResourceIdByOrigin* incremental_sync_origins,
                             ResourceIdByOrigin* disabled_origins);
 
  private:
+  friend class DriveMetadataStore;
+
   bool CalledOnValidThread() const {
     return task_runner_->RunsTasksOnCurrentThread();
   }
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   std::string db_path_;
   scoped_ptr<leveldb::DB> db_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveMetadataDB);
 };
 
 struct DriveMetadataDBContents {
   int64 largest_changestamp;
   DriveMetadataStore::MetadataMap metadata_map;
   std::string sync_root_directory_resource_id;
-  ResourceIdByOrigin batch_sync_origins;
   ResourceIdByOrigin incremental_sync_origins;
   ResourceIdByOrigin disabled_origins;
 };
 
 namespace {
 
 SyncStatusCode InitializeDBOnFileThread(DriveMetadataDB* db,
                                         DriveMetadataDBContents* contents) {
   DCHECK(db);
   DCHECK(contents);
 
   contents->largest_changestamp = 0;
   contents->metadata_map.clear();
-  contents->batch_sync_origins.clear();
   contents->incremental_sync_origins.clear();
   contents->disabled_origins.clear();
 
   bool created = false;
   SyncStatusCode status = db->Initialize(&created);
   if (status != SYNC_STATUS_OK)
     return status;
 
   if (!created) {
     status = db->MigrateDatabaseIfNeeded();
     if (status != SYNC_STATUS_OK) {
       LOG(WARNING) << "Failed to migrate DriveMetadataStore to latest version.";
       return status;
     }
   }
 
   return db->ReadContents(contents);
 }
 
 // Returns a key string for the given origin.
 // For example, when |origin| is "http://www.example.com" and |sync_type| is
 // BATCH_SYNC_ORIGIN, returns "BSYNC_ORIGIN: http://www.example.com".
 std::string CreateKeyForOriginRoot(const GURL& origin,
                                    DriveMetadataDB::OriginSyncType sync_type) {
   DCHECK(origin.is_valid());
   switch (sync_type) {
-    case DriveMetadataDB::BATCH_SYNC_ORIGIN:
-      return kDriveBatchSyncOriginKeyPrefix + origin.spec();
     case DriveMetadataDB::INCREMENTAL_SYNC_ORIGIN:
       return kDriveIncrementalSyncOriginKeyPrefix + origin.spec();
     case DriveMetadataDB::DISABLED_ORIGIN:
       return kDriveDisabledOriginKeyPrefix + origin.spec();
   }
   NOTREACHED();
   return std::string();
 }
 
 void AddOriginsToVector(std::vector<GURL>* all_origins,
@@ skipping 59 matching lines @@
 
   db_status_ = status;
   if (status != SYNC_STATUS_OK) {
     callback.Run(status, false);
     return;
   }
 
   largest_changestamp_ = contents->largest_changestamp;
   metadata_map_.swap(contents->metadata_map);
   sync_root_directory_resource_id_ = contents->sync_root_directory_resource_id;
-  batch_sync_origins_.swap(contents->batch_sync_origins);
   incremental_sync_origins_.swap(contents->incremental_sync_origins);
   disabled_origins_.swap(contents->disabled_origins);
   // |largest_changestamp_| is set to 0 for a fresh empty database.
 
   origin_by_resource_id_.clear();
-  InsertReverseMap(batch_sync_origins_, &origin_by_resource_id_);
   InsertReverseMap(incremental_sync_origins_, &origin_by_resource_id_);
   InsertReverseMap(disabled_origins_, &origin_by_resource_id_);
 
   callback.Run(status, largest_changestamp_ <= 0);
 }
 
 void DriveMetadataStore::RestoreSyncRootDirectory(
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   std::string* sync_root_directory_resource_id = new std::string;
@@ skipping 20 matching lines @@
     return;
   }
 
   sync_root_directory_resource_id_.swap(*sync_root_directory_resource_id);
   callback.Run(status);
 }
 
 void DriveMetadataStore::RestoreOrigins(
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
-  ResourceIdByOrigin* batch_sync_origins = new ResourceIdByOrigin;
   ResourceIdByOrigin* incremental_sync_origins = new ResourceIdByOrigin;
   ResourceIdByOrigin* disabled_origins = new ResourceIdByOrigin;
   base::PostTaskAndReplyWithResult(
       file_task_runner_, FROM_HERE,
       base::Bind(&DriveMetadataDB::GetOrigins,
                  base::Unretained(db_.get()),
-                 batch_sync_origins,
                  incremental_sync_origins,
                  disabled_origins),
       base::Bind(&DriveMetadataStore::DidRestoreOrigins,
                  AsWeakPtr(), callback,
-                 base::Owned(batch_sync_origins),
                  base::Owned(incremental_sync_origins),
                  base::Owned(disabled_origins)));
 }
 
 void DriveMetadataStore::DidRestoreOrigins(
     const SyncStatusCallback& callback,
-    ResourceIdByOrigin* batch_sync_origins,
     ResourceIdByOrigin* incremental_sync_origins,
     ResourceIdByOrigin* disabled_origins,
     SyncStatusCode status) {
   DCHECK(CalledOnValidThread());
-  DCHECK(batch_sync_origins);
   DCHECK(incremental_sync_origins);
   DCHECK(disabled_origins);
 
   db_status_ = status;
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
 
-  batch_sync_origins_.swap(*batch_sync_origins);
   incremental_sync_origins_.swap(*incremental_sync_origins);
   disabled_origins_.swap(*disabled_origins);
 
   origin_by_resource_id_.clear();
-  InsertReverseMap(batch_sync_origins_, &origin_by_resource_id_);
   InsertReverseMap(incremental_sync_origins_, &origin_by_resource_id_);
   InsertReverseMap(disabled_origins_, &origin_by_resource_id_);
 
   callback.Run(status);
 }
 
+leveldb::DB* DriveMetadataStore::GetDBInstanceForTesting() {
+  return db_->db_.get();
+}
+
 void DriveMetadataStore::SetLargestChangeStamp(
     int64 largest_changestamp,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(SYNC_STATUS_OK, db_status_);
   largest_changestamp_ = largest_changestamp;
   base::PostTaskAndReplyWithResult(
       file_task_runner_, FROM_HERE,
       base::Bind(&DriveMetadataDB::SetLargestChangestamp,
                  base::Unretained(db_.get()), largest_changestamp),
@@ skipping 67 matching lines @@
   if (found == found_origin->second.end())
     return SYNC_DATABASE_ERROR_NOT_FOUND;
 
   *metadata = found->second;
   return SYNC_STATUS_OK;
 }
 
 void DriveMetadataStore::AddIncrementalSyncOrigin(
     const GURL& origin,
     const std::string& resource_id) {
-  AddBatchSyncOrigin(origin, resource_id);
-  MoveBatchSyncOriginToIncremental(origin);
+  DCHECK(CalledOnValidThread());
+  DCHECK(!IsIncrementalSyncOrigin(origin));
+  DCHECK(!IsOriginDisabled(origin));
+  DCHECK_EQ(SYNC_STATUS_OK, db_status_);
+
+  incremental_sync_origins_.insert(std::make_pair(origin, resource_id));
+  origin_by_resource_id_.insert(std::make_pair(resource_id, origin));
+
+  // Store a pair of |origin| and |resource_id| in the DB.
+  base::PostTaskAndReplyWithResult(
+      file_task_runner_, FROM_HERE,
+      base::Bind(&DriveMetadataDB::UpdateOriginAsIncrementalSync,
+                 base::Unretained(db_.get()), origin, resource_id),
+      base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
 }
 
 void DriveMetadataStore::SetSyncRootDirectory(const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
 
   sync_root_directory_resource_id_ = resource_id;
 
   // Set the resource ID for the sync root directory in the DB.
   base::PostTaskAndReplyWithResult(
       file_task_runner_, FROM_HERE,
       base::Bind(&DriveMetadataDB::SetSyncRootDirectory,
                  base::Unretained(db_.get()), resource_id),
       base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
 }
 
 void DriveMetadataStore::SetOriginRootDirectory(
     const GURL& origin,
     const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsKnownOrigin(origin));
 
   DriveMetadataDB::OriginSyncType sync_type;
-  if (UpdateResourceIdMap(&batch_sync_origins_, &origin_by_resource_id_,
-                          origin, resource_id)) {
-    sync_type = DriveMetadataDB::BATCH_SYNC_ORIGIN;
-  } else if (UpdateResourceIdMap(
+  if (UpdateResourceIdMap(
       &incremental_sync_origins_, &origin_by_resource_id_,
       origin, resource_id)) {
     sync_type = DriveMetadataDB::INCREMENTAL_SYNC_ORIGIN;
   } else if (UpdateResourceIdMap(&disabled_origins_, &origin_by_resource_id_,
                                  origin, resource_id)) {
     sync_type = DriveMetadataDB::DISABLED_ORIGIN;
   } else {
     return;
   }
   base::PostTaskAndReplyWithResult(
       file_task_runner_, FROM_HERE,
       base::Bind(&DriveMetadataDB::SetOriginRootDirectory,
                  base::Unretained(db_.get()), origin, sync_type, resource_id),
       base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
 }
 
 bool DriveMetadataStore::IsKnownOrigin(const GURL& origin) const {
   DCHECK(CalledOnValidThread());
-  return IsBatchSyncOrigin(origin) ||
-      IsIncrementalSyncOrigin(origin) ||
-      IsOriginDisabled(origin);
-}
-
-bool DriveMetadataStore::IsBatchSyncOrigin(const GURL& origin) const {
-  DCHECK(CalledOnValidThread());
-  return ContainsKey(batch_sync_origins_, origin);
+  return IsIncrementalSyncOrigin(origin) || IsOriginDisabled(origin);
 }
 
 bool DriveMetadataStore::IsIncrementalSyncOrigin(const GURL& origin) const {
   DCHECK(CalledOnValidThread());
   return ContainsKey(incremental_sync_origins_, origin);
 }
 
 bool DriveMetadataStore::IsOriginDisabled(const GURL& origin) const {
   DCHECK(CalledOnValidThread());
   return ContainsKey(disabled_origins_, origin);
@@ skipping 26 matching lines @@
       base::Bind(&DriveMetadataStore::DidUpdateOrigin, AsWeakPtr(), callback));
 }
 
 void DriveMetadataStore::DisableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   std::string resource_id;
   std::map<GURL, std::string>::iterator found =
-      batch_sync_origins_.find(origin);
-  if (found != batch_sync_origins_.end()) {
-    resource_id = found->second;
-    batch_sync_origins_.erase(found);
-  }
-
-  found = incremental_sync_origins_.find(origin);
+      incremental_sync_origins_.find(origin);
   if (found != incremental_sync_origins_.end()) {
     resource_id = found->second;
     incremental_sync_origins_.erase(found);
   }
 
   if (resource_id.empty()) {
     // |origin| has not been registered yet.
     return;
   }
 
   disabled_origins_.insert(std::make_pair(origin, resource_id));
 
   // Store a pair of |origin| and |resource_id| in the DB.
   base::PostTaskAndReplyWithResult(
       file_task_runner_, FROM_HERE,
       base::Bind(&DriveMetadataDB::DisableOrigin,
                  base::Unretained(db_.get()), origin, resource_id),
       base::Bind(&DriveMetadataStore::DidUpdateOrigin, AsWeakPtr(), callback));
 }
 
 void DriveMetadataStore::RemoveOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   metadata_map_.erase(origin);
 
   std::string resource_id;
-  if (EraseIfExists(&batch_sync_origins_, origin, &resource_id) ||
-      EraseIfExists(&incremental_sync_origins_, origin, &resource_id) ||
+  if (EraseIfExists(&incremental_sync_origins_, origin, &resource_id) ||
       EraseIfExists(&disabled_origins_, origin, &resource_id)) {
     origin_by_resource_id_.erase(resource_id);
   }
 
   base::PostTaskAndReplyWithResult(
       file_task_runner_, FROM_HERE,
       base::Bind(&DriveMetadataDB::RemoveOrigin,
                  base::Unretained(db_.get()), origin),
       base::Bind(&DriveMetadataStore::DidUpdateOrigin, AsWeakPtr(), callback));
 }
 
 void DriveMetadataStore::DidUpdateOrigin(
     const SyncStatusCallback& callback,
     SyncStatusCode status) {
   UpdateDBStatus(status);
   callback.Run(status);
 }
 
-void DriveMetadataStore::AddBatchSyncOrigin(const GURL& origin,
-                                            const std::string& resource_id) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!IsIncrementalSyncOrigin(origin));
-  DCHECK(!IsOriginDisabled(origin));
-  DCHECK_EQ(SYNC_STATUS_OK, db_status_);
-
-  if (IsBatchSyncOrigin(origin))
-    return;
-
-  batch_sync_origins_.insert(std::make_pair(origin, resource_id));
-  origin_by_resource_id_.insert(std::make_pair(resource_id, origin));
-
-  // Store a pair of |origin| and |resource_id| in the DB.
-  base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
-      base::Bind(&DriveMetadataDB::UpdateOriginAsBatchSync,
-                 base::Unretained(db_.get()), origin, resource_id),
-      base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
-}
-
-void DriveMetadataStore::MoveBatchSyncOriginToIncremental(const GURL& origin) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(IsBatchSyncOrigin(origin));
-  DCHECK(!IsIncrementalSyncOrigin(origin));
-  DCHECK(!IsOriginDisabled(origin));
-  DCHECK_EQ(SYNC_STATUS_OK, db_status_);
-
-  std::map<GURL, std::string>::iterator found =
-      batch_sync_origins_.find(origin);
-  incremental_sync_origins_.insert(std::make_pair(origin, found->second));
-
-  // Store a pair of |origin| and |resource_id| in the DB.
-  base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
-      base::Bind(&DriveMetadataDB::UpdateOriginAsIncrementalSync,
-                 base::Unretained(db_.get()), origin, found->second),
-      base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
-
-  batch_sync_origins_.erase(found);
-}
-
 void DriveMetadataStore::UpdateDBStatus(SyncStatusCode status) {
   DCHECK(CalledOnValidThread());
   if (db_status_ != SYNC_STATUS_OK &&
       db_status_ != SYNC_DATABASE_ERROR_NOT_FOUND) {
     // TODO(tzik): Handle database corruption. http://crbug.com/153709
     db_status_ = status;
     LOG(WARNING) << "DriveMetadataStore turned to wrong state: " << status;
     return;
   }
   db_status_ = SYNC_STATUS_OK;
@@ skipping 57 matching lines @@
   // initialized) just return empty string, as the origin directories
   // in the root directory must have become invalid now too.
   if (sync_root_directory().empty())
     return std::string();
 
   ResourceIdByOrigin::const_iterator found =
       incremental_sync_origins_.find(origin);
   if (found != incremental_sync_origins_.end())
     return found->second;
 
-  found = batch_sync_origins_.find(origin);
-  if (found != batch_sync_origins_.end())
-    return found->second;
-
   found = disabled_origins_.find(origin);
   if (found != disabled_origins_.end())
     return found->second;
 
   return std::string();
 }
 
 void DriveMetadataStore::GetAllOrigins(std::vector<GURL>* origins) {
   DCHECK(CalledOnValidThread());
   DCHECK(origins);
   origins->clear();
-  origins->reserve(batch_sync_origins_.size() +
-                   incremental_sync_origins_.size() +
+  origins->reserve(incremental_sync_origins_.size() +
                    disabled_origins_.size());
-  AddOriginsToVector(origins, batch_sync_origins_);
   AddOriginsToVector(origins, incremental_sync_origins_);
   AddOriginsToVector(origins, disabled_origins_);
 }
 
 bool DriveMetadataStore::GetOriginByOriginRootDirectoryId(
     const std::string& resource_id,
     GURL* origin) {
   DCHECK(CalledOnValidThread());
   DCHECK(origin);
 
@@ skipping 40 matching lines @@
     status = db->Put(leveldb::WriteOptions(),
                      kDatabaseVersionKey,
                      base::Int64ToString(kCurrentDatabaseVersion));
     if (!status.ok()) {
       delete db;
       return LevelDBStatusToSyncStatusCode(status);
     }
   }
 
   db_.reset(db);
-  return SYNC_STATUS_OK;
+
+
+  // Remove legacy batch sync origin entries that are no longer needed.
+  leveldb::WriteBatch batch;
+  scoped_ptr<leveldb::Iterator> batch_origin_itr(
+      db_->NewIterator(leveldb::ReadOptions()));
+  for (batch_origin_itr->Seek(kDriveBatchSyncOriginKeyPrefix);
+       batch_origin_itr->Valid();
+       batch_origin_itr->Next()) {
+    std::string key = batch_origin_itr->key().ToString();
+    if (!StartsWithASCII(key, kDriveBatchSyncOriginKeyPrefix, false))

[tzik, 2013/05/27 12:14:10]

s/false/true/
This should be case sensitive.

[calvinlo, 2013/05/28 02:18:55]

Done.

+      break;
+
+    batch.Delete(key);
+  }
+  status = db_->Write(leveldb::WriteOptions(), &batch);
+  return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::ReadContents(
     DriveMetadataDBContents* contents) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
   DCHECK(contents);
 
   contents->largest_changestamp = 0;
   contents->metadata_map.clear();
-  contents->batch_sync_origins.clear();
   contents->incremental_sync_origins.clear();
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   for (itr->SeekToFirst(); itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (key == kChangeStampKey) {
       bool success = base::StringToInt64(itr->value().ToString(),
                                          &contents->largest_changestamp);
       DCHECK(success);
     } else if (StartsWithASCII(key, kDriveMetadataKeyPrefix, true)) {
       GURL origin;
       base::FilePath path;
       MetadataKeyToOriginAndPath(key, &origin, &path);
 
       DriveMetadata metadata;
       bool success = metadata.ParseFromString(itr->value().ToString());
       DCHECK(success);
 
       success = contents->metadata_map[origin].insert(
           std::make_pair(path, metadata)).second;
       DCHECK(success);
     }
   }
 
-  SyncStatusCode status = GetOrigins(&contents->batch_sync_origins,
-                                     &contents->incremental_sync_origins,
+  SyncStatusCode status = GetOrigins(&contents->incremental_sync_origins,
                                      &contents->disabled_origins);
   if (status != SYNC_STATUS_OK &&
       status != SYNC_DATABASE_ERROR_NOT_FOUND)
     return status;
 
   status = GetSyncRootDirectory(&contents->sync_root_directory_resource_id);
   if (status != SYNC_STATUS_OK &&
       status != SYNC_DATABASE_ERROR_NOT_FOUND)
     return status;
 
@@ skipping 153 matching lines @@
 SyncStatusCode DriveMetadataDB::DeleteEntry(const FileSystemURL& url) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   std::string metadata_key = FileSystemURLToMetadataKey(url);
   leveldb::Status status = db_->Delete(
       leveldb::WriteOptions(), metadata_key);
   return LevelDBStatusToSyncStatusCode(status);
 }
 
-SyncStatusCode DriveMetadataDB::UpdateOriginAsBatchSync(
-    const GURL& origin, const std::string& resource_id) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(db_.get());
-
-  leveldb::Status status = db_->Put(
-      leveldb::WriteOptions(),
-      CreateKeyForOriginRoot(origin, BATCH_SYNC_ORIGIN),
-      resource_id);
-  return LevelDBStatusToSyncStatusCode(status);
-}
-
 SyncStatusCode DriveMetadataDB::UpdateOriginAsIncrementalSync(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::WriteBatch batch;
-  batch.Delete(CreateKeyForOriginRoot(origin, BATCH_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin, DISABLED_ORIGIN));
   batch.Put(CreateKeyForOriginRoot(origin, INCREMENTAL_SYNC_ORIGIN),
             resource_id);
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
 
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::EnableOrigin(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
+  // No DB entry as enabled origins go back to
+  // DriveFileSyncService.pending_batch_sync_origins only.
   leveldb::WriteBatch batch;
   batch.Delete(CreateKeyForOriginRoot(origin, INCREMENTAL_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin, DISABLED_ORIGIN));
-  batch.Put(CreateKeyForOriginRoot(origin, BATCH_SYNC_ORIGIN), resource_id);
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
 
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::DisableOrigin(
     const GURL& origin_to_disable, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::WriteBatch batch;
-  batch.Delete(CreateKeyForOriginRoot(origin_to_disable, BATCH_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin_to_disable,
                                       INCREMENTAL_SYNC_ORIGIN));
   batch.Put(CreateKeyForOriginRoot(origin_to_disable, DISABLED_ORIGIN),
             resource_id);
 
   // Remove entries specified by |origin_to_disable|.
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   std::string metadata_key = kDriveMetadataKeyPrefix + origin_to_disable.spec();
   for (itr->Seek(metadata_key); itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveMetadataKeyPrefix, true))
       break;
     GURL origin;
     base::FilePath path;
     MetadataKeyToOriginAndPath(key, &origin, &path);
     if (origin != origin_to_disable)
       break;
     batch.Delete(key);
   }
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
 
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::RemoveOrigin(const GURL& origin_to_remove) {
   DCHECK(CalledOnValidThread());
 
   leveldb::WriteBatch batch;
-  batch.Delete(CreateKeyForOriginRoot(origin_to_remove, BATCH_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin_to_remove,
                                       INCREMENTAL_SYNC_ORIGIN));
   batch.Delete(CreateKeyForOriginRoot(origin_to_remove, DISABLED_ORIGIN));
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   std::string metadata_key = kDriveMetadataKeyPrefix + origin_to_remove.spec();
   for (itr->Seek(metadata_key); itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveMetadataKeyPrefix, true))
       break;
     GURL origin;
     base::FilePath path;
     MetadataKeyToOriginAndPath(key, &origin, &path);
     if (origin != origin_to_remove)
       break;
     batch.Delete(key);
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::GetOrigins(
-    ResourceIdByOrigin* batch_sync_origins,
     ResourceIdByOrigin* incremental_sync_origins,
     ResourceIdByOrigin* disabled_origins) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
 
-  // Get batch sync origins from the DB.
-  for (itr->Seek(kDriveBatchSyncOriginKeyPrefix);
-       itr->Valid(); itr->Next()) {
-    std::string key = itr->key().ToString();
-    if (!StartsWithASCII(key, kDriveBatchSyncOriginKeyPrefix, true))
-      break;
-    GURL origin(std::string(
-        key.begin() + arraysize(kDriveBatchSyncOriginKeyPrefix) - 1,
-        key.end()));
-    DCHECK(origin.is_valid());
-    bool result = batch_sync_origins->insert(
-        std::make_pair(origin, itr->value().ToString())).second;
-    DCHECK(result);
-  }
-
   // Get incremental sync origins from the DB.
   for (itr->Seek(kDriveIncrementalSyncOriginKeyPrefix);
        itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveIncrementalSyncOriginKeyPrefix, true))
       break;
     GURL origin(std::string(
         key.begin() + arraysize(kDriveIncrementalSyncOriginKeyPrefix) - 1,
         key.end()));
     DCHECK(origin.is_valid());
@@ skipping 14 matching lines @@
     DCHECK(origin.is_valid());
     bool result = disabled_origins->insert(
         std::make_pair(origin, itr->value().ToString())).second;
     DCHECK(result);
   }
 
   return SYNC_STATUS_OK;
 }
 
 }  // namespace sync_file_system