SyncFS: store disabled origins in DriveMetadataStore

chrome/browser/sync_file_system/drive_metadata_store.cc

Index: chrome/browser/sync_file_system/drive_metadata_store.cc
diff --git a/chrome/browser/sync_file_system/drive_metadata_store.cc b/chrome/browser/sync_file_system/drive_metadata_store.cc
index 0f94c444fc577206b025ee9274a43dfaf47b12bc..3f52c58f0229d9121ad89fb95cf5643c22d044e3 100644
--- a/chrome/browser/sync_file_system/drive_metadata_store.cc
+++ b/chrome/browser/sync_file_system/drive_metadata_store.cc
@@ -47,6 +47,7 @@ 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[] =
@@ -113,14 +114,23 @@ class DriveMetadataDB {
                              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 {
@@ -141,6 +151,7 @@ struct DriveMetadataDBContents {
   std::string sync_root_directory_resource_id;
   ResourceIdByOrigin batch_sync_origins;
   ResourceIdByOrigin incremental_sync_origins;
+  ResourceIdByOrigin disabled_origins;
 };
 
 namespace {
@@ -154,6 +165,7 @@ SyncStatusCode InitializeDBOnFileThread(DriveMetadataDB* db,
   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);
@@ -174,6 +186,8 @@ SyncStatusCode InitializeDBOnFileThread(DriveMetadataDB* db,
 // 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();
@@ -187,6 +201,14 @@ std::string CreateKeyForIncrementalSyncOrigin(const GURL& origin) {
   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();
@@ -259,11 +281,13 @@ void DriveMetadataStore::DidInitialize(const InitializationCallback& callback,
   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);
 }
@@ -299,31 +323,36 @@ void DriveMetadataStore::DidRestoreSyncRootDirectory(
   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) {
@@ -333,10 +362,12 @@ void DriveMetadataStore::DidRestoreSyncOrigins(
 
   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);
 }
@@ -449,11 +480,17 @@ bool DriveMetadataStore::IsIncrementalSyncOrigin(const GURL& origin) const {
   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));
@@ -462,7 +499,7 @@ void DriveMetadataStore::AddBatchSyncOrigin(const GURL& 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()));
 }
@@ -471,6 +508,7 @@ 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 =
@@ -480,13 +518,74 @@ void DriveMetadataStore::MoveBatchSyncOriginToIncremental(const GURL& origin) {
   // 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) {
@@ -496,7 +595,8 @@ void DriveMetadataStore::RemoveOrigin(
 
   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);
   }
 
@@ -504,10 +604,10 @@ void DriveMetadataStore::RemoveOrigin(
       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);
@@ -579,7 +679,9 @@ SyncStatusCode DriveMetadataStore::GetToBeFetchedFiles(
 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);
@@ -590,18 +692,30 @@ std::string DriveMetadataStore::GetResourceIdForOrigin(
   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) {
@@ -694,8 +808,9 @@ SyncStatusCode DriveMetadataDB::ReadContents(
     }
   }
 
-  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;
@@ -767,6 +882,9 @@ SyncStatusCode DriveMetadataDB::MigrateFromVersion0Database() {
   //
   //   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,
@@ -850,7 +968,7 @@ SyncStatusCode DriveMetadataDB::DeleteEntry(const FileSystemURL& url) {
   return LevelDBStatusToSyncStatusCode(status);
 }
 
-SyncStatusCode DriveMetadataDB::UpdateSyncOriginAsBatch(
+SyncStatusCode DriveMetadataDB::UpdateOriginAsBatchSync(
     const GURL& origin, const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_.get());
@@ -862,25 +980,70 @@ SyncStatusCode DriveMetadataDB::UpdateSyncOriginAsBatch(
   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();
@@ -900,9 +1063,10 @@ SyncStatusCode DriveMetadataDB::RemoveOrigin(const GURL& origin_to_remove) {
   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());
 
@@ -938,6 +1102,21 @@ SyncStatusCode DriveMetadataDB::GetSyncOrigins(
     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;
 }