sync: Add method to Directory to remove all entries for a set of ModelTypes....

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 592 matching lines @@
         kernel_->extended_attributes->find(key);
     if (found == kernel_->extended_attributes->end() ||
         found->second.dirty || !i->second.is_deleted) {
       ++i;
     } else {
       kernel_->extended_attributes->erase(found);
     }
   }
 }
 
+void Directory::PurgeEntriesWithTypeIn(const std::set<ModelType>& types) {
+  DCHECK_EQ(0U, types.count(UNSPECIFIED));
+  DCHECK_EQ(0U, types.count(TOP_LEVEL_FOLDER));
+
+  if (types.empty())
+    return;
+
+  ScopedKernelLock lock(this);
+  MetahandleSet to_delete;
+  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);
+
+    // Note the dance around incrementing |it|, since we sometimes use erase().
+    if (types.count(local_type) > 0 || types.count(server_type) > 0) {
+      to_delete.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);
+      kernel_->metahandles_index->erase(it++);
+    } else {
+      ++it;
+    }
+  }
+
+  // Synchronously wipe these entries from disk.
+  store_->DeleteEntries(to_delete);
+}
+
 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();
@@ skipping 969 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;
 }