[Sync] Move ModelType and related classes to 'syncer' namespace

sync/engine/sync_scheduler.cc

 // Copyright (c) 2012 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 "sync/engine/sync_scheduler.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "sync/util/logging.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using sessions::SyncSessionSnapshot;
 using sessions::SyncSourceInfo;
-using syncable::ModelTypeSet;
-using syncable::ModelTypeSetToString;
-using syncable::ModelTypePayloadMap;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 bool ShouldRequestEarlyExit(
     const syncer::SyncProtocolError& error) {
   switch (error.error_type) {
     case syncer::SYNC_SUCCESS:
     case syncer::MIGRATION_DONE:
     case syncer::THROTTLED:
     case syncer::TRANSIENT_ERROR:
@@ skipping 273 matching lines @@
   return job.is_canary_job ? CONTINUE : SAVE;
 }
 
 SyncScheduler::JobProcessDecision SyncScheduler::DecideOnJob(
     const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (job.purpose == SyncSessionJob::CLEANUP_DISABLED_TYPES)
     return CONTINUE;
 
   // See if our type is throttled.
-  syncable::ModelTypeSet throttled_types =
+  syncer::ModelTypeSet throttled_types =
       session_context_->throttled_data_type_tracker()->GetThrottledTypes();
   if (job.purpose == SyncSessionJob::NUDGE &&
       job.session->source().updates_source == GetUpdatesCallerInfo::LOCAL) {
-    syncable::ModelTypeSet requested_types;
+    syncer::ModelTypeSet requested_types;
     for (ModelTypePayloadMap::const_iterator i =
          job.session->source().types.begin();
          i != job.session->source().types.end();
          ++i) {
       requested_types.Put(i->first);
     }
 
     if (!requested_types.Empty() && throttled_types.HasAll(requested_types))
       return SAVE;
   }
@@ skipping 116 matching lines @@
     const TimeDelta& delay,
     NudgeSource source, ModelTypeSet 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 " << ModelTypeSetToString(types);
 
   ModelTypePayloadMap types_with_payloads =
-      syncable::ModelTypePayloadMapFromEnumSet(types, std::string());
+      syncer::ModelTypePayloadMapFromEnumSet(types, std::string());
   SyncScheduler::ScheduleNudgeImpl(delay,
                                    GetUpdatesFromNudgeSource(source),
                                    types_with_payloads,
                                    false,
                                    nudge_location);
 }
 
 void SyncScheduler::ScheduleNudgeWithPayloadsAsync(
     const TimeDelta& delay,
     NudgeSource source, const ModelTypePayloadMap& types_with_payloads,
     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) << ", "
       << "payloads "
-      << syncable::ModelTypePayloadMapToString(types_with_payloads);
+      << syncer::ModelTypePayloadMapToString(types_with_payloads);
 
   SyncScheduler::ScheduleNudgeImpl(delay,
                                    GetUpdatesFromNudgeSource(source),
                                    types_with_payloads,
                                    false,
                                    nudge_location);
 }
 
 void SyncScheduler::ScheduleNudgeImpl(
     const TimeDelta& delay,
     GetUpdatesCallerInfo::GetUpdatesSource source,
     const ModelTypePayloadMap& types_with_payloads,
     bool is_canary_job, const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   SDVLOG_LOC(nudge_location, 2)
       << "In ScheduleNudgeImpl with delay "
       << delay.InMilliseconds() << " ms, "
       << "source " << GetUpdatesSourceString(source) << ", "
       << "payloads "
-      << syncable::ModelTypePayloadMapToString(types_with_payloads)
+      << syncer::ModelTypePayloadMapToString(types_with_payloads)
       << (is_canary_job ? " (canary)" : "");
 
   SyncSourceInfo info(source, types_with_payloads);
 
   SyncSession* session(CreateSyncSession(info));
   SyncSessionJob job(SyncSessionJob::NUDGE, TimeTicks::Now() + delay,
                      make_linked_ptr(session), is_canary_job,
                      nudge_location);
 
   session = NULL;
@@ skipping 30 matching lines @@
 void GetModelSafeParamsForTypes(ModelTypeSet types,
     const ModelSafeRoutingInfo& current_routes,
     const std::vector<ModelSafeWorker*>& current_workers,
     ModelSafeRoutingInfo* result_routes,
     std::vector<ModelSafeWorker*>* result_workers) {
   bool passive_group_added = false;
 
   typedef std::vector<ModelSafeWorker*>::const_iterator iter;
   for (ModelTypeSet::Iterator it = types.First();
        it.Good(); it.Inc()) {
-    const syncable::ModelType t = it.Get();
+    const syncer::ModelType t = it.Get();
     ModelSafeRoutingInfo::const_iterator route = current_routes.find(t);
     DCHECK(route != current_routes.end());
     ModelSafeGroup group = route->second;
 
     (*result_routes)[t] = group;
     iter w_tmp_it = std::find_if(current_workers.begin(), current_workers.end(),
                                  ModelSafeWorkerGroupIs(group));
     if (w_tmp_it != current_workers.end()) {
       iter result_workers_it = std::find_if(
           result_workers->begin(), result_workers->end(),
@@ skipping 566 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer