[Sync] Remove unneeded 'using syncer::' lines and 'syncer::' scopings

sync/engine/sync_scheduler_impl.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_impl.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 using base::TimeTicks;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using sessions::SyncSessionSnapshot;
 using sessions::SyncSourceInfo;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
-bool ShouldRequestEarlyExit(
-    const syncer::SyncProtocolError& error) {
+bool ShouldRequestEarlyExit(const SyncProtocolError& error) {
   switch (error.error_type) {
-    case syncer::SYNC_SUCCESS:
-    case syncer::MIGRATION_DONE:
-    case syncer::THROTTLED:
-    case syncer::TRANSIENT_ERROR:
+    case SYNC_SUCCESS:
+    case MIGRATION_DONE:
+    case THROTTLED:
+    case TRANSIENT_ERROR:
       return false;
-    case syncer::NOT_MY_BIRTHDAY:
-    case syncer::CLEAR_PENDING:
+    case NOT_MY_BIRTHDAY:
+    case CLEAR_PENDING:
       // If we send terminate sync early then |sync_cycle_ended| notification
       // would not be sent. If there were no actions then |ACTIONABLE_ERROR|
       // notification wouldnt be sent either. Then the UI layer would be left
       // waiting forever. So assert we would send something.
-      DCHECK(error.action != syncer::UNKNOWN_ACTION);
+      DCHECK_NE(error.action, UNKNOWN_ACTION);
       return true;
-    case syncer::INVALID_CREDENTIAL:
+    case INVALID_CREDENTIAL:
       // The notification for this is handled by PostAndProcessHeaders|.
       // Server does no have to send any action for this.
       return true;
     // Make the default a NOTREACHED. So if a new error is introduced we
     // think about its expected functionality.
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool IsActionableError(
-    const syncer::SyncProtocolError& error) {
-  return (error.action != syncer::UNKNOWN_ACTION);
+    const SyncProtocolError& error) {
+  return (error.action != UNKNOWN_ACTION);
 }
 }  // namespace
 
 ConfigurationParams::ConfigurationParams()
     : source(GetUpdatesCallerInfo::UNKNOWN),
       keystore_key_status(KEYSTORE_KEY_UNNECESSARY) {}
 ConfigurationParams::ConfigurationParams(
     const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& source,
-    const syncer::ModelTypeSet& types_to_download,
-    const syncer::ModelSafeRoutingInfo& routing_info,
+    const ModelTypeSet& types_to_download,
+    const ModelSafeRoutingInfo& routing_info,
     KeystoreKeyStatus keystore_key_status,
     const base::Closure& ready_task)
     : source(source),
       types_to_download(types_to_download),
       routing_info(routing_info),
       keystore_key_status(keystore_key_status),
       ready_task(ready_task) {
   DCHECK(!ready_task.is_null());
 }
 ConfigurationParams::~ConfigurationParams() {}
@@ skipping 222 matching lines @@
 void BuildModelSafeParams(
     const ModelTypeSet& types_to_download,
     const ModelSafeRoutingInfo& current_routes,
     const std::vector<ModelSafeWorker*>& current_workers,
     ModelSafeRoutingInfo* result_routes,
     std::vector<ModelSafeWorker*>* result_workers) {
   std::set<ModelSafeGroup> active_groups;
   active_groups.insert(GROUP_PASSIVE);
   for (ModelTypeSet::Iterator iter = types_to_download.First(); iter.Good();
        iter.Inc()) {
-    syncer::ModelType type = iter.Get();
+    ModelType type = iter.Get();
     ModelSafeRoutingInfo::const_iterator route = current_routes.find(type);
     DCHECK(route != current_routes.end());
     ModelSafeGroup group = route->second;
     (*result_routes)[type] = group;
     active_groups.insert(group);
   }
 
   for(std::vector<ModelSafeWorker*>::const_iterator iter =
           current_workers.begin(); iter != current_workers.end(); ++iter) {
     if (active_groups.count((*iter)->GetModelSafeGroup()) > 0)
@@ skipping 11 matching lines @@
   DCHECK(!params.ready_task.is_null());
   SDVLOG(2) << "Reconfiguring syncer.";
 
   // Only one configuration is allowed at a time. Verify we're not waiting
   // for a pending configure job.
   DCHECK(!wait_interval_.get() || !wait_interval_->pending_configure_job.get());
 
   // TODO(sync): now that ModelChanging commands only use those workers within
   // the routing info, we don't really need |restricted_workers|. Remove it.
   // crbug.com/133030
-  syncer::ModelSafeRoutingInfo restricted_routes;
+  ModelSafeRoutingInfo restricted_routes;
   std::vector<ModelSafeWorker*> restricted_workers;
   BuildModelSafeParams(params.types_to_download,
                        params.routing_info,
                        session_context_->workers(),
                        &restricted_routes,
                        &restricted_workers);
   session_context_->set_routing_info(params.routing_info);
 
   // We rely on this not failing, so don't need to worry about checking for
   // success. In addition, this will be removed as part of crbug.com/131433.
@@ skipping 82 matching lines @@
   return job.is_canary_job ? CONTINUE : SAVE;
 }
 
 SyncSchedulerImpl::JobProcessDecision SyncSchedulerImpl::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.
-  syncer::ModelTypeSet throttled_types =
+  ModelTypeSet throttled_types =
       session_context_->throttled_data_type_tracker()->GetThrottledTypes();
   if (job.purpose == SyncSessionJob::NUDGE &&
       job.session->source().updates_source == GetUpdatesCallerInfo::LOCAL) {
-    syncer::ModelTypeSet requested_types;
+    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 114 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 =
-      syncer::ModelTypePayloadMapFromEnumSet(types, std::string());
+      ModelTypePayloadMapFromEnumSet(types, std::string());
   SyncSchedulerImpl::ScheduleNudgeImpl(delay,
                                        GetUpdatesFromNudgeSource(source),
                                        types_with_payloads,
                                        false,
                                        nudge_location);
 }
 
 void SyncSchedulerImpl::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 "
-      << syncer::ModelTypePayloadMapToString(types_with_payloads);
+      << ModelTypePayloadMapToString(types_with_payloads);
 
   SyncSchedulerImpl::ScheduleNudgeImpl(delay,
                                        GetUpdatesFromNudgeSource(source),
                                        types_with_payloads,
                                        false,
                                        nudge_location);
 }
 
 void SyncSchedulerImpl::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 "
-      << syncer::ModelTypePayloadMapToString(types_with_payloads)
+      << 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,
                      ConfigurationParams(), nudge_location);
 
   session = NULL;
@@ skipping 560 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer