Reduce usage of FOR_EACH_OBSERVER macro in components/

components/proximity_auth/messenger_impl.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 "components/proximity_auth/messenger_impl.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
@@ skipping 97 matching lines @@
   message.SetString(kTypeKey, kMessageTypeLocalEvent);
   message.SetString(kNameKey, kUnlockEventName);
   queued_messages_.push_back(PendingMessage(message));
   ProcessMessageQueue();
 }
 
 void MessengerImpl::RequestDecryption(const std::string& challenge) {
   if (!SupportsSignIn()) {
     PA_LOG(WARNING) << "Dropping decryption request, as remote device "
                     << "does not support protocol v3.1.";
-    FOR_EACH_OBSERVER(MessengerObserver, observers_,
-                      OnDecryptResponse(std::string()));
+    for (auto& observer : observers_)
+      observer.OnDecryptResponse(std::string());
     return;
   }
 
   const std::string encrypted_message_data = challenge;
   std::string encrypted_message_data_base64;
   base::Base64UrlEncode(encrypted_message_data,
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         &encrypted_message_data_base64);
 
   base::DictionaryValue message;
   message.SetString(kTypeKey, kMessageTypeDecryptRequest);
   message.SetString(kEncryptedDataKey, encrypted_message_data_base64);
   queued_messages_.push_back(PendingMessage(message));
   ProcessMessageQueue();
 }
 
 void MessengerImpl::RequestUnlock() {
   if (!SupportsSignIn()) {
     PA_LOG(WARNING) << "Dropping unlock request, as remote device does not "
                     << "support protocol v3.1.";
-    FOR_EACH_OBSERVER(MessengerObserver, observers_, OnUnlockResponse(false));
+    for (auto& observer : observers_)
+      observer.OnUnlockResponse(false);
     return;
   }
 
   base::DictionaryValue message;
   message.SetString(kTypeKey, kMessageTypeUnlockRequest);
   queued_messages_.push_back(PendingMessage(message));
   ProcessMessageQueue();
 }
 
 SecureContext* MessengerImpl::GetSecureContext() const {
@@ skipping 31 matching lines @@
 
 void MessengerImpl::OnMessageDecoded(const std::string& decoded_message) {
   // TODO(tengs): Unify the iOS status update protocol with the existing Android
   // protocol, so we don't have this special case.
   if (decoded_message == kScreenUnlocked || decoded_message == kScreenLocked) {
     RemoteStatusUpdate update;
     update.user_presence =
         (decoded_message == kScreenUnlocked ? USER_PRESENT : USER_ABSENT);
     update.secure_screen_lock_state = SECURE_SCREEN_LOCK_ENABLED;
     update.trust_agent_state = TRUST_AGENT_ENABLED;
-    FOR_EACH_OBSERVER(MessengerObserver, observers_,
-                      OnRemoteStatusUpdate(update));
+    for (auto& observer : observers_)
+      observer.OnRemoteStatusUpdate(update);
     pending_message_.reset();
     ProcessMessageQueue();
     return;
   }
 
   // The decoded message should be a JSON string.
   std::unique_ptr<base::Value> message_value =
       base::JSONReader::Read(decoded_message);
   if (!message_value || !message_value->IsType(base::Value::TYPE_DICTIONARY)) {
     PA_LOG(ERROR) << "Unable to parse message as JSON:\n" << decoded_message;
@@ skipping 52 matching lines @@
 
 void MessengerImpl::HandleRemoteStatusUpdateMessage(
     const base::DictionaryValue& message) {
   std::unique_ptr<RemoteStatusUpdate> status_update =
       RemoteStatusUpdate::Deserialize(message);
   if (!status_update) {
     PA_LOG(ERROR) << "Unexpected remote status update: " << message;
     return;
   }
 
-  FOR_EACH_OBSERVER(MessengerObserver, observers_,
-                    OnRemoteStatusUpdate(*status_update));
+  for (auto& observer : observers_)
+    observer.OnRemoteStatusUpdate(*status_update);
 }
 
 void MessengerImpl::HandleDecryptResponseMessage(
     const base::DictionaryValue& message) {
   std::string base64_data;
   std::string decrypted_data;
   if (!message.GetString(kDataKey, &base64_data) || base64_data.empty()) {
     PA_LOG(ERROR) << "Decrypt response missing '" << kDataKey << "' value.";
   } else if (!base::Base64UrlDecode(
                  base64_data, base::Base64UrlDecodePolicy::REQUIRE_PADDING,
                  &decrypted_data)) {
     PA_LOG(ERROR) << "Unable to base64-decode decrypt response.";
   }
 
-  FOR_EACH_OBSERVER(MessengerObserver, observers_,
-                    OnDecryptResponse(decrypted_data));
+  for (auto& observer : observers_)
+    observer.OnDecryptResponse(decrypted_data);
 }
 
 void MessengerImpl::HandleUnlockResponseMessage(
     const base::DictionaryValue& message) {
-  FOR_EACH_OBSERVER(MessengerObserver, observers_, OnUnlockResponse(true));
+  for (auto& observer : observers_)
+    observer.OnUnlockResponse(true);
 }
 
 void MessengerImpl::PollScreenStateForIOS() {
   if (!connection_->IsConnected())
     return;
 
   // Sends message requesting screen state.
   queued_messages_.push_back(PendingMessage(std::string(kPollScreenState)));
   ProcessMessageQueue();
 
   // Schedules the next message in |kPollingIntervalSeconds|.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&MessengerImpl::PollScreenStateForIOS,
                             weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kIOSPollingIntervalSeconds));
 }
 
 void MessengerImpl::OnConnectionStatusChanged(Connection* connection,
                                               Connection::Status old_status,
                                               Connection::Status new_status) {
   DCHECK_EQ(connection, connection_.get());
   if (new_status == Connection::DISCONNECTED) {
     PA_LOG(INFO) << "Secure channel disconnected...";
     connection_->RemoveObserver(this);
-    FOR_EACH_OBSERVER(MessengerObserver, observers_, OnDisconnected());
+    for (auto& observer : observers_)
+      observer.OnDisconnected();
     // TODO(isherman): Determine whether it's also necessary/appropriate to fire
     // this notification from the destructor.
   }
 }
 
 void MessengerImpl::OnMessageReceived(const Connection& connection,
                                       const WireMessage& wire_message) {
   secure_context_->Decode(wire_message.payload(),
                           base::Bind(&MessengerImpl::OnMessageDecoded,
                                      weak_ptr_factory_.GetWeakPtr()));
@@ skipping 11 matching lines @@
   // Don't wait if the message could not be sent, as there won't ever be a
   // response in that case. Likewise, don't wait for a response to local
   // event messages, as there is no response for such messages.
   if (success && pending_message_->type != kMessageTypeLocalEvent)
     return;
 
   // Notify observer of failure if sending the message fails.
   // For local events, we don't expect a response, so on success, we
   // notify observers right away.
   if (pending_message_->type == kMessageTypeDecryptRequest) {
-    FOR_EACH_OBSERVER(MessengerObserver, observers_,
-                      OnDecryptResponse(std::string()));
+    for (auto& observer : observers_)
+      observer.OnDecryptResponse(std::string());
   } else if (pending_message_->type == kMessageTypeUnlockRequest) {
-    FOR_EACH_OBSERVER(MessengerObserver, observers_, OnUnlockResponse(false));
+    for (auto& observer : observers_)
+      observer.OnUnlockResponse(false);
   } else if (pending_message_->type == kMessageTypeLocalEvent) {
-    FOR_EACH_OBSERVER(MessengerObserver, observers_,
-                      OnUnlockEventSent(success));
+    for (auto& observer : observers_)
+      observer.OnUnlockEventSent(success);
   } else {
     PA_LOG(ERROR) << "Message of unknown type '" << pending_message_->type
                   << "' sent.";
   }
 
   pending_message_.reset();
   ProcessMessageQueue();
 }
 
 }  // namespace proximity_auth