sync: add CleanupDisabledTypesCommand to purge data pertaining to previously...

chrome/browser/sync/syncable/syncable_unittest.cc

 // Copyright (c) 2009 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/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/types.h>
 
@@ skipping 282 matching lines @@
 
   void SaveAndReloadDir() {
     dir_->SaveChanges();
     ReloadDir();
   }
 
   bool IsInDirtyMetahandles(int64 metahandle) {
     return 1 == dir_->kernel_->dirty_metahandles->count(metahandle);
   }
 
-  bool IsSafeToPermanentlyDelete(Entry* e) {
-    return e->Get(IS_DEL) && !e->Get(IS_UNSYNCED) &&
-           !e->Get(IS_UNAPPLIED_UPDATE);
+  bool IsInMetahandlesToPurge(int64 metahandle) {
+    return 1 == dir_->kernel_->metahandles_to_purge->count(metahandle);
   }
 
   void CheckPurgeEntriesWithTypeInSucceeded(const ModelTypeSet& types_to_purge,
                                             bool before_reload) {
+    SCOPED_TRACE(testing::Message("Before reload: ") << before_reload);
     {
       ReadTransaction trans(dir_.get(), __FILE__, __LINE__);
       MetahandleSet all_set;
       dir_->GetAllMetaHandles(&trans, &all_set);
-      EXPECT_EQ(before_reload ? 7U : 3U, all_set.size());
+      EXPECT_EQ(3U, all_set.size());
+      if (before_reload)
+        EXPECT_EQ(4U, dir_->kernel_->metahandles_to_purge->size());
       for (MetahandleSet::iterator iter = all_set.begin();
            iter != all_set.end(); ++iter) {
         Entry e(&trans, GET_BY_HANDLE, *iter);
         if ((types_to_purge.count(e.GetModelType()) ||
-             types_to_purge.count(e.GetServerModelType())) &&
-             (!before_reload || !IsSafeToPermanentlyDelete(&e))) {
+             types_to_purge.count(e.GetServerModelType()))) {
           FAIL() << "Illegal type should have been deleted.";
         }
       }
     }
 
     EXPECT_FALSE(dir_->initial_sync_ended_for_type(PREFERENCES));
     EXPECT_FALSE(dir_->initial_sync_ended_for_type(AUTOFILL));
     EXPECT_TRUE(dir_->initial_sync_ended_for_type(BOOKMARKS));
 
     EXPECT_EQ(0, dir_->last_download_timestamp(PREFERENCES));
@@ skipping 21 matching lines @@
     me.Put(IS_UNSYNCED, true);
   }
 
   void ValidateEntry(BaseTransaction* trans, int64 id, bool check_name,
       string name, int64 base_version, int64 server_version, bool is_del);
   void CreateAndCheck(WriteTransaction* trans, int64 parent_id, int64 id,
       string name, string server_name, int64 version,
       bool set_server_fields, bool is_dir, bool add_to_lru, int64 *meta_handle);
 };
 
+TEST_F(SyncableDirectoryTest, TakeSnapshotGetsMetahandlesToPurge) {
+  const int metas_to_create = 50;
+  MetahandleSet expected_purges;
+  MetahandleSet all_handles;
+  {
+    WriteTransaction trans(dir_.get(), UNITTEST, __FILE__, __LINE__);
+    for (int i = 0; i < metas_to_create; i++) {
+      MutableEntry e(&trans, CREATE, trans.root_id(), "foo");
+      e.Put(IS_UNSYNCED, true);
+      sync_pb::EntitySpecifics specs;
+      if (i % 2 == 0) {
+        AddDefaultExtensionValue(BOOKMARKS, &specs);
+        expected_purges.insert(e.Get(META_HANDLE));
+        all_handles.insert(e.Get(META_HANDLE));
+      } else {
+        AddDefaultExtensionValue(PREFERENCES, &specs);
+        all_handles.insert(e.Get(META_HANDLE));
+      }
+      e.Put(SPECIFICS, specs);
+      e.Put(SERVER_SPECIFICS, specs);
+    }
+  }
+
+  ModelTypeSet to_purge;
+  to_purge.insert(BOOKMARKS);
+  dir_->PurgeEntriesWithTypeIn(to_purge);
+
+  Directory::SaveChangesSnapshot snapshot1;
+  AutoLock scoped_lock(dir_->kernel_->save_changes_mutex);
+  dir_->TakeSnapshotForSaveChanges(&snapshot1);
+  EXPECT_TRUE(expected_purges == snapshot1.metahandles_to_purge);
+
+  to_purge.clear();
+  to_purge.insert(PREFERENCES);
+  dir_->PurgeEntriesWithTypeIn(to_purge);
+
+  dir_->HandleSaveChangesFailure(snapshot1);
+
+  Directory::SaveChangesSnapshot snapshot2;
+  dir_->TakeSnapshotForSaveChanges(&snapshot2);
+  EXPECT_TRUE(all_handles == snapshot2.metahandles_to_purge);
+}
+
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsAllDirtyHandlesTest) {
   const int metahandles_to_create = 100;
   std::vector<int64> expected_dirty_metahandles;
   {
     WriteTransaction trans(dir_.get(), UNITTEST, __FILE__, __LINE__);
     for (int i = 0; i < metahandles_to_create; i++) {
       MutableEntry e(&trans, CREATE, trans.root_id(), "foo");
       expected_dirty_metahandles.push_back(e.Get(META_HANDLE));
       e.Put(IS_UNSYNCED, true);
     }
@@ skipping 776 matching lines @@
      EntryKernel aguilera = e1.GetKernelCopy();
      Entry kids(&trans, GET_BY_HANDLE, handle2);
      ASSERT_TRUE(kids.good());
      EXPECT_TRUE(kids.GetKernelCopy().is_dirty());
      EXPECT_TRUE(IsInDirtyMetahandles(handle2));
      EXPECT_TRUE(aguilera.is_dirty());
      EXPECT_TRUE(IsInDirtyMetahandles(handle1));
   }
 }
 
+TEST_F(SyncableDirectoryTest, TestSaveChangesFailureWithPurge) {
+  int64 handle1 = 0;
+  // Set up an item using a regular, saveable directory.
+  {
+    WriteTransaction trans(dir_.get(), UNITTEST, __FILE__, __LINE__);
+
+    MutableEntry e1(&trans, CREATE, trans.root_id(), "aguilera");
+    ASSERT_TRUE(e1.good());
+    EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
+    handle1 = e1.Get(META_HANDLE);
+    e1.Put(BASE_VERSION, 1);
+    e1.Put(IS_DIR, true);
+    e1.Put(ID, TestIdFactory::FromNumber(101));
+    sync_pb::EntitySpecifics bookmark_specs;
+    AddDefaultExtensionValue(BOOKMARKS, &bookmark_specs);
+    e1.Put(SPECIFICS, bookmark_specs);
+    e1.Put(SERVER_SPECIFICS, bookmark_specs);
+    e1.Put(ID, TestIdFactory::FromNumber(101));
+    EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
+    EXPECT_TRUE(IsInDirtyMetahandles(handle1));
+  }
+  ASSERT_TRUE(dir_->SaveChanges());
+
+  // Now do some operations using a directory for which SaveChanges will
+  // always fail.
+  dir_.reset(new TestUnsaveableDirectory());
+  ASSERT_TRUE(dir_.get());
+  ASSERT_TRUE(OPENED == dir_->Open(FilePath(kFilePath), kName));
+  ASSERT_TRUE(dir_->good());
+
+  ModelTypeSet set;
+  set.insert(BOOKMARKS);
+  dir_->PurgeEntriesWithTypeIn(set);
+  EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
+  ASSERT_FALSE(dir_->SaveChanges());
+  EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
+}
+
 // Create items of each model type, and check that GetModelType and
 // GetServerModelType return the right value.
 TEST_F(SyncableDirectoryTest, GetModelType) {
   TestIdFactory id_factory;
   for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
     ModelType datatype = ModelTypeFromInt(i);
     SCOPED_TRACE(testing::Message("Testing model type ") << datatype);
     switch (datatype) {
       case UNSPECIFIED:
       case TOP_LEVEL_FOLDER:
@@ skipping 498 matching lines @@
 TEST_F(SyncableClientTagTest, TestClientTagIndexDuplicateServer) {
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable