| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * libjingle | |
| 3 * Copyright 2012 Google Inc. | |
| 4 * | |
| 5 * Redistribution and use in source and binary forms, with or without | |
| 6 * modification, are permitted provided that the following conditions are met: | |
| 7 * | |
| 8 * 1. Redistributions of source code must retain the above copyright notice, | |
| 9 * this list of conditions and the following disclaimer. | |
| 10 * 2. Redistributions in binary form must reproduce the above copyright notice, | |
| 11 * this list of conditions and the following disclaimer in the documentation | |
| 12 * and/or other materials provided with the distribution. | |
| 13 * 3. The name of the author may not be used to endorse or promote products | |
| 14 * derived from this software without specific prior written permission. | |
| 15 * | |
| 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED | |
| 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
| 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO | |
| 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
| 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | |
| 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
| 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
| 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | |
| 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 26 */ | |
| 27 | |
| 28 #include "talk/app/webrtc/mediastreamhandler.h" | |
| 29 | |
| 30 #include <string> | |
| 31 | |
| 32 #include "talk/app/webrtc/audiotrack.h" | |
| 33 #include "talk/app/webrtc/mediastream.h" | |
| 34 #include "talk/app/webrtc/remoteaudiosource.h" | |
| 35 #include "talk/app/webrtc/streamcollection.h" | |
| 36 #include "talk/app/webrtc/videosource.h" | |
| 37 #include "talk/app/webrtc/videotrack.h" | |
| 38 #include "talk/media/base/fakevideocapturer.h" | |
| 39 #include "talk/media/base/mediachannel.h" | |
| 40 #include "testing/gmock/include/gmock/gmock.h" | |
| 41 #include "testing/gtest/include/gtest/gtest.h" | |
| 42 #include "webrtc/base/gunit.h" | |
| 43 | |
| 44 using ::testing::_; | |
| 45 using ::testing::Exactly; | |
| 46 | |
| 47 static const char kStreamLabel1[] = "local_stream_1"; | |
| 48 static const char kVideoTrackId[] = "video_1"; | |
| 49 static const char kAudioTrackId[] = "audio_1"; | |
| 50 static const uint32 kVideoSsrc = 98; | |
| 51 static const uint32 kAudioSsrc = 99; | |
| 52 | |
| 53 namespace webrtc { | |
| 54 | |
| 55 // Helper class to test MediaStreamHandler. | |
| 56 class MockAudioProvider : public AudioProviderInterface { | |
| 57 public: | |
| 58 virtual ~MockAudioProvider() {} | |
| 59 MOCK_METHOD3(SetAudioPlayout, void(uint32 ssrc, bool enable, | |
| 60 cricket::AudioRenderer* renderer)); | |
| 61 MOCK_METHOD4(SetAudioSend, void(uint32 ssrc, bool enable, | |
| 62 const cricket::AudioOptions& options, | |
| 63 cricket::AudioRenderer* renderer)); | |
| 64 MOCK_METHOD2(SetAudioPlayoutVolume, void(uint32 ssrc, double volume)); | |
| 65 }; | |
| 66 | |
| 67 // Helper class to test MediaStreamHandler. | |
| 68 class MockVideoProvider : public VideoProviderInterface { | |
| 69 public: | |
| 70 virtual ~MockVideoProvider() {} | |
| 71 MOCK_METHOD2(SetCaptureDevice, bool(uint32 ssrc, | |
| 72 cricket::VideoCapturer* camera)); | |
| 73 MOCK_METHOD3(SetVideoPlayout, void(uint32 ssrc, | |
| 74 bool enable, | |
| 75 cricket::VideoRenderer* renderer)); | |
| 76 MOCK_METHOD3(SetVideoSend, void(uint32 ssrc, bool enable, | |
| 77 const cricket::VideoOptions* options)); | |
| 78 }; | |
| 79 | |
| 80 class FakeVideoSource : public Notifier<VideoSourceInterface> { | |
| 81 public: | |
| 82 static rtc::scoped_refptr<FakeVideoSource> Create() { | |
| 83 return new rtc::RefCountedObject<FakeVideoSource>(); | |
| 84 } | |
| 85 virtual cricket::VideoCapturer* GetVideoCapturer() { | |
| 86 return &fake_capturer_; | |
| 87 } | |
| 88 virtual void Stop() {} | |
| 89 virtual void Restart() {} | |
| 90 virtual void AddSink(cricket::VideoRenderer* output) {} | |
| 91 virtual void RemoveSink(cricket::VideoRenderer* output) {} | |
| 92 virtual SourceState state() const { return state_; } | |
| 93 virtual const cricket::VideoOptions* options() const { return &options_; } | |
| 94 virtual cricket::VideoRenderer* FrameInput() { return NULL; } | |
| 95 | |
| 96 protected: | |
| 97 FakeVideoSource() : state_(kLive) {} | |
| 98 ~FakeVideoSource() {} | |
| 99 | |
| 100 private: | |
| 101 cricket::FakeVideoCapturer fake_capturer_; | |
| 102 SourceState state_; | |
| 103 cricket::VideoOptions options_; | |
| 104 }; | |
| 105 | |
| 106 class MediaStreamHandlerTest : public testing::Test { | |
| 107 public: | |
| 108 MediaStreamHandlerTest() | |
| 109 : handlers_(&audio_provider_, &video_provider_) { | |
| 110 } | |
| 111 | |
| 112 virtual void SetUp() { | |
| 113 stream_ = MediaStream::Create(kStreamLabel1); | |
| 114 rtc::scoped_refptr<VideoSourceInterface> source( | |
| 115 FakeVideoSource::Create()); | |
| 116 video_track_ = VideoTrack::Create(kVideoTrackId, source); | |
| 117 EXPECT_TRUE(stream_->AddTrack(video_track_)); | |
| 118 } | |
| 119 | |
| 120 void AddLocalAudioTrack() { | |
| 121 audio_track_ = AudioTrack::Create(kAudioTrackId, NULL); | |
| 122 EXPECT_TRUE(stream_->AddTrack(audio_track_)); | |
| 123 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | |
| 124 handlers_.AddLocalAudioTrack(stream_, stream_->GetAudioTracks()[0], | |
| 125 kAudioSsrc); | |
| 126 } | |
| 127 | |
| 128 void AddLocalVideoTrack() { | |
| 129 EXPECT_CALL(video_provider_, SetCaptureDevice( | |
| 130 kVideoSsrc, video_track_->GetSource()->GetVideoCapturer())); | |
| 131 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); | |
| 132 handlers_.AddLocalVideoTrack(stream_, stream_->GetVideoTracks()[0], | |
| 133 kVideoSsrc); | |
| 134 } | |
| 135 | |
| 136 void RemoveLocalAudioTrack() { | |
| 137 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)) | |
| 138 .Times(1); | |
| 139 handlers_.RemoveLocalTrack(stream_, audio_track_); | |
| 140 } | |
| 141 | |
| 142 void RemoveLocalVideoTrack() { | |
| 143 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, NULL)) | |
| 144 .Times(1); | |
| 145 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)) | |
| 146 .Times(1); | |
| 147 handlers_.RemoveLocalTrack(stream_, video_track_); | |
| 148 } | |
| 149 | |
| 150 void AddRemoteAudioTrack() { | |
| 151 audio_track_ = AudioTrack::Create(kAudioTrackId, | |
| 152 RemoteAudioSource::Create().get()); | |
| 153 EXPECT_TRUE(stream_->AddTrack(audio_track_)); | |
| 154 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true, _)); | |
| 155 handlers_.AddRemoteAudioTrack(stream_, stream_->GetAudioTracks()[0], | |
| 156 kAudioSsrc); | |
| 157 } | |
| 158 | |
| 159 void AddRemoteVideoTrack() { | |
| 160 EXPECT_CALL(video_provider_, SetVideoPlayout( | |
| 161 kVideoSsrc, true, video_track_->GetSource()->FrameInput())); | |
| 162 handlers_.AddRemoteVideoTrack(stream_, stream_->GetVideoTracks()[0], | |
| 163 kVideoSsrc); | |
| 164 } | |
| 165 | |
| 166 void RemoveRemoteAudioTrack() { | |
| 167 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false, _)); | |
| 168 handlers_.RemoveRemoteTrack(stream_, stream_->GetAudioTracks()[0]); | |
| 169 } | |
| 170 | |
| 171 void RemoveRemoteVideoTrack() { | |
| 172 EXPECT_CALL(video_provider_, SetVideoPlayout(kVideoSsrc, false, NULL)); | |
| 173 handlers_.RemoveRemoteTrack(stream_, stream_->GetVideoTracks()[0]); | |
| 174 } | |
| 175 | |
| 176 protected: | |
| 177 MockAudioProvider audio_provider_; | |
| 178 MockVideoProvider video_provider_; | |
| 179 MediaStreamHandlerContainer handlers_; | |
| 180 rtc::scoped_refptr<MediaStreamInterface> stream_; | |
| 181 rtc::scoped_refptr<VideoTrackInterface> video_track_; | |
| 182 rtc::scoped_refptr<AudioTrackInterface> audio_track_; | |
| 183 }; | |
| 184 | |
| 185 // Test that |audio_provider_| is notified when an audio track is associated | |
| 186 // and disassociated with a MediaStreamHandler. | |
| 187 TEST_F(MediaStreamHandlerTest, AddAndRemoveLocalAudioTrack) { | |
| 188 AddLocalAudioTrack(); | |
| 189 RemoveLocalAudioTrack(); | |
| 190 | |
| 191 handlers_.RemoveLocalStream(stream_); | |
| 192 } | |
| 193 | |
| 194 // Test that |video_provider_| is notified when a video track is associated and | |
| 195 // disassociated with a MediaStreamHandler. | |
| 196 TEST_F(MediaStreamHandlerTest, AddAndRemoveLocalVideoTrack) { | |
| 197 AddLocalVideoTrack(); | |
| 198 RemoveLocalVideoTrack(); | |
| 199 | |
| 200 handlers_.RemoveLocalStream(stream_); | |
| 201 } | |
| 202 | |
| 203 // Test that |video_provider_| and |audio_provider_| is notified when an audio | |
| 204 // and video track is disassociated with a MediaStreamHandler by calling | |
| 205 // RemoveLocalStream. | |
| 206 TEST_F(MediaStreamHandlerTest, RemoveLocalStream) { | |
| 207 AddLocalAudioTrack(); | |
| 208 AddLocalVideoTrack(); | |
| 209 | |
| 210 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, NULL)) | |
| 211 .Times(1); | |
| 212 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)) | |
| 213 .Times(1); | |
| 214 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)) | |
| 215 .Times(1); | |
| 216 handlers_.RemoveLocalStream(stream_); | |
| 217 } | |
| 218 | |
| 219 | |
| 220 // Test that |audio_provider_| is notified when a remote audio and track is | |
| 221 // associated and disassociated with a MediaStreamHandler. | |
| 222 TEST_F(MediaStreamHandlerTest, AddAndRemoveRemoteAudioTrack) { | |
| 223 AddRemoteAudioTrack(); | |
| 224 RemoveRemoteAudioTrack(); | |
| 225 | |
| 226 handlers_.RemoveRemoteStream(stream_); | |
| 227 } | |
| 228 | |
| 229 // Test that |video_provider_| is notified when a remote | |
| 230 // video track is associated and disassociated with a MediaStreamHandler. | |
| 231 TEST_F(MediaStreamHandlerTest, AddAndRemoveRemoteVideoTrack) { | |
| 232 AddRemoteVideoTrack(); | |
| 233 RemoveRemoteVideoTrack(); | |
| 234 | |
| 235 handlers_.RemoveRemoteStream(stream_); | |
| 236 } | |
| 237 | |
| 238 // Test that |audio_provider_| and |video_provider_| is notified when an audio | |
| 239 // and video track is disassociated with a MediaStreamHandler by calling | |
| 240 // RemoveRemoveStream. | |
| 241 TEST_F(MediaStreamHandlerTest, RemoveRemoteStream) { | |
| 242 AddRemoteAudioTrack(); | |
| 243 AddRemoteVideoTrack(); | |
| 244 | |
| 245 EXPECT_CALL(video_provider_, SetVideoPlayout(kVideoSsrc, false, NULL)) | |
| 246 .Times(1); | |
| 247 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false, _)) | |
| 248 .Times(1); | |
| 249 handlers_.RemoveRemoteStream(stream_); | |
| 250 } | |
| 251 | |
| 252 TEST_F(MediaStreamHandlerTest, LocalAudioTrackDisable) { | |
| 253 AddLocalAudioTrack(); | |
| 254 | |
| 255 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)); | |
| 256 audio_track_->set_enabled(false); | |
| 257 | |
| 258 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | |
| 259 audio_track_->set_enabled(true); | |
| 260 | |
| 261 RemoveLocalAudioTrack(); | |
| 262 handlers_.TearDown(); | |
| 263 } | |
| 264 | |
| 265 TEST_F(MediaStreamHandlerTest, RemoteAudioTrackDisable) { | |
| 266 AddRemoteAudioTrack(); | |
| 267 | |
| 268 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false, _)); | |
| 269 audio_track_->set_enabled(false); | |
| 270 | |
| 271 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true, _)); | |
| 272 audio_track_->set_enabled(true); | |
| 273 | |
| 274 RemoveRemoteAudioTrack(); | |
| 275 handlers_.TearDown(); | |
| 276 } | |
| 277 | |
| 278 TEST_F(MediaStreamHandlerTest, LocalVideoTrackDisable) { | |
| 279 AddLocalVideoTrack(); | |
| 280 | |
| 281 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)); | |
| 282 video_track_->set_enabled(false); | |
| 283 | |
| 284 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); | |
| 285 video_track_->set_enabled(true); | |
| 286 | |
| 287 RemoveLocalVideoTrack(); | |
| 288 handlers_.TearDown(); | |
| 289 } | |
| 290 | |
| 291 TEST_F(MediaStreamHandlerTest, RemoteVideoTrackDisable) { | |
| 292 AddRemoteVideoTrack(); | |
| 293 | |
| 294 video_track_->set_enabled(false); | |
| 295 | |
| 296 video_track_->set_enabled(true); | |
| 297 | |
| 298 RemoveRemoteVideoTrack(); | |
| 299 handlers_.TearDown(); | |
| 300 } | |
| 301 | |
| 302 TEST_F(MediaStreamHandlerTest, RemoteAudioTrackSetVolume) { | |
| 303 AddRemoteAudioTrack(); | |
| 304 | |
| 305 double volume = 0.5; | |
| 306 EXPECT_CALL(audio_provider_, SetAudioPlayoutVolume(kAudioSsrc, volume)); | |
| 307 audio_track_->GetSource()->SetVolume(volume); | |
| 308 | |
| 309 // Disable the audio track, this should prevent setting the volume. | |
| 310 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false, _)); | |
| 311 audio_track_->set_enabled(false); | |
| 312 audio_track_->GetSource()->SetVolume(1.0); | |
| 313 | |
| 314 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true, _)); | |
| 315 audio_track_->set_enabled(true); | |
| 316 | |
| 317 double new_volume = 0.8; | |
| 318 EXPECT_CALL(audio_provider_, SetAudioPlayoutVolume(kAudioSsrc, new_volume)); | |
| 319 audio_track_->GetSource()->SetVolume(new_volume); | |
| 320 | |
| 321 RemoveRemoteAudioTrack(); | |
| 322 handlers_.TearDown(); | |
| 323 } | |
| 324 | |
| 325 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1351803002:
Exposing RtpSenders and RtpReceivers from PeerConnection. (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master