Adding support for Unified Plan offer/answer negotiation.

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 16 matching lines @@
 
 #define ASSERT_CRYPTO(cd, s, cs) \
     ASSERT_EQ(s, cd->cryptos().size()); \
     ASSERT_EQ(std::string(cs), cd->cryptos()[0].cipher_suite)
 
 typedef std::vector<cricket::Candidate> Candidates;
 
 using cricket::MediaContentDescription;
 using cricket::MediaSessionDescriptionFactory;
 using cricket::MediaContentDirection;
+using cricket::MediaDescriptionOptions;
 using cricket::MediaSessionOptions;
 using cricket::MediaType;
 using cricket::SessionDescription;
 using cricket::SsrcGroup;
 using cricket::StreamParams;
 using cricket::StreamParamsVec;
 using cricket::TransportDescription;
 using cricket::TransportDescriptionFactory;
 using cricket::TransportInfo;
 using cricket::ContentInfo;
@@ skipping 11 matching lines @@
 using cricket::AudioCodec;
 using cricket::VideoCodec;
 using cricket::DataCodec;
 using cricket::NS_JINGLE_RTP;
 using cricket::MEDIA_TYPE_AUDIO;
 using cricket::MEDIA_TYPE_VIDEO;
 using cricket::MEDIA_TYPE_DATA;
 using cricket::SEC_DISABLED;
 using cricket::SEC_ENABLED;
 using cricket::SEC_REQUIRED;
+using cricket::RtpTransceiverDirection;
 using rtc::CS_AES_CM_128_HMAC_SHA1_32;
 using rtc::CS_AES_CM_128_HMAC_SHA1_80;
 using rtc::CS_AEAD_AES_128_GCM;
 using rtc::CS_AEAD_AES_256_GCM;
 using webrtc::RtpExtension;
 
 static const AudioCodec kAudioCodecs1[] = {
     AudioCodec(103, "ISAC", 16000, -1, 1),
     AudioCodec(102, "iLBC", 8000, 13300, 1),
     AudioCodec(0, "PCMU", 8000, 64000, 1),
@@ skipping 123 matching lines @@
 static const char kDataTrack1[] = "data_1";
 static const char kDataTrack2[] = "data_2";
 static const char kDataTrack3[] = "data_3";
 
 static const char* kMediaProtocols[] = {"RTP/AVP", "RTP/SAVP", "RTP/AVPF",
                                         "RTP/SAVPF"};
 static const char* kMediaProtocolsDtls[] = {
     "TCP/TLS/RTP/SAVPF", "TCP/TLS/RTP/SAVP", "UDP/TLS/RTP/SAVPF",
     "UDP/TLS/RTP/SAVP"};
 
+static constexpr bool kStopped = true;
+
 static bool IsMediaContentOfType(const ContentInfo* content,
                                  MediaType media_type) {
   const MediaContentDescription* mdesc =
       static_cast<const MediaContentDescription*>(content->description);
   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);
 }
 
 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;
 }
 
+// MIDs are not the identification of the MediaDescriptionOptions.

[Taylor Brandstetter, 2017/08/03 00:24:48]

Can you explain what this comment means?

[Zhi Huang, 2017/08/04 18:38:25]

Done.

+std::vector<MediaDescriptionOptions>::iterator FindFirstMediaDescriptionByMid(
+    const std::string& mid,
+    MediaSessionOptions* opts) {
+  return std::find_if(
+      opts->media_description_options.begin(),
+      opts->media_description_options.end(),
+      [mid](const MediaDescriptionOptions& t) { return t.mid == mid; });
+}
+
+// Add a media section to the |session_options|.
+static void AddMediaSection(MediaType type,
+                            const std::string& mid,
+                            MediaContentDirection direction,
+                            bool stopped,
+                            MediaSessionOptions* opts) {
+  opts->media_description_options.push_back(MediaDescriptionOptions(
+      type, mid,
+      cricket::RtpTransceiverDirection::FromMediaContentDirection(direction),
+      stopped));
+}
+
+static void AddAudioVideoSections(MediaContentDirection direction,
+                                  MediaSessionOptions* opts) {
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", direction, !kStopped, opts);
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", direction, !kStopped, opts);
+}
+
+static void AddDataSection(cricket::DataChannelType dct,
+                           MediaContentDirection direction,
+                           MediaSessionOptions* opts) {
+  opts->data_channel_type = dct;
+  AddMediaSection(MEDIA_TYPE_DATA, "data", direction, !kStopped, opts);
+}
+
+static void AttachSenderToMediaSection(const std::string& mid,
+                                       MediaType type,
+                                       const std::string& track_id,
+                                       const std::string& stream_id,
+                                       int num_sim_layer,
+                                       MediaSessionOptions* session_options) {
+  auto it = FindFirstMediaDescriptionByMid(mid, session_options);
+  switch (type) {
+    case MEDIA_TYPE_AUDIO:
+      it->AddAudioSender(track_id, stream_id);
+      break;
+    case MEDIA_TYPE_VIDEO:
+      it->AddVideoSender(track_id, stream_id, num_sim_layer);
+      break;
+    case MEDIA_TYPE_DATA:
+      it->AddRtpDataChannel(track_id, stream_id);
+      break;
+    default:
+      RTC_NOTREACHED();
+  }
+}
+
+static void DetachSenderFromMediaSection(const std::string& mid,
+                                         const std::string& track_id,
+                                         MediaSessionOptions* session_options) {
+  auto it = FindFirstMediaDescriptionByMid(mid, session_options);
+  auto sender_it = it->sender_options.begin();
+  for (; sender_it != it->sender_options.end(); ++sender_it) {
+    if (sender_it->track_id == track_id) {
+      it->sender_options.erase(sender_it);
+      return;
+    }
+  }
+  RTC_NOTREACHED();
+}
+
+// Helper function used to create a default MediaSessionOptions for Plan B SDP.
+// (https://tools.ietf.org/html/draft-uberti-rtcweb-plan-00).
+static MediaSessionOptions CreatePlanBMediaSessionOptions() {
+  MediaSessionOptions session_options;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &session_options);
+  return session_options;
+}
+
+// TODO(zhihuang): Most of these tests were written while MediaSessionOptions
+// was designed for Plan B SDP, where only one audio "m=" section and one video
+// "m=" section could be generated, and ordering couldn't be controlled. Many of
+// these tests may be obsolete as a result, and should be refactored or removed.
 class MediaSessionDescriptionFactoryTest : public testing::Test {
  public:
-  MediaSessionDescriptionFactoryTest()
-      : f1_(&tdf1_),
-        f2_(&tdf2_) {
+  MediaSessionDescriptionFactoryTest() : f1_(&tdf1_), f2_(&tdf2_) {
     f1_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs1),
                          MAKE_VECTOR(kAudioCodecs1));
     f1_.set_video_codecs(MAKE_VECTOR(kVideoCodecs1));
     f1_.set_data_codecs(MAKE_VECTOR(kDataCodecs1));
     f2_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs2),
                          MAKE_VECTOR(kAudioCodecs2));
     f2_.set_video_codecs(MAKE_VECTOR(kVideoCodecs2));
     f2_.set_data_codecs(MAKE_VECTOR(kDataCodecs2));
     tdf1_.set_certificate(rtc::RTCCertificate::Create(
         std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id1"))));
@@ skipping 43 matching lines @@
   // Returns true if the transport info contains "renomination" as an
   // ICE option.
   bool GetIceRenomination(const TransportInfo* transport_info) {
     const std::vector<std::string>& ice_options =
         transport_info->description.transport_options;
     auto iter =
         std::find(ice_options.begin(), ice_options.end(), "renomination");
     return iter != ice_options.end();
   }
 
-  void TestTransportInfo(bool offer, const MediaSessionOptions& options,
+  void TestTransportInfo(bool offer,
+                         MediaSessionOptions& options,
                          bool has_current_desc) {
     const std::string current_audio_ufrag = "current_audio_ufrag";
     const std::string current_audio_pwd = "current_audio_pwd";
     const std::string current_video_ufrag = "current_video_ufrag";
     const std::string current_video_pwd = "current_video_pwd";
     const std::string current_data_ufrag = "current_data_ufrag";
     const std::string current_data_pwd = "current_data_pwd";
     std::unique_ptr<SessionDescription> current_desc;
     std::unique_ptr<SessionDescription> desc;
     if (has_current_desc) {
@@ skipping 24 matching lines @@
       EXPECT_TRUE(ti_audio != NULL);
       if (has_current_desc) {
         EXPECT_EQ(current_audio_ufrag, ti_audio->description.ice_ufrag);
         EXPECT_EQ(current_audio_pwd, ti_audio->description.ice_pwd);
       } else {
         EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
                   ti_audio->description.ice_ufrag.size());
         EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
                   ti_audio->description.ice_pwd.size());
       }
-      EXPECT_EQ(options.enable_ice_renomination, GetIceRenomination(ti_audio));
+      auto media_desc_options_it =
+          FindFirstMediaDescriptionByMid("audio", &options);
+      EXPECT_EQ(
+          media_desc_options_it->transport_options.enable_ice_renomination,
+          GetIceRenomination(ti_audio));
 
     } else {
       EXPECT_TRUE(ti_audio == NULL);
     }
     const TransportInfo* ti_video = desc->GetTransportInfoByName("video");
     if (options.has_video()) {
       EXPECT_TRUE(ti_video != NULL);
       if (options.bundle_enabled) {
         EXPECT_EQ(ti_audio->description.ice_ufrag,
                   ti_video->description.ice_ufrag);
         EXPECT_EQ(ti_audio->description.ice_pwd,
                   ti_video->description.ice_pwd);
       } else {
         if (has_current_desc) {
           EXPECT_EQ(current_video_ufrag, ti_video->description.ice_ufrag);
           EXPECT_EQ(current_video_pwd, ti_video->description.ice_pwd);
         } else {
           EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
                     ti_video->description.ice_ufrag.size());
           EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
                     ti_video->description.ice_pwd.size());
         }
       }
-      EXPECT_EQ(options.enable_ice_renomination, GetIceRenomination(ti_video));
+      auto media_desc_options_it =
+          FindFirstMediaDescriptionByMid("video", &options);
+      EXPECT_EQ(
+          media_desc_options_it->transport_options.enable_ice_renomination,
+          GetIceRenomination(ti_video));
     } else {
       EXPECT_TRUE(ti_video == NULL);
     }
     const TransportInfo* ti_data = desc->GetTransportInfoByName("data");
     if (options.has_data()) {
       EXPECT_TRUE(ti_data != NULL);
       if (options.bundle_enabled) {
         EXPECT_EQ(ti_audio->description.ice_ufrag,
                   ti_data->description.ice_ufrag);
         EXPECT_EQ(ti_audio->description.ice_pwd,
                   ti_data->description.ice_pwd);
       } else {
         if (has_current_desc) {
           EXPECT_EQ(current_data_ufrag, ti_data->description.ice_ufrag);
           EXPECT_EQ(current_data_pwd, ti_data->description.ice_pwd);
         } else {
           EXPECT_EQ(static_cast<size_t>(cricket::ICE_UFRAG_LENGTH),
                     ti_data->description.ice_ufrag.size());
           EXPECT_EQ(static_cast<size_t>(cricket::ICE_PWD_LENGTH),
                     ti_data->description.ice_pwd.size());
         }
       }
-      EXPECT_EQ(options.enable_ice_renomination, GetIceRenomination(ti_data));
+      auto media_desc_options_it =
+          FindFirstMediaDescriptionByMid("data", &options);
+      EXPECT_EQ(
+          media_desc_options_it->transport_options.enable_ice_renomination,
+          GetIceRenomination(ti_data));
 
     } else {
       EXPECT_TRUE(ti_video == NULL);
     }
   }
 
   void TestCryptoWithBundle(bool offer) {
     f1_.set_secure(SEC_ENABLED);
     MediaSessionOptions options;
-    options.recv_audio = true;
-    options.recv_video = true;
-    options.data_channel_type = cricket::DCT_RTP;
+    AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+    AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
     std::unique_ptr<SessionDescription> ref_desc;
     std::unique_ptr<SessionDescription> desc;
     if (offer) {
       options.bundle_enabled = false;
       ref_desc.reset(f1_.CreateOffer(options, NULL));
       options.bundle_enabled = true;
       desc.reset(f1_.CreateOffer(options, ref_desc.get()));
     } else {
       options.bundle_enabled = true;
       ref_desc.reset(f1_.CreateOffer(options, NULL));
@@ skipping 25 matching lines @@
           audio_media_desc->cryptos()[0])) {
         found = true;
         break;
       }
     }
     EXPECT_TRUE(found);
   }
 
   // This test that the audio and video media direction is set to
   // |expected_direction_in_answer| in an answer if the offer direction is set
-  // to |direction_in_offer|.
+  // to |direction_in_offer| and the answer is willing to both send and receive.
   void TestMediaDirectionInAnswer(
       cricket::MediaContentDirection direction_in_offer,
       cricket::MediaContentDirection expected_direction_in_answer) {
-    MediaSessionOptions opts;
-    opts.recv_video = true;
-    std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+    MediaSessionOptions offer_opts;
+    AddAudioVideoSections(direction_in_offer, &offer_opts);
+
+    std::unique_ptr<SessionDescription> offer(
+        f1_.CreateOffer(offer_opts, NULL));
     ASSERT_TRUE(offer.get() != NULL);
     ContentInfo* ac_offer = offer->GetContentByName("audio");
     ASSERT_TRUE(ac_offer != NULL);
-    AudioContentDescription* acd_offer =
-        static_cast<AudioContentDescription*>(ac_offer->description);
-    acd_offer->set_direction(direction_in_offer);
     ContentInfo* vc_offer = offer->GetContentByName("video");
     ASSERT_TRUE(vc_offer != NULL);
-    VideoContentDescription* vcd_offer =
-        static_cast<VideoContentDescription*>(vc_offer->description);
-    vcd_offer->set_direction(direction_in_offer);
 
+    MediaSessionOptions answer_opts;
+    AddAudioVideoSections(cricket::MD_SENDRECV, &answer_opts);
     std::unique_ptr<SessionDescription> answer(
-        f2_.CreateAnswer(offer.get(), opts, NULL));
+        f2_.CreateAnswer(offer.get(), answer_opts, NULL));
     const AudioContentDescription* acd_answer =
         GetFirstAudioContentDescription(answer.get());
     EXPECT_EQ(expected_direction_in_answer, acd_answer->direction());
     const VideoContentDescription* vcd_answer =
         GetFirstVideoContentDescription(answer.get());
     EXPECT_EQ(expected_direction_in_answer, vcd_answer->direction());
   }
 
   bool VerifyNoCNCodecs(const cricket::ContentInfo* content) {
     const cricket::ContentDescription* description = content->description;
     RTC_CHECK(description != NULL);
     const cricket::AudioContentDescription* audio_content_desc =
         static_cast<const cricket::AudioContentDescription*>(description);
     RTC_CHECK(audio_content_desc != NULL);
     for (size_t i = 0; i < audio_content_desc->codecs().size(); ++i) {
       if (audio_content_desc->codecs()[i].name == "CN")
         return false;
     }
     return true;
   }
 
   void TestVideoGcmCipher(bool gcm_offer, bool gcm_answer) {
     MediaSessionOptions offer_opts;
-    offer_opts.recv_video = true;
+    AddAudioVideoSections(cricket::MD_RECVONLY, &offer_opts);
     offer_opts.crypto_options.enable_gcm_crypto_suites = gcm_offer;
+
     MediaSessionOptions answer_opts;
-    answer_opts.recv_video = true;
+    AddAudioVideoSections(cricket::MD_RECVONLY, &answer_opts);
     answer_opts.crypto_options.enable_gcm_crypto_suites = gcm_answer;
+
     f1_.set_secure(SEC_ENABLED);
     f2_.set_secure(SEC_ENABLED);
     std::unique_ptr<SessionDescription> offer(
         f1_.CreateOffer(offer_opts, NULL));
     ASSERT_TRUE(offer.get() != NULL);
     std::unique_ptr<SessionDescription> answer(
         f2_.CreateAnswer(offer.get(), answer_opts, NULL));
     const ContentInfo* ac = answer->GetContentByName("audio");
     const ContentInfo* vc = answer->GetContentByName("video");
     ASSERT_TRUE(ac != NULL);
     ASSERT_TRUE(vc != NULL);
     EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
     EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
     const AudioContentDescription* acd =
         static_cast<const AudioContentDescription*>(ac->description);
     const VideoContentDescription* vcd =
         static_cast<const VideoContentDescription*>(vc->description);
     EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
     EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
     EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
-    EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+    EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attached
     EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
     if (gcm_offer && gcm_answer) {
       ASSERT_CRYPTO(acd, 1U, CS_AEAD_AES_256_GCM);
     } else {
       ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
     }
     EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
     EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
-    EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
+    EXPECT_EQ(0U, vcd->first_ssrc());             // no sender is attached
     EXPECT_TRUE(vcd->rtcp_mux());                 // negotiated rtcp-mux
     if (gcm_offer && gcm_answer) {
       ASSERT_CRYPTO(vcd, 1U, CS_AEAD_AES_256_GCM);
     } else {
       ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
     }
     EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
   }
 
  protected:
   MediaSessionDescriptionFactory f1_;
   MediaSessionDescriptionFactory f2_;
   TransportDescriptionFactory tdf1_;
   TransportDescriptionFactory tdf2_;
 };
 
 // Create a typical audio offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOffer) {
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(MediaSessionOptions(), NULL));
+      f1_.CreateOffer(CreatePlanBMediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc == NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attached.
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical video offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attached
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
   EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
-  EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, vcd->first_ssrc());             // no sender is attached
   EXPECT_EQ(kAutoBandwidth, vcd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(vcd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 }
 
 // Test creating an offer with bundle where the Codecs have the same dynamic
 // RTP playlod type. The test verifies that the offer don't contain the
 // duplicate RTP payload types.
 TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
   const VideoCodec& offered_video_codec = f2_.video_codecs()[0];
   const AudioCodec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
   const DataCodec& offered_data_codec = f2_.data_codecs()[0];
   ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
   ASSERT_EQ(offered_video_codec.id, offered_data_codec.id);
 
   MediaSessionOptions opts;
-  opts.recv_audio = true;
-  opts.recv_video = true;
-  opts.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &opts);
   opts.bundle_enabled = true;
   std::unique_ptr<SessionDescription> offer(f2_.CreateOffer(opts, NULL));
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(offer.get());
   const AudioContentDescription* acd =
       GetFirstAudioContentDescription(offer.get());
   const DataContentDescription* dcd =
       GetFirstDataContentDescription(offer.get());
   ASSERT_TRUE(NULL != vcd);
   ASSERT_TRUE(NULL != acd);
   ASSERT_TRUE(NULL != dcd);
   EXPECT_NE(vcd->codecs()[0].id, acd->codecs()[0].id);
   EXPECT_NE(vcd->codecs()[0].id, dcd->codecs()[0].id);
   EXPECT_NE(acd->codecs()[0].id, dcd->codecs()[0].id);
   EXPECT_EQ(vcd->codecs()[0].name, offered_video_codec.name);
   EXPECT_EQ(acd->codecs()[0].name, offered_audio_codec.name);
   EXPECT_EQ(dcd->codecs()[0].name, offered_data_codec.name);
 }
 
 // Test creating an updated offer with with bundle, audio, video and data
 // after an audio only session has been negotiated.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestCreateUpdatedVideoOfferWithBundle) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   MediaSessionOptions opts;
-  opts.recv_audio = true;
-  opts.recv_video = false;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_INACTIVE, kStopped,
+                  &opts);
   opts.data_channel_type = cricket::DCT_NONE;
   opts.bundle_enabled = true;
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   MediaSessionOptions updated_opts;
-  updated_opts.recv_audio = true;
-  updated_opts.recv_video = true;
-  updated_opts.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &updated_opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &updated_opts);
   updated_opts.bundle_enabled = true;
   std::unique_ptr<SessionDescription> updated_offer(
       f1_.CreateOffer(updated_opts, answer.get()));
 
   const AudioContentDescription* acd =
       GetFirstAudioContentDescription(updated_offer.get());
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(updated_offer.get());
   const DataContentDescription* dcd =
       GetFirstDataContentDescription(updated_offer.get());
   EXPECT_TRUE(NULL != vcd);
   EXPECT_TRUE(NULL != acd);
   EXPECT_TRUE(NULL != dcd);
 
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 }
 
 // Create a RTP data offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateRtpDataOffer) {
   MediaSessionOptions opts;
-  opts.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &opts);
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* dc = offer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(dc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), dc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attched.
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
   EXPECT_EQ(f1_.data_codecs(), dcd->codecs());
-  EXPECT_NE(0U, dcd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, dcd->first_ssrc());  // no sender is attached.
   EXPECT_EQ(cricket::kDataMaxBandwidth,
             dcd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 }
 
 // Create an SCTP data offer with bundle without error.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSctpDataOffer) {
   MediaSessionOptions opts;
-  opts.recv_audio = false;
   opts.bundle_enabled = true;
-  opts.data_channel_type = cricket::DCT_SCTP;
+  AddDataSection(cricket::DCT_SCTP, cricket::MD_SENDRECV, &opts);
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   EXPECT_TRUE(offer.get() != NULL);
   EXPECT_TRUE(offer->GetContentByName("data") != NULL);
 }
 
 // Test creating an sctp data channel from an already generated offer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateImplicitSctpDataOffer) {
   MediaSessionOptions opts;
-  opts.recv_audio = false;
   opts.bundle_enabled = true;
-  opts.data_channel_type = cricket::DCT_SCTP;
+  AddDataSection(cricket::DCT_SCTP, cricket::MD_SENDRECV, &opts);
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer1.get() != NULL);
   const ContentInfo* data = offer1->GetContentByName("data");
   ASSERT_TRUE(data != NULL);
   const MediaContentDescription* mdesc =
       static_cast<const MediaContentDescription*>(data->description);
   ASSERT_EQ(cricket::kMediaProtocolSctp, mdesc->protocol());
 
   // Now set data_channel_type to 'none' (default) and make sure that the
   // datachannel type that gets generated from the previous offer, is of the
   // same type.
   opts.data_channel_type = cricket::DCT_NONE;
   std::unique_ptr<SessionDescription> offer2(
       f1_.CreateOffer(opts, offer1.get()));
   data = offer2->GetContentByName("data");
   ASSERT_TRUE(data != NULL);
   mdesc = static_cast<const MediaContentDescription*>(data->description);
   EXPECT_EQ(cricket::kMediaProtocolSctp, mdesc->protocol());
 }
 
 // Create an audio, video offer without legacy StreamParams.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestCreateOfferWithoutLegacyStreams) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
-  f1_.set_add_legacy_streams(false);
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
 
   EXPECT_FALSE(vcd->has_ssrcs());             // No StreamParams.
   EXPECT_FALSE(acd->has_ssrcs());             // No StreamParams.
 }
 
 // Creates an audio+video sendonly offer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSendOnlyOffer) {
-  MediaSessionOptions options;
-  options.recv_audio = false;
-  options.recv_video = false;
-  options.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
-  options.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
+  MediaSessionOptions opts;
+  AddAudioVideoSections(cricket::MD_SENDONLY, &opts);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, kVideoTrack1,
+                             kMediaStream1, 1, &opts);
+  AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack1,
+                             kMediaStream1, 1, &opts);
 
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, NULL));
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   EXPECT_EQ(2u, offer->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer->contents()[0], MEDIA_TYPE_AUDIO));
   EXPECT_TRUE(IsMediaContentOfType(&offer->contents()[1], MEDIA_TYPE_VIDEO));
 
   EXPECT_EQ(cricket::MD_SENDONLY, GetMediaDirection(&offer->contents()[0]));
   EXPECT_EQ(cricket::MD_SENDONLY, GetMediaDirection(&offer->contents()[1]));
 }
 
 // Verifies that the order of the media contents in the current
 // SessionDescription is preserved in the new SessionDescription.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateOfferContentOrder) {
   MediaSessionOptions opts;
-  opts.recv_audio = false;
-  opts.recv_video = false;
-  opts.data_channel_type = cricket::DCT_SCTP;
+  AddDataSection(cricket::DCT_SCTP, cricket::MD_SENDRECV, &opts);
 
   std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer1.get() != NULL);
   EXPECT_EQ(1u, offer1->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer1->contents()[0], MEDIA_TYPE_DATA));
 
-  opts.recv_video = true;
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   std::unique_ptr<SessionDescription> offer2(
       f1_.CreateOffer(opts, offer1.get()));
   ASSERT_TRUE(offer2.get() != NULL);
   EXPECT_EQ(2u, offer2->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[0], MEDIA_TYPE_DATA));
   EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[1], MEDIA_TYPE_VIDEO));
 
-  opts.recv_audio = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   std::unique_ptr<SessionDescription> offer3(
       f1_.CreateOffer(opts, offer2.get()));
   ASSERT_TRUE(offer3.get() != NULL);
   EXPECT_EQ(3u, offer3->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[0], MEDIA_TYPE_DATA));
   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[1], MEDIA_TYPE_VIDEO));
   EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[2], MEDIA_TYPE_AUDIO));
-
-  // Verifies the default order is audio-video-data, so that the previous checks
-  // didn't pass by accident.
-  std::unique_ptr<SessionDescription> offer4(f1_.CreateOffer(opts, NULL));
-  ASSERT_TRUE(offer4.get() != NULL);
-  EXPECT_EQ(3u, offer4->contents().size());
-  EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[0], MEDIA_TYPE_AUDIO));
-  EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[1], MEDIA_TYPE_VIDEO));
-  EXPECT_TRUE(IsMediaContentOfType(&offer4->contents()[2], MEDIA_TYPE_DATA));
 }
 
 // Create a typical audio answer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswer) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(MediaSessionOptions(), NULL));
+      f1_.CreateOffer(CreatePlanBMediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+      f2_.CreateAnswer(offer.get(), CreatePlanBMediaSessionOptions(), NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc == NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attached
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical audio answer with GCM ciphers enabled, and ensure it
 // matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerGcm) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  MediaSessionOptions options;
-  options.crypto_options.enable_gcm_crypto_suites = true;
-  std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(options, NULL));
+  MediaSessionOptions opts;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, kStopped,
+                  &opts);
+  opts.crypto_options.enable_gcm_crypto_suites = true;
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), options, NULL));
+      f2_.CreateAnswer(offer.get(), opts, NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc == NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attached
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AEAD_AES_256_GCM);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical video answer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswer) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   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 ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attached
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
   EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
-  EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, vcd->first_ssrc());             // no sender is attached
   EXPECT_TRUE(vcd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 }
 
 // Create a typical video answer with GCM ciphers enabled, and ensure it
 // matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerGcm) {
   TestVideoGcmCipher(true, true);
 }
 
 // Create a typical video answer with GCM ciphers enabled for the offer only,
 // and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerGcmOffer) {
   TestVideoGcmCipher(true, false);
 }
 
 // Create a typical video answer with GCM ciphers enabled for the answer only,
 // and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerGcmAnswer) {
   TestVideoGcmCipher(false, true);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswer) {
-  MediaSessionOptions opts;
-  opts.data_channel_type = cricket::DCT_RTP;
+  MediaSessionOptions opts = CreatePlanBMediaSessionOptions();
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &opts);
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   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 ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* dc = answer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(dc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), dc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attached
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
   EXPECT_EQ(MAKE_VECTOR(kDataCodecsAnswer), dcd->codecs());
-  EXPECT_NE(0U, dcd->first_ssrc());  // a random nonzero ssrc
+  EXPECT_EQ(0U, dcd->first_ssrc());  // no sender is attached
   EXPECT_TRUE(dcd->rtcp_mux());      // negotiated rtcp-mux
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerGcm) {
-  MediaSessionOptions opts;
-  opts.data_channel_type = cricket::DCT_RTP;
+  MediaSessionOptions opts = CreatePlanBMediaSessionOptions();
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &opts);
   opts.crypto_options.enable_gcm_crypto_suites = true;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   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 ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* dc = answer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(dc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), dc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
   EXPECT_EQ(MAKE_VECTOR(kAudioCodecsAnswer), acd->codecs());
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // negotiated auto bw
-  EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
+  EXPECT_EQ(0U, acd->first_ssrc());             // no sender is attached
   EXPECT_TRUE(acd->rtcp_mux());                 // negotiated rtcp-mux
   ASSERT_CRYPTO(acd, 1U, CS_AEAD_AES_256_GCM);
   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
   EXPECT_EQ(MAKE_VECTOR(kDataCodecsAnswer), dcd->codecs());
-  EXPECT_NE(0U, dcd->first_ssrc());  // a random nonzero ssrc
+  EXPECT_EQ(0U, dcd->first_ssrc());  // no sender is attached
   EXPECT_TRUE(dcd->rtcp_mux());      // negotiated rtcp-mux
   ASSERT_CRYPTO(dcd, 1U, CS_AEAD_AES_256_GCM);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), dcd->protocol());
 }
 
 // The use_sctpmap flag should be set in a DataContentDescription by default.
 // The answer's use_sctpmap flag should match the offer's.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerUsesSctpmap) {
   MediaSessionOptions opts;
-  opts.data_channel_type = cricket::DCT_SCTP;
+  AddDataSection(cricket::DCT_SCTP, cricket::MD_SENDRECV, &opts);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   ContentInfo* dc_offer = offer->GetContentByName("data");
   ASSERT_TRUE(dc_offer != NULL);
   DataContentDescription* dcd_offer =
       static_cast<DataContentDescription*>(dc_offer->description);
   EXPECT_TRUE(dcd_offer->use_sctpmap());
 
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   const ContentInfo* dc_answer = answer->GetContentByName("data");
   ASSERT_TRUE(dc_answer != NULL);
   const DataContentDescription* dcd_answer =
       static_cast<const DataContentDescription*>(dc_answer->description);
   EXPECT_TRUE(dcd_answer->use_sctpmap());
 }
 
 // The answer's use_sctpmap flag should match the offer's.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerWithoutSctpmap) {
   MediaSessionOptions opts;
-  opts.data_channel_type = cricket::DCT_SCTP;
+  AddDataSection(cricket::DCT_SCTP, cricket::MD_SENDRECV, &opts);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   ContentInfo* dc_offer = offer->GetContentByName("data");
   ASSERT_TRUE(dc_offer != NULL);
   DataContentDescription* dcd_offer =
       static_cast<DataContentDescription*>(dc_offer->description);
   dcd_offer->set_use_sctpmap(false);
 
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   const ContentInfo* dc_answer = answer->GetContentByName("data");
   ASSERT_TRUE(dc_answer != NULL);
   const DataContentDescription* dcd_answer =
       static_cast<const DataContentDescription*>(dc_answer->description);
   EXPECT_FALSE(dcd_answer->use_sctpmap());
 }
 
 // Test that a valid answer will be created for "DTLS/SCTP", "UDP/DTLS/SCTP"
 // and "TCP/DTLS/SCTP" offers.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestCreateDataAnswerToDifferentOfferedProtos) {
   // Need to enable DTLS offer/answer generation (disabled by default in this
   // test).
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_ENABLED);
   tdf2_.set_secure(SEC_ENABLED);
 
   MediaSessionOptions opts;
-  opts.data_channel_type = cricket::DCT_SCTP;
+  AddDataSection(cricket::DCT_SCTP, cricket::MD_SENDRECV, &opts);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   ASSERT_TRUE(offer.get() != nullptr);
   ContentInfo* dc_offer = offer->GetContentByName("data");
   ASSERT_TRUE(dc_offer != nullptr);
   DataContentDescription* dcd_offer =
       static_cast<DataContentDescription*>(dc_offer->description);
 
   std::vector<std::string> protos = {"DTLS/SCTP", "UDP/DTLS/SCTP",
                                      "TCP/DTLS/SCTP"};
   for (const std::string& proto : protos) {
     dcd_offer->set_protocol(proto);
     std::unique_ptr<SessionDescription> answer(
         f2_.CreateAnswer(offer.get(), opts, nullptr));
     const ContentInfo* dc_answer = answer->GetContentByName("data");
     ASSERT_TRUE(dc_answer != nullptr);
     const DataContentDescription* dcd_answer =
         static_cast<const DataContentDescription*>(dc_answer->description);
     EXPECT_FALSE(dc_answer->rejected);
     EXPECT_EQ(proto, dcd_answer->protocol());
   }
 }
 
 // Verifies that the order of the media contents in the offer is preserved in
 // the answer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAnswerContentOrder) {
   MediaSessionOptions opts;
 
   // Creates a data only offer.
-  opts.recv_audio = false;
-  opts.data_channel_type = cricket::DCT_SCTP;
+  AddDataSection(cricket::DCT_SCTP, cricket::MD_SENDRECV, &opts);
   std::unique_ptr<SessionDescription> offer1(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer1.get() != NULL);
 
   // Appends audio to the offer.
-  opts.recv_audio = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   std::unique_ptr<SessionDescription> offer2(
       f1_.CreateOffer(opts, offer1.get()));
   ASSERT_TRUE(offer2.get() != NULL);
 
   // Appends video to the offer.
-  opts.recv_video = true;
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   std::unique_ptr<SessionDescription> offer3(
       f1_.CreateOffer(opts, offer2.get()));
   ASSERT_TRUE(offer3.get() != NULL);
 
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer3.get(), opts, NULL));
   ASSERT_TRUE(answer.get() != NULL);
   EXPECT_EQ(3u, answer->contents().size());
   EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[0], MEDIA_TYPE_DATA));
   EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[1], MEDIA_TYPE_AUDIO));
@@ skipping 24 matching lines @@
 // This test that the media direction is set to inactive in an answer if
 // the offer is inactive.
 TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToInactiveOffer) {
   TestMediaDirectionInAnswer(cricket::MD_INACTIVE, cricket::MD_INACTIVE);
 }
 
 // Test that a data content with an unknown protocol is rejected in an answer.
 TEST_F(MediaSessionDescriptionFactoryTest,
        CreateDataAnswerToOfferWithUnknownProtocol) {
   MediaSessionOptions opts;
-  opts.data_channel_type = cricket::DCT_RTP;
-  opts.recv_audio = false;
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &opts);
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ContentInfo* dc_offer = offer->GetContentByName("data");
   ASSERT_TRUE(dc_offer != NULL);
   DataContentDescription* dcd_offer =
       static_cast<DataContentDescription*>(dc_offer->description);
   ASSERT_TRUE(dcd_offer != NULL);
   std::string protocol = "a weird unknown protocol";
   dcd_offer->set_protocol(protocol);
 
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const ContentInfo* dc_answer = answer->GetContentByName("data");
   ASSERT_TRUE(dc_answer != NULL);
   EXPECT_TRUE(dc_answer->rejected);
   const DataContentDescription* dcd_answer =
       static_cast<const DataContentDescription*>(dc_answer->description);
   ASSERT_TRUE(dcd_answer != NULL);
   EXPECT_EQ(protocol, dcd_answer->protocol());
 }
 
 // Test that the media protocol is RTP/AVPF if DTLS and SDES are disabled.
 TEST_F(MediaSessionDescriptionFactoryTest, AudioOfferAnswerWithCryptoDisabled) {
-  MediaSessionOptions opts;
+  MediaSessionOptions opts = CreatePlanBMediaSessionOptions();
   f1_.set_secure(SEC_DISABLED);
   f2_.set_secure(SEC_DISABLED);
   tdf1_.set_secure(SEC_DISABLED);
   tdf2_.set_secure(SEC_DISABLED);
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   const AudioContentDescription* offer_acd =
       GetFirstAudioContentDescription(offer.get());
   ASSERT_TRUE(offer_acd != NULL);
   EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf), offer_acd->protocol());
 
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const ContentInfo* ac_answer = answer->GetContentByName("audio");
   ASSERT_TRUE(ac_answer != NULL);
   EXPECT_FALSE(ac_answer->rejected);
 
   const AudioContentDescription* answer_acd =
       GetFirstAudioContentDescription(answer.get());
   ASSERT_TRUE(answer_acd != NULL);
   EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf), answer_acd->protocol());
 }
 
 // Create a video offer and answer and ensure the RTP header extensions
 // matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithRtpExtensions) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
-
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension1));
   f1_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension1));
   f2_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension2));
   f2_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension2));
 
   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));
 
   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtension1),
             GetFirstAudioContentDescription(
                 offer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtension1),
             GetFirstVideoContentDescription(
                 offer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtensionAnswer),
             GetFirstAudioContentDescription(
                 answer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtensionAnswer),
             GetFirstVideoContentDescription(
                 answer.get())->rtp_header_extensions());
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
     TestOfferAnswerWithEncryptedRtpExtensionsBoth) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   f1_.set_enable_encrypted_rtp_header_extensions(true);
   f2_.set_enable_encrypted_rtp_header_extensions(true);
 
   f1_.set_audio_rtp_header_extensions(
       MAKE_VECTOR(kAudioRtpExtension1));
   f1_.set_video_rtp_header_extensions(
       MAKE_VECTOR(kVideoRtpExtension1));
   f2_.set_audio_rtp_header_extensions(
       MAKE_VECTOR(kAudioRtpExtension2));
@@ skipping 15 matching lines @@
             GetFirstAudioContentDescription(
                 answer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtensionEncryptedAnswer),
             GetFirstVideoContentDescription(
                 answer.get())->rtp_header_extensions());
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
     TestOfferAnswerWithEncryptedRtpExtensionsOffer) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   f1_.set_enable_encrypted_rtp_header_extensions(true);
 
   f1_.set_audio_rtp_header_extensions(
       MAKE_VECTOR(kAudioRtpExtension1));
   f1_.set_video_rtp_header_extensions(
       MAKE_VECTOR(kVideoRtpExtension1));
   f2_.set_audio_rtp_header_extensions(
       MAKE_VECTOR(kAudioRtpExtension2));
   f2_.set_video_rtp_header_extensions(
@@ skipping 14 matching lines @@
             GetFirstAudioContentDescription(
                 answer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtensionAnswer),
             GetFirstVideoContentDescription(
                 answer.get())->rtp_header_extensions());
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
     TestOfferAnswerWithEncryptedRtpExtensionsAnswer) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   f2_.set_enable_encrypted_rtp_header_extensions(true);
 
   f1_.set_audio_rtp_header_extensions(
       MAKE_VECTOR(kAudioRtpExtension1));
   f1_.set_video_rtp_header_extensions(
       MAKE_VECTOR(kVideoRtpExtension1));
   f2_.set_audio_rtp_header_extensions(
       MAKE_VECTOR(kAudioRtpExtension2));
   f2_.set_video_rtp_header_extensions(
@@ skipping 15 matching lines @@
                 answer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kVideoRtpExtensionAnswer),
             GetFirstVideoContentDescription(
                 answer.get())->rtp_header_extensions());
 }
 
 // Create an audio, video, data answer without legacy StreamParams.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestCreateAnswerWithoutLegacyStreams) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
-  opts.data_channel_type = cricket::DCT_RTP;
-  f1_.set_add_legacy_streams(false);
-  f2_.set_add_legacy_streams(false);
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &opts);
   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 ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   const ContentInfo* dc = answer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
 
   EXPECT_FALSE(acd->has_ssrcs());  // No StreamParams.
   EXPECT_FALSE(vcd->has_ssrcs());  // No StreamParams.
   EXPECT_FALSE(dcd->has_ssrcs());  // No StreamParams.
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestPartial) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
-  opts.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &opts);
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   const ContentInfo* dc = offer->GetContentByName("data");
   AudioContentDescription* acd = const_cast<AudioContentDescription*>(
       static_cast<const AudioContentDescription*>(ac->description));
   VideoContentDescription* vcd = const_cast<VideoContentDescription*>(
       static_cast<const VideoContentDescription*>(vc->description));
@@ skipping 15 matching lines @@
   EXPECT_FALSE(dcd->partial());  // default is false.
   dcd->set_partial(true);
   EXPECT_TRUE(dcd->partial());
   dcd->set_partial(false);
   EXPECT_FALSE(dcd->partial());
 }
 
 // Create a typical video answer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerRtcpMux) {
   MediaSessionOptions offer_opts;
+  AddAudioVideoSections(cricket::MD_SENDRECV, &offer_opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_SENDRECV, &offer_opts);
+
   MediaSessionOptions answer_opts;
-  answer_opts.recv_video = true;
-  offer_opts.recv_video = true;
-  answer_opts.data_channel_type = cricket::DCT_RTP;
-  offer_opts.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_SENDRECV, &answer_opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_SENDRECV, &answer_opts);
 
   std::unique_ptr<SessionDescription> offer;
   std::unique_ptr<SessionDescription> answer;
 
   offer_opts.rtcp_mux_enabled = true;
   answer_opts.rtcp_mux_enabled = true;
-
   offer.reset(f1_.CreateOffer(offer_opts, NULL));
   answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
   ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
   EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
 
   offer_opts.rtcp_mux_enabled = true;
   answer_opts.rtcp_mux_enabled = false;
-
   offer.reset(f1_.CreateOffer(offer_opts, NULL));
   answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
   ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
   EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
   EXPECT_TRUE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
 
   offer_opts.rtcp_mux_enabled = false;
   answer_opts.rtcp_mux_enabled = true;
-
   offer.reset(f1_.CreateOffer(offer_opts, NULL));
   answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
   ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
   EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
 
   offer_opts.rtcp_mux_enabled = false;
   answer_opts.rtcp_mux_enabled = false;
-
   offer.reset(f1_.CreateOffer(offer_opts, NULL));
   answer.reset(f2_.CreateAnswer(offer.get(), answer_opts, NULL));
   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstDataContentDescription(offer.get()));
   ASSERT_TRUE(NULL != GetFirstAudioContentDescription(answer.get()));
   ASSERT_TRUE(NULL != GetFirstVideoContentDescription(answer.get()));
   ASSERT_TRUE(NULL != GetFirstDataContentDescription(answer.get()));
   EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(offer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux());
   EXPECT_FALSE(GetFirstDataContentDescription(answer.get())->rtcp_mux());
 }
 
 // Create an audio-only answer to a video offer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerToVideo) {
-  MediaSessionOptions opts;
-  opts.recv_video = true;
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  MediaSessionOptions offer_opts;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &offer_opts);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(offer_opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
+
+  MediaSessionOptions answer_opts;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &answer_opts);
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_INACTIVE, kStopped,
+                  &answer_opts);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+      f2_.CreateAnswer(offer.get(), answer_opts, NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   ASSERT_TRUE(vc->description != NULL);
   EXPECT_TRUE(vc->rejected);
 }
 
 // Create an audio-only answer to an offer with data.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateNoDataAnswerToDataOffer) {
-  MediaSessionOptions opts;
-  opts.data_channel_type = cricket::DCT_RTP;
-  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  MediaSessionOptions offer_opts = CreatePlanBMediaSessionOptions();
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &offer_opts);
+  std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(offer_opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
+
+  MediaSessionOptions answer_opts = CreatePlanBMediaSessionOptions();
+  answer_opts.data_channel_type = cricket::DCT_RTP;
+  AddMediaSection(MEDIA_TYPE_DATA, "data", cricket::MD_INACTIVE, kStopped,
+                  &answer_opts);
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+      f2_.CreateAnswer(offer.get(), answer_opts, NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* dc = answer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(dc != NULL);
   ASSERT_TRUE(dc->description != NULL);
   EXPECT_TRUE(dc->rejected);
 }
 
 // Create an answer that rejects the contents which are rejected in the offer.
 TEST_F(MediaSessionDescriptionFactoryTest,
        CreateAnswerToOfferWithRejectedMedia) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
-  opts.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &opts);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   ContentInfo* ac = offer->GetContentByName("audio");
   ContentInfo* vc = offer->GetContentByName("video");
   ContentInfo* dc = offer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   ASSERT_TRUE(dc != NULL);
   ac->rejected = true;
   vc->rejected = true;
@@ skipping 12 matching lines @@
 }
 
 // Create an audio and video offer with:
 // - one video track
 // - two audio tracks
 // - two data tracks
 // and ensure it matches what we expect. Also updates the initial offer by
 // adding a new video track and replaces one of the audio tracks.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
   MediaSessionOptions opts;
-  opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
-  opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
-  opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2, kMediaStream1);
-  opts.data_channel_type = cricket::DCT_RTP;
-  opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack1, kMediaStream1);
-  opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack2, kMediaStream1);
+  AddAudioVideoSections(cricket::MD_SENDRECV, &opts);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, kVideoTrack1,
+                             kMediaStream1, 1, &opts);
+  AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack1,
+                             kMediaStream1, 1, &opts);
+  AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack2,
+                             kMediaStream1, 1, &opts);
+
+  AddDataSection(cricket::DCT_RTP, cricket::MD_SENDRECV, &opts);
+  AttachSenderToMediaSection("data", MEDIA_TYPE_DATA, kDataTrack1,
+                             kMediaStream1, 1, &opts);
+  AttachSenderToMediaSection("data", MEDIA_TYPE_DATA, kDataTrack2,
+                             kMediaStream1, 1, &opts);
 
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   const ContentInfo* dc = offer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
@@ skipping 44 matching lines @@
   EXPECT_NE(0U, data_streams[0].ssrcs[0]);
   EXPECT_EQ(kDataTrack2, data_streams[1].id);
   ASSERT_EQ(1U, data_streams[1].ssrcs.size());
   EXPECT_NE(0U, data_streams[1].ssrcs[0]);
 
   EXPECT_EQ(cricket::kDataMaxBandwidth,
             dcd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(dcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
 
-
   // Update the offer. Add a new video track that is not synched to the
   // other tracks and replace audio track 2 with audio track 3.
-  opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
-  opts.RemoveSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
-  opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack3, kMediaStream1);
-  opts.RemoveSendStream(MEDIA_TYPE_DATA, kDataTrack2);
-  opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack3, kMediaStream1);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, kVideoTrack2,
+                             kMediaStream2, 1, &opts);
+  DetachSenderFromMediaSection("audio", kAudioTrack2, &opts);
+  AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack3,
+                             kMediaStream1, 1, &opts);
+  DetachSenderFromMediaSection("data", kDataTrack2, &opts);
+  AttachSenderToMediaSection("data", MEDIA_TYPE_DATA, kDataTrack3,
+                             kMediaStream1, 1, &opts);
   std::unique_ptr<SessionDescription> updated_offer(
       f1_.CreateOffer(opts, offer.get()));
 
   ASSERT_TRUE(updated_offer.get() != NULL);
   ac = updated_offer->GetContentByName("audio");
   vc = updated_offer->GetContentByName("video");
   dc = updated_offer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   ASSERT_TRUE(dc != NULL);
@@ skipping 41 matching lines @@
   EXPECT_EQ(updated_data_streams[0].cname, updated_data_streams[1].cname);
   // The stream correctly got the CNAME from the MediaSessionOptions.
   // The Expected RTCP CNAME is the default one as we are using the default
   // MediaSessionOptions.
   EXPECT_EQ(updated_data_streams[0].cname, cricket::kDefaultRtcpCname);
 }
 
 // Create an offer with simulcast video stream.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSimulcastVideoOffer) {
   MediaSessionOptions opts;
+  AddAudioVideoSections(cricket::MD_SENDRECV, &opts);
   const int num_sim_layers = 3;
-  opts.AddSendVideoStream(kVideoTrack1, kMediaStream1, num_sim_layers);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, kVideoTrack1,
+                             kMediaStream1, num_sim_layers, &opts);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* vc = offer->GetContentByName("video");
   ASSERT_TRUE(vc != NULL);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
 
   const StreamParamsVec& video_streams = vcd->streams();
   ASSERT_EQ(1U, video_streams.size());
   EXPECT_EQ(kVideoTrack1, video_streams[0].id);
   const SsrcGroup* sim_ssrc_group =
       video_streams[0].get_ssrc_group(cricket::kSimSsrcGroupSemantics);
   ASSERT_TRUE(sim_ssrc_group != NULL);
   EXPECT_EQ(static_cast<size_t>(num_sim_layers), sim_ssrc_group->ssrcs.size());
 }
 
 // Create an audio and video answer to a standard video offer with:
 // - one video track
 // - two audio tracks
 // - two data tracks
 // and ensure it matches what we expect. Also updates the initial answer by
 // adding a new video track and removes one of the audio tracks.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) {
   MediaSessionOptions offer_opts;
-  offer_opts.recv_video = true;
-  offer_opts.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &offer_opts);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &offer_opts);
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(offer_opts, NULL));
 
-  MediaSessionOptions opts;
-  opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack1, kMediaStream1);
-  opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
-  opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2, kMediaStream1);
-  opts.data_channel_type = cricket::DCT_RTP;
-  opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack1, kMediaStream1);
-  opts.AddSendStream(MEDIA_TYPE_DATA, kDataTrack2, kMediaStream1);
+  MediaSessionOptions answer_opts;
+  AddAudioVideoSections(cricket::MD_SENDRECV, &answer_opts);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, kVideoTrack1,
+                             kMediaStream1, 1, &answer_opts);
+  AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack1,
+                             kMediaStream1, 1, &answer_opts);
+  AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack2,
+                             kMediaStream1, 1, &answer_opts);
+
+  AddDataSection(cricket::DCT_RTP, cricket::MD_SENDRECV, &answer_opts);
+  AttachSenderToMediaSection("data", MEDIA_TYPE_DATA, kDataTrack1,
+                             kMediaStream1, 1, &answer_opts);
+  AttachSenderToMediaSection("data", MEDIA_TYPE_DATA, kDataTrack2,
+                             kMediaStream1, 1, &answer_opts);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), opts, NULL));
+      f2_.CreateAnswer(offer.get(), answer_opts, NULL));
 
   ASSERT_TRUE(answer.get() != NULL);
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
   const ContentInfo* dc = answer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   ASSERT_TRUE(dc != NULL);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
@@ skipping 43 matching lines @@
   EXPECT_EQ(kDataTrack2, data_streams[1].id);
   ASSERT_EQ(1U, data_streams[1].ssrcs.size());
   EXPECT_NE(0U, data_streams[1].ssrcs[0]);
 
   EXPECT_EQ(cricket::kDataMaxBandwidth,
             dcd->bandwidth());                  // default bandwidth (auto)
   EXPECT_TRUE(dcd->rtcp_mux());                 // rtcp-mux defaults on
 
   // Update the answer. Add a new video track that is not synched to the
   // other tracks and remove 1 audio track.
-  opts.AddSendStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
-  opts.RemoveSendStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
-  opts.RemoveSendStream(MEDIA_TYPE_DATA, kDataTrack2);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, kVideoTrack2,
+                             kMediaStream2, 1, &answer_opts);
+  DetachSenderFromMediaSection("audio", kAudioTrack2, &answer_opts);
+  DetachSenderFromMediaSection("data", kDataTrack2, &answer_opts);
   std::unique_ptr<SessionDescription> updated_answer(
-      f2_.CreateAnswer(offer.get(), opts, answer.get()));
+      f2_.CreateAnswer(offer.get(), answer_opts, answer.get()));
 
   ASSERT_TRUE(updated_answer.get() != NULL);
   ac = updated_answer->GetContentByName("audio");
   vc = updated_answer->GetContentByName("video");
   dc = updated_answer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   ASSERT_TRUE(dc != NULL);
   const AudioContentDescription* updated_acd =
       static_cast<const AudioContentDescription*>(ac->description);
@@ skipping 31 matching lines @@
   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;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   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());
 
   const VideoContentDescription* vcd =
@@ skipping 30 matching lines @@
       GetFirstVideoContentDescription(updated_offer.get());
   EXPECT_EQ(MAKE_VECTOR(kUpdatedVideoCodecOffer), updated_vcd->codecs());
 }
 
 // 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;
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   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);
   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);
   f2_.set_video_codecs(f2_codecs);
 
@@ skipping 31 matching lines @@
 // 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);
   f1_.set_video_codecs(f1_codecs);
 
   MediaSessionOptions opts;
-  opts.recv_audio = true;
-  opts.recv_video = false;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
 
   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;
+  opts.media_description_options.clear();
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   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);
   f2_.set_video_codecs(f2_codecs);
 
   std::unique_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
   ASSERT_TRUE(updated_offer);
@@ skipping 16 matching lines @@
       rtx.params[cricket::kCodecParamAssociatedPayloadType]);
   EXPECT_EQ(new_h264_pl_type, pt_referenced_by_rtx);
 }
 
 // Create an updated offer with RTX after creating an answer to an offer
 // 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;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   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);
   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));
@@ skipping 17 matching lines @@
   // 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);
   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;
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX without associated payload type parameter.
   AddRtxCodec(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);
   f2_.set_video_codecs(f2_codecs);
 
@@ skipping 22 matching lines @@
   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 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;
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
   // This creates RTX for H264 in sender.
   AddRtxCodec(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);
   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;
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   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);
   f1_.set_video_codecs(f1_codecs);
 
   // This creates RTX for H264 in sender.
   AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
   f1_.set_video_codecs(f1_codecs);
 
   std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
@@ skipping 13 matching lines @@
   AddRtxCodec(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;
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_RECVONLY, !kStopped,
+                  &opts);
   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);
   f1_.set_video_codecs(f1_codecs);
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   ASSERT_TRUE(offer);
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(offer.get());
 
@@ skipping 13 matching lines @@
 
   AddRtxCodec(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;
-
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_SENDRECV, !kStopped,
+                  &opts);
   // Add simulcast streams.
-  opts.AddSendVideoStream("stream1", "stream1label", 3);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, "stream1",
+                             "stream1label", 3, &opts);
 
   // 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);
   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));
@@ skipping 16 matching lines @@
   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;
-
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_SENDRECV, !kStopped,
+                  &opts);
   // Add single stream.
-  opts.AddSendVideoStream("stream1", "stream1label", 1);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, "stream1",
+                             "stream1label", 1, &opts);
 
   // Use a single real codec, and then add FlexFEC for it.
   std::vector<VideoCodec> f1_codecs;
   f1_codecs.push_back(VideoCodec(97, "H264"));
   f1_codecs.push_back(VideoCodec(118, "flexfec-03"));
   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));
@@ skipping 15 matching lines @@
   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;
-
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_SENDRECV, !kStopped,
+                  &opts);
   // Add simulcast streams.
-  opts.AddSendVideoStream("stream1", "stream1label", 3);
+  AttachSenderToMediaSection("video", MEDIA_TYPE_VIDEO, "stream1",
+                             "stream1label", 3, &opts);
 
   // Use a single real codec, and then add FlexFEC for it.
   std::vector<VideoCodec> f1_codecs;
   f1_codecs.push_back(VideoCodec(97, "H264"));
   f1_codecs.push_back(VideoCodec(118, "flexfec-03"));
   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));
@@ skipping 19 matching lines @@
     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;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension1));
   f1_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension1));
   f2_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension2));
   f2_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension2));
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
@@ skipping 33 matching lines @@
       GetFirstVideoContentDescription(updated_offer.get());
   EXPECT_EQ(MAKE_VECTOR(kUpdatedVideoRtpExtensions),
             updated_vcd->rtp_header_extensions());
 }
 
 // Verify that if the same RTP extension URI is used for audio and video, the
 // same ID is used. Also verify that the ID isn't changed when creating an
 // updated offer (this was previously a bug).
 TEST_F(MediaSessionDescriptionFactoryTest, RtpExtensionIdReused) {
   MediaSessionOptions opts;
-  opts.recv_audio = true;
-  opts.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   f1_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension3));
   f1_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension3));
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 
   // Since the audio extensions used ID 3 for "both_audio_and_video", so should
   // the video extensions.
   const RtpExtension kExpectedVideoRtpExtension[] = {
       kVideoRtpExtension3[0], kAudioRtpExtension3[1],
@@ skipping 14 matching lines @@
             GetFirstAudioContentDescription(
                 updated_offer.get())->rtp_header_extensions());
   EXPECT_EQ(MAKE_VECTOR(kExpectedVideoRtpExtension),
             GetFirstVideoContentDescription(
                 updated_offer.get())->rtp_header_extensions());
 }
 
 // Same as "RtpExtensionIdReused" above for encrypted RTP extensions.
 TEST_F(MediaSessionDescriptionFactoryTest, RtpExtensionIdReusedEncrypted) {
   MediaSessionOptions opts;
-  opts.recv_audio = true;
-  opts.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
 
   f1_.set_enable_encrypted_rtp_header_extensions(true);
   f2_.set_enable_encrypted_rtp_header_extensions(true);
 
   f1_.set_audio_rtp_header_extensions(
       MAKE_VECTOR(kAudioRtpExtension3ForEncryption));
   f1_.set_video_rtp_header_extensions(
       MAKE_VECTOR(kVideoRtpExtension3ForEncryption));
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
@@ skipping 55 matching lines @@
   const VideoContentDescription* vcd_copy =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(vcd->codecs(), vcd_copy->codecs());
   EXPECT_EQ(2u, vcd->first_ssrc());
 }
 
 // The below TestTransportInfoXXX tests create different offers/answers, and
 // ensure the TransportInfo in the SessionDescription matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferAudio) {
   MediaSessionOptions options;
-  options.recv_audio = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &options);
   TestTransportInfo(true, options, false);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestTransportInfoOfferIceRenomination) {
   MediaSessionOptions options;
-  options.enable_ice_renomination = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &options);
+  auto media_desc_options_it =
+      FindFirstMediaDescriptionByMid("audio", &options);
+  media_desc_options_it->transport_options.enable_ice_renomination = true;
   TestTransportInfo(true, options, false);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferAudioCurrent) {
   MediaSessionOptions options;
-  options.recv_audio = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &options);
   TestTransportInfo(true, options, true);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferMultimedia) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
   TestTransportInfo(true, options, false);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
     TestTransportInfoOfferMultimediaCurrent) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
   TestTransportInfo(true, options, true);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferBundle) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
   options.bundle_enabled = true;
   TestTransportInfo(true, options, false);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestTransportInfoOfferBundleCurrent) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
   options.bundle_enabled = true;
   TestTransportInfo(true, options, true);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerAudio) {
   MediaSessionOptions options;
-  options.recv_audio = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &options);
   TestTransportInfo(false, options, false);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestTransportInfoAnswerIceRenomination) {
   MediaSessionOptions options;
-  options.enable_ice_renomination = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &options);
+  auto media_desc_options_it =
+      FindFirstMediaDescriptionByMid("audio", &options);
+  media_desc_options_it->transport_options.enable_ice_renomination = true;
   TestTransportInfo(false, options, false);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestTransportInfoAnswerAudioCurrent) {
   MediaSessionOptions options;
-  options.recv_audio = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", cricket::MD_RECVONLY, !kStopped,
+                  &options);
   TestTransportInfo(false, options, true);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerMultimedia) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
   TestTransportInfo(false, options, false);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
     TestTransportInfoAnswerMultimediaCurrent) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
   TestTransportInfo(false, options, true);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerBundle) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
   options.bundle_enabled = true;
   TestTransportInfo(false, options, false);
 }
 
 TEST_F(MediaSessionDescriptionFactoryTest,
     TestTransportInfoAnswerBundleCurrent) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
   options.bundle_enabled = true;
   TestTransportInfo(false, options, true);
 }
 
 // Create an offer with bundle enabled and verify the crypto parameters are
 // the common set of the available cryptos.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoWithOfferBundle) {
   TestCryptoWithBundle(true);
 }
 
 // Create an answer with bundle enabled and verify the crypto parameters are
 // the common set of the available cryptos.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoWithAnswerBundle) {
   TestCryptoWithBundle(false);
 }
 
 // Verifies that creating answer fails if the offer has UDP/TLS/RTP/SAVPF but
 // DTLS is not enabled locally.
 TEST_F(MediaSessionDescriptionFactoryTest,
        TestOfferDtlsSavpfWithoutDtlsFailed) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_DISABLED);
   tdf2_.set_secure(SEC_DISABLED);
 
   std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(MediaSessionOptions(), NULL));
+      f1_.CreateOffer(CreatePlanBMediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   ContentInfo* offer_content = offer->GetContentByName("audio");
   ASSERT_TRUE(offer_content != NULL);
   AudioContentDescription* offer_audio_desc =
       static_cast<AudioContentDescription*>(offer_content->description);
   offer_audio_desc->set_protocol(cricket::kMediaProtocolDtlsSavpf);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+      f2_.CreateAnswer(offer.get(), CreatePlanBMediaSessionOptions(), NULL));
   ASSERT_TRUE(answer != NULL);
   ContentInfo* answer_content = answer->GetContentByName("audio");
   ASSERT_TRUE(answer_content != NULL);
 
   ASSERT_TRUE(answer_content->rejected);
 }
 
 // Offers UDP/TLS/RTP/SAVPF and verifies the answer can be created and contains
 // UDP/TLS/RTP/SAVPF.
 TEST_F(MediaSessionDescriptionFactoryTest, TestOfferDtlsSavpfCreateAnswer) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_ENABLED);
   tdf2_.set_secure(SEC_ENABLED);
 
   std::unique_ptr<SessionDescription> offer(
-      f1_.CreateOffer(MediaSessionOptions(), NULL));
+      f1_.CreateOffer(CreatePlanBMediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   ContentInfo* offer_content = offer->GetContentByName("audio");
   ASSERT_TRUE(offer_content != NULL);
   AudioContentDescription* offer_audio_desc =
       static_cast<AudioContentDescription*>(offer_content->description);
   offer_audio_desc->set_protocol(cricket::kMediaProtocolDtlsSavpf);
 
   std::unique_ptr<SessionDescription> answer(
-      f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
+      f2_.CreateAnswer(offer.get(), CreatePlanBMediaSessionOptions(), NULL));
   ASSERT_TRUE(answer != NULL);
 
   const ContentInfo* answer_content = answer->GetContentByName("audio");
   ASSERT_TRUE(answer_content != NULL);
   ASSERT_FALSE(answer_content->rejected);
 
   const AudioContentDescription* answer_audio_desc =
       static_cast<const AudioContentDescription*>(answer_content->description);
   EXPECT_EQ(std::string(cricket::kMediaProtocolDtlsSavpf),
                         answer_audio_desc->protocol());
 }
 
 // Test that we include both SDES and DTLS in the offer, but only include SDES
 // in the answer if DTLS isn't negotiated.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoDtls) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_ENABLED);
   tdf2_.set_secure(SEC_DISABLED);
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
   std::unique_ptr<SessionDescription> offer, answer;
   const cricket::MediaContentDescription* audio_media_desc;
   const cricket::MediaContentDescription* video_media_desc;
   const cricket::TransportDescription* audio_trans_desc;
   const cricket::TransportDescription* video_trans_desc;
 
   // Generate an offer with SDES and DTLS support.
   offer.reset(f1_.CreateOffer(options, NULL));
   ASSERT_TRUE(offer.get() != NULL);
 
@@ skipping 75 matching lines @@
   ASSERT_TRUE(audio_trans_desc != NULL);
   video_trans_desc = offer->GetTransportDescriptionByName("video");
   ASSERT_TRUE(video_trans_desc != NULL);
   ASSERT_TRUE(audio_trans_desc->identity_fingerprint.get() != NULL);
   ASSERT_TRUE(video_trans_desc->identity_fingerprint.get() != NULL);
 }
 
 // Test that an answer can't be created if cryptos are required but the offer is
 // unsecure.
 TEST_F(MediaSessionDescriptionFactoryTest, TestSecureAnswerToUnsecureOffer) {
-  MediaSessionOptions options;
+  MediaSessionOptions options = CreatePlanBMediaSessionOptions();
   f1_.set_secure(SEC_DISABLED);
   tdf1_.set_secure(SEC_DISABLED);
   f2_.set_secure(SEC_REQUIRED);
   tdf1_.set_secure(SEC_ENABLED);
 
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), options, NULL));
   EXPECT_TRUE(answer.get() == NULL);
 }
 
 // Test that we accept a DTLS offer without SDES and create an appropriate
 // answer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoOfferDtlsButNotSdes) {
   f1_.set_secure(SEC_DISABLED);
   f2_.set_secure(SEC_ENABLED);
   tdf1_.set_secure(SEC_ENABLED);
   tdf2_.set_secure(SEC_ENABLED);
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
-  options.data_channel_type = cricket::DCT_RTP;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
+  AddDataSection(cricket::DCT_RTP, cricket::MD_RECVONLY, &options);
 
   std::unique_ptr<SessionDescription> offer, answer;
 
   // Generate an offer with DTLS but without SDES.
   offer.reset(f1_.CreateOffer(options, NULL));
   ASSERT_TRUE(offer.get() != NULL);
 
   const AudioContentDescription* audio_offer =
       GetFirstAudioContentDescription(offer.get());
   ASSERT_TRUE(audio_offer->cryptos().empty());
@@ skipping 26 matching lines @@
   EXPECT_TRUE(video_answer_trans_desc->identity_fingerprint.get() != NULL);
   const cricket::TransportDescription* data_answer_trans_desc =
       answer->GetTransportDescriptionByName("data");
   EXPECT_TRUE(data_answer_trans_desc->identity_fingerprint.get() != NULL);
 }
 
 // Verifies if vad_enabled option is set to false, CN codecs are not present in
 // offer or answer.
 TEST_F(MediaSessionDescriptionFactoryTest, TestVADEnableOption) {
   MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &options);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(options, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* audio_content = offer->GetContentByName("audio");
   EXPECT_FALSE(VerifyNoCNCodecs(audio_content));
 
   options.vad_enabled = false;
   offer.reset(f1_.CreateOffer(options, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   audio_content = offer->GetContentByName("audio");
   EXPECT_TRUE(VerifyNoCNCodecs(audio_content));
   std::unique_ptr<SessionDescription> answer(
       f1_.CreateAnswer(offer.get(), options, NULL));
   ASSERT_TRUE(answer.get() != NULL);
   audio_content = answer->GetContentByName("audio");
   EXPECT_TRUE(VerifyNoCNCodecs(audio_content));
 }
 
-// Test that the content name ("mid" in SDP) is unchanged when creating a
-// new offer.
-TEST_F(MediaSessionDescriptionFactoryTest,
-       TestContentNameNotChangedInSubsequentOffers) {
+// Test that the generated MIDs match the existing offer.
+TEST_F(MediaSessionDescriptionFactoryTest, TestMIDsMatchesExistingOffer) {
   MediaSessionOptions opts;
-  opts.recv_audio = true;
-  opts.recv_video = true;
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio_modified", cricket::MD_RECVONLY,
+                  !kStopped, &opts);
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video_modified", cricket::MD_RECVONLY,
+                  !kStopped, &opts);
   opts.data_channel_type = cricket::DCT_SCTP;
-  // Create offer and modify the default content names.
+  AddMediaSection(MEDIA_TYPE_DATA, "data_modified", cricket::MD_SENDRECV,
+                  !kStopped, &opts);
+  // Create offer.
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
-  for (ContentInfo& content : offer->contents()) {
-    content.name.append("_modified");
-  }
-
   std::unique_ptr<SessionDescription> updated_offer(
       f1_.CreateOffer(opts, offer.get()));
+
   const ContentInfo* audio_content = GetFirstAudioContent(updated_offer.get());
   const ContentInfo* video_content = GetFirstVideoContent(updated_offer.get());
   const ContentInfo* data_content = GetFirstDataContent(updated_offer.get());
   ASSERT_TRUE(audio_content != nullptr);
   ASSERT_TRUE(video_content != nullptr);
   ASSERT_TRUE(data_content != nullptr);
   EXPECT_EQ("audio_modified", audio_content->name);
   EXPECT_EQ("video_modified", video_content->name);
   EXPECT_EQ("data_modified", data_content->name);
 }
@@ skipping 21 matching lines @@
 
  protected:
   MediaSessionDescriptionFactory f1_;
   MediaSessionDescriptionFactory f2_;
   TransportDescriptionFactory tdf1_;
   TransportDescriptionFactory tdf2_;
 };
 
 TEST_P(MediaProtocolTest, TestAudioVideoAcceptance) {
   MediaSessionOptions opts;
-  opts.recv_video = true;
+  AddAudioVideoSections(cricket::MD_RECVONLY, &opts);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, nullptr));
   ASSERT_TRUE(offer.get() != nullptr);
   // Set the protocol for all the contents.
   for (auto content : offer.get()->contents()) {
     static_cast<MediaContentDescription*>(content.description)
         ->set_protocol(GetParam());
   }
   std::unique_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, nullptr));
   const ContentInfo* ac = answer->GetContentByName("audio");
@@ skipping 39 matching lines @@
   // Alter iLBC send codec to have zero channels, to test that that is handled
   // properly.
   send_codecs[1].channels = 0;
 
   // Alther iLBC receive codec to be lowercase, to test that case conversions
   // are handled properly.
   recv_codecs[2].name = "ilbc";
 
   // Test proper merge
   sf.set_audio_codecs(send_codecs, recv_codecs);
-  EXPECT_TRUE(sf.audio_send_codecs() == send_codecs);
-  EXPECT_TRUE(sf.audio_recv_codecs() == recv_codecs);
-  EXPECT_TRUE(sf.audio_sendrecv_codecs() == sendrecv_codecs);
+  EXPECT_EQ(send_codecs, sf.audio_send_codecs());
+  EXPECT_EQ(recv_codecs, sf.audio_recv_codecs());
+  EXPECT_EQ(sendrecv_codecs, sf.audio_sendrecv_codecs());
 
   // Test empty send codecs list
   sf.set_audio_codecs(no_codecs, recv_codecs);
-  EXPECT_TRUE(sf.audio_send_codecs() == no_codecs);
-  EXPECT_TRUE(sf.audio_recv_codecs() == recv_codecs);
-  EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
+  EXPECT_EQ(no_codecs, sf.audio_send_codecs());
+  EXPECT_EQ(recv_codecs, sf.audio_recv_codecs());
+  EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs());
 
   // Test empty recv codecs list
   sf.set_audio_codecs(send_codecs, no_codecs);
-  EXPECT_TRUE(sf.audio_send_codecs() == send_codecs);
-  EXPECT_TRUE(sf.audio_recv_codecs() == no_codecs);
-  EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
+  EXPECT_EQ(send_codecs, sf.audio_send_codecs());
+  EXPECT_EQ(no_codecs, sf.audio_recv_codecs());
+  EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs());
 
   // Test all empty codec lists
   sf.set_audio_codecs(no_codecs, no_codecs);
-  EXPECT_TRUE(sf.audio_send_codecs() == no_codecs);
-  EXPECT_TRUE(sf.audio_recv_codecs() == no_codecs);
-  EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
+  EXPECT_EQ(no_codecs, sf.audio_send_codecs());
+  EXPECT_EQ(no_codecs, sf.audio_recv_codecs());
+  EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs());
 }
 
 namespace {
-void TestAudioCodecsOffer(MediaContentDirection direction,
-                          bool add_legacy_stream) {
+void TestAudioCodecsOffer(MediaContentDirection direction) {
   TransportDescriptionFactory tdf;
   MediaSessionDescriptionFactory sf(&tdf);
   const std::vector<AudioCodec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
   const std::vector<AudioCodec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
   const std::vector<AudioCodec> sendrecv_codecs =
       MAKE_VECTOR(kAudioCodecsAnswer);
   sf.set_audio_codecs(send_codecs, recv_codecs);
-  sf.set_add_legacy_streams(add_legacy_stream);
 
   MediaSessionOptions opts;
-  opts.recv_audio = (direction == cricket::MD_RECVONLY ||
-                     direction == cricket::MD_SENDRECV);
-  opts.recv_video = false;
-  if (direction == cricket::MD_SENDONLY || direction == cricket::MD_SENDRECV)
-    opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", direction, !kStopped, &opts);
+
+  if (RtpTransceiverDirection::FromMediaContentDirection(direction).send) {
+    AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack1,
+                               kMediaStream1, 1, &opts);
+  }
 
   std::unique_ptr<SessionDescription> offer(sf.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
 
   // If the factory didn't add any audio content to the offer, we cannot check
   // that the codecs put in are right. This happens when we neither want to send
   // nor receive audio. The checks are still in place if at some point we'd
   // instead create an inactive stream.
   if (ac) {
     AudioContentDescription* acd =
         static_cast<AudioContentDescription*>(ac->description);
     // sendrecv and inactive should both present lists as if the channel was to
     // be used for sending and receiving. Inactive essentially means it might
     // eventually be used anything, but we don't know more at this moment.
     if (acd->direction() == cricket::MD_SENDONLY) {
-      EXPECT_TRUE(acd->codecs() == send_codecs);
+      EXPECT_EQ(send_codecs, acd->codecs());
     } else if (acd->direction() == cricket::MD_RECVONLY) {
-      EXPECT_TRUE(acd->codecs() == recv_codecs);
+      EXPECT_EQ(recv_codecs, acd->codecs());
     } else {
-      EXPECT_TRUE(acd->codecs() == sendrecv_codecs);
+      EXPECT_EQ(sendrecv_codecs, acd->codecs());
     }
   }
 }
 
 static const AudioCodec kOfferAnswerCodecs[] = {
   AudioCodec(0, "codec0", 16000,    -1, 1),
   AudioCodec(1, "codec1",  8000, 13300, 1),
   AudioCodec(2, "codec2",  8000, 64000, 1),
   AudioCodec(3, "codec3",  8000, 64000, 1),
   AudioCodec(4, "codec4",  8000,     0, 2),
@@ skipping 51 matching lines @@
   TransportDescriptionFactory answer_tdf;
   MediaSessionDescriptionFactory offer_factory(&offer_tdf);
   MediaSessionDescriptionFactory answer_factory(&answer_tdf);
   offer_factory.set_audio_codecs(
       VectorFromIndices(kOfferAnswerCodecs, kOfferSendCodecs),
       VectorFromIndices(kOfferAnswerCodecs, kOfferRecvCodecs));
   answer_factory.set_audio_codecs(
       VectorFromIndices(kOfferAnswerCodecs, kAnswerSendCodecs),
       VectorFromIndices(kOfferAnswerCodecs, kAnswerRecvCodecs));
 
-  // Never add a legacy stream to offer - we want to control the offer
-  // parameters exactly.
-  offer_factory.set_add_legacy_streams(false);
-  answer_factory.set_add_legacy_streams(add_legacy_stream);
   MediaSessionOptions offer_opts;
-  offer_opts.recv_audio = (offer_direction == cricket::MD_RECVONLY ||
-                           offer_direction == cricket::MD_SENDRECV);
-  offer_opts.recv_video = false;
-  if (offer_direction == cricket::MD_SENDONLY ||
-      offer_direction == cricket::MD_SENDRECV) {
-    offer_opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", offer_direction, !kStopped,
+                  &offer_opts);
+
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_INACTIVE, kStopped,
+                  &offer_opts);
+
+  if (RtpTransceiverDirection::FromMediaContentDirection(offer_direction)
+          .send) {
+    AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack1,
+                               kMediaStream1, 1, &offer_opts);
   }
 
   std::unique_ptr<SessionDescription> offer(
       offer_factory.CreateOffer(offer_opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
 
   MediaSessionOptions answer_opts;
-  answer_opts.recv_audio = (answer_direction == cricket::MD_RECVONLY ||
-                            answer_direction == cricket::MD_SENDRECV);
-  answer_opts.recv_video = false;
-  if (answer_direction == cricket::MD_SENDONLY ||
-      answer_direction == cricket::MD_SENDRECV) {
-    answer_opts.AddSendStream(MEDIA_TYPE_AUDIO, kAudioTrack1, kMediaStream1);
+  AddMediaSection(MEDIA_TYPE_AUDIO, "audio", answer_direction, !kStopped,
+                  &answer_opts);
+
+  AddMediaSection(MEDIA_TYPE_VIDEO, "video", cricket::MD_INACTIVE, kStopped,
+                  &answer_opts);
+
+  if (RtpTransceiverDirection::FromMediaContentDirection(answer_direction)
+          .send) {
+    AttachSenderToMediaSection("audio", MEDIA_TYPE_AUDIO, kAudioTrack1,
+                               kMediaStream1, 1, &answer_opts);
   }
   std::unique_ptr<SessionDescription> answer(
       answer_factory.CreateAnswer(offer.get(), answer_opts, NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
 
   // If the factory didn't add any audio content to the answer, we cannot check
   // that the codecs put in are right. This happens when we neither want to send
   // nor receive audio. The checks are still in place if at some point we'd
   // instead create an inactive stream.
   if (ac) {
@@ skipping 53 matching lines @@
         << "; 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<::testing::tuple<MediaContentDirection,
-                                                       bool>> {
-};
+    : public ::testing::TestWithParam<MediaContentDirection> {};
 
 TEST_P(AudioCodecsOfferTest, TestCodecsInOffer) {
-  TestAudioCodecsOffer(::testing::get<0>(GetParam()),
-                       ::testing::get<1>(GetParam()));
+  TestAudioCodecsOffer(GetParam());
 }
 
 INSTANTIATE_TEST_CASE_P(MediaSessionDescriptionFactoryTest,
                         AudioCodecsOfferTest,
-                        ::testing::Combine(
-                             ::testing::Values(cricket::MD_SENDONLY,
-                                               cricket::MD_RECVONLY,
-                                               cricket::MD_SENDRECV,
-                                               cricket::MD_INACTIVE),
-                             ::testing::Bool()));
+                        ::testing::Values(cricket::MD_SENDONLY,
+                                          cricket::MD_RECVONLY,
+                                          cricket::MD_SENDRECV,
+                                          cricket::MD_INACTIVE));
 
 class AudioCodecsAnswerTest
     : public ::testing::TestWithParam<::testing::tuple<MediaContentDirection,
                                                        MediaContentDirection,
                                                        bool>> {
 };
 
 TEST_P(AudioCodecsAnswerTest, TestCodecsInAnswer) {
   TestAudioCodecsAnswer(::testing::get<0>(GetParam()),
                         ::testing::get<1>(GetParam()),
                         ::testing::get<2>(GetParam()));
 }
 
 INSTANTIATE_TEST_CASE_P(MediaSessionDescriptionFactoryTest,
                         AudioCodecsAnswerTest,
                         ::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()));