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 26 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 kDriveDisabledSyncOriginKeyPrefix[] = "DSYNC_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 47 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);
 
+  // TODO(calvinlo): consolidate these state transition functions for sync
+  // origins like "UpdateSyncOrigin(GURL, SyncStatusEnum)". And manage origins
+  // in just one map like "Map<SyncStatusEnum, ResourceIDMap>".

[kinuko, 2013/03/16 23:16:51]

Can we file a bug for this?

[nhiroki, 2013/03/18 09:40:18]

Done.

   SyncStatusCode UpdateSyncOriginAsBatch(const GURL& origin,
                                          const std::string& resource_id);
   SyncStatusCode UpdateSyncOriginAsIncremental(const GURL& origin,
                                                const std::string& resource_id);
+  SyncStatusCode EnableOriginSync(const GURL& origin,
+                                  const std::string& resource_id);
+  SyncStatusCode DisableOriginSync(const GURL& origin,
+                                   const std::string& resource_id);
   SyncStatusCode RemoveOrigin(const GURL& origin);
 
   SyncStatusCode GetSyncOrigins(ResourceIDMap* batch_sync_origins,
-                                ResourceIDMap* incremental_sync_origins);
+                                ResourceIDMap* incremental_sync_origins,
+                                ResourceIDMap* disabled_sync_origins);

[kinuko, 2013/03/16 23:16:51]

Hmm, ok so we seem to use the term 'SyncOrigin' a lot in this class.  Then the
name 'EnableOriginSync' and 'DisableOriginSync' may look a bit inconsistent...
and returning disabled ones for the method 'GetSyncOrigins' feels a bit weird.

I feel we could just drop 'Sync' from most method names and can rename them to:

UpdateSyncOriginAs... -> UpdateOriginAs...Sync
GetSyncOrigins -> GetOrigins
EnableOriginSync -> EnableOrigin
DisableOriginSync -> DisableOrigin
IsDisabledSyncOrigin -> IsOriginDisabled

These would match better with following MetadataStore method names:

MetadataStore::GetEnabledOrigins()
MetadataStore::GetDisabledOrigins()

wdyt?

[nhiroki, 2013/03/18 09:40:18]

Looks good. (hopefully) I replaced them without any omission. Done.

 
  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;
   DriveMetadataStore::ResourceIDMap batch_sync_origins;
   DriveMetadataStore::ResourceIDMap incremental_sync_origins;
+  DriveMetadataStore::ResourceIDMap disabled_sync_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_sync_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.
 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 sync origin.
+// For example, when |origin| is "http://www.example.com",
+// returns "DSYNC_ORIGIN: http://www.example.com".
+std::string CreateKeyForDisabledSyncOrigin(const GURL& origin) {
+  DCHECK(origin.is_valid());
+  return kDriveDisabledSyncOriginKeyPrefix + origin.spec();
+}
+
 void AddOriginsToVector(std::vector<GURL>* all_origins,
                         const DriveMetadataStore::ResourceIDMap& resource_map) {
   typedef DriveMetadataStore::ResourceIDMap::const_iterator itr;
   for (std::map<GURL, std::string>::const_iterator itr = resource_map.begin();
        itr != resource_map.end();
        ++itr) {
     all_origins->push_back(itr->first);
   }
 }
 
@@ skipping 35 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_sync_origins_.swap(contents->disabled_sync_origins);
   // |largest_changestamp_| is set to 0 for a fresh empty database.
   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 20 matching lines @@
 
   sync_root_directory_resource_id_.swap(*sync_root_directory_resource_id);
   callback.Run(status);
 }
 
 void DriveMetadataStore::RestoreSyncOrigins(
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   ResourceIDMap* batch_sync_origins = new ResourceIDMap;
   ResourceIDMap* incremental_sync_origins = new ResourceIDMap;
+  ResourceIDMap* disabled_sync_origins = new ResourceIDMap;
   base::PostTaskAndReplyWithResult(
       file_task_runner_, FROM_HERE,
       base::Bind(&DriveMetadataDB::GetSyncOrigins,
                  base::Unretained(db_.get()),
                  batch_sync_origins,
-                 incremental_sync_origins),
+                 incremental_sync_origins,
+                 disabled_sync_origins),
       base::Bind(&DriveMetadataStore::DidRestoreSyncOrigins,
                  AsWeakPtr(), callback,
                  base::Owned(batch_sync_origins),
-                 base::Owned(incremental_sync_origins)));
+                 base::Owned(incremental_sync_origins),
+                 base::Owned(disabled_sync_origins)));
 }
 
 void DriveMetadataStore::DidRestoreSyncOrigins(
     const SyncStatusCallback& callback,
     ResourceIDMap* batch_sync_origins,
     ResourceIDMap* incremental_sync_origins,
+    ResourceIDMap* disabled_sync_origins,
     SyncStatusCode status) {
   DCHECK(CalledOnValidThread());
   DCHECK(batch_sync_origins);
   DCHECK(incremental_sync_origins);
+  DCHECK(disabled_sync_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_sync_origins_.swap(*disabled_sync_origins);
   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;
   base::PostTaskAndReplyWithResult(
@@ skipping 91 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::IsDisabledSyncOrigin(const GURL& origin) const {
+  DCHECK(CalledOnValidThread());
+  return ContainsKey(disabled_sync_origins_, origin);
+}
+
 void DriveMetadataStore::AddBatchSyncOrigin(const GURL& origin,
                                             const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsBatchSyncOrigin(origin));
   DCHECK(!IsIncrementalSyncOrigin(origin));
+  DCHECK(!IsDisabledSyncOrigin(origin));
   DCHECK_EQ(SYNC_STATUS_OK, db_status_);
 
   batch_sync_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::UpdateSyncOriginAsBatch,
                  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(!IsDisabledSyncOrigin(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::Unretained(db_.get()), origin, found->second),
       base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
 
   batch_sync_origins_.erase(found);
 }
 
+void DriveMetadataStore::EnableOriginSync(
+    const GURL& origin,
+    const SyncStatusCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(IsDisabledSyncOrigin(origin));
+  DCHECK(!IsBatchSyncOrigin(origin));
+  DCHECK(!IsIncrementalSyncOrigin(origin));

[kinuko, 2013/03/16 23:16:51]

Nit-picky comment: If we had a crash after an extension is disabled (and the
status change is persisted in extension system) but before the changes are
successfully written into the metadata store, this method may get called without
meeting these conditions, am I correct?  DCHECKs aren't hit in release build but
if something goes wrong enabling the extension may keep failing in debug build?

[nhiroki, 2013/03/18 09:40:18]

You are right. I think it's not needed to check them strictly here. I changed
these checks to simple if-statements.

+
+  std::map<GURL, std::string>::iterator found =
+      disabled_sync_origins_.find(origin);
+  batch_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::EnableOriginSync,
+                 base::Unretained(db_.get()), origin, found->second),
+      base::Bind(&DriveMetadataStore::DidChangeOrigin, AsWeakPtr(), callback));
+
+  disabled_sync_origins_.erase(found);
+}
+
+void DriveMetadataStore::DisableOriginSync(
+    const GURL& origin,
+    const SyncStatusCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(IsBatchSyncOrigin(origin) || IsIncrementalSyncOrigin(origin));
+  DCHECK(!IsDisabledSyncOrigin(origin));

[kinuko, 2013/03/16 23:16:51]

Ditto.

[nhiroki, 2013/03/18 09:40:18]

Done.

+
+  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);
+  }
+
+  DCHECK(!resource_id.empty());
+  disabled_sync_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::DisableOriginSync,
+                 base::Unretained(db_.get()), origin, resource_id),
+      base::Bind(&DriveMetadataStore::DidChangeOrigin, AsWeakPtr(), callback));
+}
+
 void DriveMetadataStore::RemoveOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   metadata_map_.erase(origin);
   batch_sync_origins_.erase(origin);
   incremental_sync_origins_.erase(origin);
+  disabled_sync_origins_.erase(origin);
 
   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::DidChangeOrigin, AsWeakPtr(), callback));
 }
 
-void DriveMetadataStore::DidRemoveOrigin(
+void DriveMetadataStore::DidChangeOrigin(
     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) ||
+         IsDisabledSyncOrigin(origin));
 
   ResourceIDMap::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_sync_origins_.find(origin);
+  if (found != disabled_sync_origins_.end())
+    return found->second;
+
   NOTREACHED();
   return std::string();
 }
 
-void DriveMetadataStore::GetAllOrigins(std::vector<GURL>* origins) {
+void DriveMetadataStore::GetEnabledOrigins(std::vector<GURL>* origins) {
+  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) {
+  origins->clear();
+  origins->reserve(disabled_sync_origins_.size());
+  AddOriginsToVector(origins, disabled_sync_origins_);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 DriveMetadataDB::DriveMetadataDB(const base::FilePath& base_dir,
                                  base::SequencedTaskRunner* task_runner)
     : task_runner_(task_runner),
       db_path_(fileapi::FilePathToString(
           base_dir.Append(DriveMetadataStore::kDatabaseName))) {
 }
 
 DriveMetadataDB::~DriveMetadataDB() {
@@ skipping 60 matching lines @@
       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);
+                                         &contents->incremental_sync_origins,
+                                         &contents->disabled_sync_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: "DSYNC_ORIGIN: " + <URL string of a disabled sync 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 82 matching lines @@
   return LevelDBStatusToSyncStatusCode(status);
 }
 
 SyncStatusCode DriveMetadataDB::UpdateSyncOriginAsIncremental(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
 
   leveldb::WriteBatch batch;
   batch.Delete(CreateKeyForBatchSyncOrigin(origin));
+  batch.Delete(CreateKeyForDisabledSyncOrigin(origin));
   batch.Put(CreateKeyForIncrementalSyncOrigin(origin), resource_id);
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
 
   return LevelDBStatusToSyncStatusCode(status);
 }
 
+SyncStatusCode DriveMetadataDB::EnableOriginSync(
+    const GURL& origin, const std::string& resource_id) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(db_.get());
+
+  leveldb::WriteBatch batch;
+  batch.Delete(CreateKeyForIncrementalSyncOrigin(origin));
+  batch.Delete(CreateKeyForDisabledSyncOrigin(origin));
+  batch.Put(CreateKeyForBatchSyncOrigin(origin), resource_id);
+  leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
+
+  return LevelDBStatusToSyncStatusCode(status);
+}
+
+SyncStatusCode DriveMetadataDB::DisableOriginSync(
+    const GURL& origin, const std::string& resource_id) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(db_.get());
+
+  leveldb::WriteBatch batch;
+  batch.Delete(CreateKeyForBatchSyncOrigin(origin));
+  batch.Delete(CreateKeyForIncrementalSyncOrigin(origin));
+  batch.Put(CreateKeyForDisabledSyncOrigin(origin), resource_id);
+  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(CreateKeyForDisabledSyncOrigin(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(
     ResourceIDMap* batch_sync_origins,
-    ResourceIDMap* incremental_sync_origins) {
+    ResourceIDMap* incremental_sync_origins,
+    ResourceIDMap* disabled_sync_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 sync origins from the DB.
+  for (itr->Seek(kDriveDisabledSyncOriginKeyPrefix);
+       itr->Valid(); itr->Next()) {
+    std::string key = itr->key().ToString();
+    if (!StartsWithASCII(key, kDriveDisabledSyncOriginKeyPrefix, true))
+      break;
+    GURL origin(std::string(
+        key.begin() + arraysize(kDriveDisabledSyncOriginKeyPrefix) - 1,
+        key.end()));
+    DCHECK(origin.is_valid());
+    bool result = disabled_sync_origins->insert(
+        std::make_pair(origin, itr->value().ToString())).second;
+    DCHECK(result);
+  }
+
   return SYNC_STATUS_OK;
 }
 
 }  // namespace sync_file_system