[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

chrome/browser/sync/engine/get_commit_ids_command.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/engine/get_commit_ids_command.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 26 matching lines @@
                                  &all_unsynced_handles);
 
   Cryptographer* cryptographer =
       session->context()->directory_manager()->GetCryptographer(
           session->write_transaction());
   if (cryptographer) {
     encrypted_types_ = cryptographer->GetEncryptedTypes();
     passphrase_missing_ = cryptographer->has_pending_keys();
   };
 
-  const syncable::ModelTypeSet& throttled_types =
+  const syncable::ModelEnumSet throttled_types =
        session->context()->GetThrottledTypes();
   // We filter out all unready entries from the set of unsynced handles to
   // ensure we don't trigger useless sync cycles attempting to retry due to
   // there being work to do. (see ScheduleNextSync in sync_scheduler)
   FilterUnreadyEntries(session->write_transaction(),
                        throttled_types,
                        &all_unsynced_handles);
 
   StatusController* status = session->mutable_status_controller();
   status->set_unsynced_handles(all_unsynced_handles);
   BuildCommitIds(status->unsynced_handles(), session->write_transaction(),
                  session->routing_info(), throttled_types);
 
   const vector<syncable::Id>& verified_commit_ids =
       ordered_commit_set_->GetAllCommitIds();
 
   for (size_t i = 0; i < verified_commit_ids.size(); i++)
     DVLOG(1) << "Debug commit batch result:" << verified_commit_ids[i];
 
   status->set_commit_set(*ordered_commit_set_.get());
 }
 
 namespace {
 
 // An entry ready for commit is defined as:
 // 1. Not in conflict (SERVER_VERSION == BASE_VERSION || SERVER_VERSION == 0)
 // and not requiring encryption (any entry containing an encrypted datatype
 // while the cryptographer requires a passphrase is not ready for commit.)
 // 2. Its type is not currently throttled.
-bool IsEntryReadyForCommit(const syncable::ModelTypeSet& encrypted_types,
+bool IsEntryReadyForCommit(syncable::ModelEnumSet encrypted_types,
                            bool passphrase_missing,
                            const syncable::Entry& entry,
-                           const syncable::ModelTypeSet& throttled_types) {
+                           syncable::ModelEnumSet throttled_types) {
   if (!entry.Get(syncable::IS_UNSYNCED))
     return false;
 
   if (entry.Get(syncable::SERVER_VERSION) > 0 &&
       (entry.Get(syncable::SERVER_VERSION) >
        entry.Get(syncable::BASE_VERSION))) {
     // The local and server versions don't match. The item must be in
     // conflict, so there's no point in attempting to commit.
     DCHECK(entry.Get(syncable::IS_UNAPPLIED_UPDATE));  // In conflict.
     // TODO(zea): switch this to DVLOG once it's clear bug 100660 is fixed.
     DVLOG(1) << "Excluding entry from commit due to version mismatch "
              << entry;
     return false;
   }
 
-  syncable::ModelType type = entry.GetModelType();
+  const syncable::ModelType type = entry.GetModelType();
   // We special case the nigori node because even though it is considered an
   // "encrypted type", not all nigori node changes require valid encryption
   // (ex: sync_tabs).
-  if (type != syncable::NIGORI &&
-      encrypted_types.count(type) > 0 &&
+  if (syncable::IsRealDataType(type) &&
+      (type != syncable::NIGORI) &&
+      encrypted_types.Has(type) &&
       (passphrase_missing ||
        syncable::EntryNeedsEncryption(encrypted_types, entry))) {
     // This entry requires encryption but is not properly encrypted (possibly
     // due to the cryptographer not being initialized or the user hasn't
     // provided the most recent passphrase).
     // TODO(zea): switch this to DVLOG once it's clear bug 100660 is fixed.
     DVLOG(1) << "Excluding entry from commit due to lack of encryption "
              << entry;
     return false;
   }
 
   // Look at the throttled types.
-  if (throttled_types.count(type) > 0)
+  if (syncable::IsRealDataType(type) && throttled_types.Has(type))
     return false;
 
   return true;
 }
 
 }  // namespace
 
 void GetCommitIdsCommand::FilterUnreadyEntries(
     syncable::BaseTransaction* trans,
-    const syncable::ModelTypeSet& throttled_types,
+    syncable::ModelEnumSet throttled_types,
     syncable::Directory::UnsyncedMetaHandles* unsynced_handles) {
   syncable::Directory::UnsyncedMetaHandles::iterator iter;
   syncable::Directory::UnsyncedMetaHandles new_unsynced_handles;
   new_unsynced_handles.reserve(unsynced_handles->size());
   for (iter = unsynced_handles->begin();
        iter != unsynced_handles->end();
        ++iter) {
     syncable::Entry entry(trans, syncable::GET_BY_HANDLE, *iter);
     if (IsEntryReadyForCommit(encrypted_types_,
                               passphrase_missing_,
                               entry,
                               throttled_types))
       new_unsynced_handles.push_back(*iter);
   }
   if (new_unsynced_handles.size() != unsynced_handles->size())
     unsynced_handles->swap(new_unsynced_handles);
 }
 
 void GetCommitIdsCommand::AddUncommittedParentsAndTheirPredecessors(
     syncable::BaseTransaction* trans,
     syncable::Id parent_id,
     const ModelSafeRoutingInfo& routes,
-    const syncable::ModelTypeSet& throttled_types) {
+    syncable::ModelEnumSet throttled_types) {
   OrderedCommitSet item_dependencies(routes);
 
   // Climb the tree adding entries leaf -> root.
   while (!parent_id.ServerKnows()) {
     syncable::Entry parent(trans, syncable::GET_BY_ID, parent_id);
     CHECK(parent.good()) << "Bad user-only parent in item path.";
     int64 handle = parent.Get(syncable::META_HANDLE);
     if (ordered_commit_set_->HaveCommitItem(handle) ||
         item_dependencies.HaveCommitItem(handle)) {
       break;
     }
     if (!AddItemThenPredecessors(trans, throttled_types, &parent,
                                  syncable::IS_UNSYNCED,
                                  &item_dependencies)) {
       break;  // Parent was already present in the set.
     }
     parent_id = parent.Get(syncable::PARENT_ID);
   }
 
   // Reverse what we added to get the correct order.
   ordered_commit_set_->AppendReverse(item_dependencies);
 }
 
 bool GetCommitIdsCommand::AddItem(syncable::Entry* item,
-    const syncable::ModelTypeSet& throttled_types,
-    OrderedCommitSet* result) {
+                                  syncable::ModelEnumSet throttled_types,
+                                  OrderedCommitSet* result) {
   if (!IsEntryReadyForCommit(encrypted_types_, passphrase_missing_, *item,
                              throttled_types))
     return false;
   int64 item_handle = item->Get(syncable::META_HANDLE);
   if (result->HaveCommitItem(item_handle) ||
       ordered_commit_set_->HaveCommitItem(item_handle)) {
     return false;
   }
   result->AddCommitItem(item_handle, item->Get(syncable::ID),
                         item->GetModelType());
   return true;
 }
 
 bool GetCommitIdsCommand::AddItemThenPredecessors(
     syncable::BaseTransaction* trans,
-    const syncable::ModelTypeSet& throttled_types,
+    syncable::ModelEnumSet throttled_types,
     syncable::Entry* item,
     syncable::IndexedBitField inclusion_filter,
     OrderedCommitSet* result) {
   if (!AddItem(item, throttled_types, result))
     return false;
   if (item->Get(syncable::IS_DEL))
     return true;  // Deleted items have no predecessors.
 
   syncable::Id prev_id = item->Get(syncable::PREV_ID);
   while (!prev_id.IsRoot()) {
     syncable::Entry prev(trans, syncable::GET_BY_ID, prev_id);
     CHECK(prev.good()) << "Bad id when walking predecessors.";
     if (!prev.Get(inclusion_filter))
       break;
     if (!AddItem(&prev, throttled_types, result))
       break;
     prev_id = prev.Get(syncable::PREV_ID);
   }
   return true;
 }
 
 void GetCommitIdsCommand::AddPredecessorsThenItem(
     syncable::BaseTransaction* trans,
-    const syncable::ModelTypeSet& throttled_types,
+    syncable::ModelEnumSet throttled_types,
     syncable::Entry* item,
     syncable::IndexedBitField inclusion_filter,
     const ModelSafeRoutingInfo& routes) {
   OrderedCommitSet item_dependencies(routes);
   AddItemThenPredecessors(trans, throttled_types, item, inclusion_filter,
                           &item_dependencies);
 
   // Reverse what we added to get the correct order.
   ordered_commit_set_->AppendReverse(item_dependencies);
 }
 
 bool GetCommitIdsCommand::IsCommitBatchFull() {
   return ordered_commit_set_->Size() >= requested_commit_batch_size_;
 }
 
 void GetCommitIdsCommand::AddCreatesAndMoves(
     const vector<int64>& unsynced_handles,
     syncable::WriteTransaction* write_transaction,
     const ModelSafeRoutingInfo& routes,
-    const syncable::ModelTypeSet& throttled_types) {
+    syncable::ModelEnumSet throttled_types) {
   // Add moves and creates, and prepend their uncommitted parents.
   for (CommitMetahandleIterator iterator(unsynced_handles, write_transaction,
                                          ordered_commit_set_.get());
        !IsCommitBatchFull() && iterator.Valid();
        iterator.Increment()) {
     int64 metahandle = iterator.Current();
 
     syncable::Entry entry(write_transaction,
                           syncable::GET_BY_HANDLE,
                           metahandle);
@@ skipping 90 matching lines @@
         ordered_commit_set_->AddCommitItem(metahandle, entry.Get(syncable::ID),
             entry.GetModelType());
       }
     }
   }
 }
 
 void GetCommitIdsCommand::BuildCommitIds(const vector<int64>& unsynced_handles,
     syncable::WriteTransaction* write_transaction,
     const ModelSafeRoutingInfo& routes,
-    const syncable::ModelTypeSet& throttled_types) {
+    syncable::ModelEnumSet throttled_types) {
   ordered_commit_set_.reset(new OrderedCommitSet(routes));
   // Commits follow these rules:
   // 1. Moves or creates are preceded by needed folder creates, from
   //    root to leaf.  For folders whose contents are ordered, moves
   //    and creates appear in order.
   // 2. Moves/Creates before deletes.
   // 3. Deletes, collapsed.
   // We commit deleted moves under deleted items as moves when collapsing
   // delete trees.
 
   // Add moves and creates, and prepend their uncommitted parents.
   AddCreatesAndMoves(unsynced_handles, write_transaction, routes,
                      throttled_types);
 
   // Add all deletes.
   AddDeletes(unsynced_handles, write_transaction);
 }
 
 }  // namespace browser_sync