Remove usage of FOR_EACH_OBSERVER macro in remoting

remoting/signaling/xmpp_signal_strategy.cc

 // Copyright 2014 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/signaling/xmpp_signal_strategy.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 156 matching lines @@
 }
 
 void XmppSignalStrategy::Core::Connect() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Disconnect first if we are currently connected.
   Disconnect();
 
   error_ = OK;
 
-  FOR_EACH_OBSERVER(Listener, listeners_,
-                    OnSignalStrategyStateChange(CONNECTING));
+  for (auto& observer : listeners_)
+    observer.OnSignalStrategyStateChange(CONNECTING);
 
   socket_.reset(new jingle_glue::ProxyResolvingClientSocket(
       socket_factory_, request_context_getter_, net::SSLConfig(),
       net::HostPortPair(xmpp_server_config_.host, xmpp_server_config_.port)));
 
   int result = socket_->Connect(base::Bind(
       &Core::OnSocketConnected, base::Unretained(this)));
 
   keep_alive_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kKeepAliveIntervalSeconds),
       base::Bind(&Core::SendKeepAlive, base::Unretained(this)));
 
   if (result != net::ERR_IO_PENDING)
     OnSocketConnected(result);
 }
 
 void XmppSignalStrategy::Core::Disconnect() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (socket_) {
     login_handler_.reset();
     stream_parser_.reset();
     writer_.reset();
     socket_.reset();
     tls_state_ = TlsState::NOT_REQUESTED;
     read_pending_ = false;
 
-    FOR_EACH_OBSERVER(Listener, listeners_,
-                      OnSignalStrategyStateChange(DISCONNECTED));
+    for (auto& observer : listeners_)
+      observer.OnSignalStrategyStateChange(DISCONNECTED);
   }
 }
 
 SignalStrategy::State XmppSignalStrategy::Core::GetState() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (stream_parser_) {
     DCHECK(socket_);
     return CONNECTED;
   } else if (socket_) {
@@ skipping 111 matching lines @@
 
   jid_ = jid;
   stream_parser_ = std::move(parser);
   stream_parser_->SetCallbacks(
       base::Bind(&Core::OnStanza, base::Unretained(this)),
       base::Bind(&Core::OnParserError, base::Unretained(this)));
 
   // Don't need |login_handler_| anymore.
   login_handler_.reset();
 
-  FOR_EACH_OBSERVER(Listener, listeners_,
-                    OnSignalStrategyStateChange(CONNECTED));
+  for (auto& observer : listeners_)
+    observer.OnSignalStrategyStateChange(CONNECTED);
 }
 
 void XmppSignalStrategy::Core::OnLoginHandlerError(
     SignalStrategy::Error error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   error_ = error;
   Disconnect();
 }
 
@@ skipping 199 matching lines @@
 std::string XmppSignalStrategy::GetNextId() {
   return base::Uint64ToString(base::RandUint64());
 }
 
 void XmppSignalStrategy::SetAuthInfo(const std::string& username,
                                      const std::string& auth_token) {
   core_->SetAuthInfo(username, auth_token);
 }
 
 }  // namespace remoting