Let MediaSession generate a FlexFEC SSRC when FlexFEC is active.

webrtc/pc/mediasession_unittest.cc

 /*
  *  Copyright 2004 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 172 matching lines @@
   return mdesc && mdesc->type() == media_type;
 }
 
 static cricket::MediaContentDirection
 GetMediaDirection(const ContentInfo* content) {
   cricket::MediaContentDescription* desc =
       reinterpret_cast<cricket::MediaContentDescription*>(content->description);
   return desc->direction();
 }
 
-static void AddRtxCodec(const VideoCodec& rtx_codec,
-                        std::vector<VideoCodec>* codecs) {
-  ASSERT_FALSE(cricket::FindCodecById(*codecs, rtx_codec.id));
-  codecs->push_back(rtx_codec);
+static void AddSecondaryCodec(const VideoCodec& secondary_codec,

[perkj_webrtc, 2016/11/17 20:41:12]

Why not just AddCodec if you want to keep it at all. I dont see the value of it.

[brandtr, 2016/11/21 09:16:30]

After a second thought, I don't think the the assert on line 195 is necessary
for FlexFEC. I'm renaming this function back to AddRtxCodec, and won't use it
for FlexFEC.

+                              std::vector<VideoCodec>* codecs) {
+  ASSERT_FALSE(cricket::FindCodecById(*codecs, secondary_codec.id));
+  codecs->push_back(secondary_codec);
 }
 
 template <class T>
 static std::vector<std::string> GetCodecNames(const std::vector<T>& codecs) {
   std::vector<std::string> codec_names;
   for (const auto& codec : codecs) {
     codec_names.push_back(codec.name);
   }
   return codec_names;
 }
@@ skipping 1417 matching lines @@
   EXPECT_EQ(video_streams[0], updated_video_streams[0]);
   EXPECT_EQ(kVideoTrack2, updated_video_streams[1].id);
   // All media streams in one PeerConnection share one CNAME.
   EXPECT_EQ(updated_video_streams[1].cname, updated_video_streams[0].cname);
 
   const StreamParamsVec& updated_data_streams = updated_dcd->streams();
   ASSERT_EQ(1U, updated_data_streams.size());
   EXPECT_TRUE(data_streams[0] == updated_data_streams[0]);
 }
 
-
 // Create an updated offer after creating an answer to the original offer and
 // verify that the codecs that were part of the original answer are not changed
 // in the updated offer.
 TEST_F(MediaSessionDescriptionFactoryTest,
        RespondentCreatesOfferAfterCreatingAnswer) {
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = true;
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
@@ skipping 42 matching lines @@
 // Create an updated offer after creating an answer to the original offer and
 // verify that the codecs that were part of the original answer are not changed
 // in the updated offer. In this test Rtx is enabled.
 TEST_F(MediaSessionDescriptionFactoryTest,
        RespondentCreatesOfferAfterCreatingAnswerWithRtx) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.recv_audio = false;
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates rtx for H264 with the payload type |f1_| uses.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
+                    &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates rtx for H264 with the payload type |f2_| uses.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id),
+                    &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
 
   std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
-  AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
-              &expected_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
+                    &expected_codecs);
 
   EXPECT_EQ(expected_codecs, vcd->codecs());
 
   // Now, make sure we get same result (except for the order) if |f2_| creates
   // an updated offer even though the default payload types between |f1_| and
   // |f2_| are different.
   std::unique_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
   ASSERT_TRUE(updated_offer);
   std::unique_ptr<SessionDescription> updated_answer(
       f1_.CreateAnswer(updated_offer.get(), opts, answer.get()));
 
   const VideoContentDescription* updated_vcd =
       GetFirstVideoContentDescription(updated_answer.get());
 
   EXPECT_EQ(expected_codecs, updated_vcd->codecs());
 }
 
 // Create an updated offer that adds video after creating an audio only answer
 // to the original offer. This test verifies that if a video codec and the RTX
 // codec have the same default payload type as an audio codec that is already in
 // use, the added codecs payload types are changed.
 TEST_F(MediaSessionDescriptionFactoryTest,
        RespondentCreatesOfferWithVideoAndRtxAfterCreatingAudioAnswer) {
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates rtx for H264 with the payload type |f1_| uses.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
+                    &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = false;
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const AudioContentDescription* acd =
       GetFirstAudioContentDescription(answer.get());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
 
   // Now - let |f2_| add video with RTX and let the payload type the RTX codec
   // reference  be the same as an audio codec that was negotiated in the
   // first offer/answer exchange.
   opts.recv_audio = true;
   opts.recv_video = true;
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   int used_pl_type = acd->codecs()[0].id;
   f2_codecs[0].id = used_pl_type;  // Set the payload type for H264.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, used_pl_type), &f2_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, used_pl_type), &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
   std::unique_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
   ASSERT_TRUE(updated_offer);
   std::unique_ptr<SessionDescription> updated_answer(
       f1_.CreateAnswer(updated_offer.get(), opts, answer.get()));
 
   const AudioContentDescription* updated_acd =
       GetFirstAudioContentDescription(answer.get());
@@ skipping 16 matching lines @@
 // without RTX, and with different default payload types.
 // Verify that the added RTX codec references the correct payload type.
 TEST_F(MediaSessionDescriptionFactoryTest,
        RespondentCreatesOfferWithRtxAfterCreatingAnswerWithoutRtx) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.recv_audio = true;
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates rtx for H264 with the payload type |f2_| uses.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id),
+                    &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   ASSERT_TRUE(offer.get() != nullptr);
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, nullptr));
 
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
 
   std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
   EXPECT_EQ(expected_codecs, vcd->codecs());
 
   // Now, ensure that the RTX codec is created correctly when |f2_| creates an
   // updated offer, even though the default payload types are different from
   // those of |f1_|.
   std::unique_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
   ASSERT_TRUE(updated_offer);
 
   const VideoContentDescription* updated_vcd =
       GetFirstVideoContentDescription(updated_offer.get());
 
   // New offer should attempt to add H263, and RTX for H264.
   expected_codecs.push_back(kVideoCodecs2[1]);
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[1].id),
-              &expected_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[1].id),
+                    &expected_codecs);
   EXPECT_EQ(expected_codecs, updated_vcd->codecs());
 }
 
 // Test that RTX is ignored when there is no associated payload type parameter.
 TEST_F(MediaSessionDescriptionFactoryTest, RtxWithoutApt) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.recv_audio = false;
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX without associated payload type parameter.
-  AddRtxCodec(VideoCodec(126, cricket::kRtxCodecName), &f1_codecs);
+  AddSecondaryCodec(VideoCodec(126, cricket::kRtxCodecName), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H264 with the payload type |f2_| uses.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id),
+                    &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   // kCodecParamAssociatedPayloadType will always be added to the offer when RTX
   // is selected. Manually remove kCodecParamAssociatedPayloadType so that it
   // is possible to test that that RTX is dropped when
   // kCodecParamAssociatedPayloadType is missing in the offer.
   VideoContentDescription* desc =
       static_cast<cricket::VideoContentDescription*>(
@@ skipping 18 matching lines @@
 }
 
 // Test that RTX will be filtered out in the answer if its associated payload
 // type doesn't match the local value.
 TEST_F(MediaSessionDescriptionFactoryTest, FilterOutRtxIfAptDoesntMatch) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.recv_audio = false;
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX for H264 in sender.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
+                    &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H263 in receiver.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[1].id), &f2_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[1].id),
+                    &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   // Associated payload type doesn't match, therefore, RTX codec is removed in
   // the answer.
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   std::vector<std::string> codec_names =
       GetCodecNames(GetFirstVideoContentDescription(answer.get())->codecs());
   EXPECT_EQ(codec_names.end(), std::find(codec_names.begin(), codec_names.end(),
                                          cricket::kRtxCodecName));
 }
 
 // Test that when multiple RTX codecs are offered, only the matched RTX codec
 // is added in the answer, and the unsupported RTX codec is filtered out.
 TEST_F(MediaSessionDescriptionFactoryTest,
        FilterOutUnsupportedRtxWhenCreatingAnswer) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.recv_audio = false;
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX for H264-SVC in sender.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[0].id),
+                    &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   // This creates RTX for H264 in sender.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
+                    &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
   // This creates RTX for H264 in receiver.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(124, kVideoCodecs2[0].id), &f2_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(124, kVideoCodecs2[0].id),
+                    &f2_codecs);
   f2_.set_video_codecs(f2_codecs);
 
   // H264-SVC codec is removed in the answer, therefore, associated RTX codec
   // for H264-SVC should also be removed.
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(answer.get());
   std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
-  AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
-              &expected_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
+                    &expected_codecs);
 
   EXPECT_EQ(expected_codecs, vcd->codecs());
 }
 
 // Test that after one RTX codec has been negotiated, a new offer can attempt
 // to add another.
 TEST_F(MediaSessionDescriptionFactoryTest, AddSecondRtxInNewOffer) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.recv_audio = false;
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX for H264 for the offerer.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
+                    &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   ASSERT_TRUE(offer);
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(offer.get());
 
   std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecs1);
-  AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
-              &expected_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id),
+                    &expected_codecs);
   EXPECT_EQ(expected_codecs, vcd->codecs());
 
   // Now, attempt to add RTX for H264-SVC.
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[0].id),
+                    &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::unique_ptr<SessionDescription> updated_offer(
       f1_.CreateOffer(opts, offer.get()));
   ASSERT_TRUE(updated_offer);
   vcd = GetFirstVideoContentDescription(updated_offer.get());
 
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[0].id),
-              &expected_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[0].id),
+                    &expected_codecs);
   EXPECT_EQ(expected_codecs, vcd->codecs());
 }
 
 // Test that when RTX is used in conjunction with simulcast, an RTX ssrc is
 // generated for each simulcast ssrc and correctly grouped.
 TEST_F(MediaSessionDescriptionFactoryTest, SimSsrcsGenerateMultipleRtxSsrcs) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   opts.recv_audio = false;
 
   // Add simulcast streams.
   opts.AddSendVideoStream("stream1", "stream1label", 3);
 
   // Use a single real codec, and then add RTX for it.
   std::vector<VideoCodec> f1_codecs;
   f1_codecs.push_back(VideoCodec(97, "H264"));
-  AddRtxCodec(VideoCodec::CreateRtxCodec(125, 97), &f1_codecs);
+  AddSecondaryCodec(VideoCodec::CreateRtxCodec(125, 97), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   // Ensure that the offer has an RTX ssrc for each regular ssrc, and that there
   // is a FID ssrc + grouping for each.
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   VideoContentDescription* desc = static_cast<VideoContentDescription*>(
       offer->GetContentDescriptionByName(cricket::CN_VIDEO));
   ASSERT_TRUE(desc != NULL);
   EXPECT_TRUE(desc->multistream());
   const StreamParamsVec& streams = desc->streams();
   // Single stream.
   ASSERT_EQ(1u, streams.size());
   // Stream should have 6 ssrcs: 3 for video, 3 for RTX.
   EXPECT_EQ(6u, streams[0].ssrcs.size());
   // And should have a SIM group for the simulcast.
   EXPECT_TRUE(streams[0].has_ssrc_group("SIM"));
   // And a FID group for RTX.
   EXPECT_TRUE(streams[0].has_ssrc_group("FID"));
   std::vector<uint32_t> primary_ssrcs;
   streams[0].GetPrimarySsrcs(&primary_ssrcs);
   EXPECT_EQ(3u, primary_ssrcs.size());
   std::vector<uint32_t> fid_ssrcs;
   streams[0].GetFidSsrcs(primary_ssrcs, &fid_ssrcs);
   EXPECT_EQ(3u, fid_ssrcs.size());
 }
 
+// Test that, when the FlexFEC codec is added, a FlexFEC ssrc is created
+// together with a FEC-FR grouping.
+TEST_F(MediaSessionDescriptionFactoryTest, GenerateFlexfecSsrc) {
+  MediaSessionOptions opts;
+  opts.recv_video = true;
+  opts.recv_audio = false;
+
+  // Add single stream.
+  opts.AddSendVideoStream("stream1", "stream1label", 1);
+
+  // Use a single real codec, and then add FlexFEC for it.
+  std::vector<VideoCodec> f1_codecs;
+  f1_codecs.push_back(VideoCodec(97, "H264"));
+  AddSecondaryCodec(VideoCodec(118, "flexfec-03"), &f1_codecs);
+  f1_.set_video_codecs(f1_codecs);
+
+  // Ensure that the offer has a single FlexFEC ssrc and that
+  // there is no FEC-FR ssrc + grouping for each.
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
+  VideoContentDescription* desc = static_cast<VideoContentDescription*>(
+      offer->GetContentDescriptionByName(cricket::CN_VIDEO));
+  ASSERT_TRUE(desc != nullptr);
+  EXPECT_TRUE(desc->multistream());
+  const StreamParamsVec& streams = desc->streams();
+  // Single stream.
+  ASSERT_EQ(1u, streams.size());
+  // Stream should have 2 ssrcs: 1 for video, 1 for FlexFEC.
+  EXPECT_EQ(2u, streams[0].ssrcs.size());
+  // And should a FEC-FR group for FlexFEC.

[perkj_webrtc, 2016/11/17 20:41:12]

and should have

[brandtr, 2016/11/21 09:16:30]

Done.

+  EXPECT_TRUE(streams[0].has_ssrc_group("FEC-FR"));
+  std::vector<uint32_t> primary_ssrcs;
+  streams[0].GetPrimarySsrcs(&primary_ssrcs);
+  ASSERT_EQ(1u, primary_ssrcs.size());
+  uint32_t flexfec_ssrc;
+  EXPECT_TRUE(streams[0].GetFecFrSsrc(primary_ssrcs[0], &flexfec_ssrc));
+  EXPECT_NE(flexfec_ssrc, 0u);
+}
+
+// Test that FlexFEC is disabled for simulcast.
+// TODO(brandtr): Remove this test when we support simulcast, either through
+// multiple FlexfecSenders, or through multistream protection.
+TEST_F(MediaSessionDescriptionFactoryTest, SimSsrcsGenerateNoFlexfecSsrcs) {
+  MediaSessionOptions opts;
+  opts.recv_video = true;
+  opts.recv_audio = false;
+
+  // Add simulcast streams.
+  opts.AddSendVideoStream("stream1", "stream1label", 3);
+
+  // Use a single real codec, and then add FlexFEC for it.
+  std::vector<VideoCodec> f1_codecs;
+  f1_codecs.push_back(VideoCodec(97, "H264"));
+  AddSecondaryCodec(VideoCodec(118, "flexfec-03"), &f1_codecs);
+  f1_.set_video_codecs(f1_codecs);
+
+  // Ensure that the offer has no FlexFEC ssrcs for each regular ssrc, and that
+  // there is no FEC-FR ssrc + grouping for each.
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
+  ASSERT_TRUE(offer.get() != nullptr);
+  VideoContentDescription* desc = static_cast<VideoContentDescription*>(
+      offer->GetContentDescriptionByName(cricket::CN_VIDEO));
+  ASSERT_TRUE(desc != nullptr);
+  EXPECT_FALSE(desc->multistream());
+  const StreamParamsVec& streams = desc->streams();
+  // Single stream.
+  ASSERT_EQ(1u, streams.size());
+  // Stream should have 3 ssrcs: 3 for video, 0 for FlexFEC.
+  EXPECT_EQ(3u, streams[0].ssrcs.size());
+  // And should have a SIM group for the simulcast.
+  EXPECT_TRUE(streams[0].has_ssrc_group("SIM"));
+  // And not a FEC-FR group for FlexFEC.
+  EXPECT_FALSE(streams[0].has_ssrc_group("FEC-FR"));
+  std::vector<uint32_t> primary_ssrcs;
+  streams[0].GetPrimarySsrcs(&primary_ssrcs);
+  EXPECT_EQ(3u, primary_ssrcs.size());
+  for (uint32_t primary_ssrc : primary_ssrcs) {
+    uint32_t flexfec_ssrc;
+    EXPECT_FALSE(streams[0].GetFecFrSsrc(primary_ssrc, &flexfec_ssrc));
+  }
+}
+
 // Create an updated offer after creating an answer to the original offer and
 // verify that the RTP header extensions that were part of the original answer
 // are not changed in the updated offer.
 TEST_F(MediaSessionDescriptionFactoryTest,
        RespondentCreatesOfferAfterCreatingAnswerWithRtpExtensions) {
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = true;
 
   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension1));
@@ skipping 827 matching lines @@
         << ", got: " << format_codecs(acd->codecs())
         << "; Offered: " << MediaContentDirectionToString(offer_direction)
         << ", answerer wants: "
         << MediaContentDirectionToString(answer_direction)
         << "; got: " << MediaContentDirectionToString(acd->direction());
   } else {
     EXPECT_EQ(offer_direction, cricket::MD_INACTIVE)
         << "Only inactive offers are allowed to not generate any audio content";
   }
 }
-}
+
+}  // namespace
 
 class AudioCodecsOfferTest
     : public ::testing::TestWithParam<std::tr1::tuple<MediaContentDirection,
                                                       bool>> {
 };
 
 TEST_P(AudioCodecsOfferTest, TestCodecsInOffer) {
   TestAudioCodecsOffer(std::tr1::get<0>(GetParam()),
                        std::tr1::get<1>(GetParam()));
 }
@@ skipping 24 matching lines @@
                         ::testing::Combine(
                              ::testing::Values(cricket::MD_SENDONLY,
                                                cricket::MD_RECVONLY,
                                                cricket::MD_SENDRECV,
                                                cricket::MD_INACTIVE),
                              ::testing::Values(cricket::MD_SENDONLY,
                                                cricket::MD_RECVONLY,
                                                cricket::MD_SENDRECV,
                                                cricket::MD_INACTIVE),
                              ::testing::Bool()));