MediaStream audio: Refactor 3 separate "glue" implementations into one.

content/renderer/media/rtc_peer_connection_handler_unittest.cc

 // Copyright (c) 2012 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/rtc_peer_connection_handler.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_audio_source.h"
+#include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/media_stream_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
+#include "content/renderer/media/mock_audio_device_factory.h"
+#include "content/renderer/media/mock_constraint_factory.h"
 #include "content/renderer/media/mock_data_channel_impl.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "content/renderer/media/mock_peer_connection_impl.h"
 #include "content/renderer/media/mock_web_rtc_peer_connection_handler_client.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
-#include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
-#include "content/renderer/media/webrtc_local_audio_track.h"
+#include "content/renderer/media/webrtc/processed_local_audio_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebRTCConfiguration.h"
 #include "third_party/WebKit/public/platform/WebRTCDTMFSenderHandler.h"
 #include "third_party/WebKit/public/platform/WebRTCDataChannelHandler.h"
 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h"
@@ skipping 199 matching lines @@
     mock_dependency_factory_.reset();
     mock_client_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
   // Creates a WebKit local MediaStream.
   blink::WebMediaStream CreateLocalMediaStream(
       const std::string& stream_label) {
     std::string video_track_label("video-label");
     std::string audio_track_label("audio-label");
-    blink::WebMediaStreamSource audio_source;
-    audio_source.initialize(blink::WebString::fromUTF8(audio_track_label),
-                            blink::WebMediaStreamSource::TypeAudio,
-                            blink::WebString::fromUTF8("audio_track"),
-                            false /* remote */, true /* readonly */);
-    audio_source.setExtraData(new MediaStreamAudioSource());
+    blink::WebMediaStreamSource blink_audio_source;
+    blink_audio_source.initialize(blink::WebString::fromUTF8(audio_track_label),
+                                  blink::WebMediaStreamSource::TypeAudio,
+                                  blink::WebString::fromUTF8("audio_track"),
+                                  false /* remote */, true /* readonly */);
+    ProcessedLocalAudioSource* const audio_source =
+        new ProcessedLocalAudioSource(
+            -1 /* consumer_render_frame_id is N/A for non-browser tests */,
+            StreamDeviceInfo(MEDIA_DEVICE_AUDIO_CAPTURE, "Mock device",
+                             "mock_device_id",
+                             media::AudioParameters::kAudioCDSampleRate,
+                             media::CHANNEL_LAYOUT_STEREO,
+                             media::AudioParameters::kAudioCDSampleRate / 100),
+            mock_dependency_factory_.get());
+    audio_source->SetAllowInvalidRenderFrameIdForTesting(true);
+    audio_source->SetSourceConstraints(
+        MockConstraintFactory().CreateWebMediaConstraints());
+    blink_audio_source.setExtraData(audio_source);  // Takes ownership.
+
     blink::WebMediaStreamSource video_source;
     video_source.initialize(blink::WebString::fromUTF8(video_track_label),
                             blink::WebMediaStreamSource::TypeVideo,
                             blink::WebString::fromUTF8("video_track"),
                             false /* remote */, true /* readonly */);
     MockMediaStreamVideoSource* native_video_source =
         new MockMediaStreamVideoSource(false);
     video_source.setExtraData(native_video_source);
 
     blink::WebVector<blink::WebMediaStreamTrack> audio_tracks(
         static_cast<size_t>(1));
-    audio_tracks[0].initialize(audio_source.id(), audio_source);
-    scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
-        WebRtcLocalAudioTrackAdapter::Create(audio_track_label, nullptr));
-    std::unique_ptr<WebRtcLocalAudioTrack> native_track(
-        new WebRtcLocalAudioTrack(adapter.get()));
-    audio_tracks[0].setExtraData(native_track.release());
+    audio_tracks[0].initialize(blink_audio_source.id(), blink_audio_source);
+    EXPECT_CALL(*mock_audio_device_factory_.mock_capturer_source(),
+                Initialize(_, _, -1));
+    EXPECT_CALL(*mock_audio_device_factory_.mock_capturer_source(),
+                SetAutomaticGainControl(true));
+    EXPECT_CALL(*mock_audio_device_factory_.mock_capturer_source(), Start());
+    EXPECT_CALL(*mock_audio_device_factory_.mock_capturer_source(), Stop());
+    CHECK(audio_source->ConnectToTrack(audio_tracks[0]));
     blink::WebVector<blink::WebMediaStreamTrack> video_tracks(
         static_cast<size_t>(1));
     blink::WebMediaConstraints video_constraints;
     video_constraints.initialize();
     video_tracks[0] = MediaStreamVideoTrack::CreateVideoTrack(
         native_video_source, video_constraints,
         MediaStreamVideoSource::ConstraintsCallback(), true);
 
     blink::WebMediaStream local_stream;
     local_stream.initialize(base::UTF8ToUTF16(stream_label), audio_tracks,
@@ skipping 13 matching lines @@
     if (!video_track_label.empty()) {
       stream->AddTrack(MockWebRtcVideoTrack::Create(video_track_label).get());
     }
     if (!audio_track_label.empty()) {
       stream->AddTrack(MockWebRtcAudioTrack::Create(audio_track_label).get());
     }
     mock_peer_connection_->AddRemoteStream(stream.get());
     return stream;
   }
 
+  void StopAllTracks(const blink::WebMediaStream& stream) {
+    blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
+    stream.audioTracks(audio_tracks);
+    for (const auto& track : audio_tracks)
+      MediaStreamAudioTrack::From(track)->Stop();
+
+    blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
+    stream.videoTracks(video_tracks);
+    for (const auto& track : video_tracks)
+      MediaStreamVideoTrack::GetVideoTrack(track)->Stop();
+  }
+
   base::MessageLoop message_loop_;
   std::unique_ptr<ChildProcess> child_process_;
   std::unique_ptr<MockWebRTCPeerConnectionHandlerClient> mock_client_;
   std::unique_ptr<MockPeerConnectionDependencyFactory> mock_dependency_factory_;
   std::unique_ptr<NiceMock<MockPeerConnectionTracker>> mock_tracker_;
   std::unique_ptr<RTCPeerConnectionHandlerUnderTest> pc_handler_;
+  MockAudioDeviceFactory mock_audio_device_factory_;
 
   // Weak reference to the mocked native peer connection implementation.
   MockPeerConnectionImpl* mock_peer_connection_;
 };
 
 TEST_F(RTCPeerConnectionHandlerTest, Destruct) {
   EXPECT_CALL(*mock_tracker_.get(), UnregisterPeerConnection(pc_handler_.get()))
       .Times(1);
   pc_handler_.reset(NULL);
 }
@@ skipping 164 matching lines @@
   EXPECT_EQ(stream_label, mock_peer_connection_->stream_label());
   EXPECT_EQ(1u,
       mock_peer_connection_->local_streams()->at(0)->GetAudioTracks().size());
   EXPECT_EQ(1u,
       mock_peer_connection_->local_streams()->at(0)->GetVideoTracks().size());
 
   EXPECT_FALSE(pc_handler_->addStream(local_stream, constraints));
 
   pc_handler_->removeStream(local_stream);
   EXPECT_EQ(0u, mock_peer_connection_->local_streams()->count());
+
+  StopAllTracks(local_stream);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, addStreamWithStoppedAudioAndVideoTrack) {
   std::string stream_label = "local_stream";
   blink::WebMediaStream local_stream(
       CreateLocalMediaStream(stream_label));
   blink::WebMediaConstraints constraints;
 
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
   local_stream.audioTracks(audio_tracks);
   MediaStreamAudioSource* native_audio_source =
       MediaStreamAudioSource::From(audio_tracks[0].source());
   native_audio_source->StopSource();
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   local_stream.videoTracks(video_tracks);
   MediaStreamVideoSource* native_video_source =
       static_cast<MediaStreamVideoSource*>(
           video_tracks[0].source().getExtraData());
   native_video_source->StopSource();
 
   EXPECT_TRUE(pc_handler_->addStream(local_stream, constraints));
   EXPECT_EQ(stream_label, mock_peer_connection_->stream_label());
   EXPECT_EQ(
       1u,
       mock_peer_connection_->local_streams()->at(0)->GetAudioTracks().size());
   EXPECT_EQ(
       1u,
       mock_peer_connection_->local_streams()->at(0)->GetVideoTracks().size());
+
+  StopAllTracks(local_stream);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsNoSelector) {
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   pc_handler_->getStats(request.get());
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(request->result());
   EXPECT_LT(1, request->result()->report_count());
 }
@@ skipping 17 matching lines @@
   blink::WebVector<blink::WebMediaStreamTrack> tracks;
   local_stream.audioTracks(tracks);
   ASSERT_LE(1ul, tracks.size());
 
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(tracks[0]);
   pc_handler_->getStats(request.get());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, request->result()->report_count());
+
+  StopAllTracks(local_stream);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithRemoteSelector) {
   scoped_refptr<webrtc::MediaStreamInterface> stream(
       AddRemoteMockMediaStream("remote_stream", "video", "audio"));
   pc_handler_->observer()->OnAddStream(stream.get());
   base::RunLoop().RunUntilIdle();
   const blink::WebMediaStream& remote_stream = mock_client_->remote_stream();
 
   blink::WebVector<blink::WebMediaStreamTrack> tracks;
@@ skipping 19 matching lines @@
   local_stream.audioTracks(tracks);
   blink::WebMediaStreamTrack component = tracks[0];
   mock_peer_connection_->SetGetStatsResult(false);
 
   scoped_refptr<MockRTCStatsRequest> request(
       new rtc::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(component);
   pc_handler_->getStats(request.get());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, request->result()->report_count());
+
+  StopAllTracks(local_stream);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, OnSignalingChange) {
   testing::InSequence sequence;
 
   webrtc::PeerConnectionInterface::SignalingState new_state =
       webrtc::PeerConnectionInterface::kHaveRemoteOffer;
   EXPECT_CALL(*mock_tracker_.get(), TrackSignalingStateChange(
       pc_handler_.get(),
       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer));
@@ skipping 406 matching lines @@
   local_stream.audioTracks(tracks);
   ASSERT_LE(1ul, tracks.size());
 
   EXPECT_CALL(*mock_tracker_.get(),
               TrackCreateDTMFSender(pc_handler_.get(),
                                     testing::Ref(tracks[0])));
 
   std::unique_ptr<blink::WebRTCDTMFSenderHandler> sender(
       pc_handler_->createDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
+
+  StopAllTracks(local_stream);
 }
 
 }  // namespace content