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 43 matching lines @@
 
   SyncStatusCode Initialize(bool* created);
   SyncStatusCode ReadContents(DriveMetadataDBContents* contents);
 
   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,

[calvinlo, 2013/03/15 03:37:48]

I don't think it's needed now at all, but I think this class would be a lot
easier to work with if a lot of these functions were changed to just one general
function. Something like
UpdateSyncOrigin(GURL, SyncStatusEnum) because all that's essentially happening
is that an origin is being moved from one list to another.

And we can probably reduce the need to remember the names of all the sync_origin
lists if we just made a Map<SyncStatusEnum, ResourceIDMap> 

If there's agreement to simplify the DriveMetaDatastore in this way, can we add
a TODO for this? 

[nhiroki, 2013/03/15 12:08:56]

I wouldn't think there are many functions here, but I think it's worth thinking
about refactoring them. tzik-san has a big reform plan for the whole SyncFS
service, so you can do it with him? Anyway, I added TODO comments. Done. 

                              const DriveMetadata& metadata);
   SyncStatusCode DeleteEntry(const FileSystemURL& url);
 
   SyncStatusCode UpdateSyncOriginAsBatch(const GURL& origin,
                                          const std::string& resource_id);
   SyncStatusCode UpdateSyncOriginAsIncremental(const GURL& origin,
                                                const std::string& resource_id);
+  SyncStatusCode EnableSyncOrigin(const GURL& origin,
+                                  const std::string& resource_id);
+  SyncStatusCode DisableSyncOrigin(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);
 
  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.";
@@ skipping 13 matching lines @@
 }
 
 // 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) {

[calvinlo, 2013/03/15 03:37:48]

Same thing with these CreateKeyFor* functions. They can be combined into a
single function that takes in a SyncStatusEnum type with a case switch to handle
the different prefixes.

[nhiroki, 2013/03/15 12:08:56]

Done.

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

[tzik, 2013/03/14 12:50:54]

How about doing like this, or making another helper function?

found = batch_sync_origins_.find(origin);
if (found != batch_sync_origins_) {
  resource_id = found->socend;
  batch_sync_origins_.erase(found);
}

[nhiroki, 2013/03/15 12:08:56]

Done.

+  if (IsBatchSyncOrigin(origin))
+    found = batch_sync_origins_.find(origin);
+  else
+    found = incremental_sync_origins_.find(origin);
+  disabled_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::DisableSyncOrigin,
+                 base::Unretained(db_.get()), origin, found->second),
+      base::Bind(&DriveMetadataStore::DidChangeOrigin, AsWeakPtr(), callback));
+
+  if (IsBatchSyncOrigin(origin))
+    batch_sync_origins_.erase(origin);
+  else
+    incremental_sync_origins_.erase(origin);
+}
+
 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);
 
   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::EnableSyncOrigin(
+    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::DisableSyncOrigin(
+    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