Remove usage of FOR_EACH_OBSERVER macro in device/

device/bluetooth/bluetooth_adapter_win.cc

 // Copyright (c) 2012 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 "device/bluetooth/bluetooth_adapter_win.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 110 matching lines @@
     else
       ui_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&RunDiscoverySessionErrorCallback, callbacks.second,
                      UMABluetoothDiscoverySessionOutcome::UNKNOWN));
   }
   num_discovery_listeners_ = on_start_discovery_callbacks_.size();
   on_start_discovery_callbacks_.clear();
 
   if (success) {
-    FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
-                      AdapterDiscoveringChanged(this, true));
+    for (auto& observer : observers_)
+      observer.AdapterDiscoveringChanged(this, true);
 
     // If there are stop discovery requests, post the stop discovery again.
     MaybePostStopDiscoveryTask();
   } else if (!on_stop_discovery_callbacks_.empty()) {
     // If there are stop discovery requests but start discovery has failed,
     // notify that stop discovery has been complete.
     DiscoveryStopped();
   }
 }
 
 void BluetoothAdapterWin::DiscoveryStopped() {
   discovered_devices_.clear();
   bool was_discovering = IsDiscovering();
   discovery_status_ = NOT_DISCOVERING;
   for (std::vector<base::Closure>::const_iterator iter =
            on_stop_discovery_callbacks_.begin();
        iter != on_stop_discovery_callbacks_.end();
        ++iter) {
     ui_task_runner_->PostTask(FROM_HERE, *iter);
   }
   num_discovery_listeners_ = 0;
   on_stop_discovery_callbacks_.clear();
   if (was_discovering)
-    FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
-                      AdapterDiscoveringChanged(this, false));
+    for (auto& observer : observers_)
+      observer.AdapterDiscoveringChanged(this, false);
 
   // If there are start discovery requests, post the start discovery again.
   MaybePostStartDiscoveryTask();
 }
 
 BluetoothAdapter::UUIDList BluetoothAdapterWin::GetUUIDs() const {
   NOTIMPLEMENTED();
   return UUIDList();
 }
 
@@ skipping 37 matching lines @@
 }
 
 void BluetoothAdapterWin::AdapterStateChanged(
     const BluetoothTaskManagerWin::AdapterState& state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   name_ = state.name;
   bool was_present = IsPresent();
   bool is_present = !state.address.empty();
   address_ = BluetoothDevice::CanonicalizeAddress(state.address);
   if (was_present != is_present) {
-    FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
-                      AdapterPresentChanged(this, is_present));
+    for (auto& observer : observers_)
+      observer.AdapterPresentChanged(this, is_present);
   }
   if (powered_ != state.powered) {
     powered_ = state.powered;
-    FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
-                      AdapterPoweredChanged(this, powered_));
+    for (auto& observer : observers_)
+      observer.AdapterPoweredChanged(this, powered_);
   }
   if (!initialized_) {
     initialized_ = true;
     init_callback_.Run();
   }
 }
 
 void BluetoothAdapterWin::DevicesPolled(
     const ScopedVector<BluetoothTaskManagerWin::DeviceState>& devices) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 19 matching lines @@
   }
 
   // Process device removal first
   DeviceAddressSet removed_devices =
       base::STLSetDifference<DeviceAddressSet>(known_devices, new_devices);
   for (DeviceAddressSet::const_iterator iter = removed_devices.begin();
        iter != removed_devices.end();
        ++iter) {
     std::unique_ptr<BluetoothDevice> device_win =
         devices_.take_and_erase(*iter);
-    FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
-                      DeviceRemoved(this, device_win.get()));
+    for (auto& observer : observers_)
+      observer.DeviceRemoved(this, device_win.get());
   }
 
   // Process added and (maybe) changed devices in one pass
   DeviceAddressSet added_devices =
       base::STLSetDifference<DeviceAddressSet>(new_devices, known_devices);
   DeviceAddressSet changed_devices =
       base::STLSetIntersection<DeviceAddressSet>(known_devices, new_devices);
   for (ScopedVector<BluetoothTaskManagerWin::DeviceState>::const_iterator iter =
            devices.begin();
        iter != devices.end();
        ++iter) {
     BluetoothTaskManagerWin::DeviceState* device_state = (*iter);
     if (added_devices.find(device_state->address) != added_devices.end()) {
       BluetoothDeviceWin* device_win =
           new BluetoothDeviceWin(this, *device_state, ui_task_runner_,
                                  socket_thread_, NULL, net::NetLogSource());
       devices_.set(device_state->address,
                    std::unique_ptr<BluetoothDevice>(device_win));
-      FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
-                        observers_,
-                        DeviceAdded(this, device_win));
+      for (auto& observer : observers_)
+        observer.DeviceAdded(this, device_win);
     } else if (changed_devices.find(device_state->address) !=
                changed_devices.end()) {
       DevicesMap::const_iterator iter = devices_.find(device_state->address);
       DCHECK(iter != devices_.end());
       BluetoothDeviceWin* device_win =
           static_cast<BluetoothDeviceWin*>(iter->second);
       if (!device_win->IsEqual(*device_state)) {
         device_win->Update(*device_state);
-        FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
-                          DeviceChanged(this, device_win));
+        for (auto& observer : observers_)
+          observer.DeviceChanged(this, device_win);
       }
       // Above IsEqual returns true if device name, address, status and services
       // (primary services of BLE device) are the same. However, in BLE tests,
       // we may simulate characteristic, descriptor and secondary GATT service
       // after device has been initialized.
       if (force_update_device_for_test_)
         device_win->Update(*device_state);
     }
   }
 }
@@ skipping 77 matching lines @@
     num_discovery_listeners_ -= on_stop_discovery_callbacks_.size();
     on_stop_discovery_callbacks_.clear();
     return;
   }
 
   discovery_status_ = DISCOVERY_STOPPING;
   task_manager_->PostStopDiscoveryTask();
 }
 
 }  // namespace device