Add UMA stats for OS input glitches 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 146 matching lines @@
   // 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(bool startup_failed);
 
+  // Updates capture timestamp, current lost frames, and total lost frames and
+  // glitches.
+  void UpdateCaptureTimestamp(const AudioTimeStamp* timestamp);
+
+  // Called from the dtor and when the stream is reset.
+  void ReportAndResetStats();
+
   // 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_;
 
+  // Stores the number of frames that we actually get callbacks for.
+  // This may be different from what we ask for, so we use this for stats in
+  // order to understand how often this happens and what are the typical values.
+  size_t number_of_frames_requested_;
+
   // The actual I/O buffer size for the input device connected to the active
   // AUHAL audio unit.
   size_t io_buffer_frame_size_;
 
   // Pointer to the object that will receive the recorded audio samples.
   AudioInputCallback* sink_;
 
   // Structure that holds the desired output format of the stream.
   // Note that, this format can differ from the device(=input) format.
   AudioStreamBasicDescription format_;
@@ skipping 60 matching lines @@
   // 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.
   // The map is always read on the creating thread but only while the notifier
   // is disabled, hence no lock is required.
   std::map<UInt32, int> device_property_changes_map_;
 
   // Set to true when we are listening for changes in device properties.
   // Only touched on the creating thread.
   bool device_listener_is_active_;
 
+  // Stores the timestamp of the previous audio buffer provided by the OS.
+  // We use this in combination with |last_number_of_frames_| to detect when
+  // the OS has decided to skip providing frames (i.e. a glitch).
+  // This can happen in case of high CPU load or excessive blocking on the
+  // callback audio thread.
+  // These variables are only touched on the callback thread and then read

[Henrik Grunell, 2016/02/25 14:40:23]

They're also read in Stop(), same as on output side. This doesn't seem safe.

Tommi: can you confirm since you wrote the original code for output side?

[tommi (sloooow) - chröme, 2016/02/26 10:07:20]

It's safe as long as the callbacks aren't active when we read them in Stop(). 
Similarly when the callbacks are active, they must only be touched from the
callback thread.

[Henrik Grunell, 2016/02/29 17:48:48]

Acknowledged.

+  // in the dtor (when no longer receiving callbacks).
+  // NOTE: Float64 and UInt32 types are used for native API compatibility.
+  Float64 last_sample_time_;
+  UInt32 last_number_of_frames_;
+  UInt32 total_lost_frames_;
+  UInt32 largest_glitch_frames_;
+  int glitches_detected_;
+
   DISALLOW_COPY_AND_ASSIGN(AUAudioInputStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_MAC_AUDIO_LOW_LATENCY_INPUT_MAC_H_