Replace FOR_EACH_OBSERVER in chromeos/ with range-based for

chromeos/network/network_state_handler.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 "chromeos/network/network_state_handler.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 62 matching lines @@
   // Normally Shutdown() will get called in ~NetworkHandler, however unit
   // tests do not use that class so this needs to call Shutdown when we
   // destry the class.
   if (!did_shutdown_)
     Shutdown();
 }
 
 void NetworkStateHandler::Shutdown() {
   DCHECK(!did_shutdown_);
   did_shutdown_ = true;
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_, OnShuttingDown());
+  for (auto& observer : observers_)
+    observer.OnShuttingDown();
 }
 
 void NetworkStateHandler::InitShillPropertyHandler() {
   shill_property_handler_.reset(new internal::ShillPropertyHandler(this));
   shill_property_handler_->Init();
 }
 
 // static
 NetworkStateHandler* NetworkStateHandler::InitializeForTest() {
   NetworkStateHandler* handler = new NetworkStateHandler();
@@ skipping 594 matching lines @@
 
 void NetworkStateHandler::ManagedStateListChanged(
     ManagedState::ManagedType type) {
   SCOPED_NET_LOG_IF_SLOW();
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     SortNetworkList();
     UpdateNetworkStats();
     // Notify observers that the list of networks has changed.
     NET_LOG_EVENT("NOTIFY:NetworkListChanged",
                   base::StringPrintf("Size:%" PRIuS, network_list_.size()));
-    FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                      NetworkListChanged());
+    for (auto& observer : observers_)
+      observer.NetworkListChanged();
   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
     std::string devices;
     for (auto iter = device_list_.begin(); iter != device_list_.end(); ++iter) {
       if (iter != device_list_.begin())
         devices += ", ";
       devices += (*iter)->name();
     }
     NET_LOG_EVENT("DeviceList", devices);
     NotifyDeviceListChanged();
   } else {
@@ skipping 121 matching lines @@
     guid = base::GenerateGUID();
     specifier_guid_map_[specifier] = guid;
   }
   network->SetGuid(guid);
 }
 
 void NetworkStateHandler::NotifyDeviceListChanged() {
   SCOPED_NET_LOG_IF_SLOW();
   NET_LOG_DEBUG("NOTIFY:DeviceListChanged",
                 base::StringPrintf("Size:%" PRIuS, device_list_.size()));
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    DeviceListChanged());
+  for (auto& observer : observers_)
+    observer.DeviceListChanged();
 }
 
 DeviceState* NetworkStateHandler::GetModifiableDeviceState(
     const std::string& device_path) const {
   ManagedState* managed = GetModifiableManagedState(&device_list_, device_path);
   if (!managed)
     return nullptr;
   return managed->AsDeviceState();
 }
 
@@ skipping 50 matching lines @@
       default_network_path_.clear();
       SortNetworkList();
       NotifyDefaultNetworkChanged(nullptr);
     }
   }
   std::string desc = "NetworkConnectionStateChanged";
   if (notify_default)
     desc = "Default" + desc;
   NET_LOG(EVENT) << "NOTIFY: " << desc << ": " << GetLogName(network) << ": "
                  << network->connection_state();
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    NetworkConnectionStateChanged(network));
+  for (auto& observer : observers_)
+    observer.NetworkConnectionStateChanged(network);
   if (notify_default)
     NotifyDefaultNetworkChanged(network);
 }
 
 void NetworkStateHandler::NotifyDefaultNetworkChanged(
     const NetworkState* default_network) {
   SCOPED_NET_LOG_IF_SLOW();
   NET_LOG_EVENT("NOTIFY:DefaultNetworkChanged", GetLogName(default_network));
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    DefaultNetworkChanged(default_network));
+  for (auto& observer : observers_)
+    observer.DefaultNetworkChanged(default_network);
 }
 
 void NetworkStateHandler::NotifyNetworkPropertiesUpdated(
     const NetworkState* network) {
   SCOPED_NET_LOG_IF_SLOW();
   NET_LOG_DEBUG("NOTIFY:NetworkPropertiesUpdated", GetLogName(network));
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    NetworkPropertiesUpdated(network));
+  for (auto& observer : observers_)
+    observer.NetworkPropertiesUpdated(network);
 }
 
 void NetworkStateHandler::NotifyDevicePropertiesUpdated(
     const DeviceState* device) {
   SCOPED_NET_LOG_IF_SLOW();
   NET_LOG_DEBUG("NOTIFY:DevicePropertiesUpdated", GetLogName(device));
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    DevicePropertiesUpdated(device));
+  for (auto& observer : observers_)
+    observer.DevicePropertiesUpdated(device);
 }
 
 void NetworkStateHandler::NotifyScanCompleted(const DeviceState* device) {
   SCOPED_NET_LOG_IF_SLOW();
   NET_LOG_DEBUG("NOTIFY:ScanCompleted", GetLogName(device));
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    ScanCompleted(device));
+  for (auto& observer : observers_)
+    observer.ScanCompleted(device);
 }
 
 std::string NetworkStateHandler::GetTechnologyForType(
     const NetworkTypePattern& type) const {
   if (type.MatchesType(shill::kTypeEthernet))
     return shill::kTypeEthernet;
 
   if (type.MatchesType(shill::kTypeWifi))
     return shill::kTypeWifi;
 
@@ skipping 27 matching lines @@
   if (type.MatchesType(shill::kTypeBluetooth))
     technologies.emplace_back(shill::kTypeBluetooth);
   if (type.MatchesType(shill::kTypeVPN))
     technologies.emplace_back(shill::kTypeVPN);
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies;
 }
 
 }  // namespace chromeos