Adding support for Unified Plan offer/answer negotiation.

webrtc/pc/webrtcsession_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 125 matching lines @@
     "a=fmtp:96 apt=0\r\n";
 
 static const char kStream1[] = "stream1";
 static const char kVideoTrack1[] = "video1";
 static const char kAudioTrack1[] = "audio1";
 
 static const char kStream2[] = "stream2";
 static const char kVideoTrack2[] = "video2";
 static const char kAudioTrack2[] = "audio2";
 
+static constexpr bool kStopped = true;
+static constexpr bool kActive = false;
+
 enum RTCCertificateGenerationMethod { ALREADY_GENERATED, DTLS_IDENTITY_STORE };
 
 class MockIceObserver : public webrtc::IceObserver {
  public:
   MockIceObserver()
       : oncandidatesready_(false),
         ice_connection_state_(PeerConnectionInterface::kIceConnectionNew),
         ice_gathering_state_(PeerConnectionInterface::kIceGatheringNew) {
   }
 
@@ skipping 235 matching lines @@
         metrics_observer_(new rtc::RefCountedObject<FakeMetricsObserver>()) {
     cricket::ServerAddresses stun_servers;
     stun_servers.insert(stun_socket_addr_);
     allocator_.reset(new cricket::BasicPortAllocator(
         &network_manager_,
         stun_servers,
         SocketAddress(), SocketAddress(), SocketAddress()));
     allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
                           cricket::PORTALLOCATOR_DISABLE_RELAY);
     EXPECT_TRUE(channel_manager_->Init());
-    desc_factory_->set_add_legacy_streams(false);
     allocator_->set_step_delay(cricket::kMinimumStepDelay);
   }
 
   void AddInterface(const SocketAddress& addr) {
     network_manager_.AddInterface(addr);
   }
   void RemoveInterface(const SocketAddress& addr) {
     network_manager_.RemoveInterface(addr);
   }
 
@@ skipping 88 matching lines @@
          PeerConnectionInterface::kRtcpMuxPolicyNegotiate,
          rtc::CryptoOptions());
   }
 
   void InitWithGcm() {
     rtc::CryptoOptions crypto_options;
     crypto_options.enable_gcm_crypto_suites = true;
     InitWithCryptoOptions(crypto_options);
   }
 
+  // The following convenience functions can be applied for both local side and
+  // remote side. The flags can be overwritten for different use cases.
   void SendAudioVideoStream1() {
     send_stream_1_ = true;
     send_stream_2_ = false;
-    send_audio_ = true;
-    send_video_ = true;
+    local_send_audio_ = true;
+    local_send_video_ = true;
+    remote_send_audio_ = true;
+    remote_send_video_ = true;
   }
 
   void SendAudioVideoStream2() {
     send_stream_1_ = false;
     send_stream_2_ = true;
-    send_audio_ = true;
-    send_video_ = true;
+    local_send_audio_ = true;
+    local_send_video_ = true;
+    remote_send_audio_ = true;
+    remote_send_video_ = true;
   }
 
   void SendAudioVideoStream1And2() {
     send_stream_1_ = true;
     send_stream_2_ = true;
-    send_audio_ = true;
-    send_video_ = true;
+    local_send_audio_ = true;
+    local_send_video_ = true;
+    remote_send_audio_ = true;
+    remote_send_video_ = true;
   }
 
   void SendNothing() {
     send_stream_1_ = false;
     send_stream_2_ = false;
-    send_audio_ = false;
-    send_video_ = false;
+    local_send_audio_ = false;
+    local_send_video_ = false;
+    remote_send_audio_ = false;
+    remote_send_video_ = false;
   }
 
   void SendAudioOnlyStream2() {
     send_stream_1_ = false;
     send_stream_2_ = true;
-    send_audio_ = true;
-    send_video_ = false;
+    local_send_audio_ = true;
+    local_send_video_ = false;
+    remote_send_audio_ = true;
+    remote_send_video_ = false;
   }
 
   void SendVideoOnlyStream2() {
     send_stream_1_ = false;
     send_stream_2_ = true;
-    send_audio_ = false;
-    send_video_ = true;
-  }
-
-  void AddStreamsToOptions(cricket::MediaSessionOptions* session_options) {
-    if (send_stream_1_ && send_audio_) {
-      session_options->AddSendStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack1,
-                                     kStream1);
-    }
-    if (send_stream_1_ && send_video_) {
-      session_options->AddSendStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack1,
-                                     kStream1);
-    }
-    if (send_stream_2_ && send_audio_) {
-      session_options->AddSendStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack2,
-                                     kStream2);
-    }
-    if (send_stream_2_ && send_video_) {
-      session_options->AddSendStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack2,
-                                     kStream2);
-    }
-    if (data_channel_ && session_->data_channel_type() == cricket::DCT_RTP) {
-      session_options->AddSendStream(cricket::MEDIA_TYPE_DATA,
-                                     data_channel_->label(),
-                                     data_channel_->label());
+    local_send_audio_ = false;
+    local_send_video_ = true;
+    remote_send_audio_ = false;
+    remote_send_video_ = true;
+  }
+
+  // Helper function used to add a specific media section to the
+  // |session_options|.
+  void AddMediaSection(cricket::MediaType type,
+                       const std::string& mid,
+                       cricket::MediaContentDirection direction,
+                       bool stopped,
+                       cricket::MediaSessionOptions* opts) {
+    opts->media_description_options.push_back(cricket::MediaDescriptionOptions(
+        type, mid,
+        cricket::RtpTransceiverDirection::FromMediaContentDirection(direction),
+        stopped));
+  }
+
+  // Add the media sections to the options from |offered_media_sections_| when
+  // creating an answer or a new offer.
+  // This duplicates a lot of logic from PeerConnection but this can be fixed
+  // when PeerConnection and WebRtcSession are merged.
+  void AddExistingMediaSectionsAndSendersToOptions(
+      cricket::MediaSessionOptions* session_options,
+      bool send_audio,
+      bool recv_audio,
+      bool send_video,
+      bool recv_video) {
+    int num_sim_layer = 1;
+    for (auto media_description_options : offered_media_sections_) {
+      if (media_description_options.type == cricket::MEDIA_TYPE_AUDIO) {
+        bool stopped = !send_audio && !recv_audio;
+        auto media_desc_options = cricket::MediaDescriptionOptions(
+            cricket::MEDIA_TYPE_AUDIO, media_description_options.mid,
+            cricket::RtpTransceiverDirection(send_audio, recv_audio), stopped);
+        if (send_stream_1_ && send_audio) {
+          media_desc_options.AddAudioSender(kAudioTrack1, kStream1);
+        }
+        if (send_stream_2_ && send_audio) {
+          media_desc_options.AddAudioSender(kAudioTrack2, kStream2);
+        }
+        session_options->media_description_options.push_back(
+            media_desc_options);
+      } else if (media_description_options.type == cricket::MEDIA_TYPE_VIDEO) {
+        bool stopped = !send_video && !recv_video;
+        auto media_desc_options = cricket::MediaDescriptionOptions(
+            cricket::MEDIA_TYPE_VIDEO, media_description_options.mid,
+            cricket::RtpTransceiverDirection(send_video, recv_video), stopped);
+        if (send_stream_1_ && send_video) {
+          media_desc_options.AddVideoSender(kVideoTrack1, kStream1,
+                                            num_sim_layer);
+        }
+        if (send_stream_2_ && send_video) {
+          media_desc_options.AddVideoSender(kVideoTrack2, kStream2,
+                                            num_sim_layer);
+        }
+        session_options->media_description_options.push_back(
+            media_desc_options);
+      } else if (media_description_options.type == cricket::MEDIA_TYPE_DATA) {
+        session_options->media_description_options.push_back(
+            cricket::MediaDescriptionOptions(
+                cricket::MEDIA_TYPE_DATA, media_description_options.mid,
+                // Direction for data sections is meaningless, but legacy
+                // endpoints might expect sendrecv.
+                cricket::RtpTransceiverDirection(true, true), false));
+      } else {
+        RTC_NOTREACHED();
+      }
+    }
+  }
+
+  // Add the existing media sections first and then add new media sections if
+  // needed.
+  void AddMediaSectionsAndSendersToOptions(
+      cricket::MediaSessionOptions* session_options,
+      bool send_audio,
+      bool recv_audio,
+      bool send_video,
+      bool recv_video) {
+    AddExistingMediaSectionsAndSendersToOptions(
+        session_options, send_audio, recv_audio, send_video, recv_video);
+
+    if (!session_options->has_audio() && (send_audio || recv_audio)) {
+      cricket::MediaDescriptionOptions media_desc_options =
+          cricket::MediaDescriptionOptions(
+              cricket::MEDIA_TYPE_AUDIO, cricket::CN_AUDIO,
+              cricket::RtpTransceiverDirection(send_audio, recv_audio),
+              kActive);
+      if (send_stream_1_ && send_audio) {
+        media_desc_options.AddAudioSender(kAudioTrack1, kStream1);
+      }
+      if (send_stream_2_ && send_audio) {
+        media_desc_options.AddAudioSender(kAudioTrack2, kStream2);
+      }
+      session_options->media_description_options.push_back(media_desc_options);
+      offered_media_sections_.push_back(media_desc_options);
+    }
+
+    if (!session_options->has_video() && (send_video || recv_video)) {
+      cricket::MediaDescriptionOptions media_desc_options =
+          cricket::MediaDescriptionOptions(
+              cricket::MEDIA_TYPE_VIDEO, cricket::CN_VIDEO,
+              cricket::RtpTransceiverDirection(send_video, recv_video),
+              kActive);
+      int num_sim_layer = 1;
+      if (send_stream_1_ && send_video) {
+        media_desc_options.AddVideoSender(kVideoTrack1, kStream1,
+                                          num_sim_layer);
+      }
+      if (send_stream_2_ && send_video) {
+        media_desc_options.AddVideoSender(kVideoTrack2, kStream2,
+                                          num_sim_layer);
+      }
+      session_options->media_description_options.push_back(media_desc_options);
+      offered_media_sections_.push_back(media_desc_options);
+    }
+
+    if (!session_options->has_data() &&
+        (data_channel_ ||
+         session_options->data_channel_type != cricket::DCT_NONE)) {
+      cricket::MediaDescriptionOptions media_desc_options =
+          cricket::MediaDescriptionOptions(
+              cricket::MEDIA_TYPE_DATA, cricket::CN_DATA,
+              cricket::RtpTransceiverDirection(true, true), kActive);
+      if (session_options->data_channel_type == cricket::DCT_RTP) {
+        media_desc_options.AddRtpDataChannel(data_channel_->label(),
+                                             data_channel_->label());
+      }
+      session_options->media_description_options.push_back(media_desc_options);
+      offered_media_sections_.push_back(media_desc_options);
     }
   }
 
   void GetOptionsForOffer(
       const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
       cricket::MediaSessionOptions* session_options) {
-    ASSERT_TRUE(ExtractMediaSessionOptions(rtc_options, true, session_options));
-
-    AddStreamsToOptions(session_options);
-    if (rtc_options.offer_to_receive_audio ==
-        RTCOfferAnswerOptions::kUndefined) {
-      session_options->recv_audio =
-          session_options->HasSendMediaStream(cricket::MEDIA_TYPE_AUDIO);
-    }
-    if (rtc_options.offer_to_receive_video ==
-        RTCOfferAnswerOptions::kUndefined) {
-      session_options->recv_video =
-          session_options->HasSendMediaStream(cricket::MEDIA_TYPE_VIDEO);
-    }
+    ExtractSharedMediaSessionOptions(rtc_options, session_options);
+
+    // |recv_X| is true by default if |offer_to_receive_X| is undefined.
+    bool recv_audio = rtc_options.offer_to_receive_audio != 0;
+    bool recv_video = rtc_options.offer_to_receive_video != 0;
+
+    AddMediaSectionsAndSendersToOptions(session_options, local_send_audio_,
+                                        recv_audio, local_send_video_,
+                                        recv_video);
     session_options->bundle_enabled =
         session_options->bundle_enabled &&
         (session_options->has_audio() || session_options->has_video() ||
          session_options->has_data());
 
-    if (session_->data_channel_type() == cricket::DCT_SCTP && data_channel_) {
-      session_options->data_channel_type = cricket::DCT_SCTP;
-    } else if (session_->data_channel_type() == cricket::DCT_QUIC) {
-      session_options->data_channel_type = cricket::DCT_QUIC;
-    }
-
     session_options->crypto_options = crypto_options_;
   }
 
   void GetOptionsForAnswer(cricket::MediaSessionOptions* session_options) {
-    // ParseConstraintsForAnswer is used to set some defaults.
-    ASSERT_TRUE(webrtc::ParseConstraintsForAnswer(nullptr, session_options));
-
-    AddStreamsToOptions(session_options);
+    AddExistingMediaSectionsAndSendersToOptions(
+        session_options, local_send_audio_, local_recv_audio_,
+        local_send_video_, local_recv_video_);
+
     session_options->bundle_enabled =
         session_options->bundle_enabled &&
         (session_options->has_audio() || session_options->has_video() ||
+         session_options->has_data());
+
+    if (session_->data_channel_type() != cricket::DCT_RTP) {
+      session_options->data_channel_type = session_->data_channel_type();
+    }
+
+    session_options->crypto_options = crypto_options_;
+  }
+
+  void GetOptionsForRemoteAnswer(
+      cricket::MediaSessionOptions* session_options) {
+    bool recv_audio = local_send_audio_ || remote_recv_audio_;
+    bool recv_video = local_send_video_ || remote_recv_video_;
+    bool send_audio = false;
+    bool send_video = false;
+
+    AddExistingMediaSectionsAndSendersToOptions(
+        session_options, send_audio, recv_audio, send_video, recv_video);
+
+    session_options->bundle_enabled =
+        session_options->bundle_enabled &&
+        (session_options->has_audio() || session_options->has_video() ||
          session_options->has_data());
 
     if (session_->data_channel_type() != cricket::DCT_RTP) {
       session_options->data_channel_type = session_->data_channel_type();
     }
 
     session_options->crypto_options = crypto_options_;
   }
 
+  void GetOptionsForAudioOnlyRemoteOffer(
+      cricket::MediaSessionOptions* session_options) {
+    remote_recv_audio_ = true;
+    remote_recv_video_ = false;
+    GetOptionsForRemoteOffer(session_options);
+  }
+
+  void GetOptionsForRemoteOffer(cricket::MediaSessionOptions* session_options) {
+    AddMediaSectionsAndSendersToOptions(session_options, remote_send_audio_,
+                                        remote_recv_audio_, remote_send_video_,
+                                        remote_recv_video_);
+    session_options->bundle_enabled =
+        (session_options->has_audio() || session_options->has_video() ||
+         session_options->has_data());
+
+    if (session_->data_channel_type() != cricket::DCT_RTP) {
+      session_options->data_channel_type = session_->data_channel_type();
+    }
+
+    session_options->crypto_options = crypto_options_;
+  }
+
   // Creates a local offer and applies it. Starts ICE.
   // Call SendAudioVideoStreamX() before this function
   // to decide which streams to create.
   void InitiateCall() {
     SessionDescriptionInterface* offer = CreateOffer();
     SetLocalDescriptionWithoutError(offer);
     EXPECT_TRUE_WAIT(PeerConnectionInterface::kIceGatheringNew !=
         observer_.ice_gathering_state_,
         kIceCandidatesTimeout);
   }
 
   SessionDescriptionInterface* CreateOffer() {
     PeerConnectionInterface::RTCOfferAnswerOptions options;
     options.offer_to_receive_audio =
         RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
-
     return CreateOffer(options);
   }
 
   SessionDescriptionInterface* CreateOffer(
       const PeerConnectionInterface::RTCOfferAnswerOptions options) {
     rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
         observer = new WebRtcSessionCreateSDPObserverForTest();
     cricket::MediaSessionOptions session_options;
     GetOptionsForOffer(options, &session_options);
     session_->CreateOffer(observer, options, session_options);
     EXPECT_TRUE_WAIT(
         observer->state() != WebRtcSessionCreateSDPObserverForTest::kInit,
         2000);
     return observer->ReleaseDescription();
   }
 
   SessionDescriptionInterface* CreateAnswer(
       const cricket::MediaSessionOptions& options) {
     rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observer
         = new WebRtcSessionCreateSDPObserverForTest();
     cricket::MediaSessionOptions session_options = options;
     GetOptionsForAnswer(&session_options);
-    // Overwrite recv_audio and recv_video with passed-in values.
-    session_options.recv_video = options.recv_video;
-    session_options.recv_audio = options.recv_audio;
     session_->CreateAnswer(observer, session_options);
     EXPECT_TRUE_WAIT(
         observer->state() != WebRtcSessionCreateSDPObserverForTest::kInit,
         2000);
     return observer->ReleaseDescription();
   }
 
   SessionDescriptionInterface* CreateAnswer() {
     cricket::MediaSessionOptions options;
-    options.recv_video = true;
-    options.recv_audio = true;
+    options.bundle_enabled = true;
     return CreateAnswer(options);
   }
 
   bool ChannelsExist() const {
     return (session_->voice_channel() != NULL &&
             session_->video_channel() != NULL);
   }
 
   void VerifyCryptoParams(const cricket::SessionDescription* sdp,
       bool gcm_enabled = false) {
@@ skipping 97 matching lines @@
     ASSERT_TRUE(audio != NULL);
     ASSERT_EQ(expected, audio->description.identity_fingerprint.get() != NULL);
     const TransportInfo* video = sdp->GetTransportInfoByName("video");
     ASSERT_TRUE(video != NULL);
     ASSERT_EQ(expected, video->description.identity_fingerprint.get() != NULL);
   }
 
   void VerifyAnswerFromNonCryptoOffer() {
     // Create an SDP without Crypto.
     cricket::MediaSessionOptions options;
-    options.recv_video = true;
+    GetOptionsForRemoteOffer(&options);
     JsepSessionDescription* offer(
         CreateRemoteOffer(options, cricket::SEC_DISABLED));
     ASSERT_TRUE(offer != NULL);
     VerifyNoCryptoParams(offer->description(), false);
     SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto,
                                          offer);
     const webrtc::SessionDescriptionInterface* answer = CreateAnswer();
     // Answer should be NULL as no crypto params in offer.
     ASSERT_TRUE(answer == NULL);
   }
 
   void VerifyAnswerFromCryptoOffer() {
     cricket::MediaSessionOptions options;
-    options.recv_video = true;
+    GetOptionsForRemoteOffer(&options);
     options.bundle_enabled = true;
     std::unique_ptr<JsepSessionDescription> offer(
         CreateRemoteOffer(options, cricket::SEC_REQUIRED));
     ASSERT_TRUE(offer.get() != NULL);
     VerifyCryptoParams(offer->description());
     SetRemoteDescriptionWithoutError(offer.release());
     std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
     ASSERT_TRUE(answer.get() != NULL);
     VerifyCryptoParams(answer->description());
   }
@@ skipping 102 matching lines @@
   // creates a local answer and applies is as a local description.
   // Call SendAudioVideoStreamX() before this function
   // to decide which local and remote streams to create.
   void CreateAndSetRemoteOfferAndLocalAnswer() {
     SessionDescriptionInterface* offer = CreateRemoteOffer();
     SetRemoteDescriptionWithoutError(offer);
     SessionDescriptionInterface* answer = CreateAnswer();
     SetLocalDescriptionWithoutError(answer);
   }
   void SetLocalDescriptionWithoutError(SessionDescriptionInterface* desc) {
-    EXPECT_TRUE(session_->SetLocalDescription(desc, NULL));
+    ASSERT_TRUE(session_->SetLocalDescription(desc, nullptr));
     session_->MaybeStartGathering();
   }
   void SetLocalDescriptionExpectState(SessionDescriptionInterface* desc,
                                       WebRtcSession::State expected_state) {
     SetLocalDescriptionWithoutError(desc);
     EXPECT_EQ(expected_state, session_->state());
   }
   void SetLocalDescriptionExpectError(const std::string& action,
                                       const std::string& expected_error,
                                       SessionDescriptionInterface* desc) {
     std::string error;
     EXPECT_FALSE(session_->SetLocalDescription(desc, &error));
     std::string sdp_type = "local ";
     sdp_type.append(action);
     EXPECT_NE(std::string::npos, error.find(sdp_type));
     EXPECT_NE(std::string::npos, error.find(expected_error));
   }
   void SetLocalDescriptionOfferExpectError(const std::string& expected_error,
                                            SessionDescriptionInterface* desc) {
     SetLocalDescriptionExpectError(SessionDescriptionInterface::kOffer,
                                    expected_error, desc);
   }
   void SetLocalDescriptionAnswerExpectError(const std::string& expected_error,
                                             SessionDescriptionInterface* desc) {
     SetLocalDescriptionExpectError(SessionDescriptionInterface::kAnswer,
                                    expected_error, desc);
   }
   void SetRemoteDescriptionWithoutError(SessionDescriptionInterface* desc) {
-    EXPECT_TRUE(session_->SetRemoteDescription(desc, NULL));
+    ASSERT_TRUE(session_->SetRemoteDescription(desc, nullptr));
   }
   void SetRemoteDescriptionExpectState(SessionDescriptionInterface* desc,
                                        WebRtcSession::State expected_state) {
     SetRemoteDescriptionWithoutError(desc);
     EXPECT_EQ(expected_state, session_->state());
   }
   void SetRemoteDescriptionExpectError(const std::string& action,
                                        const std::string& expected_error,
                                        SessionDescriptionInterface* desc) {
     std::string error;
@@ skipping 16 matching lines @@
   void SetRemoteDescriptionAnswerExpectError(
       const std::string& expected_error, SessionDescriptionInterface* desc) {
     SetRemoteDescriptionExpectError(SessionDescriptionInterface::kAnswer,
                                     expected_error, desc);
   }
 
   void CreateCryptoOfferAndNonCryptoAnswer(SessionDescriptionInterface** offer,
       SessionDescriptionInterface** nocrypto_answer) {
     // Create a SDP without Crypto.
     cricket::MediaSessionOptions options;
-    options.recv_video = true;
+    GetOptionsForRemoteOffer(&options);
     options.bundle_enabled = true;
     *offer = CreateRemoteOffer(options, cricket::SEC_ENABLED);
     ASSERT_TRUE(*offer != NULL);
     VerifyCryptoParams((*offer)->description());
 
-    *nocrypto_answer = CreateRemoteAnswer(*offer, options,
-                                          cricket::SEC_DISABLED);
+    cricket::MediaSessionOptions answer_options;
+    GetOptionsForRemoteAnswer(&answer_options);
+    *nocrypto_answer =
+        CreateRemoteAnswer(*offer, answer_options, cricket::SEC_DISABLED);
     EXPECT_TRUE(*nocrypto_answer != NULL);
   }
 
   void CreateDtlsOfferAndNonDtlsAnswer(SessionDescriptionInterface** offer,
       SessionDescriptionInterface** nodtls_answer) {
     cricket::MediaSessionOptions options;
-    options.recv_video = true;
+    AddMediaSection(cricket::MEDIA_TYPE_AUDIO, cricket::CN_AUDIO,
+                    cricket::MD_RECVONLY, kActive, &options);
+    AddMediaSection(cricket::MEDIA_TYPE_VIDEO, cricket::CN_VIDEO,
+                    cricket::MD_RECVONLY, kActive, &options);
     options.bundle_enabled = true;
 
     std::unique_ptr<SessionDescriptionInterface> temp_offer(
         CreateRemoteOffer(options, cricket::SEC_ENABLED));
 
     *nodtls_answer =
         CreateRemoteAnswer(temp_offer.get(), options, cricket::SEC_ENABLED);
     EXPECT_TRUE(*nodtls_answer != NULL);
     VerifyFingerprintStatus((*nodtls_answer)->description(), false);
     VerifyCryptoParams((*nodtls_answer)->description());
@@ skipping 41 matching lines @@
       cricket::MediaSessionOptions options,
       const SessionDescriptionInterface* current_desc) {
     return CreateRemoteOfferWithVersion(options, cricket::SEC_ENABLED,
                                         kSessionVersion, current_desc);
   }
 
   JsepSessionDescription* CreateRemoteOfferWithSctpPort(
       const char* sctp_stream_name, int new_port,
       cricket::MediaSessionOptions options) {
     options.data_channel_type = cricket::DCT_SCTP;
-    options.AddSendStream(cricket::MEDIA_TYPE_DATA, "datachannel",
-                          sctp_stream_name);
+    GetOptionsForRemoteOffer(&options);
     return ChangeSDPSctpPort(new_port, CreateRemoteOffer(options));
   }
 
   // Takes ownership of offer_basis (and deletes it).
   JsepSessionDescription* ChangeSDPSctpPort(
       int new_port, webrtc::SessionDescriptionInterface *offer_basis) {
     // Stringify the input SDP, swap the 5000 for 'new_port' and create a new
     // SessionDescription from the mutated string.
     const char* default_port_str = "5000";
     char new_port_str[16];
     rtc::sprintfn(new_port_str, sizeof(new_port_str), "%d", new_port);
     std::string offer_str;
     offer_basis->ToString(&offer_str);
     rtc::replace_substrs(default_port_str, strlen(default_port_str),
                                new_port_str, strlen(new_port_str),
                                &offer_str);
     JsepSessionDescription* offer = new JsepSessionDescription(
         offer_basis->type());
     delete offer_basis;
     offer->Initialize(offer_str, NULL);
     return offer;
   }
 
   // Create a remote offer. Call SendAudioVideoStreamX()
   // before this function to decide which streams to create.
   JsepSessionDescription* CreateRemoteOffer() {
     cricket::MediaSessionOptions options;
-    GetOptionsForAnswer(&options);
+    GetOptionsForRemoteOffer(&options);
     return CreateRemoteOffer(options, session_->remote_description());
   }
 
   JsepSessionDescription* CreateRemoteAnswer(
       const SessionDescriptionInterface* offer,
       cricket::MediaSessionOptions options,
       cricket::SecurePolicy policy) {
     desc_factory_->set_secure(policy);
     const std::string session_id =
         rtc::ToString(rtc::CreateRandomId64());
@@ skipping 14 matching lines @@
       return CreateRemoteAnswer(offer, options, cricket::SEC_REQUIRED);
   }
 
   // Creates an answer session description.
   // Call SendAudioVideoStreamX() before this function
   // to decide which streams to create.
   JsepSessionDescription* CreateRemoteAnswer(
       const SessionDescriptionInterface* offer) {
     cricket::MediaSessionOptions options;
     GetOptionsForAnswer(&options);
+    options.bundle_enabled = true;
     return CreateRemoteAnswer(offer, options, cricket::SEC_REQUIRED);
   }
 
   void TestSessionCandidatesWithBundleRtcpMux(bool bundle, bool rtcp_mux) {
     AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
     Init();
     SendAudioVideoStream1();
 
     PeerConnectionInterface::RTCOfferAnswerOptions options;
     options.use_rtp_mux = bundle;
@@ skipping 303 matching lines @@
     InitWithDtlsIdentityGenFail();
     VerifyMultipleAsyncCreateDescriptionAfterInit(false, type);
   }
 
   void VerifyMultipleAsyncCreateDescriptionAfterInit(
       bool success, CreateSessionDescriptionRequest::Type type) {
     RTC_CHECK(session_);
     SetFactoryDtlsSrtp();
     if (type == CreateSessionDescriptionRequest::kAnswer) {
       cricket::MediaSessionOptions options;
+      GetOptionsForRemoteOffer(&options);
       std::unique_ptr<JsepSessionDescription> offer(
           CreateRemoteOffer(options, cricket::SEC_DISABLED));
       ASSERT_TRUE(offer.get() != NULL);
       SetRemoteDescriptionWithoutError(offer.release());
     }
 
     PeerConnectionInterface::RTCOfferAnswerOptions options;
-    cricket::MediaSessionOptions session_options;
+    cricket::MediaSessionOptions offer_session_options;
+    cricket::MediaSessionOptions answer_session_options;
+    GetOptionsForOffer(options, &offer_session_options);
+    GetOptionsForAnswer(&answer_session_options);
     const int kNumber = 3;
     rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
         observers[kNumber];
     for (int i = 0; i < kNumber; ++i) {
       observers[i] = new WebRtcSessionCreateSDPObserverForTest();
       if (type == CreateSessionDescriptionRequest::kOffer) {
-        session_->CreateOffer(observers[i], options, session_options);
+        session_->CreateOffer(observers[i], options, offer_session_options);
       } else {
-        session_->CreateAnswer(observers[i], session_options);
+        session_->CreateAnswer(observers[i], answer_session_options);
       }
     }
 
     WebRtcSessionCreateSDPObserverForTest::State expected_state =
         success ? WebRtcSessionCreateSDPObserverForTest::kSucceeded :
                   WebRtcSessionCreateSDPObserverForTest::kFailed;
 
     for (int i = 0; i < kNumber; ++i) {
       EXPECT_EQ_WAIT(expected_state, observers[i]->state(), 1000);
       if (success) {
@@ skipping 37 matching lines @@
   PeerConnectionFactoryInterface::Options options_;
   PeerConnectionInterface::RTCConfiguration configuration_;
   std::unique_ptr<WebRtcSessionForTest> session_;
   MockIceObserver observer_;
   cricket::FakeVideoMediaChannel* video_channel_;
   cricket::FakeVoiceMediaChannel* voice_channel_;
   rtc::scoped_refptr<FakeMetricsObserver> metrics_observer_;
   // The following flags affect options created for CreateOffer/CreateAnswer.
   bool send_stream_1_ = false;
   bool send_stream_2_ = false;
-  bool send_audio_ = false;
-  bool send_video_ = false;
+  bool local_send_audio_ = false;
+  bool local_send_video_ = false;
+  bool local_recv_audio_ = true;
+  bool local_recv_video_ = true;
+  bool remote_send_audio_ = false;
+  bool remote_send_video_ = false;
+  bool remote_recv_audio_ = true;
+  bool remote_recv_video_ = true;
+  std::vector<cricket::MediaDescriptionOptions> offered_media_sections_;
   rtc::scoped_refptr<DataChannel> data_channel_;
   // Last values received from data channel creation signal.
   std::string last_data_channel_label_;
   InternalDataChannelInit last_data_channel_config_;
   rtc::CryptoOptions crypto_options_;
 };
 
 TEST_P(WebRtcSessionTest, TestInitializeWithDtls) {
   InitWithDtls(GetParam());
   // SDES is disabled when DTLS is on.
@@ skipping 219 matching lines @@
 //     answer without SDES or DTLS --> success
 // TestCreateAnswerReceiveOfferWithoutEncryption: set remote offer and local
 //     answer without SDES or DTLS --> success
 //
 
 // Test that we return a failure when applying a remote/local offer that doesn't
 // have cryptos enabled when DTLS is off.
 TEST_F(WebRtcSessionTest, TestSetNonSdesOfferWhenSdesOn) {
   Init();
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   JsepSessionDescription* offer = CreateRemoteOffer(
       options, cricket::SEC_DISABLED);
   ASSERT_TRUE(offer != NULL);
   VerifyNoCryptoParams(offer->description(), false);
   // SetRemoteDescription and SetLocalDescription will take the ownership of
   // the offer.
   SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto, offer);
   offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
   ASSERT_TRUE(offer != NULL);
   SetLocalDescriptionOfferExpectError(kSdpWithoutSdesCrypto, offer);
@@ skipping 25 matching lines @@
   SetRemoteDescriptionAnswerExpectError(kSdpWithoutSdesCrypto, answer);
 }
 
 // Test that we accept an offer with a DTLS fingerprint when DTLS is on
 // and that we return an answer with a DTLS fingerprint.
 TEST_P(WebRtcSessionTest, TestReceiveDtlsOfferCreateDtlsAnswer) {
   SendAudioVideoStream1();
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   JsepSessionDescription* offer =
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
   ASSERT_TRUE(offer != NULL);
   VerifyFingerprintStatus(offer->description(), true);
   VerifyNoCryptoParams(offer->description(), true);
 
   // SetRemoteDescription will take the ownership of the offer.
   SetRemoteDescriptionWithoutError(offer);
 
   // Verify that we get a crypto fingerprint in the answer.
@@ skipping 18 matching lines @@
   SessionDescriptionInterface* offer = CreateOffer();
   ASSERT_TRUE(offer != NULL);
   VerifyFingerprintStatus(offer->description(), true);
   // Check that we don't have an a=crypto line in the offer.
   VerifyNoCryptoParams(offer->description(), true);
 
   // Now set the local description, which should work, even without a=crypto.
   SetLocalDescriptionWithoutError(offer);
 
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForAnswer(&options);
   JsepSessionDescription* answer =
       CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
   ASSERT_TRUE(answer != NULL);
   VerifyFingerprintStatus(answer->description(), true);
   VerifyNoCryptoParams(answer->description(), true);
 
   // SetRemoteDescription will take the ownership of the answer.
   SetRemoteDescriptionWithoutError(answer);
 }
 
 // Test that if we support DTLS and the other side didn't offer a fingerprint,
 // we will fail to set the remote description.
 TEST_P(WebRtcSessionTest, TestReceiveNonDtlsOfferWhenDtlsOn) {
   InitWithDtls(GetParam());
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   options.bundle_enabled = true;
   JsepSessionDescription* offer = CreateRemoteOffer(
       options, cricket::SEC_REQUIRED);
   ASSERT_TRUE(offer != NULL);
   VerifyFingerprintStatus(offer->description(), false);
   VerifyCryptoParams(offer->description());
 
   // SetRemoteDescription will take the ownership of the offer.
   SetRemoteDescriptionOfferExpectError(
       kSdpWithoutDtlsFingerprint, offer);
@@ skipping 17 matching lines @@
   SetRemoteDescriptionWithoutError(offer);
   SetLocalDescriptionAnswerExpectError(
       kSdpWithoutDtlsFingerprint, answer);
 }
 
 // Test that we return a failure when applying a remote answer that doesn't have
 // a DTLS fingerprint when DTLS is required.
 TEST_P(WebRtcSessionTest, TestSetRemoteNonDtlsAnswerWhenDtlsOn) {
   InitWithDtls(GetParam());
   SessionDescriptionInterface* offer = CreateOffer();
-  cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  cricket::MediaSessionOptions offer_options;
+  GetOptionsForRemoteOffer(&offer_options);
+
   std::unique_ptr<SessionDescriptionInterface> temp_offer(
-      CreateRemoteOffer(options, cricket::SEC_ENABLED));
-  JsepSessionDescription* answer =
-      CreateRemoteAnswer(temp_offer.get(), options, cricket::SEC_ENABLED);
+      CreateRemoteOffer(offer_options, cricket::SEC_ENABLED));
+
+  cricket::MediaSessionOptions answer_options;
+  GetOptionsForAnswer(&answer_options);
+  JsepSessionDescription* answer = CreateRemoteAnswer(
+      temp_offer.get(), answer_options, cricket::SEC_ENABLED);
 
   // SetRemoteDescription and SetLocalDescription will take the ownership of
   // the offer and answer.
   SetLocalDescriptionWithoutError(offer);
   SetRemoteDescriptionAnswerExpectError(
       kSdpWithoutDtlsFingerprint, answer);
 }
 
 // Test that we create a local offer without SDES or DTLS and accept a remote
 // answer without SDES or DTLS when encryption is disabled.
 TEST_P(WebRtcSessionTest, TestCreateOfferReceiveAnswerWithoutEncryption) {
   SendAudioVideoStream1();
   options_.disable_encryption = true;
   InitWithDtls(GetParam());
 
   // Verify that we get a crypto fingerprint in the answer.
   SessionDescriptionInterface* offer = CreateOffer();
   ASSERT_TRUE(offer != NULL);
   VerifyFingerprintStatus(offer->description(), false);
   // Check that we don't have an a=crypto line in the offer.
   VerifyNoCryptoParams(offer->description(), false);
 
   // Now set the local description, which should work, even without a=crypto.
   SetLocalDescriptionWithoutError(offer);
 
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForAnswer(&options);
   JsepSessionDescription* answer =
       CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
   ASSERT_TRUE(answer != NULL);
   VerifyFingerprintStatus(answer->description(), false);
   VerifyNoCryptoParams(answer->description(), false);
 
   // SetRemoteDescription will take the ownership of the answer.
   SetRemoteDescriptionWithoutError(answer);
 }
 
 // Test that we create a local answer without SDES or DTLS and accept a remote
 // offer without SDES or DTLS when encryption is disabled.
 TEST_P(WebRtcSessionTest, TestCreateAnswerReceiveOfferWithoutEncryption) {
   options_.disable_encryption = true;
   InitWithDtls(GetParam());
 
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   JsepSessionDescription* offer =
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
   ASSERT_TRUE(offer != NULL);
   VerifyFingerprintStatus(offer->description(), false);
   VerifyNoCryptoParams(offer->description(), false);
 
   // SetRemoteDescription will take the ownership of the offer.
   SetRemoteDescriptionWithoutError(offer);
 
   // Verify that we get a crypto fingerprint in the answer.
@@ skipping 12 matching lines @@
 // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4525
 TEST_P(WebRtcSessionTest, TestCreateAnswerWithDifferentSslRoles) {
   SendAudioVideoStream1();
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
 
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForAnswer(&options);
 
   // First, negotiate different SSL roles.
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
   TransportInfo* audio_transport_info =
       answer->description()->GetTransportInfoByName("audio");
   audio_transport_info->description.connection_role =
       cricket::CONNECTIONROLE_ACTIVE;
   TransportInfo* video_transport_info =
       answer->description()->GetTransportInfoByName("video");
   video_transport_info->description.connection_role =
       cricket::CONNECTIONROLE_PASSIVE;
   SetRemoteDescriptionWithoutError(answer);
 
   // Now create an offer in the reverse direction, and ensure the initial
   // offerer responds with an answer with correct SSL roles.
   offer = CreateRemoteOfferWithVersion(options, cricket::SEC_DISABLED,
                                        kSessionVersion,
                                        session_->remote_description());
   SetRemoteDescriptionWithoutError(offer);
 
-  answer = CreateAnswer();
+  cricket::MediaSessionOptions answer_options;
+  answer_options.bundle_enabled = true;
+  answer = CreateAnswer(answer_options);
   audio_transport_info = answer->description()->GetTransportInfoByName("audio");
   EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
             audio_transport_info->description.connection_role);
   video_transport_info = answer->description()->GetTransportInfoByName("video");
   EXPECT_EQ(cricket::CONNECTIONROLE_ACTIVE,
             video_transport_info->description.connection_role);
   SetLocalDescriptionWithoutError(answer);
 
   // Lastly, start BUNDLE-ing on "audio", expecting that the "passive" role of
   // audio is transferred over to video in the answer that completes the BUNDLE
   // negotiation.
   options.bundle_enabled = true;
   offer = CreateRemoteOfferWithVersion(options, cricket::SEC_DISABLED,
                                        kSessionVersion,
                                        session_->remote_description());
   SetRemoteDescriptionWithoutError(offer);
-  answer = CreateAnswer();
+  answer = CreateAnswer(answer_options);
   audio_transport_info = answer->description()->GetTransportInfoByName("audio");
   EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
             audio_transport_info->description.connection_role);
   video_transport_info = answer->description()->GetTransportInfoByName("video");
   EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
             video_transport_info->description.connection_role);
   SetLocalDescriptionWithoutError(answer);
 }
 
 TEST_F(WebRtcSessionTest, TestSetLocalOfferTwice) {
@@ skipping 340 matching lines @@
   // is called.
   EXPECT_EQ(0u, observer_.mline_0_candidates_.size());
   EXPECT_EQ(0u, observer_.mline_1_candidates_.size());
   CreateAndSetRemoteOfferAndLocalAnswer();
   // Wait until at least one local candidate has been collected.
   EXPECT_TRUE_WAIT(0u < observer_.mline_0_candidates_.size(),
                    kIceCandidatesTimeout);
 
   std::unique_ptr<SessionDescriptionInterface> local_offer(CreateOffer());
 
+  ASSERT_TRUE(local_offer);
   ASSERT_TRUE(local_offer->candidates(kMediaContentIndex0) != NULL);
   EXPECT_LT(0u, local_offer->candidates(kMediaContentIndex0)->count());
 
   SessionDescriptionInterface* remote_offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(remote_offer);
   SessionDescriptionInterface* answer = CreateAnswer();
   ASSERT_TRUE(answer->candidates(kMediaContentIndex0) != NULL);
   EXPECT_LT(0u, answer->candidates(kMediaContentIndex0)->count());
   SetLocalDescriptionWithoutError(answer);
 }
 
 // Verifies TransportProxy and media channels are created with content names
 // present in the SessionDescription.
 TEST_F(WebRtcSessionTest, TestChannelCreationsWithContentNames) {
   Init();
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   // CreateOffer creates session description with the content names "audio" and
   // "video". Goal is to modify these content names and verify transport
   // channels
   // in the WebRtcSession, as channels are created with the content names
   // present in SDP.
   std::string sdp;
   EXPECT_TRUE(offer->ToString(&sdp));
-  const std::string kAudioMid = "a=mid:audio";
-  const std::string kAudioMidReplaceStr = "a=mid:audio_content_name";
-  const std::string kVideoMid = "a=mid:video";
-  const std::string kVideoMidReplaceStr = "a=mid:video_content_name";
-
-  // Replacing |audio| with |audio_content_name|.
-  rtc::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
-                             kAudioMidReplaceStr.c_str(),
-                             kAudioMidReplaceStr.length(),
-                             &sdp);
-  // Replacing |video| with |video_content_name|.
-  rtc::replace_substrs(kVideoMid.c_str(), kVideoMid.length(),
-                             kVideoMidReplaceStr.c_str(),
-                             kVideoMidReplaceStr.length(),
-                             &sdp);
 
   SessionDescriptionInterface* modified_offer =
       CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
 
   SetRemoteDescriptionWithoutError(modified_offer);
 
-  SessionDescriptionInterface* answer = CreateAnswer();
+  cricket::MediaSessionOptions answer_options;
+  answer_options.bundle_enabled = false;
+  SessionDescriptionInterface* answer = CreateAnswer(answer_options);
   SetLocalDescriptionWithoutError(answer);
 
   rtc::PacketTransportInternal* voice_transport_channel =
       session_->voice_rtp_transport_channel();
   EXPECT_TRUE(voice_transport_channel != NULL);
   EXPECT_EQ(voice_transport_channel->debug_name(),
-            "audio_content_name " +
-                std::to_string(cricket::ICE_CANDIDATE_COMPONENT_RTP));
+            "audio " + std::to_string(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   rtc::PacketTransportInternal* video_transport_channel =
       session_->video_rtp_transport_channel();
   ASSERT_TRUE(video_transport_channel != NULL);
   EXPECT_EQ(video_transport_channel->debug_name(),
-            "video_content_name " +
-                std::to_string(cricket::ICE_CANDIDATE_COMPONENT_RTP));
+            "video " + std::to_string(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   EXPECT_TRUE((video_channel_ = media_engine_->GetVideoChannel(0)) != NULL);
   EXPECT_TRUE((voice_channel_ = media_engine_->GetVoiceChannel(0)) != NULL);
 }
 
 // Test that an offer contains the correct media content descriptions based on
 // the send streams when no constraints have been set.
 TEST_F(WebRtcSessionTest, CreateOfferWithoutConstraintsOrStreams) {
   Init();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   ASSERT_TRUE(offer != NULL);
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  ASSERT_TRUE(content != NULL);
+  EXPECT_EQ(
+      cricket::MD_RECVONLY,
+      static_cast<const cricket::AudioContentDescription*>(content->description)
+          ->direction());
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  ASSERT_TRUE(content != NULL);
+  EXPECT_EQ(
+      cricket::MD_RECVONLY,
+      static_cast<const cricket::VideoContentDescription*>(content->description)
+          ->direction());
 }
 
 // Test that an offer contains the correct media content descriptions based on
 // the send streams when no constraints have been set.
 TEST_F(WebRtcSessionTest, CreateOfferWithoutConstraints) {
   Init();
   // Test Audio only offer.
   SendAudioOnlyStream2();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  ASSERT_TRUE(content != NULL);
+  EXPECT_EQ(
+      cricket::MD_SENDRECV,
+      static_cast<const cricket::AudioContentDescription*>(content->description)
+          ->direction());
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content == NULL);
+  ASSERT_TRUE(content != NULL);
+  EXPECT_EQ(
+      cricket::MD_RECVONLY,
+      static_cast<const cricket::VideoContentDescription*>(content->description)
+          ->direction());
 
   // Test Audio / Video offer.
   SendAudioVideoStream1();
   offer.reset(CreateOffer());
   content = cricket::GetFirstAudioContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  ASSERT_TRUE(content != NULL);
+  EXPECT_EQ(
+      cricket::MD_SENDRECV,
+      static_cast<const cricket::AudioContentDescription*>(content->description)
+          ->direction());
+
   content = cricket::GetFirstVideoContent(offer->description());
-  EXPECT_TRUE(content != NULL);
+  ASSERT_TRUE(content != NULL);
+  EXPECT_EQ(
+      cricket::MD_SENDRECV,
+      static_cast<const cricket::VideoContentDescription*>(content->description)
+          ->direction());
 }
 
 // Test that an offer contains no media content descriptions if
 // kOfferToReceiveVideo and kOfferToReceiveAudio constraints are set to false.
 TEST_F(WebRtcSessionTest, CreateOfferWithConstraintsWithoutStreams) {
   Init();
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.offer_to_receive_audio = 0;
   options.offer_to_receive_video = 0;
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
 
   ASSERT_TRUE(offer != NULL);
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
   EXPECT_TRUE(content == NULL);
   content = cricket::GetFirstVideoContent(offer->description());
   EXPECT_TRUE(content == NULL);
 }
 
 // Test that an offer contains only audio media content descriptions if
 // kOfferToReceiveAudio constraints are set to true.
 TEST_F(WebRtcSessionTest, CreateAudioOnlyOfferWithConstraints) {
   Init();
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.offer_to_receive_audio =
       RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
+  options.offer_to_receive_video = 0;
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
   EXPECT_TRUE(content != NULL);
   content = cricket::GetFirstVideoContent(offer->description());
   EXPECT_TRUE(content == NULL);
 }
 
@@ skipping 14 matching lines @@
       cricket::GetFirstAudioContent(offer->description());
   EXPECT_TRUE(content != NULL);
 
   content = cricket::GetFirstVideoContent(offer->description());
   EXPECT_TRUE(content != NULL);
 
   // Sets constraints to false and verifies that audio/video contents are
   // removed.
   options.offer_to_receive_audio = 0;
   options.offer_to_receive_video = 0;
+  // Remove the media sections added in previous offer.
+  offered_media_sections_.clear();
   offer.reset(CreateOffer(options));
 
   content = cricket::GetFirstAudioContent(offer->description());
   EXPECT_TRUE(content == NULL);
   content = cricket::GetFirstVideoContent(offer->description());
   EXPECT_TRUE(content == NULL);
 }
 
 // Test that an answer can not be created if the last remote description is not
 // an offer.
@@ skipping 23 matching lines @@
   ASSERT_TRUE(content != NULL);
   EXPECT_FALSE(content->rejected);
 }
 
 // Test that an answer contains the correct media content descriptions when no
 // constraints have been set and the offer only contain audio.
 TEST_F(WebRtcSessionTest, CreateAudioAnswerWithoutConstraintsOrStreams) {
   Init();
   // Create a remote offer with audio only.
   cricket::MediaSessionOptions options;
+  GetOptionsForAudioOnlyRemoteOffer(&options);
 
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
   ASSERT_TRUE(cricket::GetFirstVideoContent(offer->description()) == NULL);
   ASSERT_TRUE(cricket::GetFirstAudioContent(offer->description()) != NULL);
 
   SetRemoteDescriptionWithoutError(offer.release());
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
@@ skipping 24 matching lines @@
 
 // Test that an answer contains the correct media content descriptions when
 // constraints have been set but no stream is sent.
 TEST_F(WebRtcSessionTest, CreateAnswerWithConstraintsWithoutStreams) {
   Init();
   // Create a remote offer with audio and video content.
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
   cricket::MediaSessionOptions session_options;
-  session_options.recv_audio = false;
-  session_options.recv_video = false;
+  remote_send_audio_ = false;
+  remote_send_video_ = false;
+  local_recv_audio_ = false;
+  local_recv_video_ = false;
   std::unique_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(session_options));
 
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_TRUE(content->rejected);
 
   content = cricket::GetFirstVideoContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_TRUE(content->rejected);
 }
 
 // Test that an answer contains the correct media content descriptions when
 // constraints have been set and streams are sent.
 TEST_F(WebRtcSessionTest, CreateAnswerWithConstraints) {
   Init();
   // Create a remote offer with audio and video content.
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
   cricket::MediaSessionOptions options;
-  options.recv_audio = false;
-  options.recv_video = false;
-
   // Test with a stream with tracks.
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer(options));
 
   // TODO(perkj): Should the direction be set to SEND_ONLY?
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
   ASSERT_TRUE(content != NULL);
   EXPECT_FALSE(content->rejected);
 
@@ skipping 39 matching lines @@
 // later updates with video.
 TEST_F(WebRtcSessionTest, TestAVOfferWithAudioOnlyAnswer) {
   Init();
   EXPECT_TRUE(media_engine_->GetVideoChannel(0) == NULL);
   EXPECT_TRUE(media_engine_->GetVoiceChannel(0) == NULL);
 
   SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
 
   cricket::MediaSessionOptions options;
+  AddMediaSection(cricket::MEDIA_TYPE_AUDIO, cricket::CN_AUDIO,
+                  cricket::MD_RECVONLY, kActive, &options);
+  AddMediaSection(cricket::MEDIA_TYPE_VIDEO, cricket::CN_VIDEO,
+                  cricket::MD_INACTIVE, kStopped, &options);
+  local_recv_video_ = false;
   SessionDescriptionInterface* answer = CreateRemoteAnswer(offer, options);
 
   // SetLocalDescription and SetRemoteDescriptions takes ownership of offer
   // and answer;
   SetLocalDescriptionWithoutError(offer);
   SetRemoteDescriptionWithoutError(answer);
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
-  ASSERT_TRUE(video_channel_ == NULL);
+  ASSERT_TRUE(video_channel_ == nullptr);
 
   ASSERT_EQ(0u, voice_channel_->recv_streams().size());
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_EQ(kAudioTrack1, voice_channel_->send_streams()[0].id);
 
   // Let the remote end update the session descriptions, with Audio and Video.
   SendAudioVideoStream2();
+  local_recv_video_ = true;
   CreateAndSetRemoteOfferAndLocalAnswer();
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
-  ASSERT_TRUE(video_channel_ != NULL);
-  ASSERT_TRUE(voice_channel_ != NULL);
+  ASSERT_TRUE(video_channel_ != nullptr);
+  ASSERT_TRUE(voice_channel_ != nullptr);
 
   ASSERT_EQ(1u, video_channel_->recv_streams().size());
   ASSERT_EQ(1u, video_channel_->send_streams().size());
   EXPECT_EQ(kVideoTrack2, video_channel_->recv_streams()[0].id);
   EXPECT_EQ(kVideoTrack2, video_channel_->send_streams()[0].id);
   ASSERT_EQ(1u, voice_channel_->recv_streams().size());
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
   EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
 
   // Change session back to audio only.
+  // The remote side doesn't send and recv video.
   SendAudioOnlyStream2();
+  remote_recv_video_ = false;
   CreateAndSetRemoteOfferAndLocalAnswer();
 
-  EXPECT_EQ(0u, video_channel_->recv_streams().size());
+  video_channel_ = media_engine_->GetVideoChannel(0);
+  voice_channel_ = media_engine_->GetVoiceChannel(0);
+
+  // The audio is expected to be rejected.
+  EXPECT_TRUE(video_channel_ == nullptr);
+
   ASSERT_EQ(1u, voice_channel_->recv_streams().size());
   EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
 }
 
 // This test verifies the call setup when remote answer with video only and
 // later updates with audio.
 TEST_F(WebRtcSessionTest, TestAVOfferWithVideoOnlyAnswer) {
   Init();
   EXPECT_TRUE(media_engine_->GetVideoChannel(0) == NULL);
   EXPECT_TRUE(media_engine_->GetVoiceChannel(0) == NULL);
   SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
 
   cricket::MediaSessionOptions options;
-  options.recv_audio = false;
-  options.recv_video = true;
-  SessionDescriptionInterface* answer = CreateRemoteAnswer(
-      offer, options, cricket::SEC_ENABLED);
+  AddMediaSection(cricket::MEDIA_TYPE_AUDIO, cricket::CN_AUDIO,
+                  cricket::MD_INACTIVE, kStopped, &options);
+  AddMediaSection(cricket::MEDIA_TYPE_VIDEO, cricket::CN_VIDEO,
+                  cricket::MD_RECVONLY, kActive, &options);
+  local_recv_audio_ = false;
+  SessionDescriptionInterface* answer =
+      CreateRemoteAnswer(offer, options, cricket::SEC_ENABLED);
 
   // SetLocalDescription and SetRemoteDescriptions takes ownership of offer
   // and answer.
   SetLocalDescriptionWithoutError(offer);
   SetRemoteDescriptionWithoutError(answer);
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
   ASSERT_TRUE(voice_channel_ == NULL);
   ASSERT_TRUE(video_channel_ != NULL);
 
   EXPECT_EQ(0u, video_channel_->recv_streams().size());
   ASSERT_EQ(1u, video_channel_->send_streams().size());
   EXPECT_EQ(kVideoTrack1, video_channel_->send_streams()[0].id);
 
   // Update the session descriptions, with Audio and Video.
   SendAudioVideoStream2();
-  CreateAndSetRemoteOfferAndLocalAnswer();
+  local_recv_audio_ = true;
+  SessionDescriptionInterface* offer2 = CreateRemoteOffer();
+  SetRemoteDescriptionWithoutError(offer2);
+  cricket::MediaSessionOptions answer_options;
+  // Disable the bundling here. If the media is bundled on audio
+  // transport, then we can't reject the audio because switching the bundled
+  // transport is not currently supported.
+  // (https://bugs.chromium.org/p/webrtc/issues/detail?id=6704)
+  answer_options.bundle_enabled = false;
+  SessionDescriptionInterface* answer2 = CreateAnswer(answer_options);
+  SetLocalDescriptionWithoutError(answer2);
 
   voice_channel_ = media_engine_->GetVoiceChannel(0);
+
   ASSERT_TRUE(voice_channel_ != NULL);
-
   ASSERT_EQ(1u, voice_channel_->recv_streams().size());
   ASSERT_EQ(1u, voice_channel_->send_streams().size());
   EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
   EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
 
   // Change session back to video only.
+  // The remote side doesn't send and recv audio.
   SendVideoOnlyStream2();
-  CreateAndSetRemoteOfferAndLocalAnswer();
+  remote_recv_audio_ = false;
+  SessionDescriptionInterface* offer3 = CreateRemoteOffer();
+  SetRemoteDescriptionWithoutError(offer3);
+  SessionDescriptionInterface* answer3 = CreateAnswer(answer_options);
+  SetLocalDescriptionWithoutError(answer3);
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   voice_channel_ = media_engine_->GetVoiceChannel(0);
 
+  // The video is expected to be rejected.
+  EXPECT_TRUE(voice_channel_ == nullptr);
+
   ASSERT_EQ(1u, video_channel_->recv_streams().size());
   EXPECT_EQ(kVideoTrack2, video_channel_->recv_streams()[0].id);
   ASSERT_EQ(1u, video_channel_->send_streams().size());
   EXPECT_EQ(kVideoTrack2, video_channel_->send_streams()[0].id);
 }
 
 TEST_F(WebRtcSessionTest, VerifyCryptoParamsInSDP) {
   Init();
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
@@ skipping 184 matching lines @@
 }
 
 // Test that candidates sent to the "video" transport do not get pushed down to
 // the "audio" transport channel when bundling.
 TEST_F(WebRtcSessionTest, TestIgnoreCandidatesForUnusedTransportWhenBundling) {
   AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
 
   InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyBalanced);
   SendAudioVideoStream1();
 
-  PeerConnectionInterface::RTCOfferAnswerOptions options;
-  options.use_rtp_mux = true;
+  cricket::MediaSessionOptions offer_options;
+  GetOptionsForRemoteOffer(&offer_options);
+  offer_options.bundle_enabled = true;
 
-  SessionDescriptionInterface* offer = CreateRemoteOffer();
+  SessionDescriptionInterface* offer = CreateRemoteOffer(offer_options);
   SetRemoteDescriptionWithoutError(offer);
 
-  SessionDescriptionInterface* answer = CreateAnswer();
+  cricket::MediaSessionOptions answer_options;
+  answer_options.bundle_enabled = true;
+  SessionDescriptionInterface* answer = CreateAnswer(answer_options);
   SetLocalDescriptionWithoutError(answer);
 
   EXPECT_EQ(session_->voice_rtp_transport_channel(),
             session_->video_rtp_transport_channel());
 
   cricket::BaseChannel* voice_channel = session_->voice_channel();
   ASSERT_TRUE(voice_channel != NULL);
 
   // Checks if one of the transport channels contains a connection using a given
   // port.
@@ skipping 144 matching lines @@
 
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.use_rtp_mux = true;
 
   SessionDescriptionInterface* offer = CreateOffer(options);
   SetLocalDescriptionWithoutError(offer);
 
   EXPECT_EQ(session_->voice_rtp_transport_channel(),
             session_->video_rtp_transport_channel());
 
-  SendAudioVideoStream2();
+  SendVideoOnlyStream2();
+  local_send_audio_ = false;
+  remote_recv_audio_ = false;
   cricket::MediaSessionOptions recv_options;
-  recv_options.recv_audio = false;
-  recv_options.recv_video = true;
+  GetOptionsForRemoteAnswer(&recv_options);
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(session_->local_description(), recv_options);
   SetRemoteDescriptionWithoutError(answer);
 
   EXPECT_TRUE(nullptr == session_->voice_channel());
   EXPECT_TRUE(nullptr != session_->video_rtp_transport_channel());
 
   session_->Close();
   EXPECT_TRUE(nullptr == session_->voice_rtp_transport_channel());
   EXPECT_TRUE(nullptr == session_->voice_rtcp_transport_channel());
@@ skipping 66 matching lines @@
   // Expect an error when applying the remote description
   SetRemoteDescriptionExpectError(JsepSessionDescription::kOffer,
                                   kCreateChannelFailed, modified_offer);
 }
 
 // kBundlePolicyMaxCompat bundle policy and answer contains BUNDLE.
 TEST_F(WebRtcSessionTest, TestMaxCompatBundleInAnswer) {
   InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxCompat);
   SendAudioVideoStream1();
 
-  PeerConnectionInterface::RTCOfferAnswerOptions options;
-  options.use_rtp_mux = true;
+  PeerConnectionInterface::RTCOfferAnswerOptions rtc_options;
+  rtc_options.use_rtp_mux = true;
 
-  SessionDescriptionInterface* offer = CreateOffer(options);
+  SessionDescriptionInterface* offer = CreateOffer(rtc_options);
   SetLocalDescriptionWithoutError(offer);
 
   EXPECT_NE(session_->voice_rtp_transport_channel(),
             session_->video_rtp_transport_channel());
 
   SendAudioVideoStream2();
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(session_->local_description());
   SetRemoteDescriptionWithoutError(answer);
 
@@ skipping 335 matching lines @@
   SetLocalDescriptionWithoutError(jsep_offer_str);
   EXPECT_FALSE(session_->voice_channel()->srtp_required_for_testing());
   EXPECT_FALSE(session_->video_channel()->srtp_required_for_testing());
 }
 
 // This test verifies that an answer contains new ufrag and password if an offer
 // with new ufrag and password is received.
 TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewUfragAndPassword) {
   Init();
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
   SetRemoteDescriptionWithoutError(offer.release());
 
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer with new ufrag and password.
-  for (const cricket::ContentInfo& content :
-       session_->local_description()->description()->contents()) {
-    options.transport_options[content.name].ice_restart = true;
+  for (size_t i = 0; i < options.media_description_options.size(); ++i) {
+    options.media_description_options[i].transport_options.ice_restart = true;
   }
+
   std::unique_ptr<JsepSessionDescription> updated_offer1(
       CreateRemoteOffer(options, session_->remote_description()));
   SetRemoteDescriptionWithoutError(updated_offer1.release());
 
   std::unique_ptr<SessionDescriptionInterface> updated_answer1(CreateAnswer());
 
   EXPECT_FALSE(IceUfragPwdEqual(updated_answer1->description(),
                                 session_->local_description()->description()));
 
   // Even a second answer (created before the description is set) should have
   // a new ufrag/password.
   std::unique_ptr<SessionDescriptionInterface> updated_answer2(CreateAnswer());
 
   EXPECT_FALSE(IceUfragPwdEqual(updated_answer2->description(),
                                 session_->local_description()->description()));
 
   SetLocalDescriptionWithoutError(updated_answer2.release());
 }
 
 // This test verifies that an answer contains new ufrag and password if an offer
 // that changes either the ufrag or password (but not both) is received.
 // RFC 5245 says: "If the offer contained a change in the a=ice-ufrag or
 // a=ice-pwd attributes compared to the previous SDP from the peer, it
 // indicates that ICE is restarting for this media stream."
 TEST_F(WebRtcSessionTest, TestOfferChangingOnlyUfragOrPassword) {
   Init();
   cricket::MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   // Create an offer with audio and video.
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
   SetIceUfragPwd(offer.get(), "original_ufrag", "original_password12345");
   SetRemoteDescriptionWithoutError(offer.release());
 
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer with a new ufrag but stale password.
@@ skipping 19 matching lines @@
   EXPECT_FALSE(IceUfragPwdEqual(updated_answer2->description(),
                                 session_->local_description()->description()));
   SetLocalDescriptionWithoutError(updated_answer2.release());
 }
 
 // This test verifies that an answer contains old ufrag and password if an offer
 // with old ufrag and password is received.
 TEST_F(WebRtcSessionTest, TestCreateAnswerWithOldUfragAndPassword) {
   Init();
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
   SetRemoteDescriptionWithoutError(offer.release());
 
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer without changed ufrag or password.
   std::unique_ptr<JsepSessionDescription> updated_offer2(
       CreateRemoteOffer(options, session_->remote_description()));
   SetRemoteDescriptionWithoutError(updated_offer2.release());
 
   std::unique_ptr<SessionDescriptionInterface> updated_answer2(CreateAnswer());
 
   EXPECT_TRUE(IceUfragPwdEqual(updated_answer2->description(),
                                session_->local_description()->description()));
 
   SetLocalDescriptionWithoutError(updated_answer2.release());
 }
 
 // This test verifies that if an offer does an ICE restart on some, but not all
 // media sections, the answer will change the ufrag/password in the correct
 // media sections.
 TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewAndOldUfragAndPassword) {
   Init();
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
-  options.recv_audio = true;
+  GetOptionsForRemoteOffer(&options);
   options.bundle_enabled = false;
   std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
 
   SetIceUfragPwd(offer.get(), cricket::MEDIA_TYPE_AUDIO, "aaaa",
                  "aaaaaaaaaaaaaaaaaaaaaa");
   SetIceUfragPwd(offer.get(), cricket::MEDIA_TYPE_VIDEO, "bbbb",
                  "bbbbbbbbbbbbbbbbbbbbbb");
   SetRemoteDescriptionWithoutError(offer.release());
 
   SendAudioVideoStream1();
@@ skipping 111 matching lines @@
   CreateDataChannel();
   InitiateCall();
   ASSERT_TRUE(session_->sctp_content_name());
   ASSERT_TRUE(session_->sctp_transport_name());
   EXPECT_EQ("data", *session_->sctp_content_name());
   EXPECT_EQ("data", *session_->sctp_transport_name());
 
   // Create answer that finishes BUNDLE negotiation, which means everything
   // should be bundled on the first transport (audio).
   cricket::MediaSessionOptions answer_options;
-  answer_options.recv_video = true;
   answer_options.bundle_enabled = true;
   answer_options.data_channel_type = cricket::DCT_SCTP;
+  GetOptionsForAnswer(&answer_options);
   SetRemoteDescriptionWithoutError(CreateRemoteAnswer(
       session_->local_description(), answer_options, cricket::SEC_DISABLED));
   ASSERT_TRUE(session_->sctp_content_name());
   ASSERT_TRUE(session_->sctp_transport_name());
   EXPECT_EQ("data", *session_->sctp_content_name());
   EXPECT_EQ("audio", *session_->sctp_transport_name());
 }
 
 TEST_P(WebRtcSessionTest, TestCreateOfferWithSctpEnabledWithoutStreams) {
   InitWithDtls(GetParam());
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
   EXPECT_TRUE(offer->description()->GetContentByName("data") == NULL);
   EXPECT_TRUE(offer->description()->GetTransportInfoByName("data") == NULL);
 }
 
 TEST_P(WebRtcSessionTest, TestCreateAnswerWithSctpInOfferAndNoStreams) {
   SetFactoryDtlsSrtp();
   InitWithDtls(GetParam());
 
   // Create remote offer with SCTP.
   cricket::MediaSessionOptions options;
   options.data_channel_type = cricket::DCT_SCTP;
+  GetOptionsForRemoteOffer(&options);
   JsepSessionDescription* offer =
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
   SetRemoteDescriptionWithoutError(offer);
 
   // Verifies the answer contains SCTP.
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   EXPECT_TRUE(answer != NULL);
   EXPECT_TRUE(answer->description()->GetContentByName("data") != NULL);
   EXPECT_TRUE(answer->description()->GetTransportInfoByName("data") != NULL);
 }
@@ skipping 123 matching lines @@
 }
 
 // Verifies that CreateAnswer succeeds when CreateOffer is called before async
 // identity generation is finished (even if a certificate is provided this is
 // an async op).
 TEST_P(WebRtcSessionTest, TestCreateAnswerBeforeIdentityRequestReturnSuccess) {
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   std::unique_ptr<JsepSessionDescription> offer(
       CreateRemoteOffer(options, cricket::SEC_DISABLED));
   ASSERT_TRUE(offer.get() != NULL);
   SetRemoteDescriptionWithoutError(offer.release());
 
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   EXPECT_TRUE(answer != NULL);
   VerifyNoCryptoParams(answer->description(), true);
   VerifyFingerprintStatus(answer->description(), true);
 }
@@ skipping 53 matching lines @@
       CreateSessionDescriptionRequest::kAnswer);
 }
 
 // Verifies that setRemoteDescription fails when DTLS is disabled and the remote
 // offer has no SDES crypto but only DTLS fingerprint.
 TEST_F(WebRtcSessionTest, TestSetRemoteOfferFailIfDtlsDisabledAndNoCrypto) {
   // Init without DTLS.
   Init();
   // Create a remote offer with secured transport disabled.
   cricket::MediaSessionOptions options;
+  GetOptionsForRemoteOffer(&options);
   JsepSessionDescription* offer(CreateRemoteOffer(
       options, cricket::SEC_DISABLED));
   // Adds a DTLS fingerprint to the remote offer.
   cricket::SessionDescription* sdp = offer->description();
   TransportInfo* audio = sdp->GetTransportInfoByName("audio");
   ASSERT_TRUE(audio != NULL);
   ASSERT_TRUE(audio->description.identity_fingerprint.get() == NULL);
   audio->description.identity_fingerprint.reset(
       rtc::SSLFingerprint::CreateFromRfc4572(
           rtc::DIGEST_SHA_256, kFakeDtlsFingerprint));
@@ skipping 23 matching lines @@
   SetFactoryDtlsSrtp();
 
   SendAudioOnlyStream2();
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
 
   SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
   SetRemoteDescriptionWithoutError(answer);
 
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
 
   cricket::Candidate candidate1;
   candidate1.set_address(rtc::SocketAddress("1.1.1.1", 5000));
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate(kMediaContentName1, kMediaContentIndex1,
                                  candidate1);
   EXPECT_TRUE(offer->AddCandidate(&ice_candidate));
   SetRemoteDescriptionWithoutError(offer);
 
   answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 }
 
 // Tests that we can renegotiate new media content with ICE candidates separated
 // from the remote SDP.
 TEST_P(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesSeparated) {
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
   SendAudioOnlyStream2();
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
 
   SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
   SetRemoteDescriptionWithoutError(answer);
 
   cricket::MediaSessionOptions options;
-  options.recv_video = true;
+  GetOptionsForRemoteOffer(&options);
   offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
   SetRemoteDescriptionWithoutError(offer);
 
   cricket::Candidate candidate1;
   candidate1.set_address(rtc::SocketAddress("1.1.1.1", 5000));
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate(kMediaContentName1, kMediaContentIndex1,
                                  candidate1);
   EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate));
 
   answer = CreateAnswer();
   SetLocalDescriptionWithoutError(answer);
 }
 
 #ifdef HAVE_QUIC
 TEST_P(WebRtcSessionTest, TestNegotiateQuic) {
   configuration_.enable_quic = true;
   InitWithDtls(GetParam());
   EXPECT_TRUE(session_->data_channel_type() == cricket::DCT_QUIC);
   SessionDescriptionInterface* offer = CreateOffer();
   ASSERT_TRUE(offer);
   ASSERT_TRUE(offer->description());
   SetLocalDescriptionWithoutError(offer);
   cricket::MediaSessionOptions options;
-  options.recv_audio = true;
-  options.recv_video = true;
+  GetOptionsForAnswer(&options);
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
   ASSERT_TRUE(answer);
   ASSERT_TRUE(answer->description());
   SetRemoteDescriptionWithoutError(answer);
 }
 #endif  // HAVE_QUIC
 
 // Tests that RTX codec is removed from the answer when it isn't supported
 // by local side.
 TEST_F(WebRtcSessionTest, TestRtxRemovedByCreateAnswer) {
   Init();
-  SendAudioVideoStream1();
+  // Send video only to match the |kSdpWithRtx|.
+  SendVideoOnlyStream2();
   std::string offer_sdp(kSdpWithRtx);
 
   SessionDescriptionInterface* offer =
       CreateSessionDescription(JsepSessionDescription::kOffer, offer_sdp, NULL);
   EXPECT_TRUE(offer->ToString(&offer_sdp));
 
   // Offer SDP contains the RTX codec.
   EXPECT_TRUE(ContainsVideoCodecWithName(offer, "rtx"));
   SetRemoteDescriptionWithoutError(offer);
 
+  // |offered_media_sections_| is used when creating answer.
+  offered_media_sections_.push_back(cricket::MediaDescriptionOptions(
+      cricket::MEDIA_TYPE_VIDEO, cricket::CN_VIDEO,
+      cricket::RtpTransceiverDirection(true, true), false));
+  // Don't create media section for audio in the answer.
   SessionDescriptionInterface* answer = CreateAnswer();
   // Answer SDP does not contain the RTX codec.
   EXPECT_FALSE(ContainsVideoCodecWithName(answer, "rtx"));
   SetLocalDescriptionWithoutError(answer);
 }
 
 // This verifies that the voice channel after bundle has both options from video
 // and voice channels.
 TEST_F(WebRtcSessionTest, TestSetSocketOptionBeforeBundle) {
   InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyBalanced);
@@ skipping 45 matching lines @@
 // and make sure we got success/failure callbacks for all of the requests.
 // Background: crbug.com/507307
 TEST_F(WebRtcSessionTest, CreateOffersAndShutdown) {
   Init();
 
   rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observers[100];
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.offer_to_receive_audio =
       RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
   cricket::MediaSessionOptions session_options;
-  session_options.recv_audio = true;
-
+  GetOptionsForOffer(options, &session_options);
   for (auto& o : observers) {
     o = new WebRtcSessionCreateSDPObserverForTest();
     session_->CreateOffer(o, options, session_options);
   }
 
   session_.reset();
 
   for (auto& o : observers) {
     // We expect to have received a notification now even if the session was
     // terminated.  The offer creation may or may not have succeeded, but we
     // must have received a notification which, so the only invalid state
     // is kInit.
     EXPECT_NE(WebRtcSessionCreateSDPObserverForTest::kInit, o->state());
   }
 }
 
 TEST_F(WebRtcSessionTest, TestPacketOptionsAndOnPacketSent) {
   TestPacketOptions();
 }
 
 // TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled.  That test
 // currently fails because upon disconnection and reconnection OnIceComplete is
 // called more than once without returning to IceGatheringGathering.
 
 INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
                         WebRtcSessionTest,
                         testing::Values(ALREADY_GENERATED,
                                         DTLS_IDENTITY_STORE));