[Sync] Replace all instances of ModelTypeBitSet with ModelEnumSet

chrome/browser/sync/engine/sync_scheduler.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/engine/sync_scheduler.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/protocol/proto_enum_conversions.h"
 #include "chrome/browser/sync/util/logging.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace browser_sync {
 
 using sessions::SyncSession;
 using sessions::SyncSessionSnapshot;
 using sessions::SyncSourceInfo;
+using syncable::ModelEnumSet;
+using syncable::ModelEnumSetToString;
 using syncable::ModelTypePayloadMap;
-using syncable::ModelTypeBitSet;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 bool ShouldRequestEarlyExit(
     const browser_sync::SyncProtocolError& error) {
   switch (error.error_type) {
     case browser_sync::SYNC_SUCCESS:
     case browser_sync::MIGRATION_DONE:
     case browser_sync::THROTTLED:
     case browser_sync::TRANSIENT_ERROR:
@@ skipping 411 matching lines @@
 // functions, too.
 void SyncScheduler::ScheduleCleanupDisabledTypes() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   ScheduleSyncSessionJob(
       TimeDelta::FromSeconds(0), SyncSessionJob::CLEANUP_DISABLED_TYPES,
       CreateSyncSession(SyncSourceInfo()), FROM_HERE);
 }
 
 void SyncScheduler::ScheduleNudge(
     const TimeDelta& delay,
-    NudgeSource source, syncable::ModelEnumSet types,
+    NudgeSource source, ModelEnumSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG_LOC(nudge_location, 2)
       << "Nudge scheduled with delay " << delay.InMilliseconds() << " ms, "
       << "source " << GetNudgeSourceString(source) << ", "
-      << "types " << syncable::ModelEnumSetToString(types);
+      << "types " << ModelEnumSetToString(types);
 
   ModelTypePayloadMap types_with_payloads =
       syncable::ModelTypePayloadMapFromEnumSet(types, std::string());
   PostTask(nudge_location, "ScheduleNudgeImpl",
            base::Bind(&SyncScheduler::ScheduleNudgeImpl,
                       weak_ptr_factory_.GetWeakPtr(),
                       delay,
                       GetUpdatesFromNudgeSource(source),
                       types_with_payloads,
                       false,
@@ skipping 76 matching lines @@
     }
   }
 
   // TODO(lipalani) - pass the job itself to ScheduleSyncSessionJob.
   ScheduleSyncSessionJob(delay, SyncSessionJob::NUDGE, job.session.release(),
       nudge_location);
 }
 
 // Helper to extract the routing info and workers corresponding to types in
 // |types| from |registrar|.
-void GetModelSafeParamsForTypes(syncable::ModelEnumSet types,
+void GetModelSafeParamsForTypes(ModelEnumSet types,
     ModelSafeWorkerRegistrar* registrar, ModelSafeRoutingInfo* routes,
     std::vector<ModelSafeWorker*>* workers) {
   ModelSafeRoutingInfo r_tmp;
   std::vector<ModelSafeWorker*> w_tmp;
   registrar->GetModelSafeRoutingInfo(&r_tmp);
   registrar->GetWorkers(&w_tmp);
 
   bool passive_group_added = false;
 
   typedef std::vector<ModelSafeWorker*>::const_iterator iter;
-  for (syncable::ModelEnumSet::Iterator it = types.First();
+  for (ModelEnumSet::Iterator it = types.First();
        it.Good(); it.Inc()) {
     const syncable::ModelType t = it.Get();
     DCHECK_EQ(1U, r_tmp.count(t));
     (*routes)[t] = r_tmp[t];
     iter w_tmp_it = std::find_if(w_tmp.begin(), w_tmp.end(),
                                  ModelSafeWorkerGroupIs(r_tmp[t]));
     if (w_tmp_it != w_tmp.end()) {
       iter workers_it = std::find_if(workers->begin(), workers->end(),
                                      ModelSafeWorkerGroupIs(r_tmp[t]));
       if (workers_it == workers->end())
@@ skipping 11 matching lines @@
     iter it = std::find_if(w_tmp.begin(), w_tmp.end(),
                            ModelSafeWorkerGroupIs(GROUP_PASSIVE));
     if (it != w_tmp.end())
       workers->push_back(*it);
     else
       NOTREACHED();
   }
 }
 
 void SyncScheduler::ScheduleConfig(
-    syncable::ModelEnumSet types,
+    ModelEnumSet types,
     GetUpdatesCallerInfo::GetUpdatesSource source) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(IsConfigRelatedUpdateSourceValue(source));
   SDVLOG(2) << "Scheduling a config";
   ModelSafeRoutingInfo routes;
   std::vector<ModelSafeWorker*> workers;
   GetModelSafeParamsForTypes(types, session_context_->registrar(),
                              &routes, &workers);
 
   PostTask(FROM_HERE, "ScheduleConfigImpl",
@@ skipping 567 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // browser_sync