[Sync] Remove some unnecessary typedefs in SyncBackendRegistrar.

components/sync/driver/glue/sync_backend_registrar.cc

 // Copyright 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 "components/sync/driver/glue/sync_backend_registrar.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <utility>
 
@@ skipping 124 matching lines @@
   return newly_added_types;
 }
 
 ModelTypeSet SyncBackendRegistrar::GetLastConfiguredTypes() const {
   return last_configured_types_;
 }
 
 void SyncBackendRegistrar::RequestWorkerStopOnUIThread() {
   DCHECK(ui_thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
-  for (WorkerMap::const_iterator it = workers_.begin(); it != workers_.end();
-       ++it) {
-    it->second->RequestStop();
+  for (const auto& kv : workers_) {
+    kv.second->RequestStop();
   }
 }
 
 void SyncBackendRegistrar::ActivateDataType(ModelType type,
                                             ModelSafeGroup group,
                                             ChangeProcessor* change_processor,
                                             UserShare* user_share) {
   DVLOG(1) << "Activate: " << ModelTypeToString(type);
 
   base::AutoLock lock(lock_);
@@ skipping 48 matching lines @@
   // This call just notifies the processor that it can commit; it
   // already buffered any changes it plans to makes so needs no
   // further information.
   processor->CommitChangesFromSyncModel();
 }
 
 void SyncBackendRegistrar::GetWorkers(
     std::vector<scoped_refptr<ModelSafeWorker>>* out) {
   base::AutoLock lock(lock_);
   out->clear();
-  for (WorkerMap::const_iterator it = workers_.begin(); it != workers_.end();
-       ++it) {
-    out->push_back(it->second.get());
+  for (const auto& kv : workers_) {
+    out->push_back(kv.second.get());
   }
 }
 
 void SyncBackendRegistrar::GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
   base::AutoLock lock(lock_);
   ModelSafeRoutingInfo copy(routing_info_);
   out->swap(copy);
 }
 
 ChangeProcessor* SyncBackendRegistrar::GetProcessor(ModelType type) const {
   base::AutoLock lock(lock_);
   ChangeProcessor* processor = GetProcessorUnsafe(type);
   if (!processor)
     return nullptr;
 
   // We can only check if |processor| exists, as otherwise the type is
   // mapped to GROUP_PASSIVE.
   CHECK(IsCurrentThreadSafeForModel(type));
   return processor;
 }
 
 ChangeProcessor* SyncBackendRegistrar::GetProcessorUnsafe(
     ModelType type) const {
   lock_.AssertAcquired();
-  std::map<ModelType, ChangeProcessor*>::const_iterator it =
-      processors_.find(type);
+  auto it = processors_.find(type);
 
   // Until model association happens for a datatype, it will not
   // appear in the processors list.  During this time, it is OK to
   // drop changes on the floor (since model association has not
   // happened yet).  When the data type is activated, model
   // association takes place then the change processor is added to the
   // |processors_| list.
   if (it == processors_.end())
     return nullptr;
 
@@ skipping 28 matching lines @@
     workers_[group] = worker;
   }
 }
 
 ModelSafeGroup SyncBackendRegistrar::GetInitialGroupForType(
     ModelType type) const {
   return non_blocking_types_.Has(type) ? GROUP_NON_BLOCKING : GROUP_PASSIVE;
 }
 
 }  // namespace syncer