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

sync/syncable/directory.h

 // Copyright 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/base/sync_export.h"
 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
 #include "sync/internal_api/public/util/weak_handle.h"
+#include "sync/syncable/delete_journal.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"
 
 namespace syncer {
 
 class Cryptographer;
 class UnrecoverableErrorHandler;
 
@@ skipping 79 matching lines @@
   typedef std::set<EntryKernel*, typename Indexer::Comparator> Set;
 };
 
 // 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);
-  }
-};
-
-typedef std::set<EntryKernel, EntryKernelLessByMetaHandle> 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 SYNC_EXPORT 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 52 matching lines @@
   // constructed and forms a consistent snapshot of what needs to be sent to
   // the backing store.
   struct SYNC_EXPORT_PRIVATE 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 108 matching lines @@
   bool UnlinkEntryFromOrder(EntryKernel* entry,
                             WriteTransaction* trans,
                             ScopedKernelLock* lock,
                             UnlinkReason unlink_reason);
 
   DirOpenResult OpenImpl(
       const std::string& name,
       DirectoryChangeDelegate* delegate,
       const WeakHandle<TransactionObserver>& transaction_observer);
 
+  DeleteJournal* delete_journal();
+
  private:
   // These private versions expect the kernel lock to already be held
   // before calling.
   EntryKernel* GetEntryById(const Id& id, ScopedKernelLock* const lock);
 
   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
 
  public:
   typedef std::vector<int64> ChildHandles;
 
@@ skipping 275 matching lines @@
 
   UnrecoverableErrorHandler* const unrecoverable_error_handler_;
   const ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
   bool unrecoverable_error_set_;
 
   // Not owned.
   NigoriHandler* const nigori_handler_;
   Cryptographer* const cryptographer_;
 
   InvariantCheckLevel invariant_check_level_;
+
+  // Maintain deleted entries not in |kernel_| until it's verified that they
+  // are deleted in native models as well.
+  scoped_ptr<DeleteJournal> delete_journal_;
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif // SYNC_SYNCABLE_DIRECTORY_H_