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

sync/syncable/directory.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_DIRECTORY_H_
 #define SYNC_SYNCABLE_DIRECTORY_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/gtest_prod_util.h"
 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/syncable/dir_open_result.h"
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/metahandle_set.h"
 #include "sync/syncable/scoped_kernel_lock.h"
+#include "sync/syncable/syncable-inl.h"
 
 namespace syncer {
 
 class Cryptographer;
 class UnrecoverableErrorHandler;
 
 namespace syncable {
 
 class BaseTransaction;
 class DirectoryChangeDelegate;
@@ skipping 77 matching lines @@
 
 // Reason for unlinking.
 enum UnlinkReason {
   NODE_MANIPULATION, // To be used by any operation manipulating the linked
                      // list.
   DATA_TYPE_PURGE    // To be used when purging a dataype.
 };
 
 class EntryKernelLessByMetaHandle {
  public:
-  inline bool operator()(const EntryKernel& a,
-                         const EntryKernel& b) const {
-    return a.ref(META_HANDLE) < b.ref(META_HANDLE);
+  inline bool operator()(const EntryKernel* a,
+                         const EntryKernel* b) const {
+    return a->ref(META_HANDLE) < b->ref(META_HANDLE);
   }
 };
 
-typedef std::set<EntryKernel, EntryKernelLessByMetaHandle> EntryKernelSet;
+typedef std::set<const EntryKernel*, EntryKernelLessByMetaHandle>

[tim (not reviewing), 2012/12/13 02:48:10]

Do we really need pointers? If so, I'd prefer to use base/memory/linked_ptr for
this. There was a thread on chromium-dev about discouraging linked_ptr with
vectors, and I just re-read it, and I still come away with the belief that
linked_ptr is preferable to a raw pointer (and using STLDeleteElements), and a
main reason is it would eliminate the need for the careful delete *it code you
have to write today. (And there's no ScopedSet style class in existence yet as
far as I know.)

[haitaol1, 2012/12/13 21:34:21]

Changed to pointer because it's more efficient to move delete journal from entry
kernel to snapshot to save. If using linked_ptr to store delete journal in entry
kernel, other indexes are converted to linked_ptr, too because they share same
template. The overhead of linked_ptr is probably not worth the cost then.

On 2012/12/13 02:48:10, timsteele wrote:

+    EntryKernelSet;
 
 enum InvariantCheckLevel {
   OFF = 0,            // No checking.
   VERIFY_CHANGES = 1, // Checks only mutated entries.  Does not check hierarchy.
   FULL_DB_VERIFICATION = 2 // Check every entry.  This can be expensive.
 };
 
 class Directory {
   friend class BaseTransaction;
   friend class Entry;
   friend class MutableEntry;
   friend class ReadTransaction;
   friend class ReadTransactionWithoutDB;
   friend class ScopedKernelLock;
   friend class ScopedKernelUnlock;
   friend class WriteTransaction;
   friend class SyncableDirectoryTest;
+  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest, ManageDeleteJournals);
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
                            TakeSnapshotGetsAllDirtyHandlesTest);
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
                            TakeSnapshotGetsOnlyDirtyHandlesTest);
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
                            TakeSnapshotGetsMetahandlesToPurge);
 
  public:
   static const FilePath::CharType kSyncDatabaseFilename[];
 
@@ skipping 54 matching lines @@
   // constructed and forms a consistent snapshot of what needs to be sent to
   // the backing store.
   struct SaveChangesSnapshot {
     SaveChangesSnapshot();
     ~SaveChangesSnapshot();
 
     KernelShareInfoStatus kernel_info_status;
     PersistedKernelInfo kernel_info;
     EntryKernelSet dirty_metas;
     MetahandleSet metahandles_to_purge;
+    EntryKernelSet delete_journals;
+    MetahandleSet delete_journals_to_purge;
   };
 
   // Does not take ownership of |encryptor|.
   // |report_unrecoverable_error_function| may be NULL.
   // Takes ownership of |store|.
   Directory(
       DirectoryBackingStore* store,
       UnrecoverableErrorHandler* unrecoverable_error_handler,
       ReportUnrecoverableErrorFunction
           report_unrecoverable_error_function,
@@ skipping 82 matching lines @@
       report_unrecoverable_error_function_();
     }
   }
 
   // Called to set the unrecoverable error on the directory and to propagate
   // the error to upper layers.
   void OnUnrecoverableError(const BaseTransaction* trans,
                             const tracked_objects::Location& location,
                             const std::string & message);
 
+  // Add/remove |entry| to/from |delete_journals_| according to its
+  // SERVER_IS_DEL field and |was_deleted|.
+  void UpdateDeleteJournals(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.
+  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.
+  void PurgeDeleteJournals(BaseTransaction* trans,
+                           const MetahandleSet& to_purge);
+
  protected:  // for friends, mainly used by Entry constructors
   virtual EntryKernel* GetEntryByHandle(int64 handle);
   virtual EntryKernel* GetEntryByHandle(int64 metahandle,
       ScopedKernelLock* lock);
   virtual EntryKernel* GetEntryById(const Id& id);
   EntryKernel* GetEntryByServerTag(const std::string& tag);
   virtual EntryKernel* GetEntryByClientTag(const std::string& tag);
   EntryKernel* GetRootEntry();
   bool ReindexId(WriteTransaction* trans, EntryKernel* const entry,
                  const Id& new_id);
@@ skipping 257 matching lines @@
     base::Lock save_changes_mutex;
 
     // The next metahandle is protected by kernel mutex.
     int64 next_metahandle;
 
     // The delegate for directory change events.  Must not be NULL.
     DirectoryChangeDelegate* const delegate;
 
     // The transaction observer.
     const WeakHandle<TransactionObserver> transaction_observer;
+
+    // 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.
+    IdsIndex* delete_journals_;
+
+    // Contains meta handles of deleted entries that have been persisted or
+    // undeleted, thus can be removed from database.
+    MetahandleSet* const delete_journals_to_purge_;
   };
 
   // Helper method used to do searches on |parent_id_child_index|.
   ParentIdChildIndex::iterator LocateInParentChildIndex(
       const ScopedKernelLock& lock,
       const Id& parent_id,
       int64 position_in_parent,
       const Id& item_id_for_tiebreaking);
 
   // Return an iterator to the beginning of the range of the children of
@@ skipping 12 matching lines @@
   void AppendChildHandles(
       const ScopedKernelLock& lock,
       const Id& parent_id, Directory::ChildHandles* result);
 
   // Return a pointer to what is probably (but not certainly) the
   // first child of |parent_id|, or NULL if |parent_id| definitely has
   // no children.
   EntryKernel* GetPossibleFirstChild(
       const ScopedKernelLock& lock, const Id& parent_id);
 
+  // Return true if delete journals of |type| are maintained.
+  static bool IsDeleteJournalEnabled(ModelType type);

[tim (not reviewing), 2012/12/13 02:48:10]

Do you anticipate needing to control this result from a test some day, or no?

[haitaol1, 2012/12/13 21:34:21]

No. I don't think that's necessary.

On 2012/12/13 02:48:10, timsteele wrote:

+
   Kernel* kernel_;
 
   scoped_ptr<DirectoryBackingStore> store_;
 
   UnrecoverableErrorHandler* const unrecoverable_error_handler_;
   const ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
   bool unrecoverable_error_set_;
 
   // Not owned.
   NigoriHandler* const nigori_handler_;
   Cryptographer* const cryptographer_;
 
+  // Delete journals of these types can be cleared from memory after being
+  // saved to database.
+  ModelTypeSet passive_delete_journal_types_;
+
   InvariantCheckLevel invariant_check_level_;
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif // SYNC_SYNCABLE_DIRECTORY_H_