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;
 }
 
+// Log if the input device is used exclusively (~hogged) by us or any other
+// process in the system.
+enum InputAudioDeviceHogResult {
+  DEVICE_IS_NOT_HOGGED = 0,
+  DEVICE_IS_HOGGED_BY_OTHER_PROCESS = 1,
+  DEVICE_IS_HOGGED_BY_OWN_PROCESS = 2,
+  DEVICE_IS_HOGGED_MAX = DEVICE_IS_HOGGED_BY_OWN_PROCESS
+};
+
+static void InputAudioDeviceHogResult(InputAudioDeviceHogResult result) {
+  UMA_HISTOGRAM_ENUMERATION("Media.Audio.InputDeviceIsHoggedMac", result,
+                            DEVICE_IS_HOGGED_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);
   DVLOG(1) << "Input device stream format: " << *format;
   return result;
 }
 
+static void CheckAudioDeviceProperties(AudioDeviceID device_id) {
+  DVLOG(1) << "CheckAudioDeviceProperties(device ID: 0x" << std::hex
+           << device_id << ")";
+  // Check if the specified audio device is running in at least one process
+  // on the system. A value of 0 means that it is not running at all.
+  // The idea of checking this state is to see if the device is "alive" or not.
+  AudioObjectPropertyAddress address = {
+      kAudioDevicePropertyDeviceIsRunningSomewhere,
+      kAudioObjectPropertyScopeInput, kAudioObjectPropertyElementMaster};
+  UInt32 is_running_somewhere = 0;
+  UInt32 data_size = sizeof(is_running_somewhere);
+  OSStatus error = AudioObjectGetPropertyData(
+      device_id, &address, 0, NULL, &data_size, &is_running_somewhere);
+  DVLOG_IF(1, !error) << "kAudioDevicePropertyDeviceIsRunningSomewhere: "
+                      << is_running_somewhere;
+  // TOOD(henrika): consider if it is worth adding this state to UMA.
+
+  // Check if there is any device conflict, i.e., if the device is currently
+  // owned exclusively by any other process than our own.
+  address.mSelector = kAudioDevicePropertyHogMode;
+  pid_t hog_pid = -1;
+  data_size = sizeof(hog_pid);
+  error = AudioObjectGetPropertyData(device_id, &address, 0, NULL, &data_size,
+                                     &hog_pid);
+  if (!error) {
+    if (hog_pid == -1) {
+      InputAudioDeviceHogResult(DEVICE_IS_NOT_HOGGED);
+      DVLOG(1) << "Device is available to all processes";
+    } else {
+      hog_pid != getpid()
+          ? InputAudioDeviceHogResult(DEVICE_IS_HOGGED_BY_OTHER_PROCESS)
+          : InputAudioDeviceHogResult(DEVICE_IS_HOGGED_BY_OWN_PROCESS);
+      DVLOG(1) << "Process with PID=" << hog_pid << " has exclusive access"
+               << " (our own PID=" << getpid() << ")";
+    }
+  }
+}
+
 // See "Technical Note TN2091 - Device input using the HAL Output Audio Unit"
 // http://developer.apple.com/library/mac/#technotes/tn2091/_index.html
 // for more details and background regarding this implementation.
 
 AUAudioInputStream::AUAudioInputStream(AudioManagerMac* manager,
                                        const AudioParameters& input_params,
                                        AudioDeviceID audio_device_id)
     : manager_(manager),
       number_of_frames_(input_params.frames_per_buffer()),
       io_buffer_frame_size_(0),
@@ skipping 280 matching lines @@
         deferred_start_cb_.callback(),
         base::TimeDelta::FromSeconds(
             AudioManagerMac::kStartDelayInSecsForPowerEvents));
     return;
   }
 
   sink_ = callback;
   last_success_time_ = base::TimeTicks::Now();
   audio_unit_render_has_worked_ = false;
   StartAgc();
-  OSStatus result = AudioOutputUnitStart(audio_unit_);
+  // OSStatus result = AudioOutputUnitStart(audio_unit_);
+  OSStatus result = noErr;
   if (result == noErr) {
     // For UMA stat purposes, start a one-shot timer which detects when input
     // callbacks starts indicating if input audio recording works as intended.
     // CheckInputStartupSuccess() will check if |input_callback_is_active_| is
     // true when the timer expires. This timer delay is currently set to
     // 5 seconds to avoid false alarms.
     input_callback_timer_.reset(new base::OneShotTimer());
     input_callback_timer_->Start(
         FROM_HERE,
         base::TimeDelta::FromSeconds(kInputCallbackStartTimeoutInSeconds), this,
@@ skipping 511 matching lines @@
 }
 
 bool AUAudioInputStream::GetInputCallbackIsActive() {
   return (base::subtle::Acquire_Load(&input_callback_is_active_) != false);
 }
 
 void AUAudioInputStream::CheckInputStartupSuccess() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // 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()) {
+  if (/*IsRunning() &&*/ GetAutomaticGainControl()) {

[tommi (sloooow) - chröme, 2016/02/15 15:30:12]

unintentional?

     // 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;
     if (!input_callback_is_active) {
       // Now when we know that startup has failed for some reason, add extra
       // UMA stats in an attempt to figure out the exact reason.
@@ skipping 40 matching lines @@
   // 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
   // fixed when we understand the problem better.
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.AutomaticGainControlMac",
                         GetAutomaticGainControl());
+  // Check some extra device properties and add more UMA stats if needed.
+  CheckAudioDeviceProperties(input_device_id_);
 }
 
 }  // namespace media