[Sync] Separate purge types step from sync manager configuration.

components/sync/syncable/directory.cc

 // Copyright 2013 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 "components/sync/syncable/directory.h"
 
 #include <inttypes.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 711 matching lines @@
     num_erased = kernel_->server_tags_map.erase(entry->ref(UNIQUE_SERVER_TAG));
     DCHECK_EQ(1u, num_erased);
   }
   RemoveFromAttachmentIndex(lock, handle, entry->ref(ATTACHMENT_METADATA));
 
   if (save_to_journal) {
     entries_to_journal->insert(std::move(entry_ptr));
   }
 }
 
-bool Directory::PurgeEntriesWithTypeIn(ModelTypeSet disabled_types,
+void Directory::PurgeEntriesWithTypeIn(ModelTypeSet disabled_types,
                                        ModelTypeSet types_to_journal,
                                        ModelTypeSet types_to_unapply) {
   disabled_types.RemoveAll(ProxyTypes());
+  if (disabled_types.Empty())
+    return;
 
-  if (disabled_types.Empty())
-    return true;
+  WriteTransaction trans(FROM_HERE, PURGE_ENTRIES, this);
+
+  OwnedEntryKernelSet entries_to_journal;
 
   {
-    WriteTransaction trans(FROM_HERE, PURGE_ENTRIES, this);
+    ScopedKernelLock lock(this);
 
-    OwnedEntryKernelSet entries_to_journal;
+    bool found_progress = false;
+    for (ModelTypeSet::Iterator iter = disabled_types.First(); iter.Good();
+         iter.Inc()) {
+      if (!kernel_->persisted_info.HasEmptyDownloadProgress(iter.Get()))
+        found_progress = true;
+    }
 
-    {
-      ScopedKernelLock lock(this);
+    // If none of the disabled types have progress markers, there's nothing to
+    // purge.
+    if (!found_progress)
+      return;
 
-      bool found_progress = false;
-      for (ModelTypeSet::Iterator iter = disabled_types.First(); iter.Good();
-           iter.Inc()) {
-        if (!kernel_->persisted_info.HasEmptyDownloadProgress(iter.Get()))
-          found_progress = true;
-      }
+    for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
+         it != kernel_->metahandles_map.end();) {
+      EntryKernel* entry = it->second.get();
+      const sync_pb::EntitySpecifics& local_specifics = entry->ref(SPECIFICS);
+      const sync_pb::EntitySpecifics& server_specifics =
+          entry->ref(SERVER_SPECIFICS);
+      ModelType local_type = GetModelTypeFromSpecifics(local_specifics);
+      ModelType server_type = GetModelTypeFromSpecifics(server_specifics);
 
-      // If none of the disabled types have progress markers, there's nothing to
-      // purge.
-      if (!found_progress)
-        return true;
+      // Increment the iterator before (potentially) calling DeleteEntry,
+      // otherwise our iterator may be invalidated.
+      ++it;
 
-      for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
-           it != kernel_->metahandles_map.end();) {
-        EntryKernel* entry = it->second.get();
-        const sync_pb::EntitySpecifics& local_specifics = entry->ref(SPECIFICS);
-        const sync_pb::EntitySpecifics& server_specifics =
-            entry->ref(SERVER_SPECIFICS);
-        ModelType local_type = GetModelTypeFromSpecifics(local_specifics);
-        ModelType server_type = GetModelTypeFromSpecifics(server_specifics);
-
-        // Increment the iterator before (potentially) calling DeleteEntry,
-        // otherwise our iterator may be invalidated.
-        ++it;
-
-        if ((IsRealDataType(local_type) && disabled_types.Has(local_type)) ||
-            (IsRealDataType(server_type) && disabled_types.Has(server_type))) {
-          if (types_to_unapply.Has(local_type) ||
-              types_to_unapply.Has(server_type)) {
-            UnapplyEntry(entry);
-          } else {
-            bool save_to_journal =
-                (types_to_journal.Has(local_type) ||
-                 types_to_journal.Has(server_type)) &&
-                (delete_journal_->IsDeleteJournalEnabled(local_type) ||
-                 delete_journal_->IsDeleteJournalEnabled(server_type));
-            DeleteEntry(lock, save_to_journal, entry, &entries_to_journal);
-          }
+      if ((IsRealDataType(local_type) && disabled_types.Has(local_type)) ||
+          (IsRealDataType(server_type) && disabled_types.Has(server_type))) {
+        if (types_to_unapply.Has(local_type) ||
+            types_to_unapply.Has(server_type)) {
+          UnapplyEntry(entry);
+        } else {
+          bool save_to_journal =
+              (types_to_journal.Has(local_type) ||
+               types_to_journal.Has(server_type)) &&
+              (delete_journal_->IsDeleteJournalEnabled(local_type) ||
+               delete_journal_->IsDeleteJournalEnabled(server_type));
+          DeleteEntry(lock, save_to_journal, entry, &entries_to_journal);
         }
       }
+    }
 
-      delete_journal_->AddJournalBatch(&trans, entries_to_journal);
+    delete_journal_->AddJournalBatch(&trans, entries_to_journal);
 
-      // Ensure meta tracking for these data types reflects the purged state.
-      for (ModelTypeSet::Iterator it = disabled_types.First(); it.Good();
-           it.Inc()) {
-        kernel_->persisted_info.transaction_version[it.Get()] = 0;
+    // Ensure meta tracking for these data types reflects the purged state.
+    for (ModelTypeSet::Iterator it = disabled_types.First(); it.Good();
+         it.Inc()) {
+      kernel_->persisted_info.transaction_version[it.Get()] = 0;
 
-        // Don't discard progress markers or context for unapplied types.
-        if (!types_to_unapply.Has(it.Get())) {
-          kernel_->persisted_info.ResetDownloadProgress(it.Get());
-          kernel_->persisted_info.datatype_context[it.Get()].Clear();
-        }
+      // Don't discard progress markers or context for unapplied types.
+      if (!types_to_unapply.Has(it.Get())) {
+        kernel_->persisted_info.ResetDownloadProgress(it.Get());
+        kernel_->persisted_info.datatype_context[it.Get()].Clear();
       }
+    }
 
-      kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
-    }
+    kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
   }
-  return true;
 }
 
 bool Directory::ResetVersionsForType(BaseWriteTransaction* trans,
                                      ModelType type) {
   if (!ProtocolTypes().Has(type))
     return false;
   DCHECK_NE(type, BOOKMARKS) << "Only non-hierarchical types are supported";
 
   EntryKernel* type_root = GetEntryByServerTag(ModelTypeToRootTag(type));
   if (!type_root)
@@ skipping 775 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer