SyncFS: store disabled origins in DriveMetadataStore

chrome/browser/sync_file_system/drive_metadata_store_unittest.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 "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 116 matching lines @@
     drive_metadata_store_->RestoreSyncRootDirectory(
         base::Bind(&DriveMetadataStoreTest::DidRestoreSyncRootDirectory,
                    base::Unretained(this)));
     message_loop_.Run();
   }
 
   void DropSyncOriginsInStore() {
     EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
     drive_metadata_store_->batch_sync_origins_.clear();
     drive_metadata_store_->incremental_sync_origins_.clear();
+    drive_metadata_store_->disabled_origins_.clear();
     EXPECT_TRUE(drive_metadata_store_->batch_sync_origins().empty());
     EXPECT_TRUE(drive_metadata_store_->incremental_sync_origins().empty());
+    EXPECT_TRUE(drive_metadata_store_->disabled_origins().empty());
   }
 
-  void RestoreSyncOriginsFromDB() {
+  void RestoreOriginsFromDB() {
     EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
-    drive_metadata_store_->RestoreSyncOrigins(
-        base::Bind(&DriveMetadataStoreTest::DidRestoreSyncOrigins,
+    drive_metadata_store_->RestoreOrigins(
+        base::Bind(&DriveMetadataStoreTest::DidRestoreOrigins,
                    base::Unretained(this)));
     message_loop_.Run();
   }
 
+  SyncStatusCode EnableOrigin(const GURL& origin) {
+    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
+    drive_metadata_store_->EnableOrigin(
+        origin, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
+                           base::Unretained(this), &status));
+    message_loop_.Run();
+    return status;
+  }
+
+  SyncStatusCode DisableOrigin(const GURL& origin) {
+    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
+    drive_metadata_store_->DisableOrigin(
+        origin, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
+                           base::Unretained(this), &status));
+    message_loop_.Run();
+    return status;
+  }
+
   SyncStatusCode RemoveOrigin(const GURL& url) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     drive_metadata_store_->RemoveOrigin(
         url, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
                         base::Unretained(this), &status));
     message_loop_.Run();
     return status;
   }
 
   SyncStatusCode UpdateEntry(const fileapi::FileSystemURL& url,
@@ skipping 29 matching lines @@
   void DidFinishDBTask(SyncStatusCode* status_out,
                        SyncStatusCode status) {
     *status_out = status;
     message_loop_.Quit();
   }
 
   void MarkAsCreated() {
     created_ = true;
   }
 
+  void VerifyUntrackedOrigin(const GURL& origin) {
+    EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(origin));
+    EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin));
+    EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin));
+  }
+
+  void VerifyBatchSyncOrigin(const GURL& origin,
+                             const std::string& resource_id) {
+    EXPECT_TRUE(metadata_store()->IsBatchSyncOrigin(origin));
+    EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin));
+    EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin));
+    EXPECT_EQ(resource_id,
+              GetResourceID(metadata_store()->batch_sync_origins(), origin));
+  }
+
+  void VerifyIncrementalSyncOrigin(const GURL& origin,
+                                   const std::string& resource_id) {
+    EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(origin));
+    EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(origin));
+    EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin));
+    EXPECT_EQ(resource_id,
+              GetResourceID(metadata_store()->incremental_sync_origins(),
+                            origin));
+  }
+
+  void VerifyDisabledOrigin(const GURL& origin,
+                            const std::string& resource_id) {
+    EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(origin));
+    EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin));
+    EXPECT_TRUE(metadata_store()->IsOriginDisabled(origin));
+    EXPECT_EQ(resource_id,
+              GetResourceID(metadata_store()->disabled_origins(), origin));
+  }
+
   base::FilePath base_dir() {
     return base_dir_.path();
   }
 
   DriveMetadataStore* metadata_store() {
     return drive_metadata_store_.get();
   }
 
   const DriveMetadataStore::MetadataMap& metadata_map() {
     return drive_metadata_store_->metadata_map_;
   }
 
   void VerifyReverseMap() {
     const ResourceIdByOrigin& batch_sync_origins =
         drive_metadata_store_->batch_sync_origins_;
     const ResourceIdByOrigin& incremental_sync_origins =
         drive_metadata_store_->incremental_sync_origins_;
+    const ResourceIdByOrigin& disabled_origins =
+        drive_metadata_store_->disabled_origins_;
     const OriginByResourceId& origin_by_resource_id =
         drive_metadata_store_->origin_by_resource_id_;
 
     size_t expected_size =
-        batch_sync_origins.size() + incremental_sync_origins.size();
+        batch_sync_origins.size() + incremental_sync_origins.size() +
+        disabled_origins.size();
     size_t actual_size = origin_by_resource_id.size();
     EXPECT_EQ(expected_size, actual_size);
     EXPECT_TRUE(VerifyReverseMapInclusion(batch_sync_origins,
                                           origin_by_resource_id));
     EXPECT_TRUE(VerifyReverseMapInclusion(incremental_sync_origins,
                                           origin_by_resource_id));
+    EXPECT_TRUE(VerifyReverseMapInclusion(disabled_origins,
+                                          origin_by_resource_id));
   }
 
  private:
   void DidInitializeDatabase(bool* done_out,
                              SyncStatusCode* status_out,
                              bool* created_out,
                              SyncStatusCode status,
                              bool created) {
     *done_out = true;
     *status_out = status;
     *created_out = created;
     message_loop_.Quit();
   }
 
   void DidRestoreSyncRootDirectory(SyncStatusCode status) {
     EXPECT_EQ(SYNC_STATUS_OK, status);
     message_loop_.Quit();
   }
 
-  void DidRestoreSyncOrigins(SyncStatusCode status) {
+  void DidRestoreOrigins(SyncStatusCode status) {
     EXPECT_EQ(SYNC_STATUS_OK, status);
     message_loop_.Quit();
   }
 
   bool VerifyReverseMapInclusion(const ResourceIdByOrigin& left,
                                  const OriginByResourceId& right) {
     for (ResourceIdByOrigin::const_iterator itr = left.begin();
          itr != left.end(); ++itr) {
       OriginByResourceId::const_iterator found = right.find(itr->second);
       if (found == right.end() || found->second != itr->first)
@@ skipping 105 matching lines @@
   EXPECT_EQ(SYNC_STATUS_OK,
             metadata_store()->GetToBeFetchedFiles(&list));
   EXPECT_EQ(2U, list.size());
   EXPECT_EQ(list[0].first, URL(path2));
   EXPECT_EQ(list[1].first, URL(path3));
 
   VerifyReverseMap();
 }
 
 TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory) {
-  const std::string kResourceID("hoge");
+  const std::string kResourceId("hoge");
 
   InitializeDatabase();
 
   EXPECT_TRUE(metadata_store()->sync_root_directory().empty());
 
-  metadata_store()->SetSyncRootDirectory(kResourceID);
-  EXPECT_EQ(kResourceID, metadata_store()->sync_root_directory());
+  metadata_store()->SetSyncRootDirectory(kResourceId);
+  EXPECT_EQ(kResourceId, metadata_store()->sync_root_directory());
 
   DropSyncRootDirectoryInStore();
   EXPECT_TRUE(metadata_store()->sync_root_directory().empty());
 
   RestoreSyncRootDirectoryFromDB();
-  EXPECT_EQ(kResourceID, metadata_store()->sync_root_directory());
+  EXPECT_EQ(kResourceId, metadata_store()->sync_root_directory());
 
   VerifyReverseMap();
 }
 
 TEST_F(DriveMetadataStoreTest, StoreSyncOrigin) {
   const GURL kOrigin1("chrome-extension://example1");
   const GURL kOrigin2("chrome-extension://example2");
-  const std::string kResourceID1("hoge");
-  const std::string kResourceID2("fuga");
+  const GURL kOrigin3("chrome-extension://example3");
+  const std::string kResourceId1("hoge");
+  const std::string kResourceId2("fuga");
+  const std::string kResourceId3("foo");
 
   InitializeDatabase();
 
   // Make sure origins have not been marked yet.
-  EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(kOrigin1));
-  EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(kOrigin2));
-  EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(kOrigin1));
-  EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(kOrigin2));
+  VerifyUntrackedOrigin(kOrigin1);
+  VerifyUntrackedOrigin(kOrigin2);
+  VerifyUntrackedOrigin(kOrigin3);
 
   // Mark origins as batch sync origins.
-  metadata_store()->AddBatchSyncOrigin(kOrigin1, kResourceID1);
-  metadata_store()->AddBatchSyncOrigin(kOrigin2, kResourceID2);
-  EXPECT_TRUE(metadata_store()->IsBatchSyncOrigin(kOrigin1));
-  EXPECT_TRUE(metadata_store()->IsBatchSyncOrigin(kOrigin2));
-  EXPECT_EQ(kResourceID1,
-            GetResourceID(metadata_store()->batch_sync_origins(), kOrigin1));
-  EXPECT_EQ(kResourceID2,
-            GetResourceID(metadata_store()->batch_sync_origins(), kOrigin2));
+  metadata_store()->AddBatchSyncOrigin(kOrigin1, kResourceId1);
+  metadata_store()->AddBatchSyncOrigin(kOrigin2, kResourceId2);
+  metadata_store()->AddBatchSyncOrigin(kOrigin3, kResourceId3);
+  VerifyBatchSyncOrigin(kOrigin1, kResourceId1);
+  VerifyBatchSyncOrigin(kOrigin2, kResourceId2);
+  VerifyBatchSyncOrigin(kOrigin3, kResourceId3);
 
-  // Mark |kOrigin1| as an incremental sync origin. |kOrigin2| should have still
-  // been marked as a batch sync origin.
+  // Mark |kOrigin1| as an incremental sync origin, and disable |kOrigin3| as
+  // a disabled sync origin. |kOrigin2| should have still been marked as a
+  // batch sync origin.
   metadata_store()->MoveBatchSyncOriginToIncremental(kOrigin1);
-  EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(kOrigin1));
-  EXPECT_TRUE(metadata_store()->IsBatchSyncOrigin(kOrigin2));
-  EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(kOrigin1));
-  EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(kOrigin2));
-  EXPECT_EQ(kResourceID1,
-            GetResourceID(metadata_store()->incremental_sync_origins(),
-                          kOrigin1));
-  EXPECT_EQ(kResourceID2,
-            GetResourceID(metadata_store()->batch_sync_origins(), kOrigin2));
+  DisableOrigin(kOrigin3);
+  VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
+  VerifyBatchSyncOrigin(kOrigin2, kResourceId2);
+  VerifyDisabledOrigin(kOrigin3, kResourceId3);
 
   DropSyncOriginsInStore();
 
   // Make sure origins have been dropped.
-  EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(kOrigin1));
-  EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(kOrigin2));
-  EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(kOrigin1));
-  EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(kOrigin2));
+  VerifyUntrackedOrigin(kOrigin1);
+  VerifyUntrackedOrigin(kOrigin2);
+  VerifyUntrackedOrigin(kOrigin3);
 
-  RestoreSyncOriginsFromDB();
+  RestoreOriginsFromDB();
 
   // Make sure origins have been restored.
-  EXPECT_FALSE(metadata_store()->IsBatchSyncOrigin(kOrigin1));
-  EXPECT_TRUE(metadata_store()->IsBatchSyncOrigin(kOrigin2));
-  EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(kOrigin1));
-  EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(kOrigin2));
-  EXPECT_EQ(kResourceID1,
-            GetResourceID(metadata_store()->incremental_sync_origins(),
-                          kOrigin1));
-  EXPECT_EQ(kResourceID2,
-            GetResourceID(metadata_store()->batch_sync_origins(), kOrigin2));
+  VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
+  VerifyBatchSyncOrigin(kOrigin2, kResourceId2);
+  VerifyDisabledOrigin(kOrigin3, kResourceId3);
 
   VerifyReverseMap();
 }
 
+TEST_F(DriveMetadataStoreTest, DisableOrigin) {
+  const GURL kOrigin1("chrome-extension://example1");
+  const GURL kOrigin2("chrome-extension://example2");
+  const std::string kResourceId1("hoge");
+  const std::string kResourceId2("fuga");
+
+  InitializeDatabase();
+  EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
+
+  metadata_store()->AddBatchSyncOrigin(kOrigin1, kResourceId1);
+  metadata_store()->AddBatchSyncOrigin(kOrigin2, kResourceId2);
+  metadata_store()->MoveBatchSyncOriginToIncremental(kOrigin2);
+  VerifyBatchSyncOrigin(kOrigin1, kResourceId1);
+  VerifyIncrementalSyncOrigin(kOrigin2, kResourceId2);
+
+  DisableOrigin(kOrigin1);
+  DisableOrigin(kOrigin2);
+  VerifyDisabledOrigin(kOrigin1, kResourceId1);
+  VerifyDisabledOrigin(kOrigin2, kResourceId2);
+
+  EnableOrigin(kOrigin1);
+  EnableOrigin(kOrigin2);
+  VerifyBatchSyncOrigin(kOrigin1, kResourceId1);
+  VerifyBatchSyncOrigin(kOrigin2, kResourceId2);
+}
+
 TEST_F(DriveMetadataStoreTest, RemoveOrigin) {
   const GURL kOrigin1("chrome-extension://example1");
   const GURL kOrigin2("chrome-extension://example2");
   const GURL kOrigin3("chrome-extension://example3");
   const GURL kOrigin4("chrome-extension://example4");
+  const GURL kOrigin5("chrome-extension://example5");
   const std::string kResourceId1("hogera");
   const std::string kResourceId2("fugaga");
   const std::string kResourceId3("piyopiyo");
+  const std::string kResourceId5("hogehoge");
 
   InitializeDatabase();
   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
 
   metadata_store()->AddBatchSyncOrigin(kOrigin1, kResourceId1);
   metadata_store()->AddBatchSyncOrigin(kOrigin2, kResourceId2);
   metadata_store()->MoveBatchSyncOriginToIncremental(kOrigin2);
   metadata_store()->AddBatchSyncOrigin(kOrigin3, kResourceId3);
+  metadata_store()->AddBatchSyncOrigin(kOrigin5, kResourceId5);
 
   EXPECT_EQ(SYNC_STATUS_OK,
             UpdateEntry(
                 CreateSyncableFileSystemURL(
                     kOrigin1, kServiceName, base::FilePath(FPL("guf"))),
                 CreateMetadata("foo", "spam", false, false)));
   EXPECT_EQ(SYNC_STATUS_OK,
             UpdateEntry(
                 CreateSyncableFileSystemURL(
                     kOrigin2, kServiceName, base::FilePath(FPL("mof"))),
                 CreateMetadata("bar", "ham", false, false)));
   EXPECT_EQ(SYNC_STATUS_OK,
             UpdateEntry(
                 CreateSyncableFileSystemURL(
                     kOrigin3, kServiceName, base::FilePath(FPL("waf"))),
                 CreateMetadata("baz", "egg", false, false)));
   EXPECT_EQ(SYNC_STATUS_OK,
             UpdateEntry(
                 CreateSyncableFileSystemURL(
                     kOrigin4, kServiceName, base::FilePath(FPL("cue"))),
                 CreateMetadata("lat", "fork", false, false)));
   EXPECT_EQ(SYNC_STATUS_OK,
             UpdateEntry(
                 CreateSyncableFileSystemURL(
+                    kOrigin5, kServiceName, base::FilePath(FPL("tac"))),
+                CreateMetadata("pov", "spoon", false, false)));
+  EXPECT_EQ(SYNC_STATUS_OK,
+            UpdateEntry(
+                CreateSyncableFileSystemURL(
                     kOrigin1, kServiceName, base::FilePath(FPL("tic"))),
                 CreateMetadata("zav", "sause", false, false)));
 
   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin1));
   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin2));
   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin4));
+  EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin5));
 
   DropDatabase();
   InitializeDatabase();
 
   // kOrigin3 should be only remaining batch sync origin.
   EXPECT_EQ(1u, metadata_store()->batch_sync_origins().size());
   EXPECT_TRUE(metadata_store()->IsBatchSyncOrigin(kOrigin3));
   EXPECT_TRUE(metadata_store()->incremental_sync_origins().empty());
+  EXPECT_TRUE(metadata_store()->disabled_origins().empty());
   EXPECT_EQ(1u, metadata_map().size());
 
   DriveMetadataStore::MetadataMap::const_iterator found =
       metadata_map().find(kOrigin3);
   EXPECT_TRUE(found != metadata_map().end() && found->second.size() == 1u);
 
   VerifyReverseMap();
 }
 
 TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin) {
   const GURL kOrigin1("chrome-extension://example1");
   const GURL kOrigin2("chrome-extension://example2");
+  const GURL kOrigin3("chrome-extension://example3");
   const std::string kResourceId1("hogera");
   const std::string kResourceId2("fugaga");
+  const std::string kResourceId3("piyopiyo");
 
   InitializeDatabase();
   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
 
   metadata_store()->AddBatchSyncOrigin(kOrigin1, kResourceId1);
   metadata_store()->AddBatchSyncOrigin(kOrigin2, kResourceId2);
   metadata_store()->MoveBatchSyncOriginToIncremental(kOrigin2);
+  metadata_store()->AddBatchSyncOrigin(kOrigin3, kResourceId3);
+  DisableOrigin(kOrigin3);
 
   EXPECT_EQ(kResourceId1, metadata_store()->GetResourceIdForOrigin(kOrigin1));
   EXPECT_EQ(kResourceId2, metadata_store()->GetResourceIdForOrigin(kOrigin2));
+  EXPECT_EQ(kResourceId3, metadata_store()->GetResourceIdForOrigin(kOrigin3));
 
   DropDatabase();
   InitializeDatabase();
 
   EXPECT_EQ(kResourceId1, metadata_store()->GetResourceIdForOrigin(kOrigin1));
   EXPECT_EQ(kResourceId2, metadata_store()->GetResourceIdForOrigin(kOrigin2));
+  EXPECT_EQ(kResourceId3, metadata_store()->GetResourceIdForOrigin(kOrigin3));
 
   VerifyReverseMap();
 }
 
 TEST_F(DriveMetadataStoreTest, MigrationFromV0) {
   const GURL kOrigin1("chrome-extension://example1");
   const GURL kOrigin2("chrome-extension://example2");
   const std::string kSyncRootResourceId("sync_root_resource_id");
   const std::string kResourceId1("hoge");
   const std::string kResourceId2("fuga");
@@ skipping 62 matching lines @@
                 &metadata));
   EXPECT_EQ(kFileResourceId, metadata.resource_id());
   EXPECT_EQ(kFileMD5, metadata.md5_checksum());
   EXPECT_FALSE(metadata.conflicted());
   EXPECT_FALSE(metadata.to_be_fetched());
 
   VerifyReverseMap();
 }
 
 }  // namespace sync_file_system