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

chrome/browser/supervised_user/supervised_user_shared_settings_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_shared_settings_service.h"
 
+#include <map>
+#include <set>
+
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/values.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
@@ skipping 178 matching lines @@
   DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, type);
   sync_processor_ = sync_processor.Pass();
   error_handler_ = error_handler.Pass();
 
   // We keep a map from MU ID to the set of keys that we have seen in the
   // initial sync data.
   std::map<std::string, std::set<std::string> > seen_keys;
 
   // Iterate over all initial sync data, and update it locally. This means that
   // the value from the server always wins over a local value.
-  for (SyncDataList::const_iterator it = initial_sync_data.begin();
-       it != initial_sync_data.end();
-       ++it) {
-    DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, it->GetDataType());
+  for (const SyncData& sync_data : initial_sync_data) {
+    DCHECK_EQ(SUPERVISED_USER_SHARED_SETTINGS, sync_data.GetDataType());
     const ::sync_pb::ManagedUserSharedSettingSpecifics&
         supervised_user_shared_setting =
-            it->GetSpecifics().managed_user_shared_setting();
+            sync_data.GetSpecifics().managed_user_shared_setting();
     scoped_ptr<Value> value(
         base::JSONReader::Read(supervised_user_shared_setting.value()));
     const std::string& su_id = supervised_user_shared_setting.mu_id();
     ScopedSupervisedUserSharedSettingsUpdate update(prefs_, su_id);
     const std::string& key = supervised_user_shared_setting.key();
     DictionaryValue* dict = FindOrCreateDictionary(update.Get(), key);
     dict->SetWithoutPathExpansion(kValue, value.release());
 
     // Every setting we get from the server should have the acknowledged flag
     // set.
@@ skipping 61 matching lines @@
     for (DictionaryValue::Iterator jt(*dict); !jt.IsAtEnd(); jt.Advance()) {
       data.push_back(CreateSyncDataForValue(it.key(), jt.key(), jt.value()));
     }
   }
   return data;
 }
 
 syncer::SyncError SupervisedUserSharedSettingsService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
-  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_USER_SHARED_SETTINGS, data.GetDataType());
     const ::sync_pb::ManagedUserSharedSettingSpecifics&
         supervised_user_shared_setting =
             data.GetSpecifics().managed_user_shared_setting();
     const std::string& key = supervised_user_shared_setting.key();
     const std::string& su_id = supervised_user_shared_setting.mu_id();
     ScopedSupervisedUserSharedSettingsUpdate update(prefs_, su_id);
     DictionaryValue* update_dict = update.Get();
     DictionaryValue* dict = NULL;
     bool has_key = update_dict->GetDictionaryWithoutPathExpansion(key, &dict);
-    switch (it->change_type()) {
+    switch (sync_change.change_type()) {
       case SyncChange::ACTION_ADD:
       case SyncChange::ACTION_UPDATE: {
         // Every setting we get from the server should have the acknowledged
         // flag set.
         DCHECK(supervised_user_shared_setting.acknowledged());
 
         if (has_key) {
           // If the supervised user already exists, it should be an update
           // action.
-          DCHECK_EQ(SyncChange::ACTION_UPDATE, it->change_type());
+          DCHECK_EQ(SyncChange::ACTION_UPDATE, sync_change.change_type());
         } else {
           // Otherwise, it should be an add action.
-          DCHECK_EQ(SyncChange::ACTION_ADD, it->change_type());
+          DCHECK_EQ(SyncChange::ACTION_ADD, sync_change.change_type());
           dict = new DictionaryValue;
           update_dict->SetWithoutPathExpansion(key, dict);
         }
         scoped_ptr<Value> value(
             base::JSONReader::Read(supervised_user_shared_setting.value()));
         dict->SetWithoutPathExpansion(kValue, value.release());
         dict->SetBooleanWithoutPathExpansion(
             kAcknowledged, supervised_user_shared_setting.acknowledged());
         break;
       }
       case SyncChange::ACTION_DELETE: {
         if (has_key)
           update_dict->RemoveWithoutPathExpansion(key, NULL);
         else
           NOTREACHED() << "Trying to delete nonexistent key " << key;
         break;
       }
       case SyncChange::ACTION_INVALID: {
         NOTREACHED();
         break;
       }
     }
     callbacks_.Notify(su_id, key);
   }
 
   SyncError error;
   return error;
 }