Adds Media.Audio.InputDevicePropertyChangedMac UMA stat on Mac

media/audio/mac/audio_low_latency_input_mac.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 "media/audio/mac/audio_low_latency_input_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
@@ skipping 40 matching lines @@
      << "frames per packet : " << format.mFramesPerPacket << std::endl
      << "bytes per frame   : " << format.mBytesPerFrame << std::endl
      << "channels per frame: " << format.mChannelsPerFrame << std::endl
      << "bits per channel  : " << format.mBitsPerChannel << std::endl
      << "reserved          : " << format.mReserved << std::endl
      << "interleaved       : "
      << (FormatIsInterleaved(format.mFormatFlags) ? "yes" : "no");
   return os;
 }
 
+// Property address to monitor device changes. Use wildcards to match any and
+// all values for their associated type. Filtering for device-specific
+// notifications will take place in the callback.
+const AudioObjectPropertyAddress
+    AUAudioInputStream::kDeviceChangePropertyAddress = {
+        kAudioObjectPropertySelectorWildcard, kAudioObjectPropertyScopeWildcard,
+        kAudioObjectPropertyElementWildcard};
+
+// TODO(henrika): add comments...
+enum AudioDevicePropertyResult {
+  PROPERTY_DEVICE_HAS_CHANGED = 0,
+  PROPERTY_IO_STOPPED_ABNORMALLY = 1,

[o1ka, 2016/02/18 13:46:23]

I would not assign values to any but the first one - just to avoid somebody
following this style and assigning the same number multiple times.

[henrika (OOO until Aug 14), 2016/02/18 15:58:03]

This style is used all over Chrome in combination with UMA histograms. I have
been advices to use it before. See e.g.
https://code.google.com/p/chromium/codesearch#chromium/src/ui/gl/gl_surface_e...
or search for UMA_HISTOGRAM_ENUMERATION and you will find many examples.

[o1ka, 2016/02/18 16:54:30]

Thank you for the info, will save me some time in the future reviews :)

[henrika (OOO until Aug 14), 2016/02/19 12:46:11]

Acknowledged.

+  PROPERTY_HOG_MODE = 2,
+  PROPERTY_BUFFER_FRAME_SIZE = 3,
+  PROPERTY_BUFFER_FRAME_SIZE_RANGE = 4,
+  PROPERTY_STREAM_CONFIGURATION = 5,
+  PROPERTY_ACTUAL_SAMPLE_RATE = 6,
+  PROPERTY_NOMINAL_SAMPLE_RATE = 7,
+  PROPERTY_DEVICE_IS_RUNNING_SOMEWHERE = 8,
+  PROPERTY_DEVICE_IS_RUNNING = 9,
+  PROPERTY_DEVICE_IS_ALIVE = 10,
+  PROPERTY_MAX = PROPERTY_DEVICE_IS_ALIVE
+};
+
+// TODO(henrika): add comments...
+static void LogDevicePropertyChange(AudioDevicePropertyResult result) {
+  UMA_HISTOGRAM_ENUMERATION("Media.Audio.InputDevicePropertyChangedMac", result,
+                            PROPERTY_MAX + 1);
+}
+
 static OSStatus GetInputDeviceStreamFormat(
     AudioUnit audio_unit,
     AudioStreamBasicDescription* format) {
   DCHECK(audio_unit);
   UInt32 property_size = sizeof(*format);
   // Get the audio stream data format on the input scope of the input element
   // since it is connected to the current input device.
   OSStatus result =
       AudioUnitGetProperty(audio_unit, kAudioUnitProperty_StreamFormat,
                            kAudioUnitScope_Input, 1, format, &property_size);
@@ skipping 15 matching lines @@
       audio_unit_(0),
       input_device_id_(audio_device_id),
       hardware_latency_frames_(0),
       number_of_channels_in_frame_(0),
       fifo_(input_params.channels(),
             number_of_frames_,
             kNumberOfBlocksBufferInFifo),
       input_callback_is_active_(false),
       start_was_deferred_(false),
       buffer_size_was_changed_(false),
-      audio_unit_render_has_worked_(false) {
+      audio_unit_render_has_worked_(false),
+      device_listener_is_active_(false) {
   DCHECK(manager_);
 
   // Set up the desired (output) format specified by the client.
   format_.mSampleRate = input_params.sample_rate();
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
   DCHECK(FormatIsInterleaved(format_.mFormatFlags));
   format_.mBitsPerChannel = input_params.bits_per_sample();
   format_.mChannelsPerFrame = input_params.channels();
@@ skipping 21 matching lines @@
   audio_buffer_list_.mNumberBuffers = 1;
 
   AudioBuffer* audio_buffer = audio_buffer_list_.mBuffers;
   audio_buffer->mNumberChannels = input_params.channels();
   audio_buffer->mDataByteSize = data_byte_size;
   audio_buffer->mData = audio_data_buffer_.get();
 }
 
 AUAudioInputStream::~AUAudioInputStream() {
   DVLOG(1) << "~dtor";
+  DeRegisterDeviceChangeListener();
 }
 
 // Obtain and open the AUHAL AudioOutputUnit for recording.
 bool AUAudioInputStream::Open() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "Open";
   DCHECK(!audio_unit_);
 
   // Verify that we have a valid device. Send appropriate error code to
   // HandleError() to ensure that the error type is added to UMA stats.
   if (input_device_id_ == kAudioObjectUnknown) {
     NOTREACHED() << "Device ID is unknown";
     HandleError(kAudioUnitErr_InvalidElement);
     return false;
   }
 
+  RegisterDeviceChangeListener();
+
   // The requested sample-rate must match the hardware sample-rate.
   int sample_rate =
       AudioManagerMac::HardwareSampleRateForDevice(input_device_id_);
   DCHECK_EQ(sample_rate, format_.mSampleRate);
 
   // Start by obtaining an AudioOuputUnit using an AUHAL component description.
 
   // Description for the Audio Unit we want to use (AUHAL in this case).
   // The kAudioUnitSubType_HALOutput audio unit interfaces to any audio device.
   // The user specifies which audio device to track. The audio unit can do
@@ skipping 257 matching lines @@
 
 void AUAudioInputStream::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "Close";
   // It is valid to call Close() before calling open or Start().
   // It is also valid to call Close() after Start() has been called.
   if (IsRunning()) {
     Stop();
   }
   CloseAudioUnit();
+  DeRegisterDeviceChangeListener();
   // Inform the audio manager that we have been closed. This will cause our
   // destruction.
   manager_->ReleaseInputStream(this);
 }
 
 double AUAudioInputStream::GetMaxVolume() {
   // Verify that we have a valid device.
   if (input_device_id_ == kAudioObjectUnknown) {
     NOTREACHED() << "Device ID is unknown";
     return 0.0;
@@ skipping 164 matching lines @@
     UInt32 bus_number,
     UInt32 number_of_frames) {
   // Indicate that input callbacks have started on the internal AUHAL IO
   // thread. The |input_callback_is_active_| member is read from the creating
   // thread when a timer fires once and set to false in Stop() on the same
   // thread. It means that this thread is the only writer of
   // |input_callback_is_active_| once the tread starts and it should therefore
   // be safe to modify.
   SetInputCallbackIsActive(true);
 
+  // We are only interested in device property changes in combination with
+  // failing input callbacks. Hence, might as well disable the listener now.
+  DeRegisterDeviceChangeListener();
+
   // Update the |mDataByteSize| value in the audio_buffer_list() since
   // |number_of_frames| can be changed on the fly.
   // |mDataByteSize| needs to be exactly mapping to |number_of_frames|,
   // otherwise it will put CoreAudio into bad state and results in
   // AudioUnitRender() returning -50 for the new created stream.
   // We have also seen kAudioUnitErr_TooManyFramesToProcess (-10874) and
   // kAudioUnitErr_CannotDoInCurrentContext (-10863) as error codes.
   // See crbug/428706 for details.
   UInt32 new_size = number_of_frames * format_.mBytesPerFrame;
   AudioBuffer* audio_buffer = audio_buffer_list_.mBuffers;
@@ skipping 118 matching lines @@
     DCHECK_EQ(audio_bus->frames(), static_cast<int>(number_of_frames_));
 
     // Compensate the audio delay caused by the FIFO.
     capture_delay_bytes += fifo_.GetAvailableFrames() * format_.mBytesPerFrame;
     sink_->OnData(this, audio_bus, capture_delay_bytes, normalized_volume);
   }
 
   return noErr;
 }
 
+OSStatus AUAudioInputStream::OnDevicePropertyChanged(

[o1ka, 2016/02/18 13:46:22]

Can there be a race between this call and deregistering |this| as a listener in
the destructor?

[henrika (OOO until Aug 14), 2016/02/18 15:58:03]

The call in the destructor is invalid (not needed) since we dereg in Close and
Close is responsible for the destruction. Will add a DCHECK just in case.

+    AudioObjectID object_id,
+    UInt32 num_addresses,
+    const AudioObjectPropertyAddress addresses[],
+    void* context) {
+  AUAudioInputStream* self = static_cast<AUAudioInputStream*>(context);
+  return self->DevicePropertyChanged(object_id, num_addresses, addresses);
+}
+
+OSStatus AUAudioInputStream::DevicePropertyChanged(
+    AudioObjectID object_id,
+    UInt32 num_addresses,
+    const AudioObjectPropertyAddress addresses[]) {
+  if (object_id != input_device_id_)
+    return noErr;
+
+  // Listeners will be called when possibly many properties have changed.

[o1ka, 2016/02/18 13:46:22]

Can the same listener be called concurrently?

[henrika (OOO until Aug 14), 2016/02/18 15:58:03]

The documentation does not say anything about that actually. Did some tests and
it seems like different types of callbacks can come from different threads (as
if some sort of thread pool was used). However, these callbacks simply must be
serialized somehow by the system and I have not found any example that uses
locks to make this method reentrant. 

+  // Consequently, the implementation of a listener must go through the array of
+  // addresses to see what exactly has changed.
+  for (UInt32 i = 0; i < num_addresses; ++i) {
+    const UInt32 property = addresses[i].mSelector;
+    switch (property) {
+      // Filter out and store certain property values provided by the
+      // AudioDevice class.
+      case kAudioDevicePropertyDeviceHasChanged:

[o1ka, 2016/02/18 13:46:22]

I would say that having both 'switch' and map is a bit of overkill, and having
switch in two places makes it a bit difficult to maintain without introducing
bugs. I would either store counters in an array by |PROPERTY_..| index and
update them here in a 'switch', or store everything in a map without using
'switch' here, and select what I'm interested in during
AddDevicePropertyChangesToUMA().

[henrika (OOO until Aug 14), 2016/02/18 15:58:03]

Great comment, thanks. Will add all to the map and filter at a later stage.

+      case kAudioDevicePropertyIOStoppedAbnormally:
+      case kAudioDevicePropertyHogMode:
+      case kAudioDevicePropertyBufferFrameSize:
+      case kAudioDevicePropertyBufferFrameSizeRange:
+      case kAudioDevicePropertyStreamConfiguration:
+      case kAudioDevicePropertyActualSampleRate:
+      case kAudioDevicePropertyNominalSampleRate:
+      case kAudioDevicePropertyDeviceIsRunningSomewhere:
+      case kAudioDevicePropertyDeviceIsRunning:
+      case kAudioDevicePropertyDeviceIsAlive:
+        // Use selector as key to a map and increase its value.
+        device_property_changes_map_[property]++;
+        break;
+      default:
+        // TODO(henrika): figure out if more property changes should be tracked.
+        DVLOG(1) << "No action for kAudioDeviceProperty: " << property;
+        break;
+    }
+  }
+  return noErr;
+}
+
+void AUAudioInputStream::RegisterDeviceChangeListener() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "RegisterDeviceChangeListener";
+  if (input_device_id_ == kAudioObjectUnknown)
+    return;
+
+  device_property_changes_map_.clear();
+
+  OSStatus result = AudioObjectAddPropertyListener(
+      input_device_id_, &kDeviceChangePropertyAddress,
+      &AUAudioInputStream::OnDevicePropertyChanged, this);
+  OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
+      << "AudioObjectAddPropertyListener() failed!";
+  SetDeviceListenerIsActive(result == noErr);
+}
+
+void AUAudioInputStream::DeRegisterDeviceChangeListener() {
+  if (!GetDeviceListenerIsActive())
+    return;
+  DVLOG(1) << "DeRegisterDeviceChangeListener";
+  if (input_device_id_ == kAudioObjectUnknown)
+    return;
+  OSStatus result = AudioObjectRemovePropertyListener(

[o1ka, 2016/02/18 13:46:23]

Is it safe to call it second time if the first attempt failed?

[henrika (OOO until Aug 14), 2016/02/18 15:58:03]

I don't know since I've never been able to make the first call fail. Feels
unsafe to do so. Agree?

[o1ka, 2016/02/18 16:54:30]

Yes, I have the same feeling. In this case, it should be
SetDeviceListenerIsActive(false) before the call, I believe

[henrika (OOO until Aug 14), 2016/02/19 12:46:12]

Done.

+      input_device_id_, &kDeviceChangePropertyAddress,
+      &AUAudioInputStream::OnDevicePropertyChanged, this);
+  OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
+      << "AudioObjectRemovePropertyListener() failed!";
+  SetDeviceListenerIsActive(!(result == noErr));
+}
+
 int AUAudioInputStream::HardwareSampleRate() {
   // Determine the default input device's sample-rate.
   AudioDeviceID device_id = kAudioObjectUnknown;
   UInt32 info_size = sizeof(device_id);
 
   AudioObjectPropertyAddress default_input_device_address = {
-    kAudioHardwarePropertyDefaultInputDevice,
-    kAudioObjectPropertyScopeGlobal,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
   OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
-                                               &default_input_device_address,
-                                               0,
-                                               0,
-                                               &info_size,
-                                               &device_id);
+                                               &default_input_device_address, 0,
+                                               0, &info_size, &device_id);
   if (result != noErr)
     return 0.0;
 
   Float64 nominal_sample_rate;
   info_size = sizeof(nominal_sample_rate);
 
   AudioObjectPropertyAddress nominal_sample_rate_address = {
-    kAudioDevicePropertyNominalSampleRate,
-    kAudioObjectPropertyScopeGlobal,
-    kAudioObjectPropertyElementMaster
-  };
-  result = AudioObjectGetPropertyData(device_id,
-                                      &nominal_sample_rate_address,
-                                      0,
-                                      0,
-                                      &info_size,
-                                      &nominal_sample_rate);
+      kAudioDevicePropertyNominalSampleRate, kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster};
+  result = AudioObjectGetPropertyData(device_id, &nominal_sample_rate_address,
+                                      0, 0, &info_size, &nominal_sample_rate);
   if (result != noErr)
     return 0.0;
 
   return static_cast<int>(nominal_sample_rate);
 }
 
 double AUAudioInputStream::GetHardwareLatency() {
   if (!audio_unit_ || input_device_id_ == kAudioObjectUnknown) {
     DLOG(WARNING) << "Audio unit object is NULL or device ID is unknown";
     return 0.0;
   }
 
   // Get audio unit latency.
   Float64 audio_unit_latency_sec = 0.0;
   UInt32 size = sizeof(audio_unit_latency_sec);
-  OSStatus result = AudioUnitGetProperty(audio_unit_,
-                                         kAudioUnitProperty_Latency,
-                                         kAudioUnitScope_Global,
-                                         0,
-                                         &audio_unit_latency_sec,
-                                         &size);
+  OSStatus result = AudioUnitGetProperty(
+      audio_unit_, kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0,
+      &audio_unit_latency_sec, &size);
   OSSTATUS_DLOG_IF(WARNING, result != noErr, result)
       << "Could not get audio unit latency";
 
   // Get input audio device latency.
   AudioObjectPropertyAddress property_address = {
-    kAudioDevicePropertyLatency,
-    kAudioDevicePropertyScopeInput,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyLatency, kAudioDevicePropertyScopeInput,
+      kAudioObjectPropertyElementMaster};
   UInt32 device_latency_frames = 0;
   size = sizeof(device_latency_frames);
   result = AudioObjectGetPropertyData(input_device_id_, &property_address, 0,
                                       nullptr, &size, &device_latency_frames);
   DLOG_IF(WARNING, result != noErr) << "Could not get audio device latency.";
 
-  return static_cast<double>((audio_unit_latency_sec *
-      format_.mSampleRate) + device_latency_frames);
+  return static_cast<double>((audio_unit_latency_sec * format_.mSampleRate) +
+                             device_latency_frames);
 }
 
 double AUAudioInputStream::GetCaptureLatency(
     const AudioTimeStamp* input_time_stamp) {
   // Get the delay between between the actual recording instant and the time
   // when the data packet is provided as a callback.
-  UInt64 capture_time_ns = AudioConvertHostTimeToNanos(
-      input_time_stamp->mHostTime);
+  UInt64 capture_time_ns =
+      AudioConvertHostTimeToNanos(input_time_stamp->mHostTime);
   UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
-  double delay_frames = static_cast<double>
-      (1e-9 * (now_ns - capture_time_ns) * format_.mSampleRate);
+  double delay_frames = static_cast<double>(1e-9 * (now_ns - capture_time_ns) *
+                                            format_.mSampleRate);
 
   // Total latency is composed by the dynamic latency and the fixed
   // hardware latency.
   return (delay_frames + hardware_latency_frames_);
 }
 
 int AUAudioInputStream::GetNumberOfChannelsFromStream() {
   // Get the stream format, to be able to read the number of channels.
   AudioObjectPropertyAddress property_address = {
-    kAudioDevicePropertyStreamFormat,
-    kAudioDevicePropertyScopeInput,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyStreamFormat, kAudioDevicePropertyScopeInput,
+      kAudioObjectPropertyElementMaster};
   AudioStreamBasicDescription stream_format;
   UInt32 size = sizeof(stream_format);
   OSStatus result = AudioObjectGetPropertyData(
       input_device_id_, &property_address, 0, nullptr, &size, &stream_format);
   if (result != noErr) {
     DLOG(WARNING) << "Could not get stream format";
     return 0;
   }
 
   return static_cast<int>(stream_format.mChannelsPerFrame);
@@ skipping 12 matching lines @@
       << "AudioUnitGetProperty(kAudioOutputUnitProperty_IsRunning) failed";
   return (error == noErr && is_running);
 }
 
 void AUAudioInputStream::HandleError(OSStatus err) {
   // Log the latest OSStatus error message and also change the sign of the
   // error if no callbacks are active. I.e., the sign of the error message
   // carries one extra level of information.
   UMA_HISTOGRAM_SPARSE_SLOWLY("Media.InputErrorMac",
                               GetInputCallbackIsActive() ? err : (err * -1));
-  NOTREACHED() << "error " << GetMacOSStatusErrorString(err)
-               << " (" << err << ")";
+  NOTREACHED() << "error " << GetMacOSStatusErrorString(err) << " (" << err
+               << ")";
   if (sink_)
     sink_->OnError(this);
 }
 
 bool AUAudioInputStream::IsVolumeSettableOnChannel(int channel) {
   Boolean is_settable = false;
   AudioObjectPropertyAddress property_address = {
-    kAudioDevicePropertyVolumeScalar,
-    kAudioDevicePropertyScopeInput,
-    static_cast<UInt32>(channel)
-  };
-  OSStatus result = AudioObjectIsPropertySettable(input_device_id_,
-                                                  &property_address,
-                                                  &is_settable);
+      kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeInput,
+      static_cast<UInt32>(channel)};
+  OSStatus result = AudioObjectIsPropertySettable(
+      input_device_id_, &property_address, &is_settable);
   return (result == noErr) ? is_settable : false;
 }
 
 void AUAudioInputStream::SetInputCallbackIsActive(bool enabled) {
   base::subtle::Release_Store(&input_callback_is_active_, enabled);
 }
 
 bool AUAudioInputStream::GetInputCallbackIsActive() {
   return (base::subtle::Acquire_Load(&input_callback_is_active_) != false);
 }
 
+void AUAudioInputStream::SetDeviceListenerIsActive(bool enabled) {
+  base::subtle::Release_Store(&device_listener_is_active_, enabled);
+}
+
+bool AUAudioInputStream::GetDeviceListenerIsActive() {
+  return (base::subtle::Acquire_Load(&device_listener_is_active_) != false);
+}
+
 void AUAudioInputStream::CheckInputStartupSuccess() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  // Remove the observer for changes in device properties. The notifier is
+  // currently only used to track down events that might lead to failure in
+  // starting input audio. Don't keep the observer alive longer than needed.
+  DeRegisterDeviceChangeListener();
   // Only add UMA stat related to failing input audio for streams where
   // the AGC has been enabled, e.g. WebRTC audio input streams.
   if (IsRunning() && GetAutomaticGainControl()) {
     // Check if we have called Start() and input callbacks have actually
     // started in time as they should. If that is not the case, we have a
     // problem and the stream is considered dead.
     const bool input_callback_is_active = GetInputCallbackIsActive();
     UMA_HISTOGRAM_BOOLEAN("Media.Audio.InputStartupSuccessMac",
                           input_callback_is_active);
     DVLOG(1) << "input_callback_is_active: " << input_callback_is_active;
@@ skipping 24 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.InputStartWasDeferredMac",
                         start_was_deferred_);
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.InputBufferSizeWasChangedMac",
                         buffer_size_was_changed_);
   UMA_HISTOGRAM_COUNTS_1000("Media.Audio.NumberOfOutputStreamsMac",
                             manager_->output_streams());
   UMA_HISTOGRAM_COUNTS_1000("Media.Audio.NumberOfLowLatencyInputStreamsMac",
                             manager_->low_latency_input_streams());
   UMA_HISTOGRAM_COUNTS_1000("Media.Audio.NumberOfBasicInputStreamsMac",
                             manager_->basic_input_streams());
-  // |number_of_frames_| is set at construction and corresponds to the requested
-  // (by the client) number of audio frames per I/O buffer connected to the
-  // selected input device. Ideally, this size will be the same as the native
-  // I/O buffer size given by |io_buffer_frame_size_|.
+  // |number_of_frames_| is set at construction and corresponds to the
+  // requested (by the client) number of audio frames per I/O buffer connected
+  // to the selected input device. Ideally, this size will be the same as the
+  // native I/O buffer size given by |io_buffer_frame_size_|.
   UMA_HISTOGRAM_SPARSE_SLOWLY("Media.Audio.RequestedInputBufferFrameSizeMac",
                               number_of_frames_);
   DVLOG(1) << "number_of_frames_: " << number_of_frames_;
-  // This value indicates the number of frames in the IO buffers connected to
-  // the selected input device. It has been set by the audio manger in Open()
-  // and can be the same as |number_of_frames_|, which is the desired buffer
-  // size. These two values might differ if other streams are using the same
-  // device and any of these streams have asked for a smaller buffer size.
+  // This value indicates the number of frames in the IO buffers connected
+  // to the selected input device. It has been set by the audio manger in
+  // Open() and can be the same as |number_of_frames_|, which is the desired
+  // buffer size. These two values might differ if other streams are using the
+  // same device and any of these streams have asked for a smaller buffer size.
   UMA_HISTOGRAM_SPARSE_SLOWLY("Media.Audio.ActualInputBufferFrameSizeMac",
                               io_buffer_frame_size_);
   DVLOG(1) << "io_buffer_frame_size_: " << io_buffer_frame_size_;
-  // TODO(henrika): this value will currently always report true. It should be
+  // TODO(henrika): this value will currently always report true. It should
+  // be
   // fixed when we understand the problem better.
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.AutomaticGainControlMac",
                         GetAutomaticGainControl());
+  // TODO(henrika): add comments...
+  AddDevicePropertyChangesToUMA();
+}
+
+void AUAudioInputStream::AddDevicePropertyChangesToUMA() {
+  DVLOG(1) << "AddDevicePropertyChangesToUMA";
+  while (!device_property_changes_map_.empty()) {

[o1ka, 2016/02/18 13:46:22]

You could just iterate through the map from the beginning to the end and then
empty it after, it would be more efficient.

[henrika (OOO until Aug 14), 2016/02/18 15:58:03]

Thanks. Will change.

+    UInt32 device_property = device_property_changes_map_.begin()->first;
+    int change_count = device_property_changes_map_.begin()->second;
+    DVLOG(1) << "property: " << device_property << " changed: " << change_count;
+    AudioDevicePropertyResult uma_result = PROPERTY_MAX;
+    switch (device_property) {
+      case kAudioDevicePropertyDeviceHasChanged:
+        uma_result = PROPERTY_DEVICE_HAS_CHANGED;
+        DVLOG(1) << "kAudioDevicePropertyDeviceHasChanged";
+        break;
+      case kAudioDevicePropertyIOStoppedAbnormally:
+        uma_result = PROPERTY_IO_STOPPED_ABNORMALLY;
+        DVLOG(1) << "kAudioDevicePropertyIOStoppedAbnormally";
+        break;
+      case kAudioDevicePropertyHogMode:
+        uma_result = PROPERTY_HOG_MODE;
+        DVLOG(1) << "kAudioDevicePropertyHogMode";
+        break;
+      case kAudioDevicePropertyBufferFrameSize:
+        uma_result = PROPERTY_BUFFER_FRAME_SIZE;
+        DVLOG(1) << "kAudioDevicePropertyBufferFrameSize";
+        break;
+      case kAudioDevicePropertyBufferFrameSizeRange:
+        uma_result = PROPERTY_BUFFER_FRAME_SIZE_RANGE;
+        DVLOG(1) << "kAudioDevicePropertyBufferFrameSizeRange";
+        break;
+      case kAudioDevicePropertyStreamConfiguration:
+        uma_result = PROPERTY_STREAM_CONFIGURATION;
+        DVLOG(1) << "kAudioDevicePropertyStreamConfiguration";
+        break;
+      case kAudioDevicePropertyActualSampleRate:
+        uma_result = PROPERTY_ACTUAL_SAMPLE_RATE;
+        DVLOG(1) << "kAudioDevicePropertyActualSampleRate";
+        break;
+      case kAudioDevicePropertyNominalSampleRate:
+        uma_result = PROPERTY_NOMINAL_SAMPLE_RATE;
+        DVLOG(1) << "kAudioDevicePropertyNominalSampleRate";
+        break;
+      case kAudioDevicePropertyDeviceIsRunningSomewhere:
+        uma_result = PROPERTY_DEVICE_IS_RUNNING_SOMEWHERE;
+        DVLOG(1) << "kAudioDevicePropertyDeviceIsRunningSomewhere";
+        break;
+      case kAudioDevicePropertyDeviceIsRunning:
+        uma_result = PROPERTY_DEVICE_IS_RUNNING;
+        DVLOG(1) << "kAudioDevicePropertyDeviceIsRunning";
+        break;
+      case kAudioDevicePropertyDeviceIsAlive:
+        uma_result = PROPERTY_DEVICE_IS_ALIVE;
+        DVLOG(1) << "kAudioDevicePropertyDeviceIsAlive";
+        break;
+      default:
+        LOG(ERROR) << "Invalid device property change";
+        break;
+    }
+    LogDevicePropertyChange(uma_result);
+    device_property_changes_map_.erase(device_property_changes_map_.begin());
+  }
 }
 
 }  // namespace media