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;
+
 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 130 matching lines @@
     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);
+  // 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 fix 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_) {

[Taylor Brandstetter, 2017/08/05 00:39:09]

It would be ideal if instead of using extra state to remember the existing
options (offered_media_sections_), they were just generated from
WebRtcSession::local_description.

[Zhi Huang, 2017/08/09 00:54:51]

There are some test cases would create answer before setting local/remote
descriptions (e.g test creating answer in the wrong state would fail) so I added
this extra vector.

+      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();
+      }
     }
-    if (send_stream_1_ && send_video_) {
-      session_options->AddSendStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack1,
-                                     kStream1);
+  }
+
+  // Add the existing media sections first and then add new media sections if
+  // needed.
+  void AddMediaSectionsAndSendersToOptions(
+      cricket::MediaSessionOptions* session_options,
+      bool recv_audio,
+      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),
+              !kStopped);
+      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 (send_stream_2_ && send_audio_) {
-      session_options->AddSendStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack2,
-                                     kStream2);
+
+    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),
+              !kStopped);
+      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 (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());
+
+    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), !kStopped);
+      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));
+    ExtractSharedMediaSessionOptions(rtc_options, 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);
-    }
+    // |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, recv_audio,
+                                        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));
+    // |recv_X| is true if callee wants to receive or the caller wants to send.
+    bool recv_audio = recv_audio_ || send_audio_;
+    bool recv_video = recv_video_ || send_video_;
+    bool send_audio = false;
+    bool send_video = false;
 
-    AddStreamsToOptions(session_options);
+    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) {
+    recv_audio_ = true;
+    recv_video_ = false;
+    GetOptionsForRemoteOffer(session_options);
+  }
+
+  void GetOptionsForRemoteOffer(cricket::MediaSessionOptions* session_options) {

[Taylor Brandstetter, 2017/08/05 00:39:10]

This method is what still confuses me; it uses a lot of state that's used for
creating a local offer, so I'm surprised it even works. Can the tests just
explicitly add to the MediaSessionOptions instead, using helper methods if
necessary for readability? For example, "AddAudioVideoSections", as in
mediasession_unittest.cc?

[Zhi Huang, 2017/08/09 00:54:51]

I modified these tests a bit to make it easier to understand.

+    AddMediaSectionsAndSendersToOptions(session_options, recv_audio_,
+                                        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 131 matching lines @@
                                            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));

[Zhi Huang, 2017/08/09 00:54:51]

I would change this to ASSERT so that the test wouldn't have undefined behavior
because of this failure.

   }
   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;
+    GetOptionsForAnswer(&answer_options);

[Taylor Brandstetter, 2017/08/05 00:39:10]

I also don't see how GetOptionsForAnswer works for remote answers. It seems like
methods that use "WebRtcSessionTest" state (like recv_audio_, send_stream_1_)
are only valid for creating a "local" offer or answer, since otherwise all the
directions would end up reversed.

[Zhi Huang, 2017/08/09 00:54:51]

I added another helper method for remote 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, !kStopped, &options);
+    AddMediaSection(cricket::MEDIA_TYPE_VIDEO, cricket::CN_VIDEO,
+                    cricket::MD_RECVONLY, !kStopped, &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 39 matching lines @@
   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 recv_audio_ = true;
+  bool 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;
+  recv_audio_ = false;
+  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, !kStopped, &options);
+  AddMediaSection(cricket::MEDIA_TYPE_VIDEO, cricket::CN_VIDEO,
+                  cricket::MD_INACTIVE, kStopped, &options);
   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);
 
@@ skipping 36 matching lines @@
 // 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, !kStopped, &options);
+
+  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);
@@ skipping 219 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();
   cricket::MediaSessionOptions recv_options;
-  recv_options.recv_audio = false;
-  recv_options.recv_video = true;
+  recv_audio_ = false;
+  GetOptionsForAnswer(&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));