[RTCInsertableStreams] Ensure correct transformer type is set

This CL ensures that a sender or receiver gets at most one transformer
and that the transformer is of the correct type.
Prior to this CL, it was possible for an audio sender or receiver
to get a video transformer if insertable streams were enabled for
video. This resulted in data not flowing due to no transformer
being set, or in crashes due to the wrong type of transformer being
executed.

Tests added in
https://chromium-review.googlesource.com/c/chromium/src/+/2139213

Bug: 1068125,1068164
Change-Id: I68a701098b09e0dfc8edaec82bc7161ae686b915
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2139231
Commit-Queue: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Harald Alvestrand <hta@chromium.org>
Cr-Commit-Position: refs/heads/master@{#757035}

third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver.cc

@@ -54,9 +54,9 @@ RTCRtpReceiver::RTCRtpReceiver(RTCPeerConnection* pc,
   DCHECK(pc_);
   DCHECK(receiver_);
   DCHECK(track_);
-  if (force_encoded_audio_insertable_streams_)
+  if (force_encoded_audio_insertable_streams_ && track_->kind() == "audio")
     RegisterEncodedAudioStreamCallback();
-  if (force_encoded_video_insertable_streams_)
+  if (force_encoded_video_insertable_streams_ && track_->kind() == "video")
     RegisterEncodedVideoStreamCallback();
 }
 
@@ -362,6 +362,7 @@ void RTCRtpReceiver::RegisterEncodedAudioStreamCallback() {
   DCHECK(!platform_receiver()
               ->GetEncodedAudioStreamTransformer()
               ->HasTransformerCallback());
+  DCHECK_EQ(track_->kind(), "audio");
   platform_receiver()
       ->GetEncodedAudioStreamTransformer()
       ->SetTransformerCallback(
@@ -370,9 +371,7 @@ void RTCRtpReceiver::RegisterEncodedAudioStreamCallback() {
 }
 
 void RTCRtpReceiver::UnregisterEncodedAudioStreamCallback() {
-  DCHECK(!platform_receiver()
-              ->GetEncodedAudioStreamTransformer()
-              ->HasTransformerCallback());
+  DCHECK_EQ(track_->kind(), "audio");
   platform_receiver()
       ->GetEncodedAudioStreamTransformer()
       ->ResetTransformerCallback();
@@ -432,6 +431,7 @@ void RTCRtpReceiver::RegisterEncodedVideoStreamCallback() {
   DCHECK(!platform_receiver()
               ->GetEncodedVideoStreamTransformer()
               ->HasTransformerCallback());
+  DCHECK_EQ(track_->kind(), "video");
   platform_receiver()
       ->GetEncodedVideoStreamTransformer()
       ->SetTransformerCallback(
@@ -440,9 +440,7 @@ void RTCRtpReceiver::RegisterEncodedVideoStreamCallback() {
 }
 
 void RTCRtpReceiver::UnregisterEncodedVideoStreamCallback() {
-  DCHECK(!platform_receiver()
-              ->GetEncodedVideoStreamTransformer()
-              ->HasTransformerCallback());
+  DCHECK_EQ(track_->kind(), "video");
   platform_receiver()
       ->GetEncodedVideoStreamTransformer()
       ->ResetTransformerCallback();

third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver_impl.cc

@@ -147,18 +147,21 @@ class RTCRtpReceiverImpl::RTCRtpReceiverInternal
         state_(std::move(state)) {
     DCHECK(native_peer_connection_);
     DCHECK(state_.is_initialized());
-    if (force_encoded_audio_insertable_streams) {
+    if (force_encoded_audio_insertable_streams &&
+        webrtc_receiver_->media_type() == cricket::MEDIA_TYPE_AUDIO) {
       encoded_audio_transformer_ =
           std::make_unique<RTCEncodedAudioStreamTransformer>(main_task_runner_);
       webrtc_receiver_->SetDepacketizerToDecoderFrameTransformer(
           encoded_audio_transformer_->Delegate());
     }
-    if (force_encoded_video_insertable_streams) {
+    if (force_encoded_video_insertable_streams &&
+        webrtc_receiver_->media_type() == cricket::MEDIA_TYPE_VIDEO) {
       encoded_video_transformer_ =
           std::make_unique<RTCEncodedVideoStreamTransformer>(main_task_runner_);
       webrtc_receiver_->SetDepacketizerToDecoderFrameTransformer(
           encoded_video_transformer_->Delegate());
     }
+    DCHECK(!encoded_audio_transformer_ || !encoded_video_transformer_);
   }
 
   const RtpReceiverState& state() const {

third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver_impl_test.cc

@@ -178,7 +178,8 @@ TEST_F(RTCRtpReceiverImplTest, CreateReceiverWithInsertableStreams) {
                              /*force_encoded_audio_insertable_streams=*/true,
                              /*force_encoded_video_insertable_streams=*/true);
   EXPECT_TRUE(receiver_->GetEncodedAudioStreamTransformer());
-  EXPECT_TRUE(receiver_->GetEncodedVideoStreamTransformer());
+  // There should be no video transformer in audio receivers.
+  EXPECT_FALSE(receiver_->GetEncodedVideoStreamTransformer());
 }
 
 }  // namespace blink

third_party/blink/renderer/modules/peerconnection/rtc_rtp_sender.cc

@@ -392,12 +392,14 @@ RTCRtpSender::RTCRtpSender(RTCPeerConnection* pc,
       track_(track),
       streams_(std::move(streams)),
       force_encoded_audio_insertable_streams_(
-          force_encoded_audio_insertable_streams),
+          force_encoded_audio_insertable_streams && kind_ == "audio"),
       force_encoded_video_insertable_streams_(
-          force_encoded_video_insertable_streams) {
+          force_encoded_video_insertable_streams && kind_ == "video") {
   DCHECK(pc_);
   DCHECK(sender_);
   DCHECK(!track || kind_ == track->kind());
+  DCHECK(!force_encoded_audio_insertable_streams_ ||
+         !force_encoded_video_insertable_streams_);
   if (force_encoded_audio_insertable_streams_)
     RegisterEncodedAudioStreamCallback();
   if (force_encoded_video_insertable_streams_)
@@ -757,6 +759,7 @@ void RTCRtpSender::RegisterEncodedAudioStreamCallback() {
   DCHECK(!web_sender()
               ->GetEncodedAudioStreamTransformer()
               ->HasTransformerCallback());
+  DCHECK_EQ(kind_, "audio");
   web_sender()->GetEncodedAudioStreamTransformer()->SetTransformerCallback(
       WTF::BindRepeating(&RTCRtpSender::OnAudioFrameFromEncoder,
                          WrapWeakPersistent(this)));
@@ -818,6 +821,7 @@ void RTCRtpSender::RegisterEncodedVideoStreamCallback() {
   DCHECK(!web_sender()
               ->GetEncodedVideoStreamTransformer()
               ->HasTransformerCallback());
+  DCHECK_EQ(kind_, "video");
   web_sender()->GetEncodedVideoStreamTransformer()->SetTransformerCallback(
       WTF::BindRepeating(&RTCRtpSender::OnVideoFrameFromEncoder,
                          WrapWeakPersistent(this)));

third_party/blink/renderer/modules/peerconnection/rtc_rtp_sender_impl.cc

@@ -196,18 +196,21 @@ class RTCRtpSenderImpl::RTCRtpSenderInternal
         state_(std::move(state)) {
     DCHECK(track_map_);
     DCHECK(state_.is_initialized());
-    if (force_encoded_audio_insertable_streams) {
+    if (force_encoded_audio_insertable_streams &&
+        webrtc_sender_->media_type() == cricket::MEDIA_TYPE_AUDIO) {
       encoded_audio_transformer_ =
           std::make_unique<RTCEncodedAudioStreamTransformer>(main_task_runner_);
       webrtc_sender_->SetEncoderToPacketizerFrameTransformer(
           encoded_audio_transformer_->Delegate());
     }
-    if (force_encoded_video_insertable_streams) {
+    if (force_encoded_video_insertable_streams &&
+        webrtc_sender_->media_type() == cricket::MEDIA_TYPE_VIDEO) {
       encoded_video_transformer_ =
           std::make_unique<RTCEncodedVideoStreamTransformer>(main_task_runner_);
       webrtc_sender_->SetEncoderToPacketizerFrameTransformer(
           encoded_video_transformer_->Delegate());
     }
+    DCHECK(!encoded_audio_transformer_ || !encoded_video_transformer_);
   }
 
   const RtpSenderState& state() const {