Replace FOR_EACH_OBSERVER in chromeos/ with range-based for

chromeos/audio/cras_audio_handler.cc

 // Copyright (c) 2013 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 "chromeos/audio/cras_audio_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 330 matching lines @@
 void CrasAudioHandler::SetOutputMono(bool mono_on) {
   output_mono_on_ = mono_on;
   if (mono_on) {
     chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
         SetGlobalOutputChannelRemix(output_channels_, kStereoToMono);
   } else {
     chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
         SetGlobalOutputChannelRemix(output_channels_, kStereoToStereo);
   }
 
-  FOR_EACH_OBSERVER(
-      AudioObserver, observers_,
-      OnOuputChannelRemixingChanged(mono_on));
+  for (auto& observer : observers_)
+    observer.OnOuputChannelRemixingChanged(mono_on);
 }
 
 bool CrasAudioHandler::IsOutputMonoEnabled() const {
   return output_mono_on_;
 }
 
 bool CrasAudioHandler::has_alternative_input() const {
   return has_alternative_input_;
 }
 
@@ skipping 42 matching lines @@
   // Save the mute state for all active output audio devices.
   for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
        it != audio_devices_.end();
        it++) {
     const AudioDevice& device = it->second;
     if (!device.is_input && device.active) {
       audio_pref_handler_->SetMuteValue(device, output_mute_on_);
     }
   }
 
-  FOR_EACH_OBSERVER(
-      AudioObserver, observers_,
-      OnOutputMuteChanged(output_mute_on_, false /* system_adjust */));
+  for (auto& observer : observers_)
+    observer.OnOutputMuteChanged(output_mute_on_, false /* system_adjust */);
 }
 
 void CrasAudioHandler::AdjustOutputVolumeToAudibleLevel() {
   if (output_volume_ <= kMuteThresholdPercent) {
     // Avoid the situation when sound has been unmuted, but the volume
     // is set to a very low value, so user still can't hear any sound.
     SetOutputVolumePercent(kDefaultUnmuteVolumePercent);
   }
 }
 
 void CrasAudioHandler::SetInputMute(bool mute_on) {
   SetInputMuteInternal(mute_on);
-  FOR_EACH_OBSERVER(AudioObserver, observers_,
-                    OnInputMuteChanged(input_mute_on_));
+  for (auto& observer : observers_)
+    observer.OnInputMuteChanged(input_mute_on_);
 }
 
 void CrasAudioHandler::SetActiveDevice(const AudioDevice& active_device,
                                        bool notify,
                                        DeviceActivateType activate_by) {
   if (active_device.is_input) {
     chromeos::DBusThreadManager::Get()
         ->GetCrasAudioClient()
         ->SetActiveInputNode(active_device.id);
   } else {
@@ skipping 197 matching lines @@
     }
   }
 
   if (std::find(automated_volume_change_reasons_.begin(),
                 automated_volume_change_reasons_.end(),
                 VOLUME_CHANGE_INITIALIZING_AUDIO_STATE) ==
       automated_volume_change_reasons_.end())
     initializing_audio_state_ = false;
 
   if (should_notify) {
-    FOR_EACH_OBSERVER(AudioObserver, observers_,
-                      OnOutputNodeVolumeChanged(node_id, volume));
+    for (auto& observer : observers_)
+      observer.OnOutputNodeVolumeChanged(node_id, volume);
   }
 }
 
 void CrasAudioHandler::ActiveOutputNodeChanged(uint64_t node_id) {
   if (active_output_node_id_ == node_id)
     return;
 
   // Active audio output device should always be changed by chrome.
   // During system boot, cras may change active input to unknown device 0x1,
   // we don't need to log it, since it is not an valid device.
@@ skipping 217 matching lines @@
 
   // NOTE: We do not sanitize input gain values since the range is completely
   // dependent on the device.
   if (active_input_node_id_ == node_id)
     input_gain_ = gain_percent;
 
   audio_pref_handler_->SetVolumeGainValue(*device, gain_percent);
 
   if (device->active) {
     SetInputNodeGain(node_id, gain_percent);
-    FOR_EACH_OBSERVER(AudioObserver, observers_,
-                      OnInputNodeGainChanged(node_id, gain_percent));
+    for (auto& observer : observers_)
+      observer.OnInputNodeGainChanged(node_id, gain_percent);
   }
 }
 
 void CrasAudioHandler::SetInputMuteInternal(bool mute_on) {
   input_mute_on_ = mute_on;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       SetInputMute(mute_on);
 }
 
 void CrasAudioHandler::GetNodes() {
@@ skipping 109 matching lines @@
     return CHANGED_DEVICE;
   } else if (device.active != device_found->active) {
     return CHANGED_DEVICE;
   }
 
   return OLD_DEVICE;
 }
 
 void CrasAudioHandler::NotifyActiveNodeChanged(bool is_input) {
   if (is_input)
-    FOR_EACH_OBSERVER(AudioObserver, observers_, OnActiveInputNodeChanged());
+    for (auto& observer : observers_)
+      observer.OnActiveInputNodeChanged();
   else
-    FOR_EACH_OBSERVER(AudioObserver, observers_, OnActiveOutputNodeChanged());
+    for (auto& observer : observers_)
+      observer.OnActiveOutputNodeChanged();
 }
 
 bool CrasAudioHandler::GetActiveDeviceFromUserPref(bool is_input,
                                                    AudioDevice* active_device) {
   bool found_active_device = false;
   bool last_active_device_activate_by_user = false;
   for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
        it != audio_devices_.end(); ++it) {
     AudioDevice device = it->second;
     if (device.is_input != is_input || !device.is_for_simple_usage())
@@ skipping 260 matching lines @@
 }
 
 void CrasAudioHandler::HandleGetNodes(const chromeos::AudioNodeList& node_list,
                                       bool success) {
   if (!success) {
     LOG_IF(ERROR, log_errors_) << "Failed to retrieve audio nodes data";
     return;
   }
 
   UpdateDevicesAndSwitchActive(node_list);
-  FOR_EACH_OBSERVER(AudioObserver, observers_, OnAudioNodesChanged());
+  for (auto& observer : observers_)
+    observer.OnAudioNodesChanged();
 }
 
 void CrasAudioHandler::HandleGetNodesError(const std::string& error_name,
                                            const std::string& error_msg) {
   LOG_IF(ERROR, log_errors_) << "Failed to call GetNodes: "
       << error_name  << ": " << error_msg;
 }
 
 void CrasAudioHandler::AddAdditionalActiveNode(uint64_t node_id, bool notify) {
   const AudioDevice* device = GetDeviceFromId(node_id);
@@ skipping 53 matching lines @@
 
 void CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod() {
   VLOG(1) << "HDMI output re-discover grace period ends.";
   hdmi_rediscovering_ = false;
   if (!IsOutputMutedForDevice(active_output_node_id_)) {
     // Unmute the audio output after the HDMI transition period.
     VLOG(1) << "Unmute output after HDMI rediscovering grace period.";
     SetOutputMuteInternal(false);
 
     // Notify UI about the mute state change.
-    FOR_EACH_OBSERVER(
-        AudioObserver, observers_,
-        OnOutputMuteChanged(output_mute_on_, true /* system adjustment */));
+    for (auto& observer : observers_) {
+      observer.OnOutputMuteChanged(output_mute_on_,
+                                   true /* system adjustment */);
+    }
   }
 }
 
 bool CrasAudioHandler::IsHDMIPrimaryOutputDevice() const {
   const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
   return (device && device->type == chromeos::AUDIO_TYPE_HDMI);
 }
 
 void CrasAudioHandler::StartHDMIRediscoverGracePeriod() {
   VLOG(1) << "Start HDMI rediscovering grace period.";
   hdmi_rediscovering_ = true;
   hdmi_rediscover_timer_.Stop();
   hdmi_rediscover_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(
                      hdmi_rediscover_grace_period_duration_in_ms_),
       this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod);
 }
 
 void CrasAudioHandler::SetHDMIRediscoverGracePeriodForTesting(
     int duration_in_ms) {
   hdmi_rediscover_grace_period_duration_in_ms_ = duration_in_ms;
 }
 
 }  // namespace chromeos