Replace FOR_EACH_OBSERVER in chromeos/ with range-based for

chromeos/network/network_connection_handler.cc

 // Copyright (c) 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/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 208 matching lines @@
   if (queued_connect_)
     ConnectToQueuedNetwork();
 }
 
 void NetworkConnectionHandler::ConnectToNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback,
     bool check_error_state) {
   NET_LOG_USER("ConnectToNetwork", service_path);
-  FOR_EACH_OBSERVER(NetworkConnectionObserver, observers_,
-                    ConnectToNetworkRequested(service_path));
+  for (auto& observer : observers_)
+    observer.ConnectToNetworkRequested(service_path);
 
   // Clear any existing queued connect request.
   queued_connect_.reset();
   if (HasConnectingNetwork(service_path)) {
     NET_LOG_USER("Connect Request While Pending", service_path);
     InvokeConnectErrorCallback(service_path, error_callback, kErrorConnecting);
     return;
   }
 
   // Check cached network state for connected, connecting, or unactivated
@@ skipping 65 matching lines @@
                  AsWeakPtr(), check_error_state),
       base::Bind(&NetworkConnectionHandler::HandleConfigurationFailure,
                  AsWeakPtr(), service_path));
 }
 
 void NetworkConnectionHandler::DisconnectNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   NET_LOG_USER("DisconnectNetwork", service_path);
-  FOR_EACH_OBSERVER(NetworkConnectionObserver, observers_,
-                    DisconnectRequested(service_path));
+  for (auto& observer : observers_)
+    observer.DisconnectRequested(service_path);
 
   const NetworkState* network =
       network_state_handler_->GetNetworkState(service_path);
   if (!network) {
     NET_LOG_ERROR("Disconnect Error: Not Found", service_path);
     network_handler::RunErrorCallback(error_callback, service_path,
                                       kErrorNotFound, "");
     return;
   }
   if (!network->IsConnectedState() && !network->IsConnectingState()) {
@@ skipping 427 matching lines @@
 }
 
 // Connect callbacks
 
 void NetworkConnectionHandler::InvokeConnectSuccessCallback(
     const std::string& service_path,
     const base::Closure& success_callback) {
   NET_LOG_EVENT("Connect Request Succeeded", service_path);
   if (!success_callback.is_null())
     success_callback.Run();
-  FOR_EACH_OBSERVER(NetworkConnectionObserver, observers_,
-                    ConnectSucceeded(service_path));
+  for (auto& observer : observers_)
+    observer.ConnectSucceeded(service_path);
 }
 
 void NetworkConnectionHandler::ErrorCallbackForPendingRequest(
     const std::string& service_path,
     const std::string& error_name) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("ErrorCallbackForPendingRequest with no pending request.",
                   service_path);
     return;
   }
   // Remove the entry before invoking the callback in case it triggers a retry.
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   InvokeConnectErrorCallback(service_path, error_callback, error_name);
 }
 
 void NetworkConnectionHandler::InvokeConnectErrorCallback(
     const std::string& service_path,
     const network_handler::ErrorCallback& error_callback,
     const std::string& error_name) {
   NET_LOG_ERROR("Connect Failure: " + error_name, service_path);
   network_handler::RunErrorCallback(error_callback, service_path, error_name,
                                     "");
-  FOR_EACH_OBSERVER(NetworkConnectionObserver, observers_,
-                    ConnectFailed(service_path, error_name));
+  for (auto& observer : observers_)
+    observer.ConnectFailed(service_path, error_name);
 }
 
 // Disconnect
 
 void NetworkConnectionHandler::CallShillDisconnect(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   NET_LOG_USER("Disconnect Request", service_path);
   DBusThreadManager::Get()->GetShillServiceClient()->Disconnect(
       dbus::ObjectPath(service_path),
       base::Bind(&NetworkConnectionHandler::HandleShillDisconnectSuccess,
                  AsWeakPtr(), service_path, success_callback),
       base::Bind(&network_handler::ShillErrorCallbackFunction,
                  kErrorDisconnectFailed, service_path, error_callback));
 }
 
 void NetworkConnectionHandler::HandleShillDisconnectSuccess(
     const std::string& service_path,
     const base::Closure& success_callback) {
   NET_LOG_EVENT("Disconnect Request Sent", service_path);
   if (!success_callback.is_null())
     success_callback.Run();
 }
 
 }  // namespace chromeos