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

sync/syncable/delete_journal.h

+// 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.
+
+#ifndef SYNC_SYNCABLE_DELETE_JOURNAL_H_
+#define SYNC_SYNCABLE_DELETE_JOURNAL_H_
+
+#include <set>
+
+#include "base/gtest_prod_util.h"
+#include "base/synchronization/lock.h"
+#include "sync/syncable/metahandle_set.h"
+#include "sync/syncable/syncable-inl.h"
+
+namespace syncer {
+namespace syncable {
+
+class BaseTransaction;
+struct EntryKernel;
+
+typedef std::set<const EntryKernel*, LessField<IdField, ID> > JournalIndex;
+
+// DeleteJournal manages deleted entries that are not in sync directory until
+// it's safe to drop them after the deletion is confirmed with native models.
+// DeleteJournal is thread-safe and can be accessed on any thread.
+class DeleteJournal {
+ public:
+  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest, ManageDeleteJournals);
+
+  // Initialize |delete_journals_| using |intitial_journal|, whose content is
+  // destroyed during initialization.
+  explicit DeleteJournal(JournalIndex* initial_journal);
+  ~DeleteJournal();
+
+  // For testing only
+  size_t GetDeleteJournalSize() const;
+
+  // Add/remove |entry| to/from |delete_journals_| according to its
+  // SERVER_IS_DEL field and |was_deleted|. Called on sync thread.
+  void UpdateDeleteJournalForServerDelete(BaseTransaction* trans,
+                                          bool was_deleted,
+                                          const EntryKernel& entry);
+
+  // Return entries of specified type in |delete_journals_|. This should be
+  // called ONCE in model association. |deleted_entries| can be used to
+  // detect deleted sync data that's not persisted in native model to
+  // prevent back-from-dead problem. |deleted_entries| are only valid during
+  // lifetime of |trans|. |type| is added to |passive_delete_journal_types_| to
+  // enable periodically saving/clearing of delete journals of |type| because
+  // new journals added later are not needed until next model association.
+  // Can be called on any thread.
+  void GetDeleteJournals(BaseTransaction* trans, ModelType type,
+                         EntryKernelSet* deleted_entries);
+
+  // Purge entries of specified type in |delete_journals_| if their handles are
+  // in |to_purge|. This should be called after model association and
+  // |to_purge| should contain handles of the entries whose deletions are
+  // confirmed in native model. Can be called on any thread.
+  void PurgeDeleteJournals(BaseTransaction* trans,
+                           const MetahandleSet& to_purge);
+
+  // Move entries in |delete_journals_| whose types are in
+  // |passive_delete_journal_types_| to |journal_entries|. Move handles in
+  // |delete_journals_to_purge_| to |journals_to_purge|. Called on sync thread.
+  void TakeSnapshotAndClear(EntryKernelSet* journal_entries,
+                            MetahandleSet* journals_to_purge);
+
+  // Add |entries| to |delete_journals_| regardless of their SERVER_IS_DEL
+  // value. This is used to:
+  // * restore delete journals from snapshot if snapshot failed to save.
+  // * batch add entries of a data type with unrecoverable error to delete
+  //   journal before purging them.
+  // Called on sync thread.
+  void AddJournals(BaseTransaction* trans, const EntryKernelSet& entries);
+
+  // Return true if delete journals of |type| are maintained.
+  static bool IsDeleteJournalEnabled(ModelType type);
+
+ private:
+  // Contains deleted entries that may not be persisted in native models. And
+  // in case of unrecoverable error, all purged entries are moved here for
+  // bookkeeping to prevent back-from-dead entries that are deleted elsewhere
+  // when sync's down.
+  JournalIndex delete_journals_;
+
+  // Contains meta handles of deleted entries that have been persisted or
+  // undeleted, thus can be removed from database.
+  MetahandleSet delete_journals_to_purge_;
+
+  // Delete journals of these types can be cleared from memory after being
+  // saved to database.
+  ModelTypeSet passive_delete_journal_types_;
+
+  // To synchronize accesses to variables above.
+  base::Lock journal_lock_;

[tim (not reviewing), 2013/01/04 15:35:46]

I read through this CL, CL 11533008, and 11578017, and I haven't managed to find
a case where we invoke any method on DeleteJournal without already being inside
a BaseTransaction.  The pattern we use elsewhere to avoid having to add
yet-another-lock is to require a valid BaseTransaction parameter on all methods
you would otherwise synchronize internally.  Is there any way this is possible?
It would really help simplicity (less locks to worry about!) and more
conventional for syncable/ code.

[haitaol1, 2013/01/04 18:49:20]

Good point. Added transaction paramenter to GetDeleteJournalSize() and
TakeSnapshotAndClear()

On 2013/01/04 15:35:46, timsteele wrote:

+};
+
+}  // namespace syncable
+}  // namespace syncer
+
+#endif  // SYNC_SYNCABLE_DELETE_JOURNAL_H_