Replace FOR_EACH_OBSERVER in chromeos/ with range-based for

chromeos/network/managed_network_configuration_handler_impl.cc

 // Copyright 2013 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 "chromeos/network/managed_network_configuration_handler_impl.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 446 matching lines @@
     base::DictionaryValue* new_entry = network->DeepCopy();
     policies->per_network_config[guid] = base::WrapUnique(new_entry);
 
     base::DictionaryValue* old_entry = old_per_network_config[guid].get();
     if (!old_entry || !old_entry->Equals(new_entry))
       modified_policies.insert(guid);
   }
 
   old_per_network_config.clear();
   ApplyOrQueuePolicies(userhash, &modified_policies);
-  FOR_EACH_OBSERVER(NetworkPolicyObserver, observers_,
-                    PoliciesChanged(userhash));
+  for (auto& observer : observers_)
+    observer.PoliciesChanged(userhash);
 }
 
 bool ManagedNetworkConfigurationHandlerImpl::IsAnyPolicyApplicationRunning()
     const {
   return !policy_applicators_.empty() || !queued_modified_policies_.empty();
 }
 
 bool ManagedNetworkConfigurationHandlerImpl::ApplyOrQueuePolicies(
     const std::string& userhash,
     std::set<std::string>* modified_policies) {
@@ skipping 118 matching lines @@
       FROM_HERE, policy_applicators_[userhash].release());
   policy_applicators_.erase(userhash);
 
   if (base::ContainsKey(queued_modified_policies_, userhash)) {
     std::set<std::string> modified_policies;
     queued_modified_policies_[userhash].swap(modified_policies);
     // Remove |userhash| from the queue.
     queued_modified_policies_.erase(userhash);
     ApplyOrQueuePolicies(userhash, &modified_policies);
   } else {
-    FOR_EACH_OBSERVER(
-        NetworkPolicyObserver, observers_, PoliciesApplied(userhash));
+    for (auto& observer : observers_)
+      observer.PoliciesApplied(userhash);
   }
 }
 
 const base::DictionaryValue*
 ManagedNetworkConfigurationHandlerImpl::FindPolicyByGUID(
     const std::string userhash,
     const std::string& guid,
     ::onc::ONCSource* onc_source) const {
   *onc_source = ::onc::ONC_SOURCE_NONE;
 
@@ skipping 104 matching lines @@
   network_device_handler_ = network_device_handler;
   network_profile_handler_->AddObserver(this);
   prohibited_technologies_handler_ = prohibited_technologies_handler;
 }
 
 void ManagedNetworkConfigurationHandlerImpl::OnPolicyAppliedToNetwork(
     const std::string& service_path,
     const std::string& guid) {
   if (service_path.empty())
     return;
-  FOR_EACH_OBSERVER(
-      NetworkPolicyObserver, observers_, PolicyAppliedToNetwork(service_path));
+  for (auto& observer : observers_)
+    observer.PolicyAppliedToNetwork(service_path);
 }
 
 // Get{Managed}Properties helpers
 
 void ManagedNetworkConfigurationHandlerImpl::GetDeviceStateProperties(
     const std::string& service_path,
     base::DictionaryValue* properties) {
   std::string connection_state;
   properties->GetStringWithoutPathExpansion(
       shill::kStateProperty, &connection_state);
@@ skipping 107 matching lines @@
     std::unique_ptr<base::DictionaryValue> network_properties,
     GetDevicePropertiesCallback send_callback,
     const std::string& error_name,
     std::unique_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Error getting device properties", service_path);
   send_callback.Run(service_path, std::move(network_properties));
 }
 
 
 }  // namespace chromeos