[Sync] Convert syncable/ directory to ModelEnumSet

chrome/browser/sync/syncable/syncable.cc

 // Copyright (c) 2011 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 <algorithm>
 #include <cstring>
 #include <functional>
 #include <iomanip>
@@ skipping 801 matching lines @@
 
       // Might not be in it
       num_erased = kernel_->client_tag_index->erase(entry);
       DCHECK_EQ(entry->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
       CHECK(!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())
+void Directory::PurgeEntriesWithTypeIn(ModelEnumSet types) {
+  if (types.Empty())
     return;
 
   {
     WriteTransaction trans(FROM_HERE, PURGE_ENTRIES, this);
     {
       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);
 
         // Note the dance around incrementing |it|, since we sometimes erase().
-        if (types.count(local_type) > 0 || types.count(server_type) > 0) {
+        if ((IsRealDataType(local_type) && types.Has(local_type)) ||
+            (IsRealDataType(server_type) && types.Has(server_type))) {
           UnlinkEntryFromOrder(*it, NULL, &lock);
           int64 handle = (*it)->ref(META_HANDLE);
           kernel_->metahandles_to_purge->insert(handle);
 
           size_t num_erased = 0;
           EntryKernel* entry = *it;
           num_erased = kernel_->ids_index->erase(entry);
           DCHECK_EQ(1u, num_erased);
           num_erased = kernel_->client_tag_index->erase(entry);
           DCHECK_EQ(entry->ref(UNIQUE_CLIENT_TAG).empty(), !num_erased);
           num_erased = kernel_->unsynced_metahandles->erase(handle);
           DCHECK_EQ(entry->ref(IS_UNSYNCED), num_erased > 0);
           num_erased =
               kernel_->unapplied_update_metahandles[server_type].erase(handle);
           DCHECK_EQ(entry->ref(IS_UNAPPLIED_UPDATE), num_erased > 0);
           num_erased = kernel_->parent_id_child_index->erase(entry);
           DCHECK_EQ(entry->ref(IS_DEL), !num_erased);
           kernel_->metahandles_index->erase(it++);
           delete entry;
         } 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);
-        kernel_->persisted_info.reset_download_progress(*it);
+      for (syncable::ModelEnumSet::Iterator it = types.First();
+           it.Good(); it.Inc()) {
+        set_initial_sync_ended_for_type_unsafe(it.Get(), false);
+        kernel_->persisted_info.reset_download_progress(it.Get());
       }
     }
   }
 }
 
 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
@@ skipping 39 matching lines @@
 void Directory::SetDownloadProgress(
     ModelType model_type,
     const sync_pb::DataTypeProgressMarker& new_progress) {
   ScopedKernelLock lock(this);
   kernel_->persisted_info.download_progress[model_type].CopyFrom(new_progress);
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
 bool Directory::initial_sync_ended_for_type(ModelType type) const {
   ScopedKernelLock lock(this);
-  return kernel_->persisted_info.initial_sync_ended[type];
+  return kernel_->persisted_info.initial_sync_ended.Has(type);
 }
 
 template <class T> void Directory::TestAndSet(
     T* kernel_data, const T* data_to_set) {
   if (*kernel_data != *data_to_set) {
     *kernel_data = *data_to_set;
     kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
   }
 }
 
 void Directory::set_initial_sync_ended_for_type(ModelType type, bool x) {
   ScopedKernelLock lock(this);
   set_initial_sync_ended_for_type_unsafe(type, x);
 }
 
 void Directory::set_initial_sync_ended_for_type_unsafe(ModelType type,
                                                        bool x) {
-  if (kernel_->persisted_info.initial_sync_ended[type] == x)
+  if (kernel_->persisted_info.initial_sync_ended.Has(type) == x)
     return;
-  kernel_->persisted_info.initial_sync_ended.set(type, x);
+  if (x) {
+    kernel_->persisted_info.initial_sync_ended.Put(type);
+  } else {
+    kernel_->persisted_info.initial_sync_ended.Remove(type);
+  }
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
 void Directory::SetNotificationStateUnsafe(
     const std::string& notification_state) {
   if (notification_state == kernel_->persisted_info.notification_state)
     return;
   kernel_->persisted_info.notification_state = notification_state;
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
@@ skipping 337 matching lines @@
       // Not actually mutated, so erase from |mutations_|.
       mutations_.erase(it++);
     }
   }
   return ImmutableEntryKernelMutationMap(&mutations_);
 }
 
 void WriteTransaction::UnlockAndNotify(
     const ImmutableEntryKernelMutationMap& mutations) {
   // Work while transaction mutex is held.
-  ModelTypeBitSet models_with_changes;
+  ModelEnumSet models_with_changes;
   bool has_mutations = !mutations.Get().empty();
   if (has_mutations) {
     models_with_changes = NotifyTransactionChangingAndEnding(mutations);
   }
   Unlock();
 
   // Work after mutex is relased.
   if (has_mutations) {
     NotifyTransactionComplete(models_with_changes);
   }
 }
 
-ModelTypeBitSet WriteTransaction::NotifyTransactionChangingAndEnding(
+ModelEnumSet WriteTransaction::NotifyTransactionChangingAndEnding(
     const ImmutableEntryKernelMutationMap& mutations) {
   dirkernel_->transaction_mutex.AssertAcquired();
   DCHECK(!mutations.Get().empty());
 
   WriteTransactionInfo write_transaction_info(
       dirkernel_->next_write_transaction_id, from_here_, writer_, mutations);
   ++dirkernel_->next_write_transaction_id;
 
   ImmutableWriteTransactionInfo immutable_write_transaction_info(
       &write_transaction_info);
   DirectoryChangeDelegate* const delegate = dirkernel_->delegate;
   if (writer_ == syncable::SYNCAPI) {
     delegate->HandleCalculateChangesChangeEventFromSyncApi(
         immutable_write_transaction_info, this);
   } else {
     delegate->HandleCalculateChangesChangeEventFromSyncer(
         immutable_write_transaction_info, this);
   }
 
-  ModelTypeBitSet models_with_changes =
+  ModelEnumSet models_with_changes =
       delegate->HandleTransactionEndingChangeEvent(
           immutable_write_transaction_info, this);
 
   dirkernel_->transaction_observer.Call(FROM_HERE,
       &TransactionObserver::OnTransactionWrite,
       immutable_write_transaction_info, models_with_changes);
 
   return models_with_changes;
 }
 
 void WriteTransaction::NotifyTransactionComplete(
-    ModelTypeBitSet models_with_changes) {
+    ModelEnumSet models_with_changes) {
   dirkernel_->delegate->HandleTransactionCompleteChangeEvent(
       models_with_changes);
 }
 
 WriteTransaction::~WriteTransaction() {
   const ImmutableEntryKernelMutationMap& mutations = RecordMutations();
 
   if (OFF != kInvariantCheckLevel) {
     const bool full_scan = (FULL_DB_VERIFICATION == kInvariantCheckLevel);
     if (full_scan)
@@ skipping 745 matching lines @@
     if (entry->ref(NEXT_ID).IsRoot() ||
         entry->ref(NEXT_ID) != entry->ref(PREV_ID)) {
       return entry;
     }
   }
   // There were no children in the linked list.
   return NULL;
 }
 
 }  // namespace syncable