Add UMA stats for AEC filter divergence metric.

content/renderer/media/media_stream_audio_processor_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/files/file_path.h"
@@ skipping 190 matching lines @@
   MediaStreamDevice::AudioDeviceParameters input_device_params_;
 };
 
 // Test crashing with ASAN on Android. crbug.com/468762
 #if defined(OS_ANDROID) && defined(ADDRESS_SANITIZER)
 #define MAYBE_WithAudioProcessing DISABLED_WithAudioProcessing
 #else
 #define MAYBE_WithAudioProcessing WithAudioProcessing
 #endif
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_WithAudioProcessing) {
+  base::MessageLoop message_loop;
   MockConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
           constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
   VerifyDefaultComponents(audio_processor.get());
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannel,
                              kAudioProcessingSampleRate / 100);
-  // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
-  // |audio_processor|.
-  audio_processor = NULL;
+
+  // Stop |audio_processor| so that it removes itself from
+  // |webrtc_audio_device| and clears its pointer to it.
+  audio_processor->Stop();
 }
 
 TEST_F(MediaStreamAudioProcessorTest, VerifyTabCaptureWithoutAudioProcessing) {
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   // Create MediaStreamAudioProcessor instance for kMediaStreamSourceTab source.
   MockConstraintFactory tab_constraint_factory;
   const std::string tab_string = kMediaStreamSourceTab;
   tab_constraint_factory.basic().mediaStreamSource.setExact(
       blink::WebString::fromUTF8(tab_string));
@@ skipping 13 matching lines @@
   // source.
   MockConstraintFactory system_constraint_factory;
   const std::string system_string = kMediaStreamSourceSystem;
   system_constraint_factory.basic().mediaStreamSource.setExact(
       blink::WebString::fromUTF8(system_string));
   audio_processor = new rtc::RefCountedObject<MediaStreamAudioProcessor>(
       system_constraint_factory.CreateWebMediaConstraints(),
       input_device_params_, webrtc_audio_device.get());
   EXPECT_FALSE(audio_processor->has_audio_processing());
 
-  // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
-  // |audio_processor|.
-  audio_processor = NULL;
+  // Stop |audio_processor| so that it removes itself from
+  // |webrtc_audio_device| and clears its pointer to it.
+  audio_processor->Stop();
 }
 
 TEST_F(MediaStreamAudioProcessorTest, TurnOffDefaultConstraints) {
   // Turn off the default constraints and pass it to MediaStreamAudioProcessor.
   MockConstraintFactory constraint_factory;
   constraint_factory.DisableDefaultAudioConstraints();
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
           constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              params_.sample_rate(),
                              params_.channels(),
                              params_.sample_rate() / 100);
-  // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
-  // |audio_processor|.
-  audio_processor = NULL;
+
+  // Stop |audio_processor| so that it removes itself from
+  // |webrtc_audio_device| and clears its pointer to it.
+  audio_processor->Stop();
 }
 
 TEST_F(MediaStreamAudioProcessorTest, VerifyConstraints) {
   {
     // Verify that echo cancellation is off when platform aec effect is on.
     MockConstraintFactory constraint_factory;
     MediaAudioConstraints audio_constraints(
         constraint_factory.CreateWebMediaConstraints(),
         media::AudioParameters::ECHO_CANCELLER);
     EXPECT_FALSE(audio_constraints.GetEchoCancellationProperty());
@@ skipping 136 matching lines @@
   }
 }
 
 // Test crashing with ASAN on Android. crbug.com/468762
 #if defined(OS_ANDROID) && defined(ADDRESS_SANITIZER)
 #define MAYBE_TestAllSampleRates DISABLED_TestAllSampleRates
 #else
 #define MAYBE_TestAllSampleRates TestAllSampleRates
 #endif
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_TestAllSampleRates) {
+  base::MessageLoop message_loop;
   MockConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
           constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
 
   static const int kSupportedSampleRates[] =
       { 8000, 16000, 22050, 32000, 44100, 48000 };
   for (size_t i = 0; i < arraysize(kSupportedSampleRates); ++i) {
     int buffer_size = (kSupportedSampleRates[i] / 100)  < 128 ?
         kSupportedSampleRates[i] / 100 : 128;
     media::AudioParameters params(
         media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
         media::CHANNEL_LAYOUT_STEREO, kSupportedSampleRates[i], 16,
         buffer_size);
     audio_processor->OnCaptureFormatChanged(params);
     VerifyDefaultComponents(audio_processor.get());
 
     ProcessDataAndVerifyFormat(audio_processor.get(),
                                kAudioProcessingSampleRate,
                                kAudioProcessingNumberOfChannel,
                                kAudioProcessingSampleRate / 100);
   }
 
-  // Set |audio_processor| to NULL to make sure |webrtc_audio_device|
-  // outlives |audio_processor|.
-  audio_processor = NULL;
+  // Stop |audio_processor| so that it removes itself from
+  // |webrtc_audio_device| and clears its pointer to it.
+  audio_processor->Stop();
 }
 
 // Test that if we have an AEC dump message filter created, we are getting it
 // correctly in MSAP. Any IPC messages will be deleted since no sender in the
 // filter will be created.
 TEST_F(MediaStreamAudioProcessorTest, GetAecDumpMessageFilter) {
   base::MessageLoopForUI message_loop;
   scoped_refptr<AecDumpMessageFilter> aec_dump_message_filter_(
       new AecDumpMessageFilter(message_loop.task_runner(),
                                message_loop.task_runner(), nullptr));
 
   MockConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
           constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
 
   EXPECT_TRUE(audio_processor->aec_dump_message_filter_.get());
 
-  audio_processor = NULL;
+  // Stop |audio_processor| so that it removes itself from
+  // |webrtc_audio_device| and clears its pointer to it.
+  audio_processor->Stop();
 }
 
 TEST_F(MediaStreamAudioProcessorTest, TestStereoAudio) {
   // Set up the correct constraints to turn off the audio processing and turn
   // on the stereo channels mirroring.
   MockConstraintFactory constraint_factory;
   constraint_factory.basic().echoCancellation.setExact(false);
   constraint_factory.basic().googAudioMirroring.setExact(true);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
@@ skipping 37 matching lines @@
     base::TimeDelta capture_delay;
     int new_volume = 0;
     EXPECT_TRUE(audio_processor->ProcessAndConsumeData(
         0, false, &processed_data, &capture_delay, &new_volume));
     EXPECT_TRUE(processed_data);
     EXPECT_EQ(processed_data->channel(0)[0], 0);
     EXPECT_NE(processed_data->channel(1)[0], 0);
     EXPECT_EQ(pushed_capture_delay, capture_delay);
   }
 
-  // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
-  // |audio_processor|.
-  audio_processor = NULL;
+  // Stop |audio_processor| so that it removes itself from
+  // |webrtc_audio_device| and clears its pointer to it.
+  audio_processor->Stop();
 }
 
 // Disabled on android clang builds due to crbug.com/470499
 #if defined(__clang__) && defined(OS_ANDROID)
 #define MAYBE_TestWithKeyboardMicChannel DISABLED_TestWithKeyboardMicChannel
 #else
 #define MAYBE_TestWithKeyboardMicChannel TestWithKeyboardMicChannel
 #endif
-
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_TestWithKeyboardMicChannel) {
+  base::MessageLoop message_loop;
   MockConstraintFactory constraint_factory;
   constraint_factory.basic().googExperimentalNoiseSuppression.setExact(true);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
           constraint_factory.CreateWebMediaConstraints(), input_device_params_,
           webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
 
   media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                 media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC,
                                 48000, 16, 512);
   audio_processor->OnCaptureFormatChanged(params);
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannel,
                              kAudioProcessingSampleRate / 100);
-  // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
-  // |audio_processor|.
-  audio_processor = NULL;
+
+  // Stop |audio_processor| so that it removes itself from
+  // |webrtc_audio_device| and clears its pointer to it.
+  audio_processor->Stop();
 }
 
 }  // namespace content