Add PeerConnectionObserver::OnRemoveTrack callback.

webrtc/pc/peerconnectioninterface_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 588 matching lines @@
 
   void OnAddTrack(
       rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
       const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
           streams) override {
     EXPECT_TRUE(receiver != nullptr);
     num_added_tracks_++;
     last_added_track_label_ = receiver->id();
   }
 
+  void OnRemoveTrack(
+      rtc::scoped_refptr<RtpReceiverInterface> receiver,
+      const std::vector<rtc::scoped_refptr<MediaStreamInterface>> &
+          streams) override {
+    EXPECT_TRUE(receiver != nullptr);
+    num_removed_tracks_++;
+    last_removed_track_label_ = receiver->id();
+  }
+
   // Returns the label of the last added stream.
   // Empty string if no stream have been added.
   std::string GetLastAddedStreamLabel() {
     if (last_added_stream_.get())
       return last_added_stream_->label();
     return "";
   }
   std::string GetLastRemovedStreamLabel() {
     if (last_removed_stream_.get())
       return last_removed_stream_->label();
     return "";
   }
 
   rtc::scoped_refptr<PeerConnectionInterface> pc_;
   PeerConnectionInterface::SignalingState state_;
   std::unique_ptr<IceCandidateInterface> last_candidate_;
   rtc::scoped_refptr<DataChannelInterface> last_datachannel_;
   rtc::scoped_refptr<StreamCollection> remote_streams_;
   bool renegotiation_needed_ = false;
   bool ice_complete_ = false;
   bool callback_triggered_ = false;
   int num_added_tracks_ = 0;
   std::string last_added_track_label_;
+  int num_removed_tracks_ = 0;
+  std::string last_removed_track_label_;
 
  private:
   rtc::scoped_refptr<MediaStreamInterface> last_added_stream_;
   rtc::scoped_refptr<MediaStreamInterface> last_removed_stream_;
 };
 
 }  // namespace
 
 // The PeerConnectionMediaConfig tests below verify that configuration and
 // constraints are propagated into the PeerConnection's MediaConfig. These
@@ skipping 215 matching lines @@
     rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(label));
     rtc::scoped_refptr<AudioTrackInterface> audio_track(
         pc_factory_->CreateAudioTrack(label + "a0", NULL));
     stream->AddTrack(audio_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
-  void AddAudioVideoStream(const std::string& stream_label,
-                           const std::string& audio_track_label,
-                           const std::string& video_track_label) {
+  rtc::scoped_refptr<MediaStreamInterface> AddAudioVideoStream(
+      const std::string& stream_label,
+      const std::string& audio_track_label,
+      const std::string& video_track_label) {
     // Create a local stream.
     rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(stream_label));
     rtc::scoped_refptr<AudioTrackInterface> audio_track(
         pc_factory_->CreateAudioTrack(
             audio_track_label, static_cast<AudioSourceInterface*>(NULL)));
     stream->AddTrack(audio_track.get());
     rtc::scoped_refptr<VideoTrackInterface> video_track(
         pc_factory_->CreateVideoTrack(
             video_track_label, pc_factory_->CreateVideoSource(
                                    std::unique_ptr<cricket::VideoCapturer>(
                                        new cricket::FakeVideoCapturer()))));
     stream->AddTrack(video_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
+    return stream;
   }
 
   bool DoCreateOfferAnswer(std::unique_ptr<SessionDescriptionInterface>* desc,
                            bool offer,
                            MediaConstraintsInterface* constraints) {
     rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockCreateSessionDescriptionObserver>());
     if (offer) {
       pc_->CreateOffer(observer, constraints);
@@ skipping 2867 matching lines @@
   observer_.renegotiation_needed_ = false;
 
   stream->RemoveTrack(audio_track);
   EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
   observer_.renegotiation_needed_ = false;
 
   stream->RemoveTrack(video_track);
   EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
   observer_.renegotiation_needed_ = false;
 }
+
+// This tests that PeerConnectionObserver::OnRemoveTrack is correctly called.
+TEST_F(PeerConnectionInterfaceTest, OnRemoveTrackCallback) {
+  CreatePeerConnectionWithoutDtls();
+  auto stream = AddAudioVideoStream(
+    kStreamLabel1, "audio_label", "video_label");
+  CreateOfferReceiveAnswer();
+
+  auto audio_track = stream->GetAudioTracks()[0];
+  EXPECT_TRUE(stream->RemoveTrack(audio_track));
+  EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
+  observer_.renegotiation_needed_ = false;
+
+  CreateOfferReceiveAnswer();
+
+  EXPECT_EQ(observer_.num_removed_tracks_, 1u);
+  EXPECT_EQ(observer_.last_removed_track_label_, audio_track->id());
+}