[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

chrome/browser/sync/internal_api/sync_manager.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/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/command_line.h"
@@ skipping 244 matching lines @@
       syncable::BaseTransaction* trans) OVERRIDE;
 
   // Listens for notifications from the ServerConnectionManager
   void HandleServerConnectionEvent(const ServerConnectionEvent& event);
 
   // Open the directory named with username_for_share
   bool OpenDirectory();
 
   // Cryptographer::Observer implementation.
   virtual void OnEncryptedTypesChanged(
-      const syncable::ModelTypeSet& encrypted_types,
+      syncable::ModelEnumSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
 
   // SyncNotifierObserver implementation.
   virtual void OnNotificationStateChange(
       bool notifications_enabled) OVERRIDE;
 
   virtual void OnIncomingNotification(
       const syncable::ModelTypePayloadMap& type_payloads) OVERRIDE;
 
   virtual void StoreState(const std::string& cookie) OVERRIDE;
@@ skipping 38 matching lines @@
                                 ChangeReorderBuffer* buffer,
                                 Cryptographer* cryptographer,
                                 const syncable::EntryKernel& original,
                                 bool existed_before,
                                 bool exists_now);
 
   // Called only by our NetworkChangeNotifier.
   virtual void OnIPAddressChanged() OVERRIDE;
 
   bool InitialSyncEndedForAllEnabledTypes() {
-    syncable::ModelTypeSet types;
+    syncable::ModelEnumSet types;
     ModelSafeRoutingInfo enabled_types;
     registrar_->GetModelSafeRoutingInfo(&enabled_types);
     for (ModelSafeRoutingInfo::const_iterator i = enabled_types.begin();
         i != enabled_types.end(); ++i) {
-      types.insert(i->first);
+      types.Put(i->first);
     }
 
     return InitialSyncEndedForTypes(types, &share_);
   }
 
   // SyncEngineEventListener implementation.
   virtual void OnSyncEngineEvent(const SyncEngineEvent& event) OVERRIDE;
 
   // ServerConnectionEventListener implementation.
   virtual void OnServerConnectionEvent(
@@ skipping 788 matching lines @@
   // types changed to ensure that any stray unencrypted entries are overwritten.
   ReEncryptEverything(&trans);
 }
 
 // TODO(zea): Add unit tests that ensure no sync changes are made when not
 // needed.
 void SyncManager::SyncInternal::ReEncryptEverything(WriteTransaction* trans) {
   Cryptographer* cryptographer = trans->GetCryptographer();
   if (!cryptographer || !cryptographer->is_ready())
     return;
-  syncable::ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
+  syncable::ModelEnumSet encrypted_types = GetEncryptedTypes(trans);
   ModelSafeRoutingInfo routes;
   registrar_->GetModelSafeRoutingInfo(&routes);
   std::string tag;
-  for (syncable::ModelTypeSet::iterator iter = encrypted_types.begin();
-       iter != encrypted_types.end(); ++iter) {
-    if (*iter == syncable::PASSWORDS ||
-        *iter == syncable::NIGORI ||
-        routes.count(*iter) == 0)
+  for (syncable::ModelEnumSet::Iterator iter = encrypted_types.First();
+       iter.Good(); iter.Inc()) {
+    if (iter.Get() == syncable::PASSWORDS ||
+        iter.Get() == syncable::NIGORI ||
+        routes.count(iter.Get()) == 0)
       continue;
     ReadNode type_root(trans);
-    tag = syncable::ModelTypeToRootTag(*iter);
+    tag = syncable::ModelTypeToRootTag(iter.Get());
     if (!type_root.InitByTagLookup(tag)) {
       // This can happen when we enable a datatype for the first time on restart
       // (for example when we upgrade) and therefore haven't done the initial
       // download for that type at the time we RefreshEncryption. There's
       // nothing we can do for now, so just move on to the next type.
       continue;
     }
 
     // Iterate through all children of this datatype.
     std::queue<int64> to_visit;
@@ skipping 685 matching lines @@
     if ((*it)->ContainsString(lowercase_query)) {
       result->Append(new StringValue(base::Int64ToString(
           (*it)->ref(syncable::META_HANDLE))));
     }
   }
 
   return JsArgList(&return_args);
 }
 
 void SyncManager::SyncInternal::OnEncryptedTypesChanged(
-    const syncable::ModelTypeSet& encrypted_types,
+    syncable::ModelEnumSet encrypted_types,
     bool encrypt_everything) {
   // NOTE: We're in a transaction.
   FOR_EACH_OBSERVER(
       SyncManager::Observer, observers_,
       OnEncryptedTypesChanged(encrypted_types, encrypt_everything));
 }
 
 void SyncManager::SyncInternal::OnNotificationStateChange(
     bool notifications_enabled) {
   DVLOG(1) << "P2P: Notifications enabled = "
@@ skipping 108 matching lines @@
 UserShare* SyncManager::GetUserShare() const {
   return data_->GetUserShare();
 }
 
 void SyncManager::RefreshEncryption() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->UpdateCryptographerAndNigori())
     data_->RefreshEncryption();
 }
 
-syncable::ModelTypeSet SyncManager::GetEncryptedDataTypesForTest() const {
+syncable::ModelEnumSet SyncManager::GetEncryptedDataTypesForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
-bool SyncManager::ReceivedExperimentalTypes(syncable::ModelTypeSet* to_add)
+bool SyncManager::ReceivedExperimentalTypes(syncable::ModelEnumSet* to_add)
     const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
   if (!node.InitByTagLookup(kNigoriTag)) {
     DVLOG(1) << "Couldn't find Nigori node.";
     return false;
   }
   if (node.GetNigoriSpecifics().sync_tabs()) {
-    to_add->insert(syncable::SESSIONS);
+    to_add->Put(syncable::SESSIONS);
     return true;
   }
   return false;
 }
 
 bool SyncManager::HasUnsyncedItems() const {
   sync_api::ReadTransaction trans(FROM_HERE, GetUserShare());
   return (trans.GetWrappedTrans()->directory()->unsynced_entity_count() != 0);
 }
 
@@ skipping 25 matching lines @@
       return "REASON_DECRYPTION";
     case REASON_SET_PASSPHRASE_FAILED:
       return "REASON_SET_PASSPHRASE_FAILED";
     default:
       NOTREACHED();
       return "INVALID_REASON";
   }
 }
 
 // Helper function to determine if initial sync had ended for types.
-bool InitialSyncEndedForTypes(syncable::ModelTypeSet types,
+bool InitialSyncEndedForTypes(syncable::ModelEnumSet types,
                               sync_api::UserShare* share) {
   syncable::ScopedDirLookup lookup(share->dir_manager.get(),
                                    share->name);
   if (!lookup.good()) {
     DCHECK(false) << "ScopedDirLookup failed when checking initial sync";
     return false;
   }
 
-  for (syncable::ModelTypeSet::const_iterator i = types.begin();
-       i != types.end(); ++i) {
-    if (!lookup->initial_sync_ended_for_type(*i))
+  for (syncable::ModelEnumSet::Iterator i = types.First();
+       i.Good(); i.Inc()) {
+    if (!lookup->initial_sync_ended_for_type(i.Get()))
       return false;
   }
   return true;
 }
 
-syncable::ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
-    const syncable::ModelTypeSet types,
+syncable::ModelEnumSet GetTypesWithEmptyProgressMarkerToken(
+    syncable::ModelEnumSet types,
     sync_api::UserShare* share) {
   syncable::ScopedDirLookup lookup(share->dir_manager.get(),
                                    share->name);
   if (!lookup.good()) {
     NOTREACHED() << "ScopedDirLookup failed for "
                   << "GetTypesWithEmptyProgressMarkerToken";
-    return syncable::ModelTypeSet();
+    return syncable::ModelEnumSet();
   }
 
-  syncable::ModelTypeSet result;
-  for (syncable::ModelTypeSet::const_iterator i = types.begin();
-       i != types.end(); ++i) {
+  syncable::ModelEnumSet result;
+  for (syncable::ModelEnumSet::Iterator i = types.First();
+       i.Good(); i.Inc()) {
     sync_pb::DataTypeProgressMarker marker;
-    lookup->GetDownloadProgress(*i, &marker);
+    lookup->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
-      result.insert(*i);
+      result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api