sync: add CleanupDisabledTypesCommand to purge data pertaining to previously...

chrome/browser/sync/syncable/syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 
 #include <algorithm>
 #include <bitset>
 #include <iosfwd>
@@ skipping 552 matching lines @@
 // the case with a GetUpdates request.
 struct MultiTypeTimeStamp {
   syncable::ModelTypeBitSet data_types;
   int64 timestamp;
 };
 
 // a WriteTransaction has a writer tag describing which body of code is doing
 // the write. This is defined up here since DirectoryChangeEvent also contains
 // one.
 enum WriterTag {
-  INVALID, SYNCER, AUTHWATCHER, UNITTEST, VACUUM_AFTER_SAVE, SYNCAPI
+  INVALID,
+  SYNCER,
+  AUTHWATCHER,
+  UNITTEST,
+  VACUUM_AFTER_SAVE,
+  PURGE_ENTRIES,
+  SYNCAPI
 };
 
 // A separate Event type and channel for very frequent changes, caused
 // by anything, not just the user.
 struct DirectoryChangeEvent {
   enum {
     // Means listener should go through list of original entries and
     // calculate what it needs to notify.  It should *not* call any
     // callbacks or attempt to lock anything because a
     // WriteTransaction is being held until the listener returns.
@@ skipping 53 matching lines @@
   friend class ReadTransactionWithoutDB;
   friend class ScopedKernelLock;
   friend class ScopedKernelUnlock;
   friend class WriteTransaction;
   friend class SyncableDirectoryTest;
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
                            TakeSnapshotGetsAllDirtyHandlesTest);
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
                            TakeSnapshotGetsOnlyDirtyHandlesTest);
   FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest, TestPurgeEntriesWithTypeIn);
+  FRIEND_TEST_ALL_PREFIXES(SyncableDirectoryTest,
+                           TakeSnapshotGetsMetahandlesToPurge);
 
  public:
   class EventListenerHookup;
 
   // Various data that the Directory::Kernel we are backing (persisting data
   // for) needs saved across runs of the application.
   struct PersistedKernelInfo {
     // Last sync timestamp fetched from the server.
     int64 last_download_timestamp[MODEL_TYPE_COUNT];
     // true iff we ever reached the end of the changelog.
@@ skipping 28 matching lines @@
     KERNEL_SHARE_INFO_DIRTY
   };
 
   // When the Directory is told to SaveChanges, a SaveChangesSnapshot is
   // constructed and forms a consistent snapshot of what needs to be sent to
   // the backing store.
   struct SaveChangesSnapshot {
     KernelShareInfoStatus kernel_info_status;
     PersistedKernelInfo kernel_info;
     OriginalEntries dirty_metas;
+    MetahandleSet metahandles_to_purge;
     SaveChangesSnapshot() : kernel_info_status(KERNEL_SHARE_INFO_INVALID) {
     }
   };
 
   Directory();
   virtual ~Directory();
 
   DirOpenResult Open(const FilePath& file_path, const std::string& name);
 
   void Close();
@@ skipping 61 matching lines @@
   EntryKernel* GetEntryByClientTag(const std::string& tag);
   EntryKernel* GetRootEntry();
   bool ReindexId(EntryKernel* const entry, const Id& new_id);
   void ReindexParentId(EntryKernel* const entry, const Id& new_parent_id);
   void ClearDirtyMetahandles();
 
   // These don't do semantic checking.
   // The semantic checking is implemented higher up.
   void Undelete(EntryKernel* const entry);
   void Delete(EntryKernel* const entry);
+  void UnlinkEntryFromOrder(EntryKernel* entry,
+                            WriteTransaction* trans,
+                            ScopedKernelLock* lock);
 
   // Overridden by tests.
   virtual DirectoryBackingStore* CreateBackingStore(
       const std::string& dir_name,
       const FilePath& backing_filepath);
 
  private:
   // These private versions expect the kernel lock to already be held
   // before calling.
   EntryKernel* GetEntryById(const Id& id, ScopedKernelLock* const lock);
@@ skipping 69 matching lines @@
                            const MetahandleSet& handles,
                            const IdFilter& idfilter);
 
   // Purges all data associated with any entries whose ModelType or
   // ServerModelType is found in |types|, from _both_ memory and disk.
   // Only  valid, "real" model types are allowed in |types| (see model_type.h
   // for definitions).  "Purge" is just meant to distinguish from "deleting"
   // entries, which means something different in the syncable namespace.
   // WARNING! This can be real slow, as it iterates over all entries.
   // WARNING! Performs synchronous I/O.
-  void PurgeEntriesWithTypeIn(const std::set<ModelType>& types);
+  virtual void PurgeEntriesWithTypeIn(const std::set<ModelType>& types);
 
  private:
   // Helper to prime ids_index, parent_id_and_names_index, unsynced_metahandles
   // and unapplied_metahandles from metahandles_index.
   void InitializeIndices();
 
   // Constructs a consistent snapshot of the current Directory state and
   // indices (by deep copy) under a ReadTransaction for use in |snapshot|.
   // See SaveChanges() for more information.
   void TakeSnapshotForSaveChanges(SaveChangesSnapshot* snapshot);
@@ skipping 43 matching lines @@
   // It allows efficient lookup of the children of a given parent.
   typedef std::set<EntryKernel*, LessParentIdAndHandle> ParentIdChildIndex;
 
   // Contains both deleted and existing entries with tags.
   // We can't store only existing tags because the client would create
   // items that had a duplicated ID in the end, resulting in a DB key
   // violation. ID reassociation would fail after an attempted commit.
   typedef std::set<EntryKernel*,
                    LessField<StringField, UNIQUE_CLIENT_TAG> > ClientTagIndex;
 
+ protected:
+  // Used by tests.
+  void init_kernel(const std::string& name);
+
  private:
 
   struct Kernel {
     Kernel(const FilePath& db_path, const std::string& name,
            const KernelLoadInfo& info);
 
     ~Kernel();
 
     void AddRef();  // For convenience.
     void Release();
@@ skipping 24 matching lines @@
     // look something up in an index.  Needle in haystack metaphor.
     EntryKernel needle;
 
     // 3 in-memory indices on bits used extremely frequently by the syncer.
     MetahandleSet* const unapplied_update_metahandles;
     MetahandleSet* const unsynced_metahandles;
     // Contains metahandles that are most likely dirty (though not
     // necessarily).  Dirtyness is confirmed in TakeSnapshotForSaveChanges().
     MetahandleSet* const dirty_metahandles;
 
+    // When a purge takes place, we remove items from all our indices and stash
+    // them in here so that SaveChanges can persist their permanent deletion.
+    MetahandleSet* const metahandles_to_purge;
+
     // TODO(ncarter): Figure out what the hell this is, and comment it.
     Channel* const channel;
 
     // The changes channel mutex is explicit because it must be locked
     // while holding the transaction mutex and released after
     // releasing the transaction mutex.
     browser_sync::Channel<DirectoryChangeEvent> changes_channel;
 
     Lock changes_channel_mutex;
     KernelShareInfoStatus info_status;
@@ skipping 119 matching lines @@
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 browser_sync::FastDump& operator <<
   (browser_sync::FastDump&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_