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

chrome/browser/sync/syncable/syncable.cc

 // Copyright (c) 2010 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 "chrome/browser/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 139 matching lines @@
 bool LessPathNames::operator() (const string& a, const string& b) const {
   return ComparePathNames(a, b) < 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Directory
 
 static const DirectoryChangeEvent kShutdownChangesEvent =
     { DirectoryChangeEvent::SHUTDOWN, 0, 0 };
 
+void Directory::init_kernel(const std::string& name) {
+  DCHECK(kernel_ == NULL);
+  kernel_ = new Kernel(FilePath(), name, KernelLoadInfo());
+}
+
 Directory::Kernel::Kernel(const FilePath& db_path,
                           const string& name,
                           const KernelLoadInfo& info)
     : db_path(db_path),
       refcount(1),
       name(name),
       metahandles_index(new Directory::MetahandlesIndex),
       ids_index(new Directory::IdsIndex),
       parent_id_child_index(new Directory::ParentIdChildIndex),
       client_tag_index(new Directory::ClientTagIndex),
       unapplied_update_metahandles(new MetahandleSet),
       unsynced_metahandles(new MetahandleSet),
       dirty_metahandles(new MetahandleSet),
+      metahandles_to_purge(new MetahandleSet),
       channel(new Directory::Channel(syncable::DIRECTORY_DESTROYED)),
       info_status(Directory::KERNEL_SHARE_INFO_VALID),
       persisted_info(info.kernel_info),
       cache_guid(info.cache_guid),
       next_metahandle(info.max_metahandle + 1) {
 }
 
 inline void DeleteEntry(EntryKernel* kernel) {
   delete kernel;
 }
 
 void Directory::Kernel::AddRef() {
   base::subtle::NoBarrier_AtomicIncrement(&refcount, 1);
 }
 
 void Directory::Kernel::Release() {
   if (!base::subtle::NoBarrier_AtomicIncrement(&refcount, -1))
     delete this;
 }
 
 Directory::Kernel::~Kernel() {
   CHECK(0 == refcount);
   delete channel;
   changes_channel.Notify(kShutdownChangesEvent);
   delete unsynced_metahandles;
   delete unapplied_update_metahandles;
   delete dirty_metahandles;
+  delete metahandles_to_purge;
   delete parent_id_child_index;
   delete client_tag_index;
   delete ids_index;
   for_each(metahandles_index->begin(), metahandles_index->end(), DeleteEntry);
   delete metahandles_index;
 }
 
 Directory::Directory() : kernel_(NULL), store_(NULL) {
 }
 
@@ skipping 305 matching lines @@
     if (!entry->is_dirty())
       continue;
     snapshot->dirty_metas.insert(snapshot->dirty_metas.end(), *entry);
     DCHECK_EQ(1U, kernel_->dirty_metahandles->count(*i));
     // We don't bother removing from the index here as we blow the entire thing
     // in a moment, and it unnecessarily complicates iteration.
     entry->clear_dirty(NULL);
   }
   ClearDirtyMetahandles();
 
+  // Set purged handles.
+  DCHECK(snapshot->metahandles_to_purge.empty());
+  snapshot->metahandles_to_purge.swap(*(kernel_->metahandles_to_purge));
+
   // Fill kernel_info_status and kernel_info.
   snapshot->kernel_info = kernel_->persisted_info;
   // To avoid duplicates when the process crashes, we record the next_id to be
   // greater magnitude than could possibly be reached before the next save
   // changes.  In other words, it's effectively impossible for the user to
   // generate 65536 new bookmarks in 3 seconds.
   snapshot->kernel_info.next_id -= 65536;
   snapshot->kernel_info_status = kernel_->info_status;
   // This one we reset on failure.
   kernel_->info_status = KERNEL_SHARE_INFO_VALID;
@@ skipping 37 matching lines @@
       size_t num_erased = 0;
       kernel_->flushed_metahandles.Push(entry->ref(META_HANDLE));
       num_erased = kernel_->ids_index->erase(entry);
       DCHECK_EQ(1u, num_erased);
       num_erased = kernel_->metahandles_index->erase(entry);
       DCHECK_EQ(1u, num_erased);
 
       // Might not be in it
       num_erased = kernel_->client_tag_index->erase(entry);
       DCHECK_EQ(entry->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
+      DCHECK(!kernel_->parent_id_child_index->count(entry));
       delete entry;
     }
   }
 }
 
 void Directory::PurgeEntriesWithTypeIn(const std::set<ModelType>& types) {
   if (types.count(UNSPECIFIED) != 0U || types.count(TOP_LEVEL_FOLDER) != 0U) {
     NOTREACHED() << "Don't support purging unspecified or top level entries.";
     return;
   }
 
   if (types.empty())
     return;
 
   {
-    ScopedKernelLock lock(this);
-    for (MetahandlesIndex::iterator it = kernel_->metahandles_index->begin();
-         it != kernel_->metahandles_index->end(); ++it) {
-      const sync_pb::EntitySpecifics& local_specifics = (*it)->ref(SPECIFICS);
-      const sync_pb::EntitySpecifics& server_specifics =
-          (*it)->ref(SERVER_SPECIFICS);
-      ModelType local_type = GetModelTypeFromSpecifics(local_specifics);
-      ModelType server_type = GetModelTypeFromSpecifics(server_specifics);
+    WriteTransaction trans(this, PURGE_ENTRIES, __FILE__, __LINE__);
+    {
+      ScopedKernelLock lock(this);
+      MetahandlesIndex::iterator it = kernel_->metahandles_index->begin();
+      while (it != kernel_->metahandles_index->end()) {
+        const sync_pb::EntitySpecifics& local_specifics = (*it)->ref(SPECIFICS);
+        const sync_pb::EntitySpecifics& server_specifics =
+            (*it)->ref(SERVER_SPECIFICS);
+        ModelType local_type = GetModelTypeFromSpecifics(local_specifics);
+        ModelType server_type = GetModelTypeFromSpecifics(server_specifics);
 
-      if (types.count(local_type) > 0 || types.count(server_type) > 0) {
-        // Set conditions for permanent deletion.
-        (*it)->put(IS_DEL, true);
-        (*it)->put(IS_UNSYNCED, false);
-        (*it)->put(IS_UNAPPLIED_UPDATE, false);
-        (*it)->mark_dirty(kernel_->dirty_metahandles);
-        DCHECK(!SafeToPurgeFromMemory(*it));
+        // Note the dance around incrementing |it|, since we sometimes erase().
+        if (types.count(local_type) > 0 || types.count(server_type) > 0) {
+          UnlinkEntryFromOrder(*it, NULL, &lock);
+
+          kernel_->metahandles_to_purge->insert((*it)->ref(META_HANDLE));
+
+          size_t num_erased = 0;
+          num_erased = kernel_->ids_index->erase(*it);
+          DCHECK_EQ(1u, num_erased);
+          num_erased = kernel_->client_tag_index->erase(*it);
+          DCHECK_EQ((*it)->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
+          num_erased = kernel_->parent_id_child_index->erase(*it);
+          DCHECK_EQ((*it)->ref(IS_DEL), !num_erased);
+          kernel_->metahandles_index->erase(it++);
+        } else {
+          ++it;
+        }
       }
-    }
 
-    // Ensure meta tracking for these data types reflects the deleted state.
-    for (std::set<ModelType>::const_iterator it = types.begin();
-         it != types.end(); ++it) {
-      set_initial_sync_ended_for_type_unsafe(*it, false);
-      set_last_download_timestamp_unsafe(*it, 0);
+      // Ensure meta tracking for these data types reflects the deleted state.
+      for (std::set<ModelType>::const_iterator it = types.begin();
+           it != types.end(); ++it) {
+        set_initial_sync_ended_for_type_unsafe(*it, false);
+        set_last_download_timestamp_unsafe(*it, 0);
+      }
     }
   }
 }
 
 void Directory::HandleSaveChangesFailure(const SaveChangesSnapshot& snapshot) {
   ScopedKernelLock lock(this);
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 
   // Because we optimistically cleared the dirty bit on the real entries when
   // taking the snapshot, we must restore it on failure.  Not doing this could
   // cause lost data, if no other changes are made to the in-memory entries
   // that would cause the dirty bit to get set again. Setting the bit ensures
   // that SaveChanges will at least try again later.
   for (OriginalEntries::const_iterator i = snapshot.dirty_metas.begin();
        i != snapshot.dirty_metas.end(); ++i) {
     kernel_->needle.put(META_HANDLE, i->ref(META_HANDLE));
     MetahandlesIndex::iterator found =
         kernel_->metahandles_index->find(&kernel_->needle);
     if (found != kernel_->metahandles_index->end()) {
       (*found)->mark_dirty(kernel_->dirty_metahandles);
     }
   }
+
+  kernel_->metahandles_to_purge->insert(snapshot.metahandles_to_purge.begin(),
+                                        snapshot.metahandles_to_purge.end());
 }
 
 int64 Directory::last_download_timestamp(ModelType model_type) const {
   ScopedKernelLock lock(this);
   return kernel_->persisted_info.last_download_timestamp[model_type];
 }
 
 void Directory::set_last_download_timestamp(ModelType model_type,
     int64 timestamp) {
   ScopedKernelLock lock(this);
@@ skipping 616 matching lines @@
       CHECK(index->insert(kernel_->ref(META_HANDLE)).second);
     else
       CHECK(1 == index->erase(kernel_->ref(META_HANDLE)));
     kernel_->put(field, value);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
 }
 
 void MutableEntry::UnlinkFromOrder() {
-  Id old_previous = Get(PREV_ID);
-  Id old_next = Get(NEXT_ID);
+  ScopedKernelLock lock(dir());
+  dir()->UnlinkEntryFromOrder(kernel_, write_transaction(), &lock);
+}
 
-  // Self-looping signifies that this item is not in the order.  If we were to
-  // set these to 0, we could get into trouble because this node might look
-  // like the first node in the ordering.
-  Put(NEXT_ID, Get(ID));
-  Put(PREV_ID, Get(ID));
+void Directory::UnlinkEntryFromOrder(EntryKernel* entry,
+                                     WriteTransaction* trans,
+                                     ScopedKernelLock* lock) {
+  CHECK(!trans || this == trans->directory());
+  Id old_previous = entry->ref(PREV_ID);
+  Id old_next = entry->ref(NEXT_ID);
+
+  entry->put(NEXT_ID, entry->ref(ID));
+  entry->put(PREV_ID, entry->ref(ID));
+  entry->mark_dirty(kernel_->dirty_metahandles);
 
   if (!old_previous.IsRoot()) {
     if (old_previous == old_next) {
       // Note previous == next doesn't imply previous == next == Get(ID). We
       // could have prev==next=="c-XX" and Get(ID)=="sX..." if an item was added
       // and deleted before receiving the server ID in the commit response.
-      CHECK((old_next == Get(ID)) || !old_next.ServerKnows());
+      CHECK((old_next == entry->ref(ID)) || !old_next.ServerKnows());
       return;  // Done if we were already self-looped (hence unlinked).
     }
-    MutableEntry previous_entry(write_transaction(), GET_BY_ID, old_previous);
-    CHECK(previous_entry.good());
-    previous_entry.Put(NEXT_ID, old_next);
+    EntryKernel* previous_entry = GetEntryById(old_previous, lock);
+    CHECK(previous_entry);
+    if (trans)
+      trans->SaveOriginal(previous_entry);
+    previous_entry->put(NEXT_ID, old_next);
+    previous_entry->mark_dirty(kernel_->dirty_metahandles);
   }
 
   if (!old_next.IsRoot()) {
-    MutableEntry next_entry(write_transaction(), GET_BY_ID, old_next);
-    CHECK(next_entry.good());
-    next_entry.Put(PREV_ID, old_previous);
+    EntryKernel* next_entry = GetEntryById(old_next, lock);
+    CHECK(next_entry);
+    if (trans)
+      trans->SaveOriginal(next_entry);
+    next_entry->put(PREV_ID, old_previous);
+    next_entry->mark_dirty(kernel_->dirty_metahandles);
   }
 }
 
 bool MutableEntry::PutPredecessor(const Id& predecessor_id) {
   UnlinkFromOrder();
 
   if (Get(IS_DEL)) {
     DCHECK(predecessor_id.IsNull());
     return true;
   }
@@ skipping 192 matching lines @@
   return s << std::dec;
 }
 
 FastDump& operator<<(FastDump& dump, const syncable::Blob& blob) {
   if (blob.empty())
     return dump;
   string buffer(HexEncode(&blob[0], blob.size()));
   dump.out_->sputn(buffer.c_str(), buffer.size());
   return dump;
 }