[Sync] Rename ModelEnumSet to ModelTypeSet

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 <cstddef>
 #include <iterator>
 #include <ostream>
 #include <set>
@@ skipping 119 matching lines @@
                                                const std::string& password) {
   username_ = username;
   password_ = password;
 }
 
 bool ProfileSyncServiceHarness::IsSyncAlreadySetup() {
   return profile_->HasProfileSyncService();
 }
 
 bool ProfileSyncServiceHarness::SetupSync() {
-  bool result = SetupSync(syncable::ModelEnumSet::All());
+  bool result = SetupSync(syncable::ModelTypeSet::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(
-    syncable::ModelEnumSet synced_datatypes) {
+    syncable::ModelTypeSet 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.Equals(syncable::ModelEnumSet::All());
+      synced_datatypes.Equals(syncable::ModelTypeSet::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 256 matching lines @@
 
 void ProfileSyncServiceHarness::OnMigrationStateChange() {
   // Update migration state.
   if (HasPendingBackendMigration()) {
     // Merge current pending migration types into
     // |pending_migration_types_|.
     pending_migration_types_.PutAll(
         service()->GetBackendMigratorForTest()->
             GetPendingMigrationTypesForTest());
     DVLOG(1) << profile_debug_name_ << ": new pending migration types "
-             << syncable::ModelEnumSetToString(pending_migration_types_);
+             << syncable::ModelTypeSetToString(pending_migration_types_);
   } else {
     // Merge just-finished pending migration types into
     // |migration_types_|.
     migrated_types_.PutAll(pending_migration_types_);
     pending_migration_types_.Clear();
     DVLOG(1) << profile_debug_name_ << ": new migrated types "
-             << syncable::ModelEnumSetToString(migrated_types_);
+             << syncable::ModelTypeSetToString(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(
-    syncable::ModelEnumSet expected_migrated_types) {
+    syncable::ModelTypeSet expected_migrated_types) {
   DVLOG(1) << GetClientInfoString("AwaitMigration");
   DVLOG(1) << profile_debug_name_ << ": waiting until migration is done for "
-          << syncable::ModelEnumSetToString(expected_migrated_types);
+          << syncable::ModelTypeSetToString(expected_migrated_types);
   while (true) {
     bool migration_finished = migrated_types_.HasAll(expected_migrated_types);
     DVLOG(1) << "Migrated types "
-             << syncable::ModelEnumSetToString(migrated_types_)
+             << syncable::ModelTypeSetToString(migrated_types_)
              << (migration_finished ? " contains " : " does not contain ")
-             << syncable::ModelEnumSetToString(expected_migrated_types);
+             << syncable::ModelTypeSetToString(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.
-  const syncable::ModelEnumSet common_types =
+  const syncable::ModelTypeSet common_types =
       Intersection(service()->GetPreferredDataTypes(),
                    partner->service()->GetPreferredDataTypes());
 
   DVLOG(2) << profile_debug_name_ << ", " << partner->profile_debug_name_
            << ": common types are "
-           << syncable::ModelEnumSetToString(common_types);
+           << syncable::ModelTypeSetToString(common_types);
 
   if (!common_types.Empty() && !partner->IsFullySynced()) {
     DVLOG(2) << "non-empty common types and "
              << partner->profile_debug_name_ << " isn't synced";
     return false;
   }
 
-  for (syncable::ModelEnumSet::Iterator i = common_types.First();
+  for (syncable::ModelTypeSet::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(
@@ skipping 22 matching lines @@
   return NULL;
 }
 
 bool ProfileSyncServiceHarness::EnableSyncForDatatype(
     syncable::ModelType datatype) {
   DVLOG(1) << GetClientInfoString(
       "EnableSyncForDatatype("
       + std::string(syncable::ModelTypeToString(datatype)) + ")");
 
   if (wait_state_ == SYNC_DISABLED) {
-    return SetupSync(syncable::ModelEnumSet(datatype));
+    return SetupSync(syncable::ModelTypeSet(datatype));
   }
 
   if (service() == NULL) {
     LOG(ERROR) << "EnableSyncForDatatype(): service() is null.";
     return false;
   }
 
-  syncable::ModelEnumSet synced_datatypes =
+  syncable::ModelTypeSet 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.Put(syncable::ModelTypeFromInt(datatype));
   service()->OnUserChoseDatatypes(false, synced_datatypes);
@@ skipping 12 matching lines @@
     syncable::ModelType datatype) {
   DVLOG(1) << GetClientInfoString(
       "DisableSyncForDatatype("
       + std::string(syncable::ModelTypeToString(datatype)) + ")");
 
   if (service() == NULL) {
     LOG(ERROR) << "DisableSyncForDatatype(): service() is null.";
     return false;
   }
 
-  syncable::ModelEnumSet synced_datatypes =
+  syncable::ModelTypeSet 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.Remove(datatype);
   service()->OnUserChoseDatatypes(false, synced_datatypes);
@@ skipping 13 matching lines @@
 
   if (wait_state_ == SYNC_DISABLED) {
     return SetupSync();
   }
 
   if (service() == NULL) {
     LOG(ERROR) << "EnableSyncForAllDatatypes(): service() is null.";
     return false;
   }
 
-  service()->OnUserChoseDatatypes(true, syncable::ModelEnumSet::All());
+  service()->OnUserChoseDatatypes(true, syncable::ModelTypeSet::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) {
-  const syncable::ModelEnumSet encrypted_types =
+  const syncable::ModelTypeSet 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.
-  const syncable::ModelEnumSet synced_datatypes =
+  const syncable::ModelTypeSet synced_datatypes =
       service_->GetPreferredDataTypes();
   bool sync_everything =
-      synced_datatypes.Equals(syncable::ModelEnumSet::All());
+      synced_datatypes.Equals(syncable::ModelTypeSet::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.
@@ skipping 11 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) {
-  const syncable::ModelEnumSet encrypted_types =
+  const syncable::ModelTypeSet 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::ModelEnumSetToString(encrypted_types);
+           << syncable::ModelTypeSetToString(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) {
   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;
 }