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 kAudioProcessingNumberOfChannels = 1;
 
 const int kMaxNumberOfBuffersInFifo = 2;
 
+// Used by UMA histograms and entries shouldn't be re-ordered or removed.
+enum AudioTrackProcessingStates {
+  AUDIO_PROCESSING_ENABLED = 0,
+  AUDIO_PROCESSING_DISABLED,
+  AUDIO_PROCESSING_IN_WEBRTC,
+  AUDIO_PROCESSING_MAX
+};
+
+void RecordProcessingState(AudioTrackProcessingStates state) {
+  UMA_HISTOGRAM_ENUMERATION("Media.AudioTrackProcessingStates",
+                            state, 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()) {
+    RecordProcessingState(AUDIO_PROCESSING_IN_WEBRTC);
     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) {
+    RecordProcessingState(AUDIO_PROCESSING_DISABLED);
     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 17 matching lines @@
     // is enabled by default.
     typing_detector_.reset(new webrtc::TypingDetection());
     EnableTypingDetection(audio_processing_.get(), typing_detector_.get());
   }
 
   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);
+  CHECK_EQ(0,
+           audio_processing_->set_sample_rate_hz(kAudioProcessingSampleRate));
+  CHECK_EQ(0, audio_processing_->set_num_channels(
+      kAudioProcessingNumberOfChannels, kAudioProcessingNumberOfChannels));
+
+  RecordProcessingState(AUDIO_PROCESSING_ENABLED);
 }
 
 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
   // 32k mono for desktops and 16k mono for Android. When the AudioProcessing
   // is disabled, the sink format will be the same as the source format.
   const int sink_sample_rate = audio_processing_ ?
       kAudioProcessingSampleRate : source_params.sample_rate();
   const media::ChannelLayout sink_channel_layout = audio_processing_ ?
-      media::GuessChannelLayout(kAudioProcessingNumberOfChannel) :
+      media::GuessChannelLayout(kAudioProcessingNumberOfChannels) :
       source_params.channel_layout();
 
   // WebRtc AudioProcessing requires 10ms as its packet size. We use this
   // native size when processing is enabled. While processing is disabled, and
   // the source is running with a buffer size smaller than 10ms buffer, we use
   // same buffer size as the incoming format to avoid extra FIFO for WebAudio.
   int sink_buffer_size =  sink_sample_rate / 100;
   if (!audio_processing_ &&
       source_params.frames_per_buffer() < sink_buffer_size) {
     sink_buffer_size = source_params.frames_per_buffer();
@@ skipping 99 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