sync: Add method to Directory to remove all entries for a set of ModelTypes....

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 268 matching lines @@
     ASSERT_TRUE(dir_->good());
   }
 
   virtual void TearDown() {
     // This also closes file handles.
     dir_->SaveChanges();
     dir_.reset();
     file_util::Delete(file_path_, true);
   }
 
-  void SaveAndReloadDir() {
-    dir_->SaveChanges();
+  void ReloadDir() {
     dir_.reset(new Directory());
     ASSERT_TRUE(dir_.get());
     ASSERT_TRUE(OPENED == dir_->Open(file_path_, kName));
   }
 
+  void SaveAndReloadDir() {
+    dir_->SaveChanges();
+    ReloadDir();
+  }
+
   bool IsInDirtyMetahandles(int64 metahandle) {
     return 1 == dir_->kernel_->dirty_metahandles->count(metahandle);
   }
 
   scoped_ptr<Directory> dir_;
   FilePath file_path_;
 
   // Creates an empty entry and sets the ID field to the default kId.
   void CreateEntry(const string& entryname) {
     CreateEntry(entryname, kId);
@@ skipping 71 matching lines @@
     // entries are marked dirty.
     EXPECT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
     for (OriginalEntries::const_iterator i = snapshot.dirty_metas.begin();
         i != snapshot.dirty_metas.end(); ++i) {
       EXPECT_TRUE(i->is_dirty());
     }
     dir_->VacuumAfterSaveChanges(snapshot);
   }
 }
 
+TEST_F(SyncableDirectoryTest, TestPurgeEntriesWithTypeIn) {
+  sync_pb::EntitySpecifics bookmark_specs;
+  sync_pb::EntitySpecifics autofill_specs;
+  sync_pb::EntitySpecifics preference_specs;
+  AddDefaultExtensionValue(BOOKMARKS, &bookmark_specs);
+  AddDefaultExtensionValue(PREFERENCES, &preference_specs);
+  AddDefaultExtensionValue(AUTOFILL, &autofill_specs);
+
+  std::set<ModelType> types_to_purge;
+  types_to_purge.insert(PREFERENCES);
+  types_to_purge.insert(AUTOFILL);
+
+  TestIdFactory id_factory;
+  // Create some items for each type.
+  {
+    WriteTransaction trans(dir_.get(), UNITTEST, __FILE__, __LINE__);
+    MutableEntry item1(&trans, CREATE, trans.root_id(), "Item");
+    ASSERT_TRUE(item1.good());
+    item1.Put(SPECIFICS, bookmark_specs);
+    item1.Put(SERVER_SPECIFICS, bookmark_specs);
+    item1.Put(IS_UNSYNCED, true);
+
+    MutableEntry item2(&trans, CREATE_NEW_UPDATE_ITEM,
+                       id_factory.NewServerId());
+    ASSERT_TRUE(item2.good());
+    item2.Put(SERVER_SPECIFICS, bookmark_specs);
+    item2.Put(IS_UNAPPLIED_UPDATE, true);
+
+    MutableEntry item3(&trans, CREATE, trans.root_id(), "Item");
+    ASSERT_TRUE(item3.good());
+    item3.Put(SPECIFICS, preference_specs);
+    item3.Put(SERVER_SPECIFICS, preference_specs);
+    item3.Put(IS_UNSYNCED, true);
+
+    MutableEntry item4(&trans, CREATE_NEW_UPDATE_ITEM,
+                       id_factory.NewServerId());
+    ASSERT_TRUE(item4.good());
+    item4.Put(SERVER_SPECIFICS, preference_specs);
+    item4.Put(IS_UNAPPLIED_UPDATE, true);
+
+    MutableEntry item5(&trans, CREATE, trans.root_id(), "Item");
+    ASSERT_TRUE(item5.good());
+    item5.Put(SPECIFICS, autofill_specs);
+    item5.Put(SERVER_SPECIFICS, autofill_specs);
+    item5.Put(IS_UNSYNCED, true);
+
+    MutableEntry item6(&trans, CREATE_NEW_UPDATE_ITEM,
+      id_factory.NewServerId());
+    ASSERT_TRUE(item6.good());
+    item6.Put(SERVER_SPECIFICS, autofill_specs);
+    item6.Put(IS_UNAPPLIED_UPDATE, true);
+  }
+
+  dir_->SaveChanges();
+  {
+    ReadTransaction trans(dir_.get(), __FILE__, __LINE__);
+    MetahandleSet all_set;
+    dir_->GetAllMetaHandles(&trans, &all_set);
+    ASSERT_EQ(7U, all_set.size());
+  }
+
+  dir_->PurgeEntriesWithTypeIn(types_to_purge);
+
+  // We first query the in-memory data, and then reload the directory (without
+  // saving) to verify that disk does not still have the data.
+  int test_scan_run = 0;
+  do {
+    string message = "Testing ";
+    message += test_scan_run == 0 ? "before " : "after ";
+    message += "directory reload.";
+    SCOPED_TRACE(testing::Message(message.c_str()));
+    {
+      ReadTransaction trans(dir_.get(), __FILE__, __LINE__);
+      MetahandleSet all_set;
+      dir_->GetAllMetaHandles(&trans, &all_set);
+      EXPECT_EQ(3U, all_set.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())) {
+          FAIL() << "Illegal type should have been deleted.";
+        }
+      }
+    }
+    if (test_scan_run == 0)
+      ReloadDir();
+    test_scan_run++;
+  } while (test_scan_run < 2);
+}
+
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsOnlyDirtyHandlesTest) {
   const int metahandles_to_create = 100;
-  const unsigned int number_changed = 100u;  // half of 2 * metahandles_to_create
+
+  // half of 2 * metahandles_to_create
+  const unsigned int number_changed = 100u;
   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);
     }
   }
   dir_->SaveChanges();
@@ skipping 1172 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