MediaStream audio object graph untangling and clean-ups.

content/renderer/media/webrtc_audio_capturer_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 "base/logging.h"
 #include "build/build_config.h"
 #include "content/public/renderer/media_stream_audio_sink.h"
 #include "content/renderer/media/mock_constraint_factory.h"
 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
@@ skipping 58 matching lines @@
                 media::CHANNEL_LAYOUT_STEREO, 48000, 16, 960) {
     // Android works with a buffer size bigger than 20ms.
 #else
       : params_(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                 media::CHANNEL_LAYOUT_STEREO, 48000, 16, 128) {
 #endif
   }
 
   void VerifyAudioParams(const blink::WebMediaConstraints& constraints,
                          bool need_audio_processing) {
-    capturer_ = WebRtcAudioCapturer::CreateCapturer(
-        -1, StreamDeviceInfo(MEDIA_DEVICE_AUDIO_CAPTURE, "", "",
-                             params_.sample_rate(), params_.channel_layout(),
-                             params_.frames_per_buffer()),
-        constraints, NULL, NULL);
-    capturer_source_ = new MockCapturerSource();
-    EXPECT_CALL(*capturer_source_.get(), Initialize(_, capturer_.get(), -1));
-    EXPECT_CALL(*capturer_source_.get(), SetAutomaticGainControl(true));
-    EXPECT_CALL(*capturer_source_.get(), Start());
-    capturer_->SetCapturerSource(capturer_source_, params_);
+    const scoped_ptr<WebRtcAudioCapturer> capturer =
+        WebRtcAudioCapturer::CreateCapturer(
+            -1, StreamDeviceInfo(
+                    MEDIA_DEVICE_AUDIO_CAPTURE, "", "", params_.sample_rate(),
+                    params_.channel_layout(), params_.frames_per_buffer()),
+            constraints, nullptr, nullptr);
+    const scoped_refptr<MockCapturerSource> capturer_source(
+        new MockCapturerSource());
+    EXPECT_CALL(*capturer_source.get(), Initialize(_, capturer.get(), -1));
+    EXPECT_CALL(*capturer_source.get(), SetAutomaticGainControl(true));
+    EXPECT_CALL(*capturer_source.get(), Start());
+    capturer->SetCapturerSource(capturer_source, params_);
 
     scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
         WebRtcLocalAudioTrackAdapter::Create(std::string(), NULL));
-    track_.reset(new WebRtcLocalAudioTrack(adapter.get(), capturer_, NULL));
-    track_->Start();
+    const scoped_ptr<WebRtcLocalAudioTrack> track(
+        new WebRtcLocalAudioTrack(adapter.get()));
+    capturer->AddTrack(track.get());
 
     // Connect a mock sink to the track.
     scoped_ptr<MockMediaStreamAudioSink> sink(new MockMediaStreamAudioSink());
-    track_->AddSink(sink.get());
+    track->AddSink(sink.get());
 
     int delay_ms = 65;
     bool key_pressed = true;
     double volume = 0.9;
 
     scoped_ptr<media::AudioBus> audio_bus = media::AudioBus::Create(params_);
     audio_bus->Zero();
 
     media::AudioCapturerSource::CaptureCallback* callback =
         static_cast<media::AudioCapturerSource::CaptureCallback*>(
-            capturer_.get());
+            capturer.get());
 
     // Verify the sink is getting the correct values.
     EXPECT_CALL(*sink, FormatIsSet());
     EXPECT_CALL(*sink, OnDataCallback()).Times(AtLeast(1));
     callback->Capture(audio_bus.get(), delay_ms, volume, key_pressed);
 
-    track_->RemoveSink(sink.get());
-    EXPECT_CALL(*capturer_source_.get(), Stop());
-    capturer_->Stop();
+    track->RemoveSink(sink.get());
+    EXPECT_CALL(*capturer_source.get(), Stop());
+    capturer->Stop();
   }
 
   media::AudioParameters params_;
-  scoped_refptr<MockCapturerSource> capturer_source_;
-  scoped_refptr<WebRtcAudioCapturer> capturer_;
-  scoped_ptr<WebRtcLocalAudioTrack> track_;
 };
 
 TEST_F(WebRtcAudioCapturerTest, VerifyAudioParamsWithAudioProcessing) {
   // Turn off the default constraints to verify that the sink will get packets
   // with a buffer size smaller than 10ms.
   MockConstraintFactory constraint_factory;
   constraint_factory.DisableDefaultAudioConstraints();
   VerifyAudioParams(constraint_factory.CreateWebMediaConstraints(), false);
 }
 
 TEST_F(WebRtcAudioCapturerTest, FailToCreateCapturerWithWrongConstraints) {
   MockConstraintFactory constraint_factory;
   const std::string dummy_constraint = "dummy";
   // Set a non-audio constraint.
   constraint_factory.basic().width.setExact(240);
 
-  scoped_refptr<WebRtcAudioCapturer> capturer(
-      WebRtcAudioCapturer::CreateCapturer(
-          0, StreamDeviceInfo(MEDIA_DEVICE_AUDIO_CAPTURE, "", "",
-                              params_.sample_rate(), params_.channel_layout(),
-                              params_.frames_per_buffer()),
-          constraint_factory.CreateWebMediaConstraints(), NULL, NULL));
+  scoped_ptr<WebRtcAudioCapturer> capturer(WebRtcAudioCapturer::CreateCapturer(
+      0, StreamDeviceInfo(MEDIA_DEVICE_AUDIO_CAPTURE, "", "",
+                          params_.sample_rate(), params_.channel_layout(),
+                          params_.frames_per_buffer()),
+      constraint_factory.CreateWebMediaConstraints(), NULL, NULL));
   EXPECT_TRUE(capturer.get() == NULL);
 }
 
 
 }  // namespace content