[Sync] Replace all instances of ModelTypeSet with ModelEnumSet

chrome/browser/sync/profile_sync_service.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.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <map>
 #include <set>
@@ skipping 298 matching lines @@
       browser_sync::SyncServiceName());
   return credentials;
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_stale_data) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
 
-  syncable::ModelTypeSet initial_types;
+  syncable::ModelEnumSet initial_types;
   // If sync setup hasn't finished, we don't want to initialize routing info
   // for any data types so that we don't download updates for types that the
   // user chooses not to sync on the first DownloadUpdatesCommand.
   if (HasSyncSetupCompleted()) {
-    GetPreferredDataTypes(&initial_types);
+    initial_types = GetPreferredDataTypes();
   }
 
   SyncCredentials credentials = GetCredentials();
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter(
       profile_->GetRequestContext());
 
   if (delete_stale_data)
     ClearStaleErrors();
 
   backend_->Initialize(
       this,
       MakeWeakHandle(sync_js_controller_.AsWeakPtr()),
       sync_service_url_,
       initial_types,
       credentials,
       delete_stale_data);
 }
 
 void ProfileSyncService::CreateBackend() {
   backend_.reset(
       new SyncBackendHost(profile_->GetDebugName(),
                           profile_, sync_prefs_.AsWeakPtr()));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
-  syncable::ModelTypeSet preferred_types;
-  GetPreferredDataTypes(&preferred_types);
-  syncable::ModelTypeSet encrypted_types;
-  GetEncryptedDataTypes(&encrypted_types);
-  const syncable::ModelEnumSet preferred_types_enum_set =
-      syncable::ModelTypeSetToEnumSet(preferred_types);
-  const syncable::ModelEnumSet encrypted_types_enum_set =
-      syncable::ModelTypeSetToEnumSet(encrypted_types);
-  DCHECK(encrypted_types.count(syncable::PASSWORDS));
-  return
-      !Intersection(preferred_types_enum_set,
-                    encrypted_types_enum_set).Empty();
+  const syncable::ModelEnumSet preferred_types = GetPreferredDataTypes();
+  const syncable::ModelEnumSet encrypted_types = GetEncryptedDataTypes();
+  DCHECK(encrypted_types.Has(syncable::PASSWORDS));
+  return !Intersection(preferred_types, encrypted_types).Empty();
 }
 
 void ProfileSyncService::OnSyncConfigureDone(
     DataTypeManager::ConfigureResult result) {
   if (failed_datatypes_handler_.UpdateFailedDatatypes(result)) {
     ReconfigureDatatypeManager();
   }
 }
 
 void ProfileSyncService::StartUp() {
@@ skipping 265 matching lines @@
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&browser_sync::SessionModelAssociator::DeleteStaleSessions,
                    GetSessionModelAssociator()->AsWeakPtr()));
   }
   DVLOG(2) << "Notifying observers sync cycle completed";
   NotifyObservers();
 }
 
 // TODO(sync): eventually support removing datatypes too.
 void ProfileSyncService::OnDataTypesChanged(
-    const syncable::ModelTypeSet& to_add) {
+    syncable::ModelEnumSet to_add) {
   // If this is a first time sync for a client, this will be called before
   // OnBackendInitialized() to ensure the new datatypes are available at sync
   // setup. As a result, the migrator won't exist yet. This is fine because for
   // first time sync cases we're only concerned with making the datatype
   // available.
   if (migrator_.get() &&
       migrator_->state() != browser_sync::BackendMigrator::IDLE) {
     DVLOG(1) << "Dropping OnDataTypesChanged due to migrator busy.";
     return;
   }
 
   DVLOG(2) << "OnDataTypesChanged called with types: "
-           << syncable::ModelTypeSetToString(to_add);
+           << syncable::ModelEnumSetToString(to_add);
 
-  syncable::ModelTypeSet registered_types;
-  GetRegisteredDataTypes(&registered_types);
+  syncable::ModelEnumSet registered_types = GetRegisteredDataTypes();
 
-  syncable::ModelTypeSet to_register;
-  std::set_difference(to_add.begin(), to_add.end(),
-                      registered_types.begin(), registered_types.end(),
-                      std::inserter(to_register, to_register.end()));
+  syncable::ModelEnumSet to_register =
+      Difference(to_add, registered_types);
 
-  DVLOG(2) << "Enabling types: " << syncable::ModelTypeSetToString(to_register);
+  DVLOG(2) << "Enabling types: " << syncable::ModelEnumSetToString(to_register);
 
-  for (syncable::ModelTypeSet::const_iterator it = to_register.begin();
-       it != to_register.end(); ++it) {
+  for (syncable::ModelEnumSet::Iterator it = to_register.First();
+       it.Good(); it.Inc()) {
     // Received notice to enable experimental type. Check if the type is
     // registered, and if not register a new datatype controller.
-    RegisterNewDataType(*it);
+    RegisterNewDataType(it.Get());
     // Enable the about:flags switch for the experimental type so we don't have
     // to always perform this reconfiguration. Once we set this, the type will
     // remain registered on restart, so we will no longer go down this code
     // path.
-    std::string experiment_name = GetExperimentNameForDataType(*it);
+    std::string experiment_name = GetExperimentNameForDataType(it.Get());
     if (experiment_name.empty())
       continue;
     about_flags::SetExperimentEnabled(g_browser_process->local_state(),
                                       experiment_name,
                                       true);
   }
 
   // Check if the user has "Keep Everything Synced" enabled. If so, we want
   // to turn on all experimental types if they're not already on. Otherwise we
   // leave them off.
   // Note: if any types are already registered, we don't turn them on. This
   // covers the case where we're already in the process of reconfiguring
   // to turn an experimental type on.
   if (sync_prefs_.HasKeepEverythingSynced()) {
     // Mark all data types as preferred.
     sync_prefs_.SetPreferredDataTypes(registered_types, registered_types);
 
     // Only automatically turn on types if we have already finished set up.
     // Otherwise, just leave the experimental types on by default.
-    if (!to_register.empty() && HasSyncSetupCompleted() && migrator_.get()) {
+    if (!to_register.Empty() && HasSyncSetupCompleted() && migrator_.get()) {
       DVLOG(1) << "Dynamically enabling new datatypes: "
-               << syncable::ModelTypeSetToString(to_register);
+               << syncable::ModelEnumSetToString(to_register);
       OnMigrationNeededForTypes(to_register);
     }
   }
 }
 
 void ProfileSyncService::UpdateAuthErrorState(
     const GoogleServiceAuthError& error) {
   last_auth_error_ = error;
   // Protect against the in-your-face dialogs that pop out of nowhere.
   // Require the user to click somewhere to run the setup wizard in the case
@@ skipping 121 matching lines @@
 void ProfileSyncService::OnPassphraseAccepted() {
   DVLOG(1) << "Received OnPassphraseAccepted.";
   // Reset passphrase_required_reason_ since we know we no longer require the
   // passphrase. We do this here rather than down in ResolvePassphraseRequired()
   // because that can be called by OnPassphraseRequired() if no encrypted data
   // types are enabled, and we don't want to clobber the true passphrase error.
   passphrase_required_reason_ = sync_api::REASON_PASSPHRASE_NOT_REQUIRED;
 
   // Make sure the data types that depend on the passphrase are started at
   // this time.
-  syncable::ModelTypeSet types;
-  GetPreferredDataTypes(&types);
+  syncable::ModelEnumSet types = GetPreferredDataTypes();
 
   if (data_type_manager_.get()) {
     // Unblock the data type manager if necessary.
     data_type_manager_->Configure(types,
                                   sync_api::CONFIGURE_REASON_RECONFIGURATION);
   }
 
   ResolvePassphraseRequired();
 }
 
 void ProfileSyncService::ResolvePassphraseRequired() {
   DCHECK(!IsPassphraseRequiredForDecryption());
   // Don't hold on to a passphrase in raw form longer than needed.
   cached_passphrases_ = CachedPassphrases();
 
   // If No encryption is pending and our passphrase has been accepted, tell the
   // wizard we're done (no need to hang around waiting for the sync to
   // complete). If encryption is pending, its successful completion will trigger
   // the done step.
   if (WizardIsVisible() && !encryption_pending())
     wizard_.Step(SyncSetupWizard::DONE);
 
   NotifyObservers();
 }
 
 void ProfileSyncService::OnEncryptedTypesChanged(
-    const syncable::ModelTypeSet& encrypted_types,
+    syncable::ModelEnumSet encrypted_types,
     bool encrypt_everything) {
   encrypted_types_ = encrypted_types;
   encrypt_everything_ = encrypt_everything;
   DVLOG(1) << "Encrypted types changed to "
-           << syncable::ModelTypeSetToString(encrypted_types_)
+           << syncable::ModelEnumSetToString(encrypted_types_)
            << " (encrypt everything is set to "
            << (encrypt_everything_ ? "true" : "false") << ")";
-  DCHECK_GT(encrypted_types_.count(syncable::PASSWORDS), 0u);
+  DCHECK(encrypted_types_.Has(syncable::PASSWORDS));
 }
 
 void ProfileSyncService::OnEncryptionComplete() {
   DVLOG(1) << "Encryption complete";
   if (encryption_pending_ && encrypt_everything_) {
     encryption_pending_ = false;
     // The user had chosen to encrypt datatypes. This is the last thing to
     // complete, so now that we're done notify the UI.
     wizard_.Step(SyncSetupWizard::DONE);
     // This is to nudge the integration tests when encryption is
     // finished.
     NotifyObservers();
   }
 }
 
 void ProfileSyncService::OnMigrationNeededForTypes(
-    const syncable::ModelTypeSet& types) {
+    syncable::ModelEnumSet types) {
   DCHECK(backend_initialized_);
   DCHECK(data_type_manager_.get());
 
   // Migrator must be valid, because we don't sync until it is created and this
   // callback originates from a sync cycle.
   migrator_->MigrateTypes(types);
 }
 
 void ProfileSyncService::OnActionableError(const SyncProtocolError& error) {
   last_actionable_error_ = error;
@@ skipping 210 matching lines @@
   is_auth_in_progress_ = true;
 
   // The user has submitted credentials, which indicates they don't
   // want to suppress start up anymore.
   sync_prefs_.SetStartSuppressed(false);
 
   signin_->StartOAuthSignIn(oauth1_request_token);
 }
 
 void ProfileSyncService::OnUserChoseDatatypes(bool sync_everything,
-    const syncable::ModelTypeSet& chosen_types) {
+    syncable::ModelEnumSet chosen_types) {
   if (!backend_.get() &&
       unrecoverable_error_detected_ == false) {
     NOTREACHED();
     return;
   }
 
   sync_prefs_.SetKeepEverythingSynced(sync_everything);
 
   failed_datatypes_handler_.OnUserChoseDatatypes();
   ChangePreferredDataTypes(chosen_types);
@@ skipping 19 matching lines @@
   // succeeds, calling OnAuthError(NONE), or b) the user clicks the button,
   // and tries to re-authenticate. (b) is a little awkward as this second
   // request will get queued behind the first and could wind up "undoing" the
   // good if invalid creds were provided, but it's an edge case and the user
   // can of course get themselves out of it.
   is_auth_in_progress_ = false;
   NotifyObservers();
 }
 
 void ProfileSyncService::ChangePreferredDataTypes(
-    const syncable::ModelTypeSet& preferred_types) {
+    syncable::ModelEnumSet preferred_types) {
 
   DVLOG(1) << "ChangePreferredDataTypes invoked";
-  syncable::ModelTypeSet registered_types;
-  GetRegisteredDataTypes(&registered_types);
-  syncable::ModelTypeSet registered_preferred_types;
-  std::set_intersection(
-      registered_types.begin(), registered_types.end(),
-      preferred_types.begin(), preferred_types.end(),
-      std::inserter(registered_preferred_types,
-                    registered_preferred_types.end()));
+  syncable::ModelEnumSet registered_types = GetRegisteredDataTypes();
+  syncable::ModelEnumSet registered_preferred_types =
+      Intersection(registered_types, preferred_types);
   sync_prefs_.SetPreferredDataTypes(registered_types,
                                     registered_preferred_types);
 
   // Now reconfigure the DTM.
   ReconfigureDatatypeManager();
 }
 
-void ProfileSyncService::GetPreferredDataTypes(
-    syncable::ModelTypeSet* preferred_types) const {
-  syncable::ModelTypeSet registered_types;
-  GetRegisteredDataTypes(&registered_types);
-  *preferred_types = sync_prefs_.GetPreferredDataTypes(registered_types);
-
-  syncable::ModelTypeSet failed_types =
+syncable::ModelEnumSet ProfileSyncService::GetPreferredDataTypes() const {
+  syncable::ModelEnumSet registered_types = GetRegisteredDataTypes();
+  syncable::ModelEnumSet preferred_types =
+      sync_prefs_.GetPreferredDataTypes(registered_types);
+  syncable::ModelEnumSet failed_types =
       failed_datatypes_handler_.GetFailedTypes();
-  syncable::ModelTypeSet difference;
-  std::set_difference(preferred_types->begin(), preferred_types->end(),
-                      failed_types.begin(), failed_types.end(),
-                      std::inserter(difference, difference.end()));
-  std::swap(*preferred_types, difference);
+  return Difference(preferred_types, failed_types);
 }
 
-void ProfileSyncService::GetRegisteredDataTypes(
-    syncable::ModelTypeSet* registered_types) const {
-  registered_types->clear();
+syncable::ModelEnumSet ProfileSyncService::GetRegisteredDataTypes() const {
+  syncable::ModelEnumSet registered_types;
   // The data_type_controllers_ are determined by command-line flags; that's
   // effectively what controls the values returned here.
   for (DataTypeController::TypeMap::const_iterator it =
        data_type_controllers_.begin();
        it != data_type_controllers_.end(); ++it) {
-    registered_types->insert((*it).first);
+    registered_types.Put(it->first);
   }
+  return registered_types;
 }
 
 bool ProfileSyncService::IsUsingSecondaryPassphrase() const {
   // Should never be called when the backend is not initialized, since at that
   // time we have no idea whether we have an explicit passphrase or not because
   // the nigori node has not been downloaded yet.
   if (!sync_initialized()) {
     NOTREACHED() << "Cannot call IsUsingSecondaryPassphrase() before the sync "
                  << "backend has downloaded the nigori node";
     return false;
@@ skipping 26 matching lines @@
                    chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
                    content::Source<DataTypeManager>(data_type_manager_.get()));
 
     // We create the migrator at the same time.
     migrator_.reset(
         new browser_sync::BackendMigrator(
             profile_->GetDebugName(), GetUserShare(),
             this, data_type_manager_.get()));
   }
 
-  syncable::ModelTypeSet types;
-  GetPreferredDataTypes(&types);
+  syncable::ModelEnumSet types = GetPreferredDataTypes();
   if (IsPassphraseRequiredForDecryption()) {
     // We need a passphrase still. We don't bother to attempt to configure
     // until we receive an OnPassphraseAccepted (which triggers a configure).
     DVLOG(1) << "ProfileSyncService::ConfigureDataTypeManager bailing out "
              << "because a passphrase required";
     return;
   }
   sync_api::ConfigureReason reason = sync_api::CONFIGURE_REASON_UNKNOWN;
   if (!HasSyncSetupCompleted()) {
     reason = sync_api::CONFIGURE_REASON_NEW_CLIENT;
@@ skipping 93 matching lines @@
   // initialized (via IsEncryptedDatatypeEnabled and
   // IsPassphraseRequiredForDecryption).
   return encryption_pending_;
 }
 
 bool ProfileSyncService::EncryptEverythingEnabled() const {
   DCHECK(backend_initialized_);
   return encrypt_everything_;
 }
 
-void ProfileSyncService::GetEncryptedDataTypes(
-    syncable::ModelTypeSet* encrypted_types) const {
-  CHECK(encrypted_types);
+syncable::ModelEnumSet ProfileSyncService::GetEncryptedDataTypes() const {
+  DCHECK(encrypted_types_.Has(syncable::PASSWORDS));
   // We may be called during the setup process before we're
   // initialized.  In this case, we default to the sensitive types.
-  *encrypted_types = encrypted_types_;
-  DCHECK_GT(encrypted_types->count(syncable::PASSWORDS), 0u);
+  return encrypted_types_;
 }
 
 void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) {
   NotifyObservers();
   if (is_sync_managed) {
     DisableForUser();
   } else if (HasSyncSetupCompleted() && AreCredentialsAvailable()) {
     StartUp();
   }
 }
@@ skipping 186 matching lines @@
   sync_prefs_.SetStartSuppressed(false);
   // Set username in SigninManager, as SigninManager::OnGetUserInfoSuccess
   // is never called for some clients.
   if (signin_->GetUsername().empty()) {
     signin_->SetUsername(sync_prefs_.GetGoogleServicesUsername());
   }
   TryStart();
 }
 
 void ProfileSyncService::AcknowledgeSyncedTypes() {
-  syncable::ModelTypeSet registered_types;
-  GetRegisteredDataTypes(&registered_types);
+  syncable::ModelEnumSet registered_types = GetRegisteredDataTypes();
   sync_prefs_.AcknowledgeSyncedTypes(registered_types);
 }
 
 void ProfileSyncService::ReconfigureDatatypeManager() {
   // If we haven't initialized yet, don't configure the DTM as it could cause
   // association to start before a Directory has even been created.
   if (backend_initialized_) {
     DCHECK(backend_.get());
     ConfigureDataTypeManager();
   } else if (unrecoverable_error_detected()) {
     // Close the wizard.
     if (WizardIsVisible()) {
        wizard_.Step(SyncSetupWizard::DONE);
     }
     // There is nothing more to configure. So inform the listeners,
     NotifyObservers();
 
     DVLOG(1) << "ConfigureDataTypeManager not invoked because of an "
              << "Unrecoverable error.";
   } else {
     DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
              << "initialized";
   }
 }
 
 const FailedDatatypesHandler& ProfileSyncService::failed_datatypes_handler() {
   return failed_datatypes_handler_;
 }