[Sync] Rename ModelEnumSet to ModelTypeSet

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 <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 288 matching lines @@
       browser_sync::SyncServiceName());
   return credentials;
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_stale_data) {
   if (!backend_.get()) {
     NOTREACHED();
     return;
   }
 
-  syncable::ModelEnumSet initial_types;
+  syncable::ModelTypeSet 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()) {
     initial_types = GetPreferredDataTypes();
   }
 
   SyncCredentials credentials = GetCredentials();
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter(
@@ skipping 13 matching lines @@
 
 void ProfileSyncService::CreateBackend() {
   backend_.reset(
       new SyncBackendHost(profile_->GetDebugName(),
                           profile_, sync_prefs_.AsWeakPtr()));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
-  const syncable::ModelEnumSet preferred_types = GetPreferredDataTypes();
-  const syncable::ModelEnumSet encrypted_types = GetEncryptedDataTypes();
+  const syncable::ModelTypeSet preferred_types = GetPreferredDataTypes();
+  const syncable::ModelTypeSet 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();
   }
 }
@@ skipping 268 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(
-    syncable::ModelEnumSet to_add) {
+    syncable::ModelTypeSet 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::ModelEnumSetToString(to_add);
+           << syncable::ModelTypeSetToString(to_add);
 
-  const syncable::ModelEnumSet registered_types = GetRegisteredDataTypes();
+  const syncable::ModelTypeSet registered_types = GetRegisteredDataTypes();
 
-  const syncable::ModelEnumSet to_register =
+  const syncable::ModelTypeSet to_register =
       Difference(to_add, registered_types);
 
-  DVLOG(2) << "Enabling types: " << syncable::ModelEnumSetToString(to_register);
+  DVLOG(2) << "Enabling types: " << syncable::ModelTypeSetToString(to_register);
 
-  for (syncable::ModelEnumSet::Iterator it = to_register.First();
+  for (syncable::ModelTypeSet::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.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.Get());
     if (experiment_name.empty())
@@ skipping 10 matching lines @@
   // 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()) {
       DVLOG(1) << "Dynamically enabling new datatypes: "
-               << syncable::ModelEnumSetToString(to_register);
+               << syncable::ModelTypeSetToString(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.
-  const syncable::ModelEnumSet types = GetPreferredDataTypes();
+  const syncable::ModelTypeSet 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(
-    syncable::ModelEnumSet encrypted_types,
+    syncable::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   encrypted_types_ = encrypted_types;
   encrypt_everything_ = encrypt_everything;
   DVLOG(1) << "Encrypted types changed to "
-           << syncable::ModelEnumSetToString(encrypted_types_)
+           << syncable::ModelTypeSetToString(encrypted_types_)
            << " (encrypt everything is set to "
            << (encrypt_everything_ ? "true" : "false") << ")";
   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(
-    syncable::ModelEnumSet types) {
+    syncable::ModelTypeSet 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 199 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,
-    syncable::ModelEnumSet chosen_types) {
+    syncable::ModelTypeSet 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(
-    syncable::ModelEnumSet preferred_types) {
+    syncable::ModelTypeSet preferred_types) {
 
   DVLOG(1) << "ChangePreferredDataTypes invoked";
-  const syncable::ModelEnumSet registered_types = GetRegisteredDataTypes();
-  const syncable::ModelEnumSet registered_preferred_types =
+  const syncable::ModelTypeSet registered_types = GetRegisteredDataTypes();
+  const syncable::ModelTypeSet registered_preferred_types =
       Intersection(registered_types, preferred_types);
   sync_prefs_.SetPreferredDataTypes(registered_types,
                                     registered_preferred_types);
 
   // Now reconfigure the DTM.
   ReconfigureDatatypeManager();
 }
 
-syncable::ModelEnumSet ProfileSyncService::GetPreferredDataTypes() const {
-  const syncable::ModelEnumSet registered_types = GetRegisteredDataTypes();
-  const syncable::ModelEnumSet preferred_types =
+syncable::ModelTypeSet ProfileSyncService::GetPreferredDataTypes() const {
+  const syncable::ModelTypeSet registered_types = GetRegisteredDataTypes();
+  const syncable::ModelTypeSet preferred_types =
       sync_prefs_.GetPreferredDataTypes(registered_types);
-  const syncable::ModelEnumSet failed_types =
+  const syncable::ModelTypeSet failed_types =
       failed_datatypes_handler_.GetFailedTypes();
   return Difference(preferred_types, failed_types);
 }
 
-syncable::ModelEnumSet ProfileSyncService::GetRegisteredDataTypes() const {
-  syncable::ModelEnumSet registered_types;
+syncable::ModelTypeSet ProfileSyncService::GetRegisteredDataTypes() const {
+  syncable::ModelTypeSet 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.Put(it->first);
   }
   return registered_types;
 }
 
@@ skipping 34 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()));
   }
 
-  const syncable::ModelEnumSet types = GetPreferredDataTypes();
+  const syncable::ModelTypeSet 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_;
 }
 
-syncable::ModelEnumSet ProfileSyncService::GetEncryptedDataTypes() const {
+syncable::ModelTypeSet 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.
   return encrypted_types_;
 }
 
 void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) {
   NotifyObservers();
   if (is_sync_managed) {
     DisableForUser();
@@ skipping 222 matching lines @@
              << "Unrecoverable error.";
   } else {
     DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
              << "initialized";
   }
 }
 
 const FailedDatatypesHandler& ProfileSyncService::failed_datatypes_handler() {
   return failed_datatypes_handler_;
 }