[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

chrome/browser/sync/engine/nigori_util.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/nigori_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/internal_api/write_node.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/util/cryptographer.h"
 
 namespace syncable {
 
 bool ProcessUnsyncedChangesForEncryption(
     WriteTransaction* const trans,
     browser_sync::Cryptographer* cryptographer) {
   DCHECK(cryptographer->is_ready());
-  syncable::ModelTypeSet encrypted_types = cryptographer->GetEncryptedTypes();
-
   // Get list of all datatypes with unsynced changes. It's possible that our
   // local changes need to be encrypted if encryption for that datatype was
   // just turned on (and vice versa). This should never affect passwords.
   std::vector<int64> handles;
   browser_sync::SyncerUtil::GetUnsyncedEntries(trans, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     MutableEntry entry(trans, GET_BY_HANDLE, handles[i]);
     if (!sync_api::WriteNode::UpdateEntryWithEncryption(cryptographer,
                                                         entry.Get(SPECIFICS),
                                                         &entry)) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool VerifyUnsyncedChangesAreEncrypted(
     BaseTransaction* const trans,
-    const ModelTypeSet& encrypted_types) {
+    ModelEnumSet encrypted_types) {
   std::vector<int64> handles;
   browser_sync::SyncerUtil::GetUnsyncedEntries(trans, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     Entry entry(trans, GET_BY_HANDLE, handles[i]);
     if (!entry.good()) {
       NOTREACHED();
       return false;
     }
     if (EntryNeedsEncryption(encrypted_types, entry))
       return false;
   }
   return true;
 }
 
-bool EntryNeedsEncryption(const ModelTypeSet& encrypted_types,
+bool EntryNeedsEncryption(ModelEnumSet encrypted_types,
                           const Entry& entry) {
   if (!entry.Get(UNIQUE_SERVER_TAG).empty())
     return false;  // We don't encrypt unique server nodes.
   syncable::ModelType type = entry.GetModelType();
   if (type == PASSWORDS || type == NIGORI)
     return false;
   // Checking NON_UNIQUE_NAME is not necessary for the correctness of encrypting
   // the data, nor for determining if data is encrypted. We simply ensure it has
   // been overwritten to avoid any possible leaks of sensitive data.
   return SpecificsNeedsEncryption(encrypted_types, entry.Get(SPECIFICS)) ||
-         (encrypted_types.count(type) > 0 &&
+         (encrypted_types.Has(type) &&
           entry.Get(NON_UNIQUE_NAME) != kEncryptedString);
 }
 
-bool SpecificsNeedsEncryption(const ModelTypeSet& encrypted_types,
+bool SpecificsNeedsEncryption(ModelEnumSet encrypted_types,
                               const sync_pb::EntitySpecifics& specifics) {
-  ModelType type = GetModelTypeFromSpecifics(specifics);
+  const ModelType type = GetModelTypeFromSpecifics(specifics);
+  if (!syncable::IsRealDataType(type))
+    return false;
   if (type == PASSWORDS || type == NIGORI)
     return false;  // These types have their own encryption schemes.
-  if (encrypted_types.count(type) == 0)
+  if (!encrypted_types.Has(type))
     return false;  // This type does not require encryption
   return !specifics.has_encrypted();
 }
 
 // Mainly for testing.
 bool VerifyDataTypeEncryptionForTest(
     BaseTransaction* const trans,
     browser_sync::Cryptographer* cryptographer,
     ModelType type,
     bool is_encrypted) {
@@ skipping 51 matching lines @@
           return false;
       }
     }
     // Push the successor.
     to_visit.push(child.Get(NEXT_ID));
   }
   return true;
 }
 
 }  // namespace syncable