Reduce usage of FOR_EACH_OBSERVER macro in content/

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.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 "content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 108 matching lines @@
 std::set<BluetoothUUID> GetUUIDs(
     const device::BluetoothDiscoveryFilter* filter) {
   std::set<BluetoothUUID> result;
   filter->GetUUIDs(result);
   return result;
 }
 
 // Notifies the adapter's observers for each device id the adapter.
 void NotifyDevicesAdded(MockBluetoothAdapter* adapter) {
   for (BluetoothDevice* device : adapter->GetMockDevices()) {
-    FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
-                      DeviceAdded(adapter, device));
+    for (auto& observer : adapter->GetObservers())
+      observer.DeviceAdded(adapter, device);
   }
 }
 
 // Notifies the adapter's observers that the services have been discovered.
 void NotifyServicesDiscovered(MockBluetoothAdapter* adapter,
                               MockBluetoothDevice* device) {
-  FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
-                    GattServicesDiscovered(adapter, device));
+  for (auto& observer : adapter->GetObservers())
+    observer.GattServicesDiscovered(adapter, device);
 }
 
 // Notifies the adapter's observers that a device has changed.
 void NotifyDeviceChanged(MockBluetoothAdapter* adapter,
                          MockBluetoothDevice* device) {
-  FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
-                    DeviceChanged(adapter, device));
+  for (auto& observer : adapter->GetObservers())
+    observer.DeviceChanged(adapter, device);
 }
 
 }  // namespace
 
 namespace content {
 
 // static
 scoped_refptr<BluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetBluetoothAdapter(
     const std::string& fake_adapter_name) {
@@ skipping 200 matching lines @@
 
   return adapter;
 }
 
 // Adds a device to |adapter| and notifies all observers about that new device.
 // Mocks can call this asynchronously to cause changes in the middle of a test.
 static void AddDevice(scoped_refptr<NiceMockBluetoothAdapter> adapter,
                       std::unique_ptr<NiceMockBluetoothDevice> new_device) {
   NiceMockBluetoothDevice* new_device_ptr = new_device.get();
   adapter->AddMockDevice(std::move(new_device));
-  FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
-                    DeviceAdded(adapter.get(), new_device_ptr));
+  for (auto& observer : adapter->GetObservers())
+    observer.DeviceAdded(adapter.get(), new_device_ptr);
 }
 
 static void RemoveDevice(scoped_refptr<NiceMockBluetoothAdapter> adapter,
                          const std::string& device_address) {
   std::unique_ptr<MockBluetoothDevice> removed_device =
       adapter->RemoveMockDevice(device_address);
-  FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
-                    DeviceRemoved(adapter.get(), removed_device.get()));
+  for (auto& observer : adapter->GetObservers())
+    observer.DeviceRemoved(adapter.get(), removed_device.get());
 }
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetSecondDiscoveryFindsHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
   NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
 
   EXPECT_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillOnce(RunCallbackWithResult<1 /* success_callback */>(
           []() { return GetDiscoverySession(); }))
@@ skipping 343 matching lines @@
   std::unique_ptr<NiceMockBluetoothGattCharacteristic>
       disconnection_characteristic(GetBaseGATTCharacteristic(
           "Disconnection Characteristic", disconnection_service.get(),
           kRequestDisconnectionCharacteristicUUID,
           BluetoothRemoteGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE));
   ON_CALL(*disconnection_characteristic, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(Invoke([adapter_ptr, device_ptr](
           const std::vector<uint8_t>& value, const base::Closure& success,
           const BluetoothRemoteGattCharacteristic::ErrorCallback& error) {
         device_ptr->SetConnected(false);
-        FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
-                          adapter_ptr->GetObservers(),
-                          DeviceChanged(adapter_ptr, device_ptr));
+        for (auto& observer : adapter_ptr->GetObservers())
+          observer.DeviceChanged(adapter_ptr, device_ptr);
         success.Run();
       }));
 
   disconnection_service->AddMockCharacteristic(
       std::move(disconnection_characteristic));
   device->AddMockService(std::move(disconnection_service));
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
@@ skipping 450 matching lines @@
   BluetoothRemoteGattCharacteristic* location_chest_ptr =
       body_sensor_location_chest.get();
 
   ON_CALL(*body_sensor_location_chest, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, location_chest_ptr]() {
             std::vector<uint8_t> location(1 /* size */);
             location[0] = 1;  // Chest
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
-            FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
-                              adapter->GetObservers(),
-                              GattCharacteristicValueChanged(
-                                  adapter, location_chest_ptr, location));
+            for (auto& observer : adapter->GetObservers()) {
+              observer.GattCharacteristicValueChanged(
+                  adapter, location_chest_ptr, location);
+            }
             return location;
           }));
 
   // Body Sensor Location Characteristic (Wrist)
   std::unique_ptr<NiceMockBluetoothGattCharacteristic>
       body_sensor_location_wrist(GetBaseGATTCharacteristic(
           "Body Sensor Location Wrist", heart_rate.get(), kBodySensorLocation,
           BluetoothRemoteGattCharacteristic::PROPERTY_READ));
   BluetoothRemoteGattCharacteristic* location_wrist_ptr =
       body_sensor_location_wrist.get();
 
   ON_CALL(*body_sensor_location_wrist, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, location_wrist_ptr]() {
             std::vector<uint8_t> location(1 /* size */);
             location[0] = 2;  // Wrist
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
-            FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
-                              adapter->GetObservers(),
-                              GattCharacteristicValueChanged(
-                                  adapter, location_wrist_ptr, location));
+            for (auto& observer : adapter->GetObservers()) {
+              observer.GattCharacteristicValueChanged(
+                  adapter, location_wrist_ptr, location);
+            }
             return location;
           }));
 
   heart_rate->AddMockCharacteristic(std::move(heart_rate_measurement));
   heart_rate->AddMockCharacteristic(std::move(body_sensor_location_chest));
   heart_rate->AddMockCharacteristic(std::move(body_sensor_location_wrist));
 
   return heart_rate;
 }
 
@@ skipping 130 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content