[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

chrome/browser/sync/profile_sync_service_harness.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/profile_sync_service_harness.h"
 
-#include <stddef.h>
-#include <algorithm>
+#include <cstddef>
 #include <iterator>
 #include <ostream>
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
@@ skipping 112 matching lines @@
                                                const std::string& password) {
   username_ = username;
   password_ = password;
 }
 
 bool ProfileSyncServiceHarness::IsSyncAlreadySetup() {
   return profile_->HasProfileSyncService();
 }
 
 bool ProfileSyncServiceHarness::SetupSync() {
-  syncable::ModelTypeSet synced_datatypes;
-  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
-      i < syncable::MODEL_TYPE_COUNT; ++i) {
-    synced_datatypes.insert(syncable::ModelTypeFromInt(i));
-  }
-  bool result = SetupSync(synced_datatypes);
+  bool result = SetupSync(syncable::ModelEnumSet::All());
   if (result == false) {
     std::string status = GetServiceStatus();
     LOG(ERROR) << profile_debug_name_
                << ": SetupSync failed. Syncer status:\n" << status;
   } else {
     DVLOG(1) << profile_debug_name_ << ": SetupSync successful.";
   }
   return result;
 }
 
 bool ProfileSyncServiceHarness::SetupSync(
-    const syncable::ModelTypeSet& synced_datatypes) {
+    syncable::ModelEnumSet synced_datatypes) {
   // Initialize the sync client's profile sync service object.
   service_ = profile_->GetProfileSyncService("");
   if (service_ == NULL) {
     LOG(ERROR) << "SetupSync(): service_ is null.";
     return false;
   }
 
   // Subscribe sync client to notifications from the profile sync service.
   if (!service_->HasObserver(this))
     service_->AddObserver(this);
 
   // Authenticate sync client using GAIA credentials.
   service_->signin()->StartSignIn(username_, password_, "", "");
 
   // Wait for the OnBackendInitialized() callback.
   if (!AwaitBackendInitialized()) {
     LOG(ERROR) << "OnBackendInitialized() not seen after "
                << kLiveSyncOperationTimeoutMs / 1000
                << " seconds.";
     return false;
   }
 
   // Choose the datatypes to be synced. If all datatypes are to be synced,
   // set sync_everything to true; otherwise, set it to false.
-  bool sync_everything = (synced_datatypes.size() ==
-      (syncable::MODEL_TYPE_COUNT - syncable::FIRST_REAL_MODEL_TYPE));
+  bool sync_everything =
+      synced_datatypes.Equals(syncable::ModelEnumSet::All());
   service()->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Subscribe sync client to notifications from the backend migrator
   // (possible only after choosing data types).
   if (!TryListeningToMigrationEvents()) {
     NOTREACHED();
     return false;
   }
 
   // Make sure that a partner client hasn't already set an explicit passphrase.
@@ skipping 252 matching lines @@
 
 void ProfileSyncServiceHarness::OnStateChanged() {
   RunStateChangeMachine();
 }
 
 void ProfileSyncServiceHarness::OnMigrationStateChange() {
   // Update migration state.
   if (HasPendingBackendMigration()) {
     // Merge current pending migration types into
     // |pending_migration_types_|.
-    syncable::ModelTypeSet new_pending_migration_types =
+    pending_migration_types_.PutAll(
         service()->GetBackendMigratorForTest()->
-        GetPendingMigrationTypesForTest();
-    syncable::ModelTypeSet temp;
-    std::set_union(pending_migration_types_.begin(),
-                   pending_migration_types_.end(),
-                   new_pending_migration_types.begin(),
-                   new_pending_migration_types.end(),
-                   std::inserter(temp, temp.end()));
-    std::swap(pending_migration_types_, temp);
+            GetPendingMigrationTypesForTest());
     DVLOG(1) << profile_debug_name_ << ": new pending migration types "
-             << syncable::ModelTypeSetToString(pending_migration_types_);
+             << syncable::ModelEnumSetToString(pending_migration_types_);
   } else {
     // Merge just-finished pending migration types into
     // |migration_types_|.
-    syncable::ModelTypeSet temp;
-    std::set_union(pending_migration_types_.begin(),
-                   pending_migration_types_.end(),
-                   migrated_types_.begin(),
-                   migrated_types_.end(),
-                   std::inserter(temp, temp.end()));
-    std::swap(migrated_types_, temp);
-    pending_migration_types_.clear();
+    migrated_types_.PutAll(pending_migration_types_);
+    pending_migration_types_.Clear();
     DVLOG(1) << profile_debug_name_ << ": new migrated types "
-             << syncable::ModelTypeSetToString(migrated_types_);
+             << syncable::ModelEnumSetToString(migrated_types_);
   }
   RunStateChangeMachine();
 }
 
 bool ProfileSyncServiceHarness::AwaitPassphraseRequired() {
   DVLOG(1) << GetClientInfoString("AwaitPassphraseRequired");
   if (wait_state_ == SYNC_DISABLED) {
     LOG(ERROR) << "Sync disabled for " << profile_debug_name_ << ".";
     return false;
   }
@@ skipping 144 matching lines @@
   CHECK(status.sync_protocol_error.action == browser_sync::UNKNOWN_ACTION);
   wait_state_ = WAITING_FOR_ACTIONABLE_ERROR;
   AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
       "Waiting for actionable error");
   status = GetStatus();
   return (status.sync_protocol_error.action != browser_sync::UNKNOWN_ACTION &&
           service_->unrecoverable_error_detected());
 }
 
 bool ProfileSyncServiceHarness::AwaitMigration(
-    const syncable::ModelTypeSet& expected_migrated_types) {
+    syncable::ModelEnumSet expected_migrated_types) {
   DVLOG(1) << GetClientInfoString("AwaitMigration");
   DVLOG(1) << profile_debug_name_ << ": waiting until migration is done for "
-           << syncable::ModelTypeSetToString(expected_migrated_types);
+          << syncable::ModelEnumSetToString(expected_migrated_types);
   while (true) {
-    bool migration_finished =
-        std::includes(migrated_types_.begin(), migrated_types_.end(),
-                      expected_migrated_types.begin(),
-                      expected_migrated_types.end());
+    bool migration_finished = migrated_types_.HasAll(expected_migrated_types);
     DVLOG(1) << "Migrated types "
-             << syncable::ModelTypeSetToString(migrated_types_)
+             << syncable::ModelEnumSetToString(migrated_types_)
              << (migration_finished ? " contains " : " does not contain ")
-             << syncable::ModelTypeSetToString(expected_migrated_types);
+             << syncable::ModelEnumSetToString(expected_migrated_types);
     if (migration_finished) {
       return true;
     }
 
     if (HasPendingBackendMigration()) {
       wait_state_ = WAITING_FOR_MIGRATION_TO_FINISH;
     } else {
       wait_state_ = WAITING_FOR_MIGRATION_TO_START;
       AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
                                    "Wait for migration to start");
@@ skipping 169 matching lines @@
     ProfileSyncServiceHarness* partner) {
   // TODO(akalin): Shouldn't this belong with the intersection check?
   // Otherwise, this function isn't symmetric.
   if (!IsFullySynced()) {
     DVLOG(2) << profile_debug_name_ << ": not synced, assuming doesn't match";
     return false;
   }
 
   // Only look for a match if we have at least one enabled datatype in
   // common with the partner client.
-  syncable::ModelTypeSet types, other_types, intersection_types;
-  service()->GetPreferredDataTypes(&types);
-  partner->service()->GetPreferredDataTypes(&other_types);
-  std::set_intersection(types.begin(), types.end(), other_types.begin(),
-                        other_types.end(),
-                        inserter(intersection_types,
-                                 intersection_types.begin()));
+  const syncable::ModelEnumSet common_types =
+      Intersection(service()->GetPreferredDataTypes(),
+                   partner->service()->GetPreferredDataTypes());
 
   DVLOG(2) << profile_debug_name_ << ", " << partner->profile_debug_name_
            << ": common types are "
-           << syncable::ModelTypeSetToString(intersection_types);
+           << syncable::ModelEnumSetToString(common_types);
 
-  if (!intersection_types.empty() && !partner->IsFullySynced()) {
+  if (!common_types.Empty() && !partner->IsFullySynced()) {
     DVLOG(2) << "non-empty common types and "
              << partner->profile_debug_name_ << " isn't synced";
     return false;
   }
 
-  for (syncable::ModelTypeSet::iterator i = intersection_types.begin();
-       i != intersection_types.end(); ++i) {
-    const std::string timestamp = GetUpdatedTimestamp(*i);
-    const std::string partner_timestamp = partner->GetUpdatedTimestamp(*i);
+  for (syncable::ModelEnumSet::Iterator i = common_types.First();
+       i.Good(); i.Inc()) {
+    const std::string timestamp = GetUpdatedTimestamp(i.Get());
+    const std::string partner_timestamp = partner->GetUpdatedTimestamp(i.Get());
     if (timestamp != partner_timestamp) {
       if (VLOG_IS_ON(2)) {
         std::string timestamp_base64, partner_timestamp_base64;
         if (!base::Base64Encode(timestamp, &timestamp_base64)) {
           NOTREACHED();
         }
         if (!base::Base64Encode(
                 partner_timestamp, &partner_timestamp_base64)) {
           NOTREACHED();
         }
-        DVLOG(2) << syncable::ModelTypeToString(*i) << ": "
+        DVLOG(2) << syncable::ModelTypeToString(i.Get()) << ": "
                  << profile_debug_name_ << " timestamp = "
                  << timestamp_base64 << ", "
                  << partner->profile_debug_name_
                  << " partner timestamp = "
                  << partner_timestamp_base64;
       }
       return false;
     }
   }
   return true;
 }
 
 const SyncSessionSnapshot*
     ProfileSyncServiceHarness::GetLastSessionSnapshot() const {
   DCHECK(service_ != NULL) << "Sync service has not yet been set up.";
   if (service_->sync_initialized()) {
     return service_->GetLastSessionSnapshot();
   }
   return NULL;
 }
 
 bool ProfileSyncServiceHarness::EnableSyncForDatatype(
     syncable::ModelType datatype) {
   DVLOG(1) << GetClientInfoString(
       "EnableSyncForDatatype("
       + std::string(syncable::ModelTypeToString(datatype)) + ")");
 
-  syncable::ModelTypeSet synced_datatypes;
   if (wait_state_ == SYNC_DISABLED) {
-    synced_datatypes.insert(datatype);
-    return SetupSync(synced_datatypes);
+    return SetupSync(syncable::ModelEnumSet(datatype));
   }
 
   if (service() == NULL) {
     LOG(ERROR) << "EnableSyncForDatatype(): service() is null.";
     return false;
   }
 
-  service()->GetPreferredDataTypes(&synced_datatypes);
-  syncable::ModelTypeSet::iterator it = synced_datatypes.find(datatype);
-  if (it != synced_datatypes.end()) {
+  syncable::ModelEnumSet synced_datatypes =
+      service()->GetPreferredDataTypes();
+  if (synced_datatypes.Has(datatype)) {
     DVLOG(1) << "EnableSyncForDatatype(): Sync already enabled for datatype "
              << syncable::ModelTypeToString(datatype)
              << " on " << profile_debug_name_ << ".";
     return true;
   }
 
-  synced_datatypes.insert(syncable::ModelTypeFromInt(datatype));
+  synced_datatypes.Put(syncable::ModelTypeFromInt(datatype));
   service()->OnUserChoseDatatypes(false, synced_datatypes);
   if (AwaitFullSyncCompletion("Datatype configuration.")) {
     DVLOG(1) << "EnableSyncForDatatype(): Enabled sync for datatype "
              << syncable::ModelTypeToString(datatype)
              << " on " << profile_debug_name_ << ".";
     return true;
   }
 
   DVLOG(0) << GetClientInfoString("EnableSyncForDatatype failed");
   return false;
 }
 
 bool ProfileSyncServiceHarness::DisableSyncForDatatype(
     syncable::ModelType datatype) {
   DVLOG(1) << GetClientInfoString(
       "DisableSyncForDatatype("
       + std::string(syncable::ModelTypeToString(datatype)) + ")");
 
-  syncable::ModelTypeSet synced_datatypes;
   if (service() == NULL) {
     LOG(ERROR) << "DisableSyncForDatatype(): service() is null.";
     return false;
   }
 
-  service()->GetPreferredDataTypes(&synced_datatypes);
-  syncable::ModelTypeSet::iterator it = synced_datatypes.find(datatype);
-  if (it == synced_datatypes.end()) {
+  syncable::ModelEnumSet synced_datatypes =
+      service()->GetPreferredDataTypes();
+  if (!synced_datatypes.Has(datatype)) {
     DVLOG(1) << "DisableSyncForDatatype(): Sync already disabled for datatype "
              << syncable::ModelTypeToString(datatype)
              << " on " << profile_debug_name_ << ".";
     return true;
   }
 
-  synced_datatypes.erase(it);
+  synced_datatypes.Remove(datatype);
   service()->OnUserChoseDatatypes(false, synced_datatypes);
   if (AwaitFullSyncCompletion("Datatype reconfiguration.")) {
     DVLOG(1) << "DisableSyncForDatatype(): Disabled sync for datatype "
              << syncable::ModelTypeToString(datatype)
              << " on " << profile_debug_name_ << ".";
     return true;
   }
 
   DVLOG(0) << GetClientInfoString("DisableSyncForDatatype failed");
   return false;
 }
 
 bool ProfileSyncServiceHarness::EnableSyncForAllDatatypes() {
   DVLOG(1) << GetClientInfoString("EnableSyncForAllDatatypes");
 
   if (wait_state_ == SYNC_DISABLED) {
     return SetupSync();
   }
 
   if (service() == NULL) {
     LOG(ERROR) << "EnableSyncForAllDatatypes(): service() is null.";
     return false;
   }
 
-  syncable::ModelTypeSet synced_datatypes;
-  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
-       i < syncable::MODEL_TYPE_COUNT;
-       ++i) {
-    synced_datatypes.insert(syncable::ModelTypeFromInt(i));
-  }
-  service()->OnUserChoseDatatypes(true, synced_datatypes);
+  service()->OnUserChoseDatatypes(true, syncable::ModelEnumSet::All());
   if (AwaitFullSyncCompletion("Datatype reconfiguration.")) {
     DVLOG(1) << "EnableSyncForAllDatatypes(): Enabled sync for all datatypes "
              << "on " << profile_debug_name_ << ".";
     return true;
   }
 
   DVLOG(0) << GetClientInfoString("EnableSyncForAllDatatypes failed");
   return false;
 }
 
@@ skipping 55 matching lines @@
   } else {
     os << "Sync service not available";
   }
   return os.str();
 }
 
 // TODO(zea): Rename this EnableEncryption, since we no longer turn on
 // encryption for individual types but for all.
 bool ProfileSyncServiceHarness::EnableEncryptionForType(
     syncable::ModelType type) {
-  syncable::ModelTypeSet encrypted_types;
-  service_->GetEncryptedDataTypes(&encrypted_types);
-  if (encrypted_types.count(type) > 0)
+  const syncable::ModelEnumSet encrypted_types =
+      service_->GetEncryptedDataTypes();
+  if (encrypted_types.Has(type))
     return true;
   service_->EnableEncryptEverything();
 
   // In order to kick off the encryption we have to reconfigure. Just grab the
   // currently synced types and use them.
-  syncable::ModelTypeSet synced_datatypes;
-  service_->GetPreferredDataTypes(&synced_datatypes);
-  bool sync_everything = (synced_datatypes.size() ==
-      (syncable::MODEL_TYPE_COUNT - syncable::FIRST_REAL_MODEL_TYPE));
-  service_->OnUserChoseDatatypes(sync_everything,
-                                 synced_datatypes);
+  const syncable::ModelEnumSet synced_datatypes =
+      service_->GetPreferredDataTypes();
+  bool sync_everything =
+      synced_datatypes.Equals(syncable::ModelEnumSet::All());
+  service_->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Wait some time to let the enryption finish.
   return WaitForTypeEncryption(type);
 }
 
 bool ProfileSyncServiceHarness::WaitForTypeEncryption(
     syncable::ModelType type) {
   // The correctness of this if condition depends on the ordering of its
   // sub-expressions.  See crbug.com/95619.
   // TODO(rlarocque): Figure out a less brittle way of detecting this.
@@ skipping 10 matching lines @@
   if (!AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason)) {
     LOG(ERROR) << "Did not receive EncryptionComplete notification after"
                << kLiveSyncOperationTimeoutMs / 1000
                << " seconds.";
     return false;
   }
   return IsTypeEncrypted(type);
 }
 
 bool ProfileSyncServiceHarness::IsTypeEncrypted(syncable::ModelType type) {
-  syncable::ModelTypeSet encrypted_types;
-  service_->GetEncryptedDataTypes(&encrypted_types);
-  bool is_type_encrypted = (encrypted_types.count(type) != 0);
+  const syncable::ModelEnumSet encrypted_types =
+      service_->GetEncryptedDataTypes();
+  bool is_type_encrypted = service_->GetEncryptedDataTypes().Has(type);
   DVLOG(2) << syncable::ModelTypeToString(type) << " is "
            << (is_type_encrypted ? "" : "not ") << "encrypted; "
            << "encrypted types = "
-           << syncable::ModelTypeSetToString(encrypted_types);
+           << syncable::ModelEnumSetToString(encrypted_types);
   return is_type_encrypted;
 }
 
 bool ProfileSyncServiceHarness::IsTypeRunning(syncable::ModelType type) {
   browser_sync::DataTypeController::StateMap state_map;
   service_->GetDataTypeControllerStates(&state_map);
   return (state_map.count(type) != 0 &&
           state_map[type] == browser_sync::DataTypeController::RUNNING);
 }
 
 bool ProfileSyncServiceHarness::IsTypePreferred(syncable::ModelType type) {
-  syncable::ModelTypeSet synced_types;
-  service_->GetPreferredDataTypes(&synced_types);
-  return (synced_types.count(type) != 0);
+  return service_->GetPreferredDataTypes().Has(type);
 }
 
 std::string ProfileSyncServiceHarness::GetServiceStatus() {
   DictionaryValue value;
   sync_ui_util::ConstructAboutInformation(service_, &value);
   std::string service_status;
   base::JSONWriter::Write(&value, true, &service_status);
   return service_status;
 }