c/b/supervised_user: Use range-based for where appropriate.

chrome/browser/supervised_user/supervised_user_sync_service.cc

 // Copyright 2014 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/supervised_user/supervised_user_sync_service.h"
 
+#include <set>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "sync/api/sync_change.h"
@@ skipping 393 matching lines @@
 
   SyncChangeList change_list;
   SyncMergeResult result(SUPERVISED_USERS);
 
   DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
   result.set_num_items_before_association(dict->size());
   std::set<std::string> seen_ids;
   int num_items_added = 0;
   int num_items_modified = 0;
-  for (SyncDataList::const_iterator it = initial_sync_data.begin();
-       it != initial_sync_data.end(); ++it) {
-    DCHECK_EQ(SUPERVISED_USERS, it->GetDataType());
+  for (const SyncData& sync_data : initial_sync_data) {
+    DCHECK_EQ(SUPERVISED_USERS, sync_data.GetDataType());
     const ManagedUserSpecifics& supervised_user =
-        it->GetSpecifics().managed_user();
+        sync_data.GetSpecifics().managed_user();
     base::DictionaryValue* value = new base::DictionaryValue();
     value->SetString(kName, supervised_user.name());
     value->SetBoolean(kAcknowledged, supervised_user.acknowledged());
     value->SetString(kMasterKey, supervised_user.master_key());
     value->SetString(kChromeAvatar, supervised_user.chrome_avatar());
     value->SetString(kChromeOsAvatar, supervised_user.chromeos_avatar());
     value->SetString(kPasswordSignatureKey,
                      supervised_user.password_signature_key());
     value->SetString(kPasswordEncryptionKey,
                      supervised_user.password_encryption_key());
@@ skipping 44 matching lines @@
 
   return data;
 }
 
 SyncError SupervisedUserSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& change_list) {
   SyncError error;
   DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
-  for (SyncChangeList::const_iterator it = change_list.begin();
-       it != change_list.end(); ++it) {
-    SyncData data = it->sync_data();
+  for (const SyncChange& sync_change : change_list) {
+    SyncData data = sync_change.sync_data();
     DCHECK_EQ(SUPERVISED_USERS, data.GetDataType());
     const ManagedUserSpecifics& supervised_user =
         data.GetSpecifics().managed_user();
-    switch (it->change_type()) {
+    switch (sync_change.change_type()) {
       case SyncChange::ACTION_ADD:
       case SyncChange::ACTION_UPDATE: {
         // Every item we get from the server should be acknowledged.
         DCHECK(supervised_user.acknowledged());
         const base::DictionaryValue* old_value = NULL;
         dict->GetDictionaryWithoutPathExpansion(supervised_user.id(),
                                                 &old_value);
 
         // For an update action, the supervised user should already exist, for
         // an add action, it should not.
         DCHECK_EQ(
             old_value ? SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD,
-            it->change_type());
+            sync_change.change_type());
 
         // If the supervised user switched from unacknowledged to acknowledged,
         // we might need to continue with a registration.
         if (old_value && !old_value->HasKey(kAcknowledged))
           NotifySupervisedUserAcknowledged(supervised_user.id());
 
         base::DictionaryValue* value = new base::DictionaryValue;
         value->SetString(kName, supervised_user.name());
         value->SetBoolean(kAcknowledged, supervised_user.acknowledged());
         value->SetString(kMasterKey, supervised_user.master_key());
@@ skipping 43 matching lines @@
 
 void SupervisedUserSyncService::NotifySupervisedUsersChanged() {
   FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver,
                     observers_,
                     OnSupervisedUsersChanged());
 }
 
 void SupervisedUserSyncService::DispatchCallbacks() {
   const base::DictionaryValue* supervised_users =
       prefs_->GetDictionary(prefs::kSupervisedUsers);
-  for (std::vector<SupervisedUsersCallback>::iterator it = callbacks_.begin();
-       it != callbacks_.end(); ++it) {
-    it->Run(supervised_users);
-  }
+  for (const auto& callback : callbacks_)
+    callback.Run(supervised_users);
   callbacks_.clear();
 }