Move talk/app/webrtc to webrtc/api

talk/app/webrtc/rtpsenderreceiver_unittest.cc

Index: talk/app/webrtc/rtpsenderreceiver_unittest.cc
diff --git a/talk/app/webrtc/rtpsenderreceiver_unittest.cc b/talk/app/webrtc/rtpsenderreceiver_unittest.cc
deleted file mode 100644
index bcd9ea035022168616bbd43ecf54405f9fc849ac..0000000000000000000000000000000000000000
--- a/talk/app/webrtc/rtpsenderreceiver_unittest.cc
+++ /dev/null
@@ -1,515 +0,0 @@
-/*
- * libjingle
- * Copyright 2012 Google Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  1. Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *  2. Redistributions in binary form must reproduce the above copyright notice,
- *     this list of conditions and the following disclaimer in the documentation
- *     and/or other materials provided with the distribution.
- *  3. The name of the author may not be used to endorse or promote products
- *     derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <string>
-#include <utility>
-
-#include "talk/app/webrtc/audiotrack.h"
-#include "talk/app/webrtc/mediastream.h"
-#include "talk/app/webrtc/remoteaudiosource.h"
-#include "talk/app/webrtc/rtpreceiver.h"
-#include "talk/app/webrtc/rtpsender.h"
-#include "talk/app/webrtc/streamcollection.h"
-#include "talk/app/webrtc/videosource.h"
-#include "talk/app/webrtc/videotrack.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/gunit.h"
-#include "webrtc/media/base/fakevideocapturer.h"
-#include "webrtc/media/base/mediachannel.h"
-
-using ::testing::_;
-using ::testing::Exactly;
-
-static const char kStreamLabel1[] = "local_stream_1";
-static const char kVideoTrackId[] = "video_1";
-static const char kAudioTrackId[] = "audio_1";
-static const uint32_t kVideoSsrc = 98;
-static const uint32_t kVideoSsrc2 = 100;
-static const uint32_t kAudioSsrc = 99;
-static const uint32_t kAudioSsrc2 = 101;
-
-namespace webrtc {
-
-// Helper class to test RtpSender/RtpReceiver.
-class MockAudioProvider : public AudioProviderInterface {
- public:
-  ~MockAudioProvider() override {}
-
-  MOCK_METHOD2(SetAudioPlayout,
-               void(uint32_t ssrc,
-                    bool enable));
-  MOCK_METHOD4(SetAudioSend,
-               void(uint32_t ssrc,
-                    bool enable,
-                    const cricket::AudioOptions& options,
-                    cricket::AudioRenderer* renderer));
-  MOCK_METHOD2(SetAudioPlayoutVolume, void(uint32_t ssrc, double volume));
-
-  void SetRawAudioSink(uint32_t,
-                       rtc::scoped_ptr<AudioSinkInterface> sink) override {
-    sink_ = std::move(sink);
-  }
-
- private:
-  rtc::scoped_ptr<AudioSinkInterface> sink_;
-};
-
-// Helper class to test RtpSender/RtpReceiver.
-class MockVideoProvider : public VideoProviderInterface {
- public:
-  virtual ~MockVideoProvider() {}
-  MOCK_METHOD2(SetCaptureDevice,
-               bool(uint32_t ssrc, cricket::VideoCapturer* camera));
-  MOCK_METHOD3(SetVideoPlayout,
-               void(uint32_t ssrc,
-                    bool enable,
-                    rtc::VideoSinkInterface<cricket::VideoFrame>* sink));
-  MOCK_METHOD3(SetVideoSend,
-               void(uint32_t ssrc,
-                    bool enable,
-                    const cricket::VideoOptions* options));
-};
-
-class FakeVideoSource : public Notifier<VideoSourceInterface> {
- public:
-  static rtc::scoped_refptr<FakeVideoSource> Create(bool remote) {
-    return new rtc::RefCountedObject<FakeVideoSource>(remote);
-  }
-  virtual cricket::VideoCapturer* GetVideoCapturer() { return &fake_capturer_; }
-  virtual void Stop() {}
-  virtual void Restart() {}
-  virtual void AddSink(rtc::VideoSinkInterface<cricket::VideoFrame>* output) {}
-  virtual void RemoveSink(
-      rtc::VideoSinkInterface<cricket::VideoFrame>* output) {}
-  virtual SourceState state() const { return state_; }
-  virtual bool remote() const { return remote_; }
-  virtual const cricket::VideoOptions* options() const { return &options_; }
-  virtual cricket::VideoRenderer* FrameInput() { return NULL; }
-
- protected:
-  explicit FakeVideoSource(bool remote) : state_(kLive), remote_(remote) {}
-  ~FakeVideoSource() {}
-
- private:
-  cricket::FakeVideoCapturer fake_capturer_;
-  SourceState state_;
-  bool remote_;
-  cricket::VideoOptions options_;
-};
-
-class RtpSenderReceiverTest : public testing::Test {
- public:
-  virtual void SetUp() {
-    stream_ = MediaStream::Create(kStreamLabel1);
-  }
-
-  void AddVideoTrack(bool remote) {
-    rtc::scoped_refptr<VideoSourceInterface> source(
-        FakeVideoSource::Create(remote));
-    video_track_ = VideoTrack::Create(kVideoTrackId, source);
-    EXPECT_TRUE(stream_->AddTrack(video_track_));
-  }
-
-  void CreateAudioRtpSender() {
-    audio_track_ = AudioTrack::Create(kAudioTrackId, NULL);
-    EXPECT_TRUE(stream_->AddTrack(audio_track_));
-    EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _));
-    audio_rtp_sender_ =
-        new AudioRtpSender(stream_->GetAudioTracks()[0], stream_->label(),
-                           &audio_provider_, nullptr);
-    audio_rtp_sender_->SetSsrc(kAudioSsrc);
-  }
-
-  void CreateVideoRtpSender() {
-    AddVideoTrack(false);
-    EXPECT_CALL(video_provider_,
-                SetCaptureDevice(
-                    kVideoSsrc, video_track_->GetSource()->GetVideoCapturer()));
-    EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _));
-    video_rtp_sender_ = new VideoRtpSender(stream_->GetVideoTracks()[0],
-                                           stream_->label(), &video_provider_);
-    video_rtp_sender_->SetSsrc(kVideoSsrc);
-  }
-
-  void DestroyAudioRtpSender() {
-    EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _))
-        .Times(1);
-    audio_rtp_sender_ = nullptr;
-  }
-
-  void DestroyVideoRtpSender() {
-    EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, NULL)).Times(1);
-    EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1);
-    video_rtp_sender_ = nullptr;
-  }
-
-  void CreateAudioRtpReceiver() {
-    audio_track_ = AudioTrack::Create(
-        kAudioTrackId, RemoteAudioSource::Create(kAudioSsrc, NULL));
-    EXPECT_TRUE(stream_->AddTrack(audio_track_));
-    EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true));
-    audio_rtp_receiver_ = new AudioRtpReceiver(stream_->GetAudioTracks()[0],
-                                               kAudioSsrc, &audio_provider_);
-  }
-
-  void CreateVideoRtpReceiver() {
-    AddVideoTrack(true);
-    EXPECT_CALL(video_provider_,
-                SetVideoPlayout(kVideoSsrc, true,
-                                video_track_->GetSink()));
-    video_rtp_receiver_ = new VideoRtpReceiver(stream_->GetVideoTracks()[0],
-                                               kVideoSsrc, &video_provider_);
-  }
-
-  void DestroyAudioRtpReceiver() {
-    EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false));
-    audio_rtp_receiver_ = nullptr;
-  }
-
-  void DestroyVideoRtpReceiver() {
-    EXPECT_CALL(video_provider_, SetVideoPlayout(kVideoSsrc, false, NULL));
-    video_rtp_receiver_ = nullptr;
-  }
-
- protected:
-  MockAudioProvider audio_provider_;
-  MockVideoProvider video_provider_;
-  rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
-  rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_;
-  rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;
-  rtc::scoped_refptr<VideoRtpReceiver> video_rtp_receiver_;
-  rtc::scoped_refptr<MediaStreamInterface> stream_;
-  rtc::scoped_refptr<VideoTrackInterface> video_track_;
-  rtc::scoped_refptr<AudioTrackInterface> audio_track_;
-};
-
-// Test that |audio_provider_| is notified when an audio track is associated
-// and disassociated with an AudioRtpSender.
-TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpSender) {
-  CreateAudioRtpSender();
-  DestroyAudioRtpSender();
-}
-
-// Test that |video_provider_| is notified when a video track is associated and
-// disassociated with a VideoRtpSender.
-TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpSender) {
-  CreateVideoRtpSender();
-  DestroyVideoRtpSender();
-}
-
-// Test that |audio_provider_| is notified when a remote audio and track is
-// associated and disassociated with an AudioRtpReceiver.
-TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpReceiver) {
-  CreateAudioRtpReceiver();
-  DestroyAudioRtpReceiver();
-}
-
-// Test that |video_provider_| is notified when a remote
-// video track is associated and disassociated with a VideoRtpReceiver.
-TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpReceiver) {
-  CreateVideoRtpReceiver();
-  DestroyVideoRtpReceiver();
-}
-
-TEST_F(RtpSenderReceiverTest, LocalAudioTrackDisable) {
-  CreateAudioRtpSender();
-
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _));
-  audio_track_->set_enabled(false);
-
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _));
-  audio_track_->set_enabled(true);
-
-  DestroyAudioRtpSender();
-}
-
-TEST_F(RtpSenderReceiverTest, RemoteAudioTrackDisable) {
-  CreateAudioRtpReceiver();
-
-  EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false));
-  audio_track_->set_enabled(false);
-
-  EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true));
-  audio_track_->set_enabled(true);
-
-  DestroyAudioRtpReceiver();
-}
-
-TEST_F(RtpSenderReceiverTest, LocalVideoTrackDisable) {
-  CreateVideoRtpSender();
-
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _));
-  video_track_->set_enabled(false);
-
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _));
-  video_track_->set_enabled(true);
-
-  DestroyVideoRtpSender();
-}
-
-TEST_F(RtpSenderReceiverTest, RemoteVideoTrackDisable) {
-  CreateVideoRtpReceiver();
-
-  video_track_->set_enabled(false);
-
-  video_track_->set_enabled(true);
-
-  DestroyVideoRtpReceiver();
-}
-
-TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) {
-  CreateAudioRtpReceiver();
-
-  double volume = 0.5;
-  EXPECT_CALL(audio_provider_, SetAudioPlayoutVolume(kAudioSsrc, volume));
-  audio_track_->GetSource()->SetVolume(volume);
-
-  // Disable the audio track, this should prevent setting the volume.
-  EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false));
-  audio_track_->set_enabled(false);
-  audio_track_->GetSource()->SetVolume(1.0);
-
-  EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true));
-  audio_track_->set_enabled(true);
-
-  double new_volume = 0.8;
-  EXPECT_CALL(audio_provider_, SetAudioPlayoutVolume(kAudioSsrc, new_volume));
-  audio_track_->GetSource()->SetVolume(new_volume);
-
-  DestroyAudioRtpReceiver();
-}
-
-// Test that provider methods aren't called without both a track and an SSRC.
-TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) {
-  rtc::scoped_refptr<AudioRtpSender> sender =
-      new AudioRtpSender(&audio_provider_, nullptr);
-  rtc::scoped_refptr<AudioTrackInterface> track =
-      AudioTrack::Create(kAudioTrackId, nullptr);
-  EXPECT_TRUE(sender->SetTrack(track));
-  EXPECT_TRUE(sender->SetTrack(nullptr));
-  sender->SetSsrc(kAudioSsrc);
-  sender->SetSsrc(0);
-  // Just let it get destroyed and make sure it doesn't call any methods on the
-  // provider interface.
-}
-
-// Test that provider methods aren't called without both a track and an SSRC.
-TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) {
-  rtc::scoped_refptr<VideoRtpSender> sender =
-      new VideoRtpSender(&video_provider_);
-  EXPECT_TRUE(sender->SetTrack(video_track_));
-  EXPECT_TRUE(sender->SetTrack(nullptr));
-  sender->SetSsrc(kVideoSsrc);
-  sender->SetSsrc(0);
-  // Just let it get destroyed and make sure it doesn't call any methods on the
-  // provider interface.
-}
-
-// Test that an audio sender calls the expected methods on the provider once
-// it has a track and SSRC, when the SSRC is set first.
-TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) {
-  rtc::scoped_refptr<AudioRtpSender> sender =
-      new AudioRtpSender(&audio_provider_, nullptr);
-  rtc::scoped_refptr<AudioTrackInterface> track =
-      AudioTrack::Create(kAudioTrackId, nullptr);
-  sender->SetSsrc(kAudioSsrc);
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _));
-  sender->SetTrack(track);
-
-  // Calls expected from destructor.
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1);
-}
-
-// Test that an audio sender calls the expected methods on the provider once
-// it has a track and SSRC, when the SSRC is set last.
-TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) {
-  rtc::scoped_refptr<AudioRtpSender> sender =
-      new AudioRtpSender(&audio_provider_, nullptr);
-  rtc::scoped_refptr<AudioTrackInterface> track =
-      AudioTrack::Create(kAudioTrackId, nullptr);
-  sender->SetTrack(track);
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _));
-  sender->SetSsrc(kAudioSsrc);
-
-  // Calls expected from destructor.
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1);
-}
-
-// Test that a video sender calls the expected methods on the provider once
-// it has a track and SSRC, when the SSRC is set first.
-TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) {
-  AddVideoTrack(false);
-  rtc::scoped_refptr<VideoRtpSender> sender =
-      new VideoRtpSender(&video_provider_);
-  sender->SetSsrc(kVideoSsrc);
-  EXPECT_CALL(video_provider_,
-              SetCaptureDevice(kVideoSsrc,
-                               video_track_->GetSource()->GetVideoCapturer()));
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _));
-  sender->SetTrack(video_track_);
-
-  // Calls expected from destructor.
-  EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1);
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1);
-}
-
-// Test that a video sender calls the expected methods on the provider once
-// it has a track and SSRC, when the SSRC is set last.
-TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) {
-  AddVideoTrack(false);
-  rtc::scoped_refptr<VideoRtpSender> sender =
-      new VideoRtpSender(&video_provider_);
-  sender->SetTrack(video_track_);
-  EXPECT_CALL(video_provider_,
-              SetCaptureDevice(kVideoSsrc,
-                               video_track_->GetSource()->GetVideoCapturer()));
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _));
-  sender->SetSsrc(kVideoSsrc);
-
-  // Calls expected from destructor.
-  EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1);
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1);
-}
-
-// Test that the sender is disconnected from the provider when its SSRC is
-// set to 0.
-TEST_F(RtpSenderReceiverTest, AudioSenderSsrcSetToZero) {
-  rtc::scoped_refptr<AudioTrackInterface> track =
-      AudioTrack::Create(kAudioTrackId, nullptr);
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _));
-  rtc::scoped_refptr<AudioRtpSender> sender =
-      new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr);
-  sender->SetSsrc(kAudioSsrc);
-
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1);
-  sender->SetSsrc(0);
-
-  // Make sure it's SetSsrc that called methods on the provider, and not the
-  // destructor.
-  EXPECT_CALL(audio_provider_, SetAudioSend(_, _, _, _)).Times(0);
-}
-
-// Test that the sender is disconnected from the provider when its SSRC is
-// set to 0.
-TEST_F(RtpSenderReceiverTest, VideoSenderSsrcSetToZero) {
-  AddVideoTrack(false);
-  EXPECT_CALL(video_provider_,
-              SetCaptureDevice(kVideoSsrc,
-                               video_track_->GetSource()->GetVideoCapturer()));
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _));
-  rtc::scoped_refptr<VideoRtpSender> sender =
-      new VideoRtpSender(video_track_, kStreamLabel1, &video_provider_);
-  sender->SetSsrc(kVideoSsrc);
-
-  EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1);
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1);
-  sender->SetSsrc(0);
-
-  // Make sure it's SetSsrc that called methods on the provider, and not the
-  // destructor.
-  EXPECT_CALL(video_provider_, SetCaptureDevice(_, _)).Times(0);
-  EXPECT_CALL(video_provider_, SetVideoSend(_, _, _)).Times(0);
-}
-
-TEST_F(RtpSenderReceiverTest, AudioSenderTrackSetToNull) {
-  rtc::scoped_refptr<AudioTrackInterface> track =
-      AudioTrack::Create(kAudioTrackId, nullptr);
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _));
-  rtc::scoped_refptr<AudioRtpSender> sender =
-      new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr);
-  sender->SetSsrc(kAudioSsrc);
-
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1);
-  EXPECT_TRUE(sender->SetTrack(nullptr));
-
-  // Make sure it's SetTrack that called methods on the provider, and not the
-  // destructor.
-  EXPECT_CALL(audio_provider_, SetAudioSend(_, _, _, _)).Times(0);
-}
-
-TEST_F(RtpSenderReceiverTest, VideoSenderTrackSetToNull) {
-  AddVideoTrack(false);
-  EXPECT_CALL(video_provider_,
-              SetCaptureDevice(kVideoSsrc,
-                               video_track_->GetSource()->GetVideoCapturer()));
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _));
-  rtc::scoped_refptr<VideoRtpSender> sender =
-      new VideoRtpSender(video_track_, kStreamLabel1, &video_provider_);
-  sender->SetSsrc(kVideoSsrc);
-
-  EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1);
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1);
-  EXPECT_TRUE(sender->SetTrack(nullptr));
-
-  // Make sure it's SetTrack that called methods on the provider, and not the
-  // destructor.
-  EXPECT_CALL(video_provider_, SetCaptureDevice(_, _)).Times(0);
-  EXPECT_CALL(video_provider_, SetVideoSend(_, _, _)).Times(0);
-}
-
-TEST_F(RtpSenderReceiverTest, AudioSenderSsrcChanged) {
-  AddVideoTrack(false);
-  rtc::scoped_refptr<AudioTrackInterface> track =
-      AudioTrack::Create(kAudioTrackId, nullptr);
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _));
-  rtc::scoped_refptr<AudioRtpSender> sender =
-      new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr);
-  sender->SetSsrc(kAudioSsrc);
-
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1);
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc2, true, _, _)).Times(1);
-  sender->SetSsrc(kAudioSsrc2);
-
-  // Calls expected from destructor.
-  EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc2, false, _, _)).Times(1);
-}
-
-TEST_F(RtpSenderReceiverTest, VideoSenderSsrcChanged) {
-  AddVideoTrack(false);
-  EXPECT_CALL(video_provider_,
-              SetCaptureDevice(kVideoSsrc,
-                               video_track_->GetSource()->GetVideoCapturer()));
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _));
-  rtc::scoped_refptr<VideoRtpSender> sender =
-      new VideoRtpSender(video_track_, kStreamLabel1, &video_provider_);
-  sender->SetSsrc(kVideoSsrc);
-
-  EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1);
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1);
-  EXPECT_CALL(video_provider_,
-              SetCaptureDevice(kVideoSsrc2,
-                               video_track_->GetSource()->GetVideoCapturer()));
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, true, _));
-  sender->SetSsrc(kVideoSsrc2);
-
-  // Calls expected from destructor.
-  EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc2, nullptr)).Times(1);
-  EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, false, _)).Times(1);
-}
-
-}  // namespace webrtc