Reduce usage of FOR_EACH_OBSERVER macro in components/

components/proximity_auth/cryptauth/cryptauth_device_manager.cc

 // Copyright 2015 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/cryptauth/cryptauth_device_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 197 matching lines @@
   pref_service_->SetBoolean(prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure,
                             false);
   pref_service_->SetDouble(prefs::kCryptAuthDeviceSyncLastSyncTimeSeconds,
                            clock_->Now().ToDoubleT());
   pref_service_->SetInteger(prefs::kCryptAuthDeviceSyncReason,
                             cryptauth::INVOCATION_REASON_UNKNOWN);
 
   sync_request_->OnDidComplete(true);
   cryptauth_client_.reset();
   sync_request_.reset();
-  FOR_EACH_OBSERVER(
-      Observer, observers_,
-      OnSyncFinished(SyncResult::SUCCESS, unlock_keys_changed
-                                              ? DeviceChangeResult::CHANGED
-                                              : DeviceChangeResult::UNCHANGED));
+  for (auto& observer : observers_) {
+    observer.OnSyncFinished(SyncResult::SUCCESS,
+                            unlock_keys_changed
+                                ? DeviceChangeResult::CHANGED
+                                : DeviceChangeResult::UNCHANGED);
+  }
 }
 
 void CryptAuthDeviceManager::OnGetMyDevicesFailure(const std::string& error) {
   PA_LOG(ERROR) << "GetMyDevices API failed: " << error;
   pref_service_->SetBoolean(prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure,
                             true);
   sync_request_->OnDidComplete(false);
   cryptauth_client_.reset();
   sync_request_.reset();
-  FOR_EACH_OBSERVER(
-      Observer, observers_,
-      OnSyncFinished(SyncResult::FAILURE, DeviceChangeResult::UNCHANGED));
+  for (auto& observer : observers_)
+    observer.OnSyncFinished(SyncResult::FAILURE, DeviceChangeResult::UNCHANGED);
 }
 
 std::unique_ptr<SyncScheduler> CryptAuthDeviceManager::CreateSyncScheduler() {
   return base::MakeUnique<SyncSchedulerImpl>(
       this, base::TimeDelta::FromHours(kRefreshPeriodHours),
       base::TimeDelta::FromMinutes(kDeviceSyncBaseRecoveryPeriodMinutes),
       kDeviceSyncMaxJitterRatio, "CryptAuth DeviceSync");
 }
 
 void CryptAuthDeviceManager::OnResyncMessage() {
@@ skipping 16 matching lines @@
       }
     } else {
       PA_LOG(ERROR) << "Can not get dictionary in list of unlock keys "
                     << "(index=" << i << "):\n" << *unlock_key_list;
     }
   }
 }
 
 void CryptAuthDeviceManager::OnSyncRequested(
     std::unique_ptr<SyncScheduler::SyncRequest> sync_request) {
-  FOR_EACH_OBSERVER(Observer, observers_, OnSyncStarted());
+  for (auto& observer : observers_)
+    observer.OnSyncStarted();
 
   sync_request_ = std::move(sync_request);
   cryptauth_client_ = client_factory_->CreateInstance();
 
   cryptauth::InvocationReason invocation_reason =
       cryptauth::INVOCATION_REASON_UNKNOWN;
 
   int reason_stored_in_prefs =
       pref_service_->GetInteger(prefs::kCryptAuthDeviceSyncReason);
 
@@ skipping 19 matching lines @@
   request.set_invocation_reason(invocation_reason);
   request.set_allow_stale_read(is_sync_speculative);
   cryptauth_client_->GetMyDevices(
       request, base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesSuccess,
                           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesFailure,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace proximity_auth