Remove usage of FOR_EACH_OBSERVER macro in remoting

remoting/host/daemon_process.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 "remoting/host/daemon_process.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 285 matching lines @@
   }
 }
 
 bool DaemonProcess::WasTerminalIdAllocated(int terminal_id) {
   return terminal_id < next_terminal_id_;
 }
 
 void DaemonProcess::OnAccessDenied(const std::string& jid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, OnAccessDenied(jid));
+  for (auto& observer : status_observers_)
+    observer.OnAccessDenied(jid);
 }
 
 void DaemonProcess::OnClientAuthenticated(const std::string& jid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnClientAuthenticated(jid));
+  for (auto& observer : status_observers_)
+    observer.OnClientAuthenticated(jid);
 }
 
 void DaemonProcess::OnClientConnected(const std::string& jid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnClientConnected(jid));
+  for (auto& observer : status_observers_)
+    observer.OnClientConnected(jid);
 }
 
 void DaemonProcess::OnClientDisconnected(const std::string& jid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnClientDisconnected(jid));
+  for (auto& observer : status_observers_)
+    observer.OnClientDisconnected(jid);
 }
 
 void DaemonProcess::OnClientRouteChange(const std::string& jid,
                                         const std::string& channel_name,
                                         const SerializedTransportRoute& route) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   protocol::TransportRoute parsed_route;
   parsed_route.type = route.type;
 
   net::IPAddress remote_ip(route.remote_ip);
   CHECK(remote_ip.empty() || remote_ip.IsValid());
   parsed_route.remote_address = net::IPEndPoint(remote_ip, route.remote_port);
 
   net::IPAddress local_ip(route.local_ip);
   CHECK(local_ip.empty() || local_ip.IsValid());
   parsed_route.local_address = net::IPEndPoint(local_ip, route.local_port);
 
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnClientRouteChange(jid, channel_name, parsed_route));
+  for (auto& observer : status_observers_)
+    observer.OnClientRouteChange(jid, channel_name, parsed_route);
 }
 
 void DaemonProcess::OnHostStarted(const std::string& xmpp_login) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, OnStart(xmpp_login));
+  for (auto& observer : status_observers_)
+    observer.OnStart(xmpp_login);
 }
 
 void DaemonProcess::OnHostShutdown() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, OnShutdown());
+  for (auto& observer : status_observers_)
+    observer.OnShutdown();
 }
 
 void DaemonProcess::DeleteAllDesktopSessions() {
   while (!desktop_sessions_.empty()) {
     delete desktop_sessions_.front();
     desktop_sessions_.pop_front();
   }
 }
 
 }  // namespace remoting