Resolves crash in device notifier for audio input on Mac OS X

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 <mach/mach.h>
 #include <string>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "media/audio/mac/audio_manager_mac.h"
 #include "media/base/audio_bus.h"
 #include "media/base/data_buffer.h"
 
@@ skipping 175 matching lines @@
       input_callback_is_active_(false),
       start_was_deferred_(false),
       buffer_size_was_changed_(false),
       audio_unit_render_has_worked_(false),
       device_listener_is_active_(false),
       started_(false),
       last_sample_time_(0.0),
       last_number_of_frames_(0),
       total_lost_frames_(0),
       largest_glitch_frames_(0),
-      glitches_detected_(0) {
+      glitches_detected_(0),
+      weak_factory_(this) {
   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 680 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;
 }
 
+void AUAudioInputStream::DevicePropertyChangedOnMainThread(
+    const std::vector<UInt32>& properties) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(device_listener_is_active_);
+  // Use property as key to a map and increase its value. We are not
+  // interested in all property changes but store all here anyhow.
+  // Filtering will be done later in AddDevicePropertyChangesToUMA();
+  for (auto property : properties) {
+    DVLOG(2) << "=> " << FourCharFormatCodeToString(property);
+    ++device_property_changes_map_[property];
+  }
+}
+
 OSStatus AUAudioInputStream::OnDevicePropertyChanged(
     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.
   // Consequently, the implementation of a listener must go through the array of
-  // addresses to see what exactly has changed.
+  // addresses to see what exactly has changed. Copy values into a local vector
+  // and update the |device_property_changes_map_| on the main thread to avoid
+  // potential race conditions.
+  std::vector<UInt32> properties;
+  properties.reserve(num_addresses);
   for (UInt32 i = 0; i < num_addresses; ++i) {

[tommi (sloooow) - chröme, 2016/03/18 10:22:39]

nit: no {}

[henrika (OOO until Aug 14), 2016/03/18 10:26:34]

Done.

-    const UInt32 property = addresses[i].mSelector;
-    // Use selector as key to a map and increase its value. We are not
-    // interested in all property changes but store all here anyhow.
-    // Filtering will be done later in AddDevicePropertyChangesToUMA();
-    ++device_property_changes_map_[property];
+    properties.push_back(addresses[i].mSelector);
   }
+  manager_->GetTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&AUAudioInputStream::DevicePropertyChangedOnMainThread,
+                 weak_factory_.GetWeakPtr(), properties));
   return noErr;
 }
 
 void AUAudioInputStream::RegisterDeviceChangeListener() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!device_listener_is_active_);
   DVLOG(1) << "RegisterDeviceChangeListener";
   if (input_device_id_ == kAudioObjectUnknown)
     return;
   device_property_changes_map_.clear();
@@ skipping 388 matching lines @@
 
   number_of_frames_provided_ = 0;
   glitches_detected_ = 0;
   last_sample_time_ = 0;
   last_number_of_frames_ = 0;
   total_lost_frames_ = 0;
   largest_glitch_frames_ = 0;
 }
 
 }  // namespace media