SyncFS: store disabled origins in DriveMetadataStore

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 29 matching lines @@
 
 const char* const kServiceName = DriveFileSyncService::kServiceName;
 const char kDatabaseVersionKey[] = "VERSION";
 const int64 kCurrentDatabaseVersion = 1;
 const char kChangeStampKey[] = "CHANGE_STAMP";
 const char kSyncRootDirectoryKey[] = "SYNC_ROOT_DIR";
 const char kDriveMetadataKeyPrefix[] = "METADATA: ";
 const char kMetadataKeySeparator = ' ';
 const char kDriveBatchSyncOriginKeyPrefix[] = "BSYNC_ORIGIN: ";
 const char kDriveIncrementalSyncOriginKeyPrefix[] = "ISYNC_ORIGIN: ";
+const char kDriveDisabledOriginKeyPrefix[] = "DISABLED_ORIGIN: ";
 const size_t kDriveMetadataKeyPrefixLength = arraysize(kDriveMetadataKeyPrefix);
 
 const base::FilePath::CharType kV0FormatPathPrefix[] =
     FILE_PATH_LITERAL("drive/");
 
 bool ParseV0FormatFileSystemURLString(const GURL& url,
                                       GURL* origin,
                                       base::FilePath* path) {
   fileapi::FileSystemType mount_type;
   base::FilePath virtual_path;
@@ skipping 46 matching lines @@
   SyncStatusCode MigrateDatabaseIfNeeded();
   SyncStatusCode MigrateFromVersion0Database();
 
   SyncStatusCode SetLargestChangestamp(int64 largest_changestamp);
   SyncStatusCode SetSyncRootDirectory(const std::string& resource_id);
   SyncStatusCode GetSyncRootDirectory(std::string* resource_id);
   SyncStatusCode UpdateEntry(const FileSystemURL& url,
                              const DriveMetadata& metadata);
   SyncStatusCode DeleteEntry(const FileSystemURL& url);
 
-  SyncStatusCode UpdateSyncOriginAsBatch(const GURL& origin,
+  // TODO(calvinlo): consolidate these state transition functions for sync
+  // origins like "UpdateOrigin(GURL, SyncStatusEnum)". And manage origins in
+  // just one map like "Map<SyncStatusEnum, ResourceIDMap>".
+  // http://crbug.com/211600
+  SyncStatusCode UpdateOriginAsBatchSync(const GURL& origin,
                                          const std::string& resource_id);
-  SyncStatusCode UpdateSyncOriginAsIncremental(const GURL& origin,
+  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 GetSyncOrigins(ResourceIdByOrigin* batch_sync_origins,
-                                ResourceIdByOrigin* incremental_sync_origins);
+  SyncStatusCode GetOrigins(ResourceIdByOrigin* batch_sync_origins,
+                            ResourceIdByOrigin* incremental_sync_origins,
+                            ResourceIdByOrigin* disabled_origins);
 
  private:
   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 batch sync origin.
 // For example, when |origin| is "http://www.example.com",
 // returns "BSYNC_ORIGIN: http://www.example.com".
+// TODO(calvinlo): consolidate these CreateKeyFor* functions.
+// http://crbug.com/211600
 std::string CreateKeyForBatchSyncOrigin(const GURL& origin) {
   DCHECK(origin.is_valid());
   return kDriveBatchSyncOriginKeyPrefix + origin.spec();
 }
 
 // Returns a key string for the given incremental sync origin.
 // For example, when |origin| is "http://www.example.com",
 // returns "ISYNC_ORIGIN: http://www.example.com".
 std::string CreateKeyForIncrementalSyncOrigin(const GURL& origin) {
   DCHECK(origin.is_valid());
   return kDriveIncrementalSyncOriginKeyPrefix + origin.spec();
 }
 
+// Returns a key string for the given disabled origin.
+// For example, when |origin| is "http://www.example.com",
+// returns "DISABLED_ORIGIN: http://www.example.com".
+std::string CreateKeyForDisabledOrigin(const GURL& origin) {
+  DCHECK(origin.is_valid());
+  return kDriveDisabledOriginKeyPrefix + origin.spec();
+}
+
 void AddOriginsToVector(std::vector<GURL>* all_origins,
                         const ResourceIdByOrigin& resource_map) {
   for (ResourceIdByOrigin::const_iterator itr = resource_map.begin();
        itr != resource_map.end();
        ++itr) {
     all_origins->push_back(itr->first);
   }
 }
 
 void InsertReverseMap(const ResourceIdByOrigin& forward_map,
@@ skipping 52 matching lines @@
   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;
   base::PostTaskAndReplyWithResult(
       file_task_runner_, FROM_HERE,
@@ skipping 15 matching lines @@
   db_status_ = status;
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
 
   sync_root_directory_resource_id_.swap(*sync_root_directory_resource_id);
   callback.Run(status);
 }
 
-void DriveMetadataStore::RestoreSyncOrigins(
+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::GetSyncOrigins,
+      base::Bind(&DriveMetadataDB::GetOrigins,
                  base::Unretained(db_.get()),
                  batch_sync_origins,
-                 incremental_sync_origins),
-      base::Bind(&DriveMetadataStore::DidRestoreSyncOrigins,
+                 incremental_sync_origins,
+                 disabled_origins),
+      base::Bind(&DriveMetadataStore::DidRestoreOrigins,
                  AsWeakPtr(), callback,
                  base::Owned(batch_sync_origins),
-                 base::Owned(incremental_sync_origins)));
+                 base::Owned(incremental_sync_origins),
+                 base::Owned(disabled_origins)));
 }
 
-void DriveMetadataStore::DidRestoreSyncOrigins(
+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);
 }
 
 void DriveMetadataStore::SetLargestChangeStamp(
     int64 largest_changestamp,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(SYNC_STATUS_OK, db_status_);
   largest_changestamp_ = largest_changestamp;
@@ skipping 92 matching lines @@
 bool DriveMetadataStore::IsBatchSyncOrigin(const GURL& origin) const {
   DCHECK(CalledOnValidThread());
   return ContainsKey(batch_sync_origins_, 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);
+}
+
 void DriveMetadataStore::AddBatchSyncOrigin(const GURL& origin,
                                             const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsBatchSyncOrigin(origin));
   DCHECK(!IsIncrementalSyncOrigin(origin));
+  DCHECK(!IsOriginDisabled(origin));
   DCHECK_EQ(SYNC_STATUS_OK, db_status_);
 
   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::UpdateSyncOriginAsBatch,
+      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::UpdateSyncOriginAsIncremental,
+      base::Bind(&DriveMetadataDB::UpdateOriginAsIncrementalSync,
                  base::Unretained(db_.get()), origin, found->second),
       base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
 
   batch_sync_origins_.erase(found);
 }
 
+void DriveMetadataStore::EnableOrigin(
+    const GURL& origin,
+    const SyncStatusCallback& callback) {
+  DCHECK(CalledOnValidThread());
+
+  std::map<GURL, std::string>::iterator found = disabled_origins_.find(origin);
+  if (found == disabled_origins_.end()) {
+    // |origin| has not been registered yet.
+    return;
+  }
+  std::string resource_id = found->second;
+  disabled_origins_.erase(found);
+
+  // Ensure |origin| is marked as a batch sync origin.
+  batch_sync_origins_.insert(std::make_pair(origin, resource_id));
+  found = incremental_sync_origins_.find(origin);
+  if (found != incremental_sync_origins_.end())
+    incremental_sync_origins_.erase(found);
+
+  // Store a pair of |origin| and |resource_id| in the DB.
+  base::PostTaskAndReplyWithResult(
+      file_task_runner_, FROM_HERE,
+      base::Bind(&DriveMetadataDB::EnableOrigin,
+                 base::Unretained(db_.get()), origin, resource_id),
+      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);
+  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)) {
+      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::DidRemoveOrigin, AsWeakPtr(), callback));
+      base::Bind(&DriveMetadataStore::DidUpdateOrigin, AsWeakPtr(), callback));
 }
 
-void DriveMetadataStore::DidRemoveOrigin(
+void DriveMetadataStore::DidUpdateOrigin(
     const SyncStatusCallback& callback,
     SyncStatusCode status) {
   UpdateDBStatus(status);
   callback.Run(status);
 }
 
 void DriveMetadataStore::UpdateDBStatus(SyncStatusCode status) {
   DCHECK(CalledOnValidThread());
   if (db_status_ != SYNC_STATUS_OK &&
       db_status_ != SYNC_DATABASE_ERROR_NOT_FOUND) {
@@ skipping 51 matching lines @@
         list->push_back(std::make_pair(url, itr->second.resource_id()));
       }
     }
   }
   return SYNC_STATUS_OK;
 }
 
 std::string DriveMetadataStore::GetResourceIdForOrigin(
     const GURL& origin) const {
   DCHECK(CalledOnValidThread());
-  DCHECK(IsBatchSyncOrigin(origin) || IsIncrementalSyncOrigin(origin));
+  DCHECK(IsBatchSyncOrigin(origin) ||
+         IsIncrementalSyncOrigin(origin) ||
+         IsOriginDisabled(origin));
 
   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;
+
   NOTREACHED();
   return std::string();
 }
 
-void DriveMetadataStore::GetAllOrigins(std::vector<GURL>* origins) {
+void DriveMetadataStore::GetEnabledOrigins(std::vector<GURL>* origins) {
   DCHECK(CalledOnValidThread());
+  origins->clear();
   origins->reserve(batch_sync_origins_.size() +
                    incremental_sync_origins_.size());
   AddOriginsToVector(origins, batch_sync_origins_);
   AddOriginsToVector(origins, incremental_sync_origins_);
 }
 
+void DriveMetadataStore::GetDisabledOrigins(std::vector<GURL>* origins) {
+  DCHECK(CalledOnValidThread());
+  origins->clear();
+  origins->reserve(disabled_origins_.size());
+  AddOriginsToVector(origins, disabled_origins_);
+}
+
 bool DriveMetadataStore::GetOriginByOriginRootDirectoryId(
     const std::string& resource_id,
     GURL* origin) {
   DCHECK(CalledOnValidThread());
   DCHECK(origin);
 
   OriginByResourceId::iterator found = origin_by_resource_id_.find(resource_id);
   if (found == origin_by_resource_id_.end())
     return false;
   *origin = found->second;
@@ skipping 72 matching lines @@
       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 = GetSyncOrigins(&contents->batch_sync_origins,
-                                         &contents->incremental_sync_origins);
+  SyncStatusCode status = GetOrigins(&contents->batch_sync_origins,
+                                     &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;
 
   return SYNC_STATUS_OK;
@@ skipping 51 matching lines @@
   //   value: <Resource ID of the sync root directory>
   //
   // * key: "METADATA: " + <Origin and URL> (changed)
   // * value: <Serialized DriveMetadata>
   //
   //   key: "BSYNC_ORIGIN: " + <URL string of a batch sync origin>
   //   value: <Resource ID of the drive directory for the origin>
   //
   //   key: "ISYNC_ORIGIN: " + <URL string of a incremental sync origin>
   //   value: <Resource ID of the drive directory for the origin>
+  //
+  //   key: "DISABLED_ORIGIN: " + <URL string of a disabled origin>
+  //   value: <Resource ID of the drive directory for the origin>
 
   leveldb::WriteBatch write_batch;
   write_batch.Put(kDatabaseVersionKey,
                   base::Int64ToString(kCurrentDatabaseVersion));
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   for (itr->Seek(kDriveMetadataKeyPrefix); itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     if (!StartsWithASCII(key, kDriveMetadataKeyPrefix, true))
       break;
@@ skipping 63 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::UpdateSyncOriginAsBatch(
+SyncStatusCode DriveMetadataDB::UpdateOriginAsBatchSync(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::Status status = db_->Put(
       leveldb::WriteOptions(),
       CreateKeyForBatchSyncOrigin(origin),
       resource_id);
   return LevelDBStatusToSyncStatusCode(status);
 }
 
-SyncStatusCode DriveMetadataDB::UpdateSyncOriginAsIncremental(
+SyncStatusCode DriveMetadataDB::UpdateOriginAsIncrementalSync(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::WriteBatch batch;
   batch.Delete(CreateKeyForBatchSyncOrigin(origin));
+  batch.Delete(CreateKeyForDisabledOrigin(origin));
   batch.Put(CreateKeyForIncrementalSyncOrigin(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());
+
+  leveldb::WriteBatch batch;
+  batch.Delete(CreateKeyForIncrementalSyncOrigin(origin));
+  batch.Delete(CreateKeyForDisabledOrigin(origin));
+  batch.Put(CreateKeyForBatchSyncOrigin(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(CreateKeyForBatchSyncOrigin(origin_to_disable));
+  batch.Delete(CreateKeyForIncrementalSyncOrigin(origin_to_disable));
+  batch.Put(CreateKeyForDisabledOrigin(origin_to_disable), 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(kDriveBatchSyncOriginKeyPrefix + origin_to_remove.spec());
-  batch.Delete(kDriveIncrementalSyncOriginKeyPrefix + origin_to_remove.spec());
+  batch.Delete(CreateKeyForBatchSyncOrigin(origin_to_remove));
+  batch.Delete(CreateKeyForIncrementalSyncOrigin(origin_to_remove));
+  batch.Delete(CreateKeyForDisabledOrigin(origin_to_remove));
 
   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::GetSyncOrigins(
+SyncStatusCode DriveMetadataDB::GetOrigins(
     ResourceIdByOrigin* batch_sync_origins,
-    ResourceIdByOrigin* incremental_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))
@@ skipping 15 matching lines @@
       break;
     GURL origin(std::string(
         key.begin() + arraysize(kDriveIncrementalSyncOriginKeyPrefix) - 1,
         key.end()));
     DCHECK(origin.is_valid());
     bool result = incremental_sync_origins->insert(
         std::make_pair(origin, itr->value().ToString())).second;
     DCHECK(result);
   }
 
+  // Get disabled origins from the DB.
+  for (itr->Seek(kDriveDisabledOriginKeyPrefix);
+       itr->Valid(); itr->Next()) {
+    std::string key = itr->key().ToString();
+    if (!StartsWithASCII(key, kDriveDisabledOriginKeyPrefix, true))
+      break;
+    GURL origin(std::string(
+        key.begin() + arraysize(kDriveDisabledOriginKeyPrefix) - 1,
+        key.end()));
+    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