Adds Media.Audio.InputDevicePropertyChangedMac UMA stat on Mac

media/audio/mac/audio_low_latency_input_mac.h

 // 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.
 //
 // Implementation of AudioInputStream for Mac OS X using the special AUHAL
 // input Audio Unit present in OS 10.4 and later.
 // The AUHAL input Audio Unit is for low-latency audio I/O.
 //
 // Overview of operation:
 //
@@ skipping 20 matching lines @@
 //   1) Hardware latency, which includes Audio Unit latency, audio device
 //      latency;
 //   2) The delay between the actual recording instant and the time when the
 //      data packet is provided as a callback.
 //
 #ifndef MEDIA_AUDIO_MAC_AUDIO_LOW_LATENCY_INPUT_MAC_H_
 #define MEDIA_AUDIO_MAC_AUDIO_LOW_LATENCY_INPUT_MAC_H_
 
 #include <AudioUnit/AudioUnit.h>
 #include <CoreAudio/CoreAudio.h>
-#include <stddef.h>
-#include <stdint.h>
+#include <map>
 
 #include "base/atomicops.h"
 #include "base/cancelable_callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "media/audio/agc_audio_stream.h"
@@ skipping 34 matching lines @@
 
   // Returns true if the audio unit is active/running.
   // The result is based on the kAudioOutputUnitProperty_IsRunning property
   // which exists for output units.
   bool IsRunning();
 
   AudioDeviceID device_id() const { return input_device_id_; }
   size_t requested_buffer_size() const { return number_of_frames_; }
 
  private:
+  static const AudioObjectPropertyAddress kDeviceChangePropertyAddress;
+
   // Callback functions called on a real-time priority I/O thread from the audio
   // unit. These methods are called when recorded audio is available.
   static OSStatus DataIsAvailable(void* context,
                                   AudioUnitRenderActionFlags* flags,
                                   const AudioTimeStamp* time_stamp,
                                   UInt32 bus_number,
                                   UInt32 number_of_frames,
                                   AudioBufferList* io_data);
   OSStatus OnDataIsAvailable(AudioUnitRenderActionFlags* flags,
                              const AudioTimeStamp* time_stamp,
                              UInt32 bus_number,
                              UInt32 number_of_frames);
 
   // Pushes recorded data to consumer of the input audio stream.
   OSStatus Provide(UInt32 number_of_frames, AudioBufferList* io_data,
                    const AudioTimeStamp* time_stamp);
 
+  // Callback functions called on different system threads from the Core Audio
+  // framework. These methods are called when device properties are changed.
+  static OSStatus OnDevicePropertyChanged(
+      AudioObjectID object_id,
+      UInt32 num_addresses,
+      const AudioObjectPropertyAddress addresses[],
+      void* context);
+  OSStatus DevicePropertyChanged(AudioObjectID object_id,
+                                 UInt32 num_addresses,
+                                 const AudioObjectPropertyAddress addresses[]);
+
+  // Registers OnDevicePropertyChanged() to receive notifications when device
+  // properties changes.
+  void RegisterDeviceChangeListener();
+  // Stop listening for changes in device properties.
+  void DeRegisterDeviceChangeListener();
+
   // Gets the fixed capture hardware latency and store it during initialization.
   // Returns 0 if not available.
   double GetHardwareLatency();
 
   // Gets the current capture delay value.
   double GetCaptureLatency(const AudioTimeStamp* input_time_stamp);
 
   // Gets the number of channels for a stream of audio data.
   int GetNumberOfChannelsFromStream();
 
@@ skipping 12 matching lines @@
   // to call InputProc() as it should. This method is called once when a timer
   // expires 5 seconds after calling Start().
   void CheckInputStartupSuccess();
 
   // Uninitializes the audio unit if needed.
   void CloseAudioUnit();
 
   // Adds extra UMA stats when it has been detected that startup failed.
   void AddHistogramsForFailedStartup();
 
+  // Scans the map of all available property changes (notification types) and
+  // filters out some that make sense to add to UMA stats.
+  void AddDevicePropertyChangesToUMA(const std::string& name);
+
   // Verifies that Open(), Start(), Stop() and Close() are all called on the
   // creating thread which is the main browser thread (CrBrowserMain) on Mac.
   base::ThreadChecker thread_checker_;
 
   // Our creator, the audio manager needs to be notified when we close.
   AudioManagerMac* const manager_;
 
   // Contains the desired number of audio frames in each callback.
   const size_t number_of_frames_;
 
@@ skipping 55 matching lines @@
   // See AudioManagerMac::ShouldDeferStreamStart() for details.
   bool start_was_deferred_;
 
   // Set to true if the audio unit's IO buffer was changed when Open() was
   // called.
   bool buffer_size_was_changed_;
 
   // Set to true once when AudioUnitRender() succeeds for the first time.
   bool audio_unit_render_has_worked_;
 
+  // Maps unique representations of device property notification types and
+  // number of times we have been notified about a change in such a type.

[tommi (sloooow) - chröme, 2016/02/19 15:17:33]

can you add a note about what thread is allowed to touch it?

[henrika (OOO until Aug 14), 2016/02/22 12:32:52]

Tommi, FYI, each callback can come from "any" thread it seems like. My guess is
that the inner implementation uses a serial dispatch queue ("Serial queues (also
known as private dispatch queues) execute one task at a time in the order in
which they are added to the queue. The currently executing task runs on a
distinct thread (which can vary from task to task) that is managed by the
dispatch queue. Serial queues are often used to synchronize access to a specific
resource.". There is no documentation that states it but I have never found any
examples from Apple that uses locks in these callbacks. 

But, hhm., I do read it from the creating thread while active. Hence, will add a
lock.

[tommi (sloooow) - chröme, 2016/02/22 14:16:43]

If we don't need a lock, I'd prefer to not have a lock.  My question is more
about us understanding and documenting why it's safe to not use a lock.

+  std::map<UInt32, int> device_property_changes_map_;
+
+  // Set to true when we are listening for changes in device properties.
+  bool device_listener_is_active_;

[tommi (sloooow) - chröme, 2016/02/19 15:17:33]

modified/checked on what threads?

[henrika (OOO until Aug 14), 2016/02/22 12:32:52]

Done, also uses DCHECK to ensure proper calling.

+
   DISALLOW_COPY_AND_ASSIGN(AUAudioInputStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_MAC_AUDIO_LOW_LATENCY_INPUT_MAC_H_