MediaStream audio sourcing: Bypass audio processing for non-WebRTC cases.

content/renderer/media/webrtc/processed_local_audio_source_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_media_constraint_factory.h"
 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
@@ skipping 70 matching lines @@
                              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_);
 
     scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
-        WebRtcLocalAudioTrackAdapter::Create(std::string(), NULL));
-    track_.reset(new WebRtcLocalAudioTrack(adapter.get(), capturer_, NULL));
-    track_->Start();
+        WebRtcLocalAudioTrackAdapter::Create(std::string(), nullptr, nullptr));
+    track_.reset(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());
 
     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());
 
     // 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();
   }
 
   media::AudioParameters params_;
   scoped_refptr<MockCapturerSource> capturer_source_;
-  scoped_refptr<WebRtcAudioCapturer> capturer_;
+  scoped_ptr<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.
   MockMediaConstraintFactory constraint_factory;
   constraint_factory.DisableDefaultAudioConstraints();
   VerifyAudioParams(constraint_factory.CreateWebMediaConstraints(), false);
 }
 
 TEST_F(WebRtcAudioCapturerTest, FailToCreateCapturerWithWrongConstraints) {
   MockMediaConstraintFactory constraint_factory;
   const std::string dummy_constraint = "dummy";
   constraint_factory.AddMandatory(dummy_constraint, true);
 
-  scoped_refptr<WebRtcAudioCapturer> capturer(
+  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