added uma stats to check the usage of media stream audio track audio processing

content/renderer/media/media_stream_audio_processor.cc

 // Copyright 2013 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 "content/renderer/media/media_stream_audio_processor.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/media/media_stream_audio_processor_options.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_converter.h"
 #include "media/base/audio_fifo.h"
 #include "media/base/channel_layout.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediaconstraintsinterface.h"
 #include "third_party/webrtc/modules/audio_processing/typing_detection.h"
 
 namespace content {
 
 namespace {
 
 using webrtc::AudioProcessing;
 using webrtc::MediaConstraintsInterface;
 
 #if defined(OS_ANDROID)
 const int kAudioProcessingSampleRate = 16000;
 #else
 const int kAudioProcessingSampleRate = 32000;
 #endif
 const int kAudioProcessingNumberOfChannel = 1;
 
 const int kMaxNumberOfBuffersInFifo = 2;
 
+enum AudioTrackProcessingStates {
+  AUDIO_PROCESSING_ENABLED = 0,
+  AUDIO_PROCESSING_DISABLED,
+  AUDIO_PROCESSING_MAX
+};
+
 }  // namespace
 
 class MediaStreamAudioProcessor::MediaStreamAudioConverter
     : public media::AudioConverter::InputCallback {
  public:
   MediaStreamAudioConverter(const media::AudioParameters& source_params,
                             const media::AudioParameters& sink_params)
      : source_params_(source_params),
        sink_params_(sink_params),
        audio_converter_(source_params, sink_params_, false) {
@@ skipping 211 matching lines @@
 void MediaStreamAudioProcessor::GetStats(AudioProcessorStats* stats) {
   stats->typing_noise_detected =
       (base::subtle::Acquire_Load(&typing_detected_) != false);
   GetAecStats(audio_processing_.get(), stats);
 }
 
 void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
     const blink::WebMediaConstraints& constraints, int effects,
     MediaStreamType type) {
   DCHECK(!audio_processing_);
-  if (!IsAudioTrackProcessingEnabled())
+  if (!IsAudioTrackProcessingEnabled()) {
+    UMA_HISTOGRAM_ENUMERATION("Media.AudioTrackProcessingStates",
+                              AUDIO_PROCESSING_DISABLED, AUDIO_PROCESSING_MAX);
     return;
+  }
 
   RTCMediaConstraints native_constraints(constraints);
 
   // Only apply the fixed constraints for gUM of MEDIA_DEVICE_AUDIO_CAPTURE.
   DCHECK(IsAudioMediaType(type));
   if (type == MEDIA_DEVICE_AUDIO_CAPTURE)
     ApplyFixedAudioConstraints(&native_constraints);
 
   if (effects & media::AudioParameters::ECHO_CANCELLER) {
     // If platform echo canceller is enabled, disable the software AEC.
@@ skipping 32 matching lines @@
   const bool enable_high_pass_filter = GetPropertyFromConstraints(
       &native_constraints, MediaConstraintsInterface::kHighpassFilter);
 
   audio_mirroring_ = GetPropertyFromConstraints(
       &native_constraints, webrtc::MediaConstraintsInterface::kAudioMirroring);
 
   // Return immediately if no audio processing component is enabled.
   if (!enable_aec && !enable_experimental_aec && !enable_ns &&
       !enable_high_pass_filter && !enable_typing_detection && !enable_agc &&
       !enable_experimental_ns) {
+    UMA_HISTOGRAM_ENUMERATION("Media.AudioTrackProcessingStates",
+                              AUDIO_PROCESSING_DISABLED, AUDIO_PROCESSING_MAX);

[tommi (sloooow) - chröme, 2014/03/14 14:38:32]

Could we have a different value for this case?

Here we're actually still running the APM in Chrome, but the constraints specify
that no APM should be done (right?).  So I think that by putting this case in
the same bucket as 'disabled' could skew the numbers (as the APM code path is
actually enabled).

Maybe AUDIO_PROCESSING_BYPASSED?

[no longer working on chromium, 2014/03/14 14:43:56]

Do we really want this? AUDIO_PROCESSING_BYPASSED will soon go away, in one
month? And it probably does not tell much.
Note that we can't keep two paths for long, the code has to go away then we can
do a thorough clean up.

     return;
   }
 
   // Create and configure the webrtc::AudioProcessing.
   audio_processing_.reset(webrtc::AudioProcessing::Create(0));
 
   // Enable the audio processing components.
   if (enable_aec) {
     EnableEchoCancellation(audio_processing_.get());
     if (enable_experimental_aec)
@@ skipping 22 matching lines @@
   if (enable_agc)
     EnableAutomaticGainControl(audio_processing_.get());
 
   // Configure the audio format the audio processing is running on. This
   // has to be done after all the needed components are enabled.
   CHECK_EQ(audio_processing_->set_sample_rate_hz(kAudioProcessingSampleRate),
            0);
   CHECK_EQ(audio_processing_->set_num_channels(kAudioProcessingNumberOfChannel,
                                                kAudioProcessingNumberOfChannel),
            0);
+
+  UMA_HISTOGRAM_ENUMERATION("Media.AudioTrackProcessingStates",
+                            AUDIO_PROCESSING_ENABLED, AUDIO_PROCESSING_MAX);
 }
 
 void MediaStreamAudioProcessor::InitializeCaptureConverter(
     const media::AudioParameters& source_params) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(source_params.IsValid());
 
   // Create and initialize audio converter for the source data.
   // When the webrtc AudioProcessing is enabled, the sink format of the
   // converter will be the same as the post-processed data format, which is
@@ skipping 114 matching lines @@
 }
 
 bool MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled() const {
   const std::string group_name =
       base::FieldTrialList::FindFullName("MediaStreamAudioTrackProcessing");
   return group_name == "Enabled" || CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableAudioTrackProcessing);
 }
 
 }  // namespace content