Reduce usage of FOR_EACH_OBSERVER macro in components/

components/pairing/bluetooth_host_pairing_controller.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/pairing/bluetooth_host_pairing_controller.h"
 
 #include "base/bind.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 110 matching lines @@
 scoped_refptr<device::BluetoothAdapter>
 BluetoothHostPairingController::GetAdapterForTesting() {
   return adapter_;
 }
 
 void BluetoothHostPairingController::ChangeStage(Stage new_stage) {
   if (current_stage_ == new_stage)
     return;
   VLOG(1) << "ChangeStage " << new_stage;
   current_stage_ = new_stage;
-  FOR_EACH_OBSERVER(Observer, observers_, PairingStageChanged(new_stage));
+  for (Observer& observer : observers_)
+    observer.PairingStageChanged(new_stage);
 }
 
 void BluetoothHostPairingController::SendHostStatus() {
   pairing_api::HostStatus host_status;
 
   host_status.set_api_version(kPairingAPIVersion);
   if (!enrollment_domain_.empty())
     host_status.mutable_parameters()->set_domain(enrollment_domain_);
   if (!permanent_id_.empty())
     host_status.mutable_parameters()->set_permanent_id(permanent_id_);
@@ skipping 235 matching lines @@
 }
 
 void BluetoothHostPairingController::OnHostStatusMessage(
     const pairing_api::HostStatus& message) {
   NOTREACHED();
 }
 
 void BluetoothHostPairingController::OnConfigureHostMessage(
     const pairing_api::ConfigureHost& message) {
   ChangeStage(STAGE_SETUP_BASIC_CONFIGURATION);
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    ConfigureHostRequested(
-                        message.parameters().accepted_eula(),
-                        message.parameters().lang(),
-                        message.parameters().timezone(),
-                        message.parameters().send_reports(),
-                        message.parameters().keyboard_layout()));
+  for (Observer& observer : observers_) {
+    observer.ConfigureHostRequested(
+        message.parameters().accepted_eula(), message.parameters().lang(),
+        message.parameters().timezone(), message.parameters().send_reports(),
+        message.parameters().keyboard_layout());
+  }
 }
 
 void BluetoothHostPairingController::OnPairDevicesMessage(
     const pairing_api::PairDevices& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   enrollment_domain_ = message.parameters().enrolling_domain();
   ChangeStage(STAGE_ENROLLING);
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    EnrollHostRequested(
-                        message.parameters().admin_access_token()));
+  for (Observer& observer : observers_)
+    observer.EnrollHostRequested(message.parameters().admin_access_token());
 }
 
 void BluetoothHostPairingController::OnCompleteSetupMessage(
     const pairing_api::CompleteSetup& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (current_stage_ != STAGE_ENROLLMENT_SUCCESS) {
     ChangeStage(STAGE_ENROLLMENT_ERROR);
   } else {
     // TODO(zork): Handle adding another controller. (http://crbug.com/405757)
     ChangeStage(STAGE_FINISHED);
   }
   Reset();
 }
 
 void BluetoothHostPairingController::OnErrorMessage(
     const pairing_api::Error& message) {
   NOTREACHED();
 }
 
 void BluetoothHostPairingController::OnAddNetworkMessage(
     const pairing_api::AddNetwork& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    AddNetworkRequested(message.parameters().onc_spec()));
+  for (Observer& observer : observers_)
+    observer.AddNetworkRequested(message.parameters().onc_spec());
 }
 
 void BluetoothHostPairingController::AdapterPresentChanged(
     device::BluetoothAdapter* adapter,
     bool present) {
   DCHECK_EQ(adapter, adapter_.get());
   if (present) {
     adapter_->RemoveObserver(this);
     SetName();
   }
@@ skipping 119 matching lines @@
   ChangeStage(STAGE_WAITING_FOR_CODE_CONFIRMATION);
 }
 
 void BluetoothHostPairingController::AuthorizePairing(
     device::BluetoothDevice* device) {
   // Disallow unknown device.
   device->RejectPairing();
 }
 
 }  // namespace pairing_chromeos