[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/internal_api/sync_manager.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/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/command_line.h"
@@ skipping 60 matching lines @@
 using browser_sync::ServerConnectionEventListener;
 using browser_sync::SyncEngineEvent;
 using browser_sync::SyncEngineEventListener;
 using browser_sync::SyncScheduler;
 using browser_sync::Syncer;
 using browser_sync::WeakHandle;
 using browser_sync::sessions::SyncSessionContext;
 using syncable::DirectoryManager;
 using syncable::ImmutableWriteTransactionInfo;
 using syncable::ModelType;
-using syncable::ModelEnumSet;
+using syncable::ModelTypeSet;
 using syncable::SPECIFICS;
 using sync_pb::GetUpdatesCallerInfo;
 
 typedef GoogleServiceAuthError AuthError;
 
 namespace {
 
 static const int kSyncSchedulerDelayMsec = 250;
 
 #if defined(OS_CHROMEOS)
@@ skipping 108 matching lines @@
   bool SignIn(const SyncCredentials& credentials);
 
   // Update tokens that we're using in Sync. Email must stay the same.
   void UpdateCredentials(const SyncCredentials& credentials);
 
   // Called when the user disables or enables a sync type.
   void UpdateEnabledTypes();
 
   // Conditionally sets the flag in the Nigori node which instructs other
   // clients to start syncing tabs.
-  void MaybeSetSyncTabsInNigoriNode(ModelEnumSet enabled_types);
+  void MaybeSetSyncTabsInNigoriNode(ModelTypeSet enabled_types);
 
   // Tell the sync engine to start the syncing process.
   void StartSyncingNormally();
 
   // Whether or not the Nigori node is encrypted using an explicit passphrase.
   bool IsUsingExplicitPassphrase();
 
   // Update the Cryptographer from the current nigori node and write back any
   // necessary changes to the nigori node. We also detect missing encryption
   // keys and write them into the nigori node.
@@ skipping 15 matching lines @@
 
   // Call periodically from a database-safe thread to persist recent changes
   // to the syncapi model.
   void SaveChanges();
 
   // DirectoryChangeDelegate implementation.
   // This listener is called upon completion of a syncable transaction, and
   // builds the list of sync-engine initiated changes that will be forwarded to
   // the SyncManager's Observers.
   virtual void HandleTransactionCompleteChangeEvent(
-      ModelEnumSet models_with_changes) OVERRIDE;
-  virtual ModelEnumSet HandleTransactionEndingChangeEvent(
+      ModelTypeSet models_with_changes) OVERRIDE;
+  virtual ModelTypeSet HandleTransactionEndingChangeEvent(
       const ImmutableWriteTransactionInfo& write_transaction_info,
       syncable::BaseTransaction* trans) OVERRIDE;
   virtual void HandleCalculateChangesChangeEventFromSyncApi(
       const ImmutableWriteTransactionInfo& write_transaction_info,
       syncable::BaseTransaction* trans) OVERRIDE;
   virtual void HandleCalculateChangesChangeEventFromSyncer(
       const ImmutableWriteTransactionInfo& write_transaction_info,
       syncable::BaseTransaction* trans) OVERRIDE;
 
   // Listens for notifications from the ServerConnectionManager
   void HandleServerConnectionEvent(const ServerConnectionEvent& event);
 
   // Open the directory named with username_for_share
   bool OpenDirectory();
 
   // Cryptographer::Observer implementation.
   virtual void OnEncryptedTypesChanged(
-      syncable::ModelEnumSet encrypted_types,
+      syncable::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
 
   // SyncNotifierObserver implementation.
   virtual void OnNotificationStateChange(
       bool notifications_enabled) OVERRIDE;
 
   virtual void OnIncomingNotification(
       const syncable::ModelTypePayloadMap& type_payloads) OVERRIDE;
 
   virtual void StoreState(const std::string& cookie) OVERRIDE;
@@ skipping 38 matching lines @@
                                 ChangeReorderBuffer* buffer,
                                 Cryptographer* cryptographer,
                                 const syncable::EntryKernel& original,
                                 bool existed_before,
                                 bool exists_now);
 
   // Called only by our NetworkChangeNotifier.
   virtual void OnIPAddressChanged() OVERRIDE;
 
   bool InitialSyncEndedForAllEnabledTypes() {
-    syncable::ModelEnumSet types;
+    syncable::ModelTypeSet types;
     ModelSafeRoutingInfo enabled_types;
     registrar_->GetModelSafeRoutingInfo(&enabled_types);
     for (ModelSafeRoutingInfo::const_iterator i = enabled_types.begin();
         i != enabled_types.end(); ++i) {
       types.Put(i->first);
     }
 
     return InitialSyncEndedForTypes(types, &share_);
   }
 
@@ skipping 300 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateCredentials(credentials);
 }
 
 void SyncManager::UpdateEnabledTypes() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateEnabledTypes();
 }
 
 void SyncManager::MaybeSetSyncTabsInNigoriNode(
-    ModelEnumSet enabled_types) {
+    ModelTypeSet enabled_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->MaybeSetSyncTabsInNigoriNode(enabled_types);
 }
 
 bool SyncManager::InitialSyncEndedForAllEnabledTypes() {
   return data_->InitialSyncEndedForAllEnabledTypes();
 }
 
 void SyncManager::StartSyncingNormally() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 39 matching lines @@
     data_->scheduler()->ScheduleCleanupDisabledTypes();
 }
 
 void SyncManager::RequestClearServerData() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->scheduler())
     data_->scheduler()->ScheduleClearUserData();
 }
 
 void SyncManager::RequestConfig(
-    ModelEnumSet types, ConfigureReason reason) {
+    ModelTypeSet types, ConfigureReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::RequestConfig: bailing out because scheduler is "
         << "null";
     return;
   }
   StartConfigurationMode(base::Closure());
   data_->scheduler()->ScheduleConfig(types, GetSourceFromReason(reason));
 }
@@ skipping 242 matching lines @@
           FROM_HERE, base::Bind(&SyncInternal::CheckServerReachable,
                                 weak_ptr_factory_.GetWeakPtr()));
     }
   }
 }
 
 void SyncManager::SyncInternal::UpdateEnabledTypes() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ModelSafeRoutingInfo routes;
   registrar_->GetModelSafeRoutingInfo(&routes);
-  const ModelEnumSet enabled_types = GetRoutingInfoTypes(routes);
+  const ModelTypeSet enabled_types = GetRoutingInfoTypes(routes);
   sync_notifier_->UpdateEnabledTypes(enabled_types);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableSyncTabsForOtherClients)) {
     MaybeSetSyncTabsInNigoriNode(enabled_types);
   }
 }
 
 void SyncManager::SyncInternal::MaybeSetSyncTabsInNigoriNode(
-    const ModelEnumSet enabled_types) {
+    const ModelTypeSet enabled_types) {
   // The initialized_ check is to ensure that we don't CHECK in GetUserShare
   // when this is called on start-up. It's ok to ignore that case, since
   // presumably this would've run when the user originally enabled sessions.
   if (initialized_ && enabled_types.Has(syncable::SESSIONS)) {
     WriteTransaction trans(FROM_HERE, GetUserShare());
     WriteNode node(&trans);
     if (!node.InitByTagLookup(kNigoriTag)) {
       NOTREACHED() << "Unable to set 'sync_tabs' bit because Nigori node not "
                    << "found.";
       return;
@@ skipping 140 matching lines @@
   // types changed to ensure that any stray unencrypted entries are overwritten.
   ReEncryptEverything(&trans);
 }
 
 // TODO(zea): Add unit tests that ensure no sync changes are made when not
 // needed.
 void SyncManager::SyncInternal::ReEncryptEverything(WriteTransaction* trans) {
   Cryptographer* cryptographer = trans->GetCryptographer();
   if (!cryptographer || !cryptographer->is_ready())
     return;
-  syncable::ModelEnumSet encrypted_types = GetEncryptedTypes(trans);
+  syncable::ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
   ModelSafeRoutingInfo routes;
   registrar_->GetModelSafeRoutingInfo(&routes);
   std::string tag;
-  for (syncable::ModelEnumSet::Iterator iter = encrypted_types.First();
+  for (syncable::ModelTypeSet::Iterator iter = encrypted_types.First();
        iter.Good(); iter.Inc()) {
     if (iter.Get() == syncable::PASSWORDS ||
         iter.Get() == syncable::NIGORI ||
         routes.count(iter.Get()) == 0)
       continue;
     ReadNode type_root(trans);
     tag = syncable::ModelTypeToRootTag(iter.Get());
     if (!type_root.InitByTagLookup(tag)) {
       // This can happen when we enable a datatype for the first time on restart
       // (for example when we upgrade) and therefore haven't done the initial
@@ skipping 189 matching lines @@
   }
 
   if (event.connection_code ==
       browser_sync::HttpResponse::SYNC_SERVER_ERROR) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
         OnAuthError(AuthError(AuthError::CONNECTION_FAILED)));
   }
 }
 
 void SyncManager::SyncInternal::HandleTransactionCompleteChangeEvent(
-    ModelEnumSet models_with_changes) {
+    ModelTypeSet models_with_changes) {
   // This notification happens immediately after the transaction mutex is
   // released. This allows work to be performed without blocking other threads
   // from acquiring a transaction.
   if (!change_delegate_)
     return;
 
   // Call commit.
-  for (ModelEnumSet::Iterator it = models_with_changes.First();
+  for (ModelTypeSet::Iterator it = models_with_changes.First();
        it.Good(); it.Inc()) {
     change_delegate_->OnChangesComplete(it.Get());
     change_observer_.Call(
         FROM_HERE, &SyncManager::ChangeObserver::OnChangesComplete, it.Get());
   }
 }
 
-ModelEnumSet
+ModelTypeSet
     SyncManager::SyncInternal::HandleTransactionEndingChangeEvent(
         const ImmutableWriteTransactionInfo& write_transaction_info,
         syncable::BaseTransaction* trans) {
   // This notification happens immediately before a syncable WriteTransaction
   // falls out of scope. It happens while the channel mutex is still held,
   // and while the transaction mutex is held, so it cannot be re-entrant.
   if (!change_delegate_ || ChangeBuffersAreEmpty())
-    return ModelEnumSet();
+    return ModelTypeSet();
 
   // This will continue the WriteTransaction using a read only wrapper.
   // This is the last chance for read to occur in the WriteTransaction
   // that's closing. This special ReadTransaction will not close the
   // underlying transaction.
   ReadTransaction read_trans(GetUserShare(), trans);
 
-  ModelEnumSet models_with_changes;
+  ModelTypeSet models_with_changes;
   for (int i = syncable::FIRST_REAL_MODEL_TYPE;
        i < syncable::MODEL_TYPE_COUNT; ++i) {
     const syncable::ModelType type = syncable::ModelTypeFromInt(i);
     if (change_buffers_[type].IsEmpty())
       continue;
 
     ImmutableChangeRecordList ordered_changes;
     // TODO(akalin): Propagate up the error further (see
     // http://crbug.com/100907).
     CHECK(change_buffers_[type].GetAllChangesInTreeOrder(&read_trans,
@@ skipping 134 matching lines @@
 
 SyncManager::Status SyncManager::SyncInternal::GetStatus() {
   return allstatus_.status();
 }
 
 void SyncManager::SyncInternal::RequestNudge(
     const tracked_objects::Location& location) {
   if (scheduler())
      scheduler()->ScheduleNudge(
         TimeDelta::FromMilliseconds(0), browser_sync::NUDGE_SOURCE_LOCAL,
-        ModelEnumSet(), location);
+        ModelTypeSet(), location);
 }
 
 void SyncManager::SyncInternal::RequestNudgeForDataType(
     const tracked_objects::Location& nudge_location,
     const ModelType& type) {
   if (!scheduler()) {
     NOTREACHED();
     return;
   }
   base::TimeDelta nudge_delay;
   switch (type) {
     case syncable::PREFERENCES:
       nudge_delay =
           TimeDelta::FromMilliseconds(kPreferencesNudgeDelayMilliseconds);
       break;
     case syncable::SESSIONS:
       nudge_delay = scheduler()->sessions_commit_delay();
       break;
     default:
       nudge_delay =
           TimeDelta::FromMilliseconds(kDefaultNudgeDelayMilliseconds);
       break;
   }
   scheduler()->ScheduleNudge(nudge_delay,
                              browser_sync::NUDGE_SOURCE_LOCAL,
-                             ModelEnumSet(type),
+                             ModelTypeSet(type),
                              nudge_location);
 }
 
 void SyncManager::SyncInternal::OnSyncEngineEvent(
     const SyncEngineEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Only send an event if this is due to a cycle ending and this cycle
   // concludes a canonical "sync" process; that is, based on what is known
   // locally we are "all happy" and up-to-date.  There may be new changes on
   // the server, but we'll get them on a subsequent sync.
@@ skipping 41 matching lines @@
 
     // This is here for tests, which are still using p2p notifications.
     //
     // TODO(chron): Consider changing this back to track has_more_to_sync
     // only notify peers if a successful commit has occurred.
     bool is_notifiable_commit =
         (event.snapshot->syncer_status.num_successful_commits > 0);
     if (is_notifiable_commit) {
       allstatus_.IncrementNotifiableCommits();
       if (sync_notifier_.get()) {
-        const ModelEnumSet changed_types =
+        const ModelTypeSet changed_types =
             syncable::ModelTypePayloadMapToEnumSet(
                 event.snapshot->source.types);
         sync_notifier_->SendNotification(changed_types);
       } else {
         DVLOG(1) << "Not sending notification: sync_notifier_ is NULL";
       }
     }
   }
 
   if (event.what_happened == SyncEngineEvent::STOP_SYNCING_PERMANENTLY) {
@@ skipping 207 matching lines @@
     if ((*it)->ContainsString(lowercase_query)) {
       result->Append(new StringValue(base::Int64ToString(
           (*it)->ref(syncable::META_HANDLE))));
     }
   }
 
   return JsArgList(&return_args);
 }
 
 void SyncManager::SyncInternal::OnEncryptedTypesChanged(
-    syncable::ModelEnumSet encrypted_types,
+    syncable::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   // NOTE: We're in a transaction.
   FOR_EACH_OBSERVER(
       SyncManager::Observer, observers_,
       OnEncryptedTypesChanged(encrypted_types, encrypt_everything));
 }
 
 void SyncManager::SyncInternal::OnNotificationStateChange(
     bool notifications_enabled) {
   DVLOG(1) << "P2P: Notifications enabled = "
@@ skipping 108 matching lines @@
 UserShare* SyncManager::GetUserShare() const {
   return data_->GetUserShare();
 }
 
 void SyncManager::RefreshEncryption() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (data_->UpdateCryptographerAndNigori())
     data_->RefreshEncryption();
 }
 
-syncable::ModelEnumSet SyncManager::GetEncryptedDataTypesForTest() const {
+syncable::ModelTypeSet SyncManager::GetEncryptedDataTypesForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
-bool SyncManager::ReceivedExperimentalTypes(syncable::ModelEnumSet* to_add)
+bool SyncManager::ReceivedExperimentalTypes(syncable::ModelTypeSet* to_add)
     const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
   if (!node.InitByTagLookup(kNigoriTag)) {
     DVLOG(1) << "Couldn't find Nigori node.";
     return false;
   }
   if (node.GetNigoriSpecifics().sync_tabs()) {
     to_add->Put(syncable::SESSIONS);
     return true;
   }
   return false;
 }
 
 bool SyncManager::HasUnsyncedItems() const {
   sync_api::ReadTransaction trans(FROM_HERE, GetUserShare());
   return (trans.GetWrappedTrans()->directory()->unsynced_entity_count() != 0);
 }
 
 void SyncManager::TriggerOnNotificationStateChangeForTest(
     bool notifications_enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->OnNotificationStateChange(notifications_enabled);
 }
 
 void SyncManager::TriggerOnIncomingNotificationForTest(
-    ModelEnumSet model_types) {
+    ModelTypeSet model_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromEnumSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 // Helper function that converts a PassphraseRequiredReason value to a string.
 std::string PassphraseRequiredReasonToString(
     PassphraseRequiredReason reason) {
   switch (reason) {
     case REASON_PASSPHRASE_NOT_REQUIRED:
       return "REASON_PASSPHRASE_NOT_REQUIRED";
     case REASON_ENCRYPTION:
       return "REASON_ENCRYPTION";
     case REASON_DECRYPTION:
       return "REASON_DECRYPTION";
     case REASON_SET_PASSPHRASE_FAILED:
       return "REASON_SET_PASSPHRASE_FAILED";
     default:
       NOTREACHED();
       return "INVALID_REASON";
   }
 }
 
 // Helper function to determine if initial sync had ended for types.
-bool InitialSyncEndedForTypes(syncable::ModelEnumSet types,
+bool InitialSyncEndedForTypes(syncable::ModelTypeSet types,
                               sync_api::UserShare* share) {
   syncable::ScopedDirLookup lookup(share->dir_manager.get(),
                                    share->name);
   if (!lookup.good()) {
     DCHECK(false) << "ScopedDirLookup failed when checking initial sync";
     return false;
   }
 
-  for (syncable::ModelEnumSet::Iterator i = types.First();
+  for (syncable::ModelTypeSet::Iterator i = types.First();
        i.Good(); i.Inc()) {
     if (!lookup->initial_sync_ended_for_type(i.Get()))
       return false;
   }
   return true;
 }
 
-syncable::ModelEnumSet GetTypesWithEmptyProgressMarkerToken(
-    syncable::ModelEnumSet types,
+syncable::ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
+    syncable::ModelTypeSet types,
     sync_api::UserShare* share) {
   syncable::ScopedDirLookup lookup(share->dir_manager.get(),
                                    share->name);
   if (!lookup.good()) {
     NOTREACHED() << "ScopedDirLookup failed for "
                   << "GetTypesWithEmptyProgressMarkerToken";
-    return syncable::ModelEnumSet();
+    return syncable::ModelTypeSet();
   }
 
-  syncable::ModelEnumSet result;
-  for (syncable::ModelEnumSet::Iterator i = types.First();
+  syncable::ModelTypeSet result;
+  for (syncable::ModelTypeSet::Iterator i = types.First();
        i.Good(); i.Inc()) {
     sync_pb::DataTypeProgressMarker marker;
     lookup->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api