Remove usage of FOR_EACH_OBSERVER macro in remoting

remoting/host/chromoting_host.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/chromoting_host.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 76 matching lines @@
   // Disconnect all of the clients.
   while (!clients_.empty()) {
     clients_.front()->DisconnectSession(protocol::OK);
   }
 
   // Destroy the session manager to make sure that |signal_strategy_| does not
   // have any listeners registered.
   session_manager_.reset();
 
   // Notify observers.
   if (started_)

[Sergey Ulanov, 2016/10/17 16:45:31]

Please add {}

[Eric Willigers, 2016/10/17 22:32:31]

Done.

-    FOR_EACH_OBSERVER(HostStatusObserver, status_observers_, OnShutdown());
+    for (auto& observer : status_observers_)
+      observer.OnShutdown();
 }
 
 void ChromotingHost::Start(const std::string& host_owner_email) {
   DCHECK(CalledOnValidThread());
   DCHECK(!started_);
 
   HOST_LOG << "Starting host";
   started_ = true;
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnStart(host_owner_email));
+  for (auto& observer : status_observers_)
+    observer.OnStart(host_owner_email);
 
   session_manager_->AcceptIncoming(
       base::Bind(&ChromotingHost::OnIncomingSession, base::Unretained(this)));
 }
 
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
   DCHECK(CalledOnValidThread());
   status_observers_.AddObserver(observer);
 }
 
@@ skipping 71 matching lines @@
         return;
     }
   }
 
   // Disconnects above must have destroyed all other clients.
   DCHECK_EQ(clients_.size(), 1U);
 
   // Notify observers that there is at least one authenticated client.
   const std::string& jid = client->client_jid();
 
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnClientAuthenticated(jid));
+  for (auto& observer : status_observers_)
+    observer.OnClientAuthenticated(jid);
 }
 
 void ChromotingHost::OnSessionChannelsConnected(ClientSession* client) {
   DCHECK(CalledOnValidThread());
 
   // Notify observers.
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnClientConnected(client->client_jid()));
+  for (auto& observer : status_observers_)
+    observer.OnClientConnected(client->client_jid());
 }
 
 void ChromotingHost::OnSessionAuthenticationFailed(ClientSession* client) {
   DCHECK(CalledOnValidThread());
 
   // Notify observers.
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnAccessDenied(client->client_jid()));
+  for (auto& observer : status_observers_)
+    observer.OnAccessDenied(client->client_jid());
 }
 
 void ChromotingHost::OnSessionClosed(ClientSession* client) {
   DCHECK(CalledOnValidThread());
 
   ClientList::iterator it = std::find(clients_.begin(), clients_.end(), client);
   CHECK(it != clients_.end());
 
   bool was_authenticated = client->is_authenticated();
   std::string jid = client->client_jid();
   clients_.erase(it);
   delete client;
 
   if (was_authenticated) {
-    FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                      OnClientDisconnected(jid));
+    for (auto& observer : status_observers_)
+      observer.OnClientDisconnected(jid);
   }
 }
 
 void ChromotingHost::OnSessionRouteChange(
     ClientSession* session,
     const std::string& channel_name,
     const protocol::TransportRoute& route) {
   DCHECK(CalledOnValidThread());
-  FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
-                    OnClientRouteChange(session->client_jid(), channel_name,
-                                        route));
+  for (auto& observer : status_observers_)
+    observer.OnClientRouteChange(session->client_jid(), channel_name, route);
 }
 
 void ChromotingHost::OnIncomingSession(
       protocol::Session* session,
       protocol::SessionManager::IncomingSessionResponse* response) {
   DCHECK(CalledOnValidThread());
   DCHECK(started_);
 
   if (login_backoff_.ShouldRejectRequest()) {
     LOG(WARNING) << "Rejecting connection due to"
@@ skipping 32 matching lines @@
   DCHECK(CalledOnValidThread());
 
   while (!clients_.empty()) {
     size_t size = clients_.size();
     clients_.front()->DisconnectSession(protocol::OK);
     CHECK_EQ(clients_.size(), size - 1);
   }
 }
 
 }  // namespace remoting