[Sync] Add support for loading, updating and querying delete journals in

sync/syncable/syncable_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 <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
+#include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/test/values_test_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/syncable/directory_backing_store.h"
 #include "sync/syncable/directory_change_delegate.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
@@ skipping 459 matching lines @@
     }
     EXPECT_FALSE(types_to_purge.Has(BOOKMARKS));
     EXPECT_TRUE(dir_->initial_sync_ended_for_type(BOOKMARKS));
   }
 
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   scoped_ptr<Directory> dir_;
   NullDirectoryChangeDelegate delegate_;
 
-  // Creates an empty entry and sets the ID field to a default one.
+  // Creates an empty entry and sets the ID field to a default one. Return meta
+  // handel of created entry.
   void CreateEntry(const std::string& entryname) {
     CreateEntry(entryname, TestIdFactory::FromNumber(-99));
   }
 
-  // Creates an empty entry and sets the ID field to id.
+  // Creates an empty entry and sets the ID field to id. Return meta handel of
+  // created entry.
   void CreateEntry(const std::string& entryname, const int id) {
     CreateEntry(entryname, TestIdFactory::FromNumber(id));
   }
   void CreateEntry(const std::string& entryname, Id id) {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir_.get());
     MutableEntry me(&wtrans, CREATE, wtrans.root_id(), entryname);
     ASSERT_TRUE(me.good());
     me.Put(ID, id);
     me.Put(IS_UNSYNCED, true);
   }
@@ skipping 81 matching lines @@
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir_->kernel_->save_changes_mutex);
     dir_->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     ASSERT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
         i != snapshot.dirty_metas.end(); ++i) {
-      ASSERT_TRUE(i->is_dirty());
+      ASSERT_TRUE((*i)->is_dirty());
     }
     dir_->VacuumAfterSaveChanges(snapshot);
   }
   // Put a new value with existing transactions as well as adding new ones.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     std::vector<int64> new_dirty_metahandles;
     for (std::vector<int64>::const_iterator i =
         expected_dirty_metahandles.begin();
         i != expected_dirty_metahandles.end(); ++i) {
@@ skipping 12 matching lines @@
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir_->kernel_->save_changes_mutex);
     dir_->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     EXPECT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
         i != snapshot.dirty_metas.end(); ++i) {
-      EXPECT_TRUE(i->is_dirty());
+      EXPECT_TRUE((*i)->is_dirty());
     }
     dir_->VacuumAfterSaveChanges(snapshot);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsOnlyDirtyHandlesTest) {
   const int metahandles_to_create = 100;
 
   // half of 2 * metahandles_to_create
   const unsigned int number_changed = 100u;
@@ skipping 68 matching lines @@
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir_->kernel_->save_changes_mutex);
     dir_->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each changed metahandle.  Make sure all
     // entries are marked dirty.
     EXPECT_EQ(number_changed, snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
         i != snapshot.dirty_metas.end(); ++i) {
-      EXPECT_TRUE(i->is_dirty());
+      EXPECT_TRUE((*i)->is_dirty());
     }
     dir_->VacuumAfterSaveChanges(snapshot);
   }
 }
 
+// Test delete journals management.
+TEST_F(SyncableDirectoryTest, ManageDeleteJournals) {
+  sync_pb::EntitySpecifics bookmark_specifics;
+  AddDefaultFieldValue(BOOKMARKS, &bookmark_specifics);
+  bookmark_specifics.mutable_bookmark()->set_url("url");
+
+  Id id1 = TestIdFactory::FromNumber(-1);
+  Id id2 = TestIdFactory::FromNumber(-2);
+  int64 handle1 = 0;
+  int64 handle2 = 0;
+  {
+    // Create two bookmark entries and save in database.
+    CreateEntry("item1", id1);
+    CreateEntry("item2", id2);
+    {
+      WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
+      MutableEntry item1(&trans, GET_BY_ID, id1);
+      ASSERT_TRUE(item1.good());
+      handle1 = item1.Get(META_HANDLE);
+      item1.Put(SPECIFICS, bookmark_specifics);
+      item1.Put(SERVER_SPECIFICS, bookmark_specifics);
+      MutableEntry item2(&trans, GET_BY_ID, id2);
+      ASSERT_TRUE(item2.good());
+      handle2 = item2.Get(META_HANDLE);
+      item2.Put(SPECIFICS, bookmark_specifics);
+      item2.Put(SERVER_SPECIFICS, bookmark_specifics);
+    }
+    ASSERT_EQ(OPENED, SimulateSaveAndReloadDir());
+  }
+
+  { // Test adding and saving delete journals.
+    {
+      WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
+      EntryKernelSet delete_journals;
+      dir_->GetDeleteJournals(&trans, BOOKMARKS, &delete_journals);
+      ASSERT_EQ(0u, delete_journals.size());
+
+      // Set SERVER_IS_DEL of the entries to true and they should be added to
+      // delete journals.
+      MutableEntry item1(&trans, GET_BY_ID, id1);
+      ASSERT_TRUE(item1.good());
+      item1.Put(SERVER_IS_DEL, true);
+      MutableEntry item2(&trans, GET_BY_ID, id2);
+      ASSERT_TRUE(item2.good());
+      item2.Put(SERVER_IS_DEL, true);
+      EntryKernel tmp;
+      tmp.put(ID, id1);
+      EXPECT_TRUE(dir_->kernel_->delete_journals_->count(&tmp));
+      tmp.put(ID, id2);
+      EXPECT_TRUE(dir_->kernel_->delete_journals_->count(&tmp));
+    }
+
+    // Save delete journals in database and verify memory clearing.
+    ASSERT_TRUE(dir_->SaveChanges());
+    EXPECT_EQ(0u, dir_->kernel_->delete_journals_->size());
+    ASSERT_EQ(OPENED, SimulateSaveAndReloadDir());
+  }
+
+  {
+    {
+      // Test reading delete journals from database.
+      WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
+      EntryKernelSet delete_journals;
+      dir_->GetDeleteJournals(&trans, BOOKMARKS, &delete_journals);
+      ASSERT_EQ(2u, delete_journals.size());
+      EntryKernel tmp;
+      tmp.put(META_HANDLE, handle1);
+      EXPECT_TRUE(delete_journals.count(&tmp));
+      tmp.put(META_HANDLE, handle2);
+      EXPECT_TRUE(delete_journals.count(&tmp));
+
+      // Purge item2.
+      MetahandleSet to_purge;
+      to_purge.insert(handle2);
+      dir_->PurgeDeleteJournals(&trans, to_purge);
+
+      // Verify that item2 is purged from journals in memory and will be
+      // purged from database.
+      tmp.put(ID, id2);
+      EXPECT_FALSE(dir_->kernel_->delete_journals_->count(&tmp));
+      EXPECT_EQ(1u, dir_->kernel_->delete_journals_to_purge_->size());
+      EXPECT_TRUE(dir_->kernel_->delete_journals_to_purge_->count(handle2));
+    }
+    ASSERT_EQ(OPENED, SimulateSaveAndReloadDir());
+  }
+
+  {
+    {
+      // Verify purged entry is gone in database.
+      WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
+      EntryKernelSet delete_journals;
+      dir_->GetDeleteJournals(&trans, BOOKMARKS, &delete_journals);
+      ASSERT_EQ(1u, delete_journals.size());
+      EntryKernel tmp;
+      tmp.put(ID, id1);
+      tmp.put(META_HANDLE, handle1);
+      EXPECT_TRUE(delete_journals.count(&tmp));
+
+      // Undelete item1.
+      MutableEntry item1(&trans, GET_BY_ID, id1);
+      ASSERT_TRUE(item1.good());
+      item1.Put(SERVER_IS_DEL, false);
+      EXPECT_TRUE(dir_->kernel_->delete_journals_->empty());
+      EXPECT_EQ(1u, dir_->kernel_->delete_journals_to_purge_->size());
+      EXPECT_TRUE(dir_->kernel_->delete_journals_to_purge_->count(handle1));
+    }
+    ASSERT_EQ(OPENED, SimulateSaveAndReloadDir());
+  }
+
+  {
+    // Verify undeleted entry is gone from database.
+    ReadTransaction trans(FROM_HERE, dir_.get());
+    EntryKernelSet delete_journals;
+    dir_->GetDeleteJournals(&trans, BOOKMARKS, &delete_journals);
+    ASSERT_EQ(0u, delete_journals.size());
+  }
+}
+
 const char SyncableDirectoryTest::kName[] = "Foo";
 
 namespace {
 
 TEST_F(SyncableDirectoryTest, TestBasicLookupNonExistantID) {
   ReadTransaction rtrans(FROM_HERE, dir_.get());
   Entry e(&rtrans, GET_BY_ID, TestIdFactory::FromNumber(-99));
   ASSERT_FALSE(e.good());
 }
 
@@ skipping 1396 matching lines @@
   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
 }  // namespace syncer