pc/jsep_transport_controller_unittest.cc - src/ - Git at Google

 /*
  *  Copyright 2018 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.
  */

 #include "pc/jsep_transport_controller.h"

 #include <map>
 #include <string>
 #include <utility>

 #include "api/dtls_transport_interface.h"
 #include "api/transport/enums.h"
 #include "p2p/base/candidate_pair_interface.h"
 #include "p2p/base/dtls_transport_factory.h"
 #include "p2p/base/fake_dtls_transport.h"
 #include "p2p/base/fake_ice_transport.h"
 #include "p2p/base/p2p_constants.h"
 #include "p2p/base/transport_info.h"
 #include "rtc_base/fake_ssl_identity.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/net_helper.h"
 #include "rtc_base/socket_address.h"
 #include "rtc_base/ssl_fingerprint.h"
 #include "rtc_base/ssl_identity.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "rtc_base/thread.h"
 #include "test/gtest.h"
 #include "test/scoped_key_value_config.h"

 using cricket::Candidate;
 using cricket::Candidates;
 using cricket::FakeDtlsTransport;
 using webrtc::SdpType;

 static const int kTimeout = 100;
 static const char kIceUfrag1[] = "u0001";
 static const char kIcePwd1[] = "TESTICEPWD00000000000001";
 static const char kIceUfrag2[] = "u0002";
 static const char kIcePwd2[] = "TESTICEPWD00000000000002";
 static const char kIceUfrag3[] = "u0003";
 static const char kIcePwd3[] = "TESTICEPWD00000000000003";
 static const char kIceUfrag4[] = "u0004";
 static const char kIcePwd4[] = "TESTICEPWD00000000000004";
 static const char kAudioMid1[] = "audio1";
 static const char kAudioMid2[] = "audio2";
 static const char kVideoMid1[] = "video1";
 static const char kVideoMid2[] = "video2";
 static const char kDataMid1[] = "data1";

 namespace webrtc {

 class FakeIceTransportFactory : public webrtc::IceTransportFactory {
  public:
   ~FakeIceTransportFactory() override = default;
   rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
       const std::string& transport_name,
       int component,
       IceTransportInit init) override {
     return rtc::make_ref_counted<cricket::FakeIceTransportWrapper>(
         std::make_unique<cricket::FakeIceTransport>(transport_name, component));
   }
 };

 class FakeDtlsTransportFactory : public cricket::DtlsTransportFactory {
  public:
   std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport(
       cricket::IceTransportInternal* ice,
       const webrtc::CryptoOptions& crypto_options,
       rtc::SSLProtocolVersion max_version) override {
     return std::make_unique<FakeDtlsTransport>(
         static_cast<cricket::FakeIceTransport*>(ice));
   }
 };

 class JsepTransportControllerTest : public JsepTransportController::Observer,
                                     public ::testing::Test,
                                     public sigslot::has_slots<> {
  public:
   JsepTransportControllerTest() : signaling_thread_(rtc::Thread::Current()) {
     fake_ice_transport_factory_ = std::make_unique<FakeIceTransportFactory>();
     fake_dtls_transport_factory_ = std::make_unique<FakeDtlsTransportFactory>();
   }

   void CreateJsepTransportController(
       JsepTransportController::Config config,
       rtc::Thread* network_thread = rtc::Thread::Current(),
       cricket::PortAllocator* port_allocator = nullptr) {
     config.transport_observer = this;
     config.rtcp_handler = [](const rtc::CopyOnWriteBuffer& packet,
                              int64_t packet_time_us) {
       RTC_DCHECK_NOTREACHED();
     };
     config.ice_transport_factory = fake_ice_transport_factory_.get();
     config.dtls_transport_factory = fake_dtls_transport_factory_.get();
     config.on_dtls_handshake_error_ = [](rtc::SSLHandshakeError s) {};
     config.field_trials = &field_trials_;
     transport_controller_ = std::make_unique<JsepTransportController>(
         network_thread, port_allocator, nullptr /* async_resolver_factory */,
         std::move(config));
     SendTask(network_thread, [&] { ConnectTransportControllerSignals(); });
   }

   void ConnectTransportControllerSignals() {
     transport_controller_->SubscribeIceConnectionState(
         [this](cricket::IceConnectionState s) {
           JsepTransportControllerTest::OnConnectionState(s);
         });
     transport_controller_->SubscribeConnectionState(
         [this](PeerConnectionInterface::PeerConnectionState s) {
           JsepTransportControllerTest::OnCombinedConnectionState(s);
         });
     transport_controller_->SubscribeStandardizedIceConnectionState(
         [this](PeerConnectionInterface::IceConnectionState s) {
           JsepTransportControllerTest::OnStandardizedIceConnectionState(s);
         });
     transport_controller_->SubscribeIceGatheringState(
         [this](cricket::IceGatheringState s) {
           JsepTransportControllerTest::OnGatheringState(s);
         });
     transport_controller_->SubscribeIceCandidateGathered(
         [this](const std::string& transport,
                const std::vector<cricket::Candidate>& candidates) {
           JsepTransportControllerTest::OnCandidatesGathered(transport,
                                                             candidates);
         });
   }

   std::unique_ptr<cricket::SessionDescription>
   CreateSessionDescriptionWithoutBundle() {
     auto description = std::make_unique<cricket::SessionDescription>();
     AddAudioSection(description.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                     cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                     nullptr);
     AddVideoSection(description.get(), kVideoMid1, kIceUfrag1, kIcePwd1,
                     cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                     nullptr);
     return description;
   }

   std::unique_ptr<cricket::SessionDescription>
   CreateSessionDescriptionWithBundleGroup() {
     auto description = CreateSessionDescriptionWithoutBundle();
     cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
     bundle_group.AddContentName(kAudioMid1);
     bundle_group.AddContentName(kVideoMid1);
     description->AddGroup(bundle_group);

     return description;
   }

   std::unique_ptr<cricket::SessionDescription>
   CreateSessionDescriptionWithBundledData() {
     auto description = CreateSessionDescriptionWithoutBundle();
     AddDataSection(description.get(), kDataMid1,
                    cricket::MediaProtocolType::kSctp, kIceUfrag1, kIcePwd1,
                    cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                    nullptr);
     cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
     bundle_group.AddContentName(kAudioMid1);
     bundle_group.AddContentName(kVideoMid1);
     bundle_group.AddContentName(kDataMid1);
     description->AddGroup(bundle_group);
     return description;
   }

   void AddAudioSection(cricket::SessionDescription* description,
                        const std::string& mid,
                        const std::string& ufrag,
                        const std::string& pwd,
                        cricket::IceMode ice_mode,
                        cricket::ConnectionRole conn_role,
                        rtc::scoped_refptr<rtc::RTCCertificate> cert) {
     std::unique_ptr<cricket::AudioContentDescription> audio(
         new cricket::AudioContentDescription());
     // Set RTCP-mux to be true because the default policy is "mux required".
     audio->set_rtcp_mux(true);
     description->AddContent(mid, cricket::MediaProtocolType::kRtp,
                             /*rejected=*/false, std::move(audio));
     AddTransportInfo(description, mid, ufrag, pwd, ice_mode, conn_role, cert);
   }

   void AddVideoSection(cricket::SessionDescription* description,
                        const std::string& mid,
                        const std::string& ufrag,
                        const std::string& pwd,
                        cricket::IceMode ice_mode,
                        cricket::ConnectionRole conn_role,
                        rtc::scoped_refptr<rtc::RTCCertificate> cert) {
     std::unique_ptr<cricket::VideoContentDescription> video(
         new cricket::VideoContentDescription());
     // Set RTCP-mux to be true because the default policy is "mux required".
     video->set_rtcp_mux(true);
     description->AddContent(mid, cricket::MediaProtocolType::kRtp,
                             /*rejected=*/false, std::move(video));
     AddTransportInfo(description, mid, ufrag, pwd, ice_mode, conn_role, cert);
   }

   void AddDataSection(cricket::SessionDescription* description,
                       const std::string& mid,
                       cricket::MediaProtocolType protocol_type,
                       const std::string& ufrag,
                       const std::string& pwd,
                       cricket::IceMode ice_mode,
                       cricket::ConnectionRole conn_role,
                       rtc::scoped_refptr<rtc::RTCCertificate> cert) {
     RTC_CHECK(protocol_type == cricket::MediaProtocolType::kSctp);
     std::unique_ptr<cricket::SctpDataContentDescription> data(
         new cricket::SctpDataContentDescription());
     data->set_rtcp_mux(true);
     description->AddContent(mid, protocol_type,
                             /*rejected=*/false, std::move(data));
     AddTransportInfo(description, mid, ufrag, pwd, ice_mode, conn_role, cert);
   }

   void AddTransportInfo(cricket::SessionDescription* description,
                         const std::string& mid,
                         const std::string& ufrag,
                         const std::string& pwd,
                         cricket::IceMode ice_mode,
                         cricket::ConnectionRole conn_role,
                         rtc::scoped_refptr<rtc::RTCCertificate> cert) {
     std::unique_ptr<rtc::SSLFingerprint> fingerprint;
     if (cert) {
       fingerprint = rtc::SSLFingerprint::CreateFromCertificate(*cert);
     }

     cricket::TransportDescription transport_desc(std::vector<std::string>(),
                                                  ufrag, pwd, ice_mode,
                                                  conn_role, fingerprint.get());
     description->AddTransportInfo(cricket::TransportInfo(mid, transport_desc));
   }

   cricket::IceConfig CreateIceConfig(
       int receiving_timeout,
       cricket::ContinualGatheringPolicy continual_gathering_policy) {
     cricket::IceConfig config;
     config.receiving_timeout = receiving_timeout;
     config.continual_gathering_policy = continual_gathering_policy;
     return config;
   }

   Candidate CreateCandidate(const std::string& transport_name, int component) {
     Candidate c;
     c.set_transport_name(transport_name);
     c.set_address(rtc::SocketAddress("192.168.1.1", 8000));
     c.set_component(component);
     c.set_protocol(cricket::UDP_PROTOCOL_NAME);
     c.set_priority(1);
     return c;
   }

   void CreateLocalDescriptionAndCompleteConnectionOnNetworkThread() {
     if (!network_thread_->IsCurrent()) {
       SendTask(network_thread_.get(), [&] {
         CreateLocalDescriptionAndCompleteConnectionOnNetworkThread();
       });
       return;
     }

     auto description = CreateSessionDescriptionWithBundleGroup();
     EXPECT_TRUE(transport_controller_
                     ->SetLocalDescription(SdpType::kOffer, description.get())
                     .ok());

     transport_controller_->MaybeStartGathering();
     auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
         transport_controller_->GetDtlsTransport(kAudioMid1));
     auto fake_video_dtls = static_cast<FakeDtlsTransport*>(
         transport_controller_->GetDtlsTransport(kVideoMid1));
     fake_audio_dtls->fake_ice_transport()->SignalCandidateGathered(
         fake_audio_dtls->fake_ice_transport(),
         CreateCandidate(kAudioMid1, /*component=*/1));
     fake_video_dtls->fake_ice_transport()->SignalCandidateGathered(
         fake_video_dtls->fake_ice_transport(),
         CreateCandidate(kVideoMid1, /*component=*/1));
     fake_audio_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
     fake_video_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
     fake_audio_dtls->fake_ice_transport()->SetConnectionCount(2);
     fake_video_dtls->fake_ice_transport()->SetConnectionCount(2);
     fake_audio_dtls->SetReceiving(true);
     fake_video_dtls->SetReceiving(true);
     fake_audio_dtls->SetWritable(true);
     fake_video_dtls->SetWritable(true);
     fake_audio_dtls->fake_ice_transport()->SetConnectionCount(1);
     fake_video_dtls->fake_ice_transport()->SetConnectionCount(1);
   }

  protected:
   void OnConnectionState(cricket::IceConnectionState state) {
     ice_signaled_on_thread_ = rtc::Thread::Current();
     connection_state_ = state;
     ++connection_state_signal_count_;
   }

   void OnStandardizedIceConnectionState(
       PeerConnectionInterface::IceConnectionState state) {
     ice_signaled_on_thread_ = rtc::Thread::Current();
     ice_connection_state_ = state;
     ++ice_connection_state_signal_count_;
   }

   void OnCombinedConnectionState(
       PeerConnectionInterface::PeerConnectionState state) {
     RTC_LOG(LS_INFO) << "OnCombinedConnectionState: "
                      << static_cast<int>(state);
     ice_signaled_on_thread_ = rtc::Thread::Current();
     combined_connection_state_ = state;
     ++combined_connection_state_signal_count_;
   }

   void OnGatheringState(cricket::IceGatheringState state) {
     ice_signaled_on_thread_ = rtc::Thread::Current();
     gathering_state_ = state;
     ++gathering_state_signal_count_;
   }

   void OnCandidatesGathered(const std::string& transport_name,
                             const Candidates& candidates) {
     ice_signaled_on_thread_ = rtc::Thread::Current();
     candidates_[transport_name].insert(candidates_[transport_name].end(),
                                        candidates.begin(), candidates.end());
     ++candidates_signal_count_;
   }

   // JsepTransportController::Observer overrides.
   bool OnTransportChanged(
       const std::string& mid,
       RtpTransportInternal* rtp_transport,
       rtc::scoped_refptr<DtlsTransport> dtls_transport,
       DataChannelTransportInterface* data_channel_transport) override {
     changed_rtp_transport_by_mid_[mid] = rtp_transport;
     if (dtls_transport) {
       changed_dtls_transport_by_mid_[mid] = dtls_transport->internal();
     } else {
       changed_dtls_transport_by_mid_[mid] = nullptr;
     }
     return true;
   }

   rtc::AutoThread main_thread_;
   // Information received from signals from transport controller.
   cricket::IceConnectionState connection_state_ =
       cricket::kIceConnectionConnecting;
   PeerConnectionInterface::IceConnectionState ice_connection_state_ =
       PeerConnectionInterface::kIceConnectionNew;
   PeerConnectionInterface::PeerConnectionState combined_connection_state_ =
       PeerConnectionInterface::PeerConnectionState::kNew;
   bool receiving_ = false;
   cricket::IceGatheringState gathering_state_ = cricket::kIceGatheringNew;
   // transport_name => candidates
   std::map<std::string, Candidates> candidates_;
   // Counts of each signal emitted.
   int connection_state_signal_count_ = 0;
   int ice_connection_state_signal_count_ = 0;
   int combined_connection_state_signal_count_ = 0;
   int receiving_signal_count_ = 0;
   int gathering_state_signal_count_ = 0;
   int candidates_signal_count_ = 0;

   // `network_thread_` should be destroyed after `transport_controller_`
   std::unique_ptr<rtc::Thread> network_thread_;
   std::unique_ptr<FakeIceTransportFactory> fake_ice_transport_factory_;
   std::unique_ptr<FakeDtlsTransportFactory> fake_dtls_transport_factory_;
   rtc::Thread* const signaling_thread_ = nullptr;
   rtc::Thread* ice_signaled_on_thread_ = nullptr;
   // Used to verify the SignalRtpTransportChanged/SignalDtlsTransportChanged are
   // signaled correctly.
   std::map<std::string, RtpTransportInternal*> changed_rtp_transport_by_mid_;
   std::map<std::string, cricket::DtlsTransportInternal*>
       changed_dtls_transport_by_mid_;

   // Transport controller needs to be destroyed first, because it may issue
   // callbacks that modify the changed_*_by_mid in the destructor.
   std::unique_ptr<JsepTransportController> transport_controller_;
   webrtc::test::ScopedKeyValueConfig field_trials_;
 };

 TEST_F(JsepTransportControllerTest, GetRtpTransport) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   auto audio_rtp_transport = transport_controller_->GetRtpTransport(kAudioMid1);
   auto video_rtp_transport = transport_controller_->GetRtpTransport(kVideoMid1);
   EXPECT_NE(nullptr, audio_rtp_transport);
   EXPECT_NE(nullptr, video_rtp_transport);
   EXPECT_NE(audio_rtp_transport, video_rtp_transport);
   // Return nullptr for non-existing ones.
   EXPECT_EQ(nullptr, transport_controller_->GetRtpTransport(kAudioMid2));
 }

 TEST_F(JsepTransportControllerTest, GetDtlsTransport) {
   JsepTransportController::Config config;
   config.rtcp_mux_policy = PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
   CreateJsepTransportController(std::move(config));
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   EXPECT_NE(nullptr, transport_controller_->GetDtlsTransport(kAudioMid1));
   EXPECT_NE(nullptr, transport_controller_->GetRtcpDtlsTransport(kAudioMid1));
   EXPECT_NE(nullptr,
             transport_controller_->LookupDtlsTransportByMid(kAudioMid1));
   EXPECT_NE(nullptr, transport_controller_->GetDtlsTransport(kVideoMid1));
   EXPECT_NE(nullptr, transport_controller_->GetRtcpDtlsTransport(kVideoMid1));
   EXPECT_NE(nullptr,
             transport_controller_->LookupDtlsTransportByMid(kVideoMid1));
   // Lookup for all MIDs should return different transports (no bundle)
   EXPECT_NE(transport_controller_->LookupDtlsTransportByMid(kAudioMid1),
             transport_controller_->LookupDtlsTransportByMid(kVideoMid1));
   // Return nullptr for non-existing ones.
   EXPECT_EQ(nullptr, transport_controller_->GetDtlsTransport(kVideoMid2));
   EXPECT_EQ(nullptr, transport_controller_->GetRtcpDtlsTransport(kVideoMid2));
   EXPECT_EQ(nullptr,
             transport_controller_->LookupDtlsTransportByMid(kVideoMid2));
   // Take a pointer to a transport, shut down the transport controller,
   // and verify that the resulting container is empty.
   auto dtls_transport =
       transport_controller_->LookupDtlsTransportByMid(kVideoMid1);
   webrtc::DtlsTransport* my_transport =
       static_cast<DtlsTransport*>(dtls_transport.get());
   EXPECT_NE(nullptr, my_transport->internal());
   transport_controller_.reset();
   EXPECT_EQ(nullptr, my_transport->internal());
 }

 TEST_F(JsepTransportControllerTest, GetDtlsTransportWithRtcpMux) {
   JsepTransportController::Config config;
   config.rtcp_mux_policy = PeerConnectionInterface::kRtcpMuxPolicyRequire;
   CreateJsepTransportController(std::move(config));
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   EXPECT_NE(nullptr, transport_controller_->GetDtlsTransport(kAudioMid1));
   EXPECT_EQ(nullptr, transport_controller_->GetRtcpDtlsTransport(kAudioMid1));
   EXPECT_NE(nullptr, transport_controller_->GetDtlsTransport(kVideoMid1));
   EXPECT_EQ(nullptr, transport_controller_->GetRtcpDtlsTransport(kVideoMid1));
 }

 TEST_F(JsepTransportControllerTest, SetIceConfig) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());

   transport_controller_->SetIceConfig(
       CreateIceConfig(kTimeout, cricket::GATHER_CONTINUALLY));
   FakeDtlsTransport* fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   ASSERT_NE(nullptr, fake_audio_dtls);
   EXPECT_EQ(kTimeout,
             fake_audio_dtls->fake_ice_transport()->receiving_timeout());
   EXPECT_TRUE(fake_audio_dtls->fake_ice_transport()->gather_continually());

   // Test that value stored in controller is applied to new transports.
   AddAudioSection(description.get(), kAudioMid2, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid2));
   ASSERT_NE(nullptr, fake_audio_dtls);
   EXPECT_EQ(kTimeout,
             fake_audio_dtls->fake_ice_transport()->receiving_timeout());
   EXPECT_TRUE(fake_audio_dtls->fake_ice_transport()->gather_continually());
 }

 // Tests the getter and setter of the ICE restart flag.
 TEST_F(JsepTransportControllerTest, NeedIceRestart) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, description.get())
                   .ok());

   // Initially NeedsIceRestart should return false.
   EXPECT_FALSE(transport_controller_->NeedsIceRestart(kAudioMid1));
   EXPECT_FALSE(transport_controller_->NeedsIceRestart(kVideoMid1));
   // Set the needs-ice-restart flag and verify NeedsIceRestart starts returning
   // true.
   transport_controller_->SetNeedsIceRestartFlag();
   EXPECT_TRUE(transport_controller_->NeedsIceRestart(kAudioMid1));
   EXPECT_TRUE(transport_controller_->NeedsIceRestart(kVideoMid1));
   // For a nonexistent transport, false should be returned.
   EXPECT_FALSE(transport_controller_->NeedsIceRestart(kVideoMid2));

   // Reset the ice_ufrag/ice_pwd for audio.
   auto audio_transport_info = description->GetTransportInfoByName(kAudioMid1);
   audio_transport_info->description.ice_ufrag = kIceUfrag2;
   audio_transport_info->description.ice_pwd = kIcePwd2;
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   // Because the ICE is only restarted for audio, NeedsIceRestart is expected to
   // return false for audio and true for video.
   EXPECT_FALSE(transport_controller_->NeedsIceRestart(kAudioMid1));
   EXPECT_TRUE(transport_controller_->NeedsIceRestart(kVideoMid1));
 }

 TEST_F(JsepTransportControllerTest, MaybeStartGathering) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithBundleGroup();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   // After setting the local description, we should be able to start gathering
   // candidates.
   transport_controller_->MaybeStartGathering();
   EXPECT_EQ_WAIT(cricket::kIceGatheringGathering, gathering_state_, kTimeout);
   EXPECT_EQ(1, gathering_state_signal_count_);
 }

 TEST_F(JsepTransportControllerTest, AddRemoveRemoteCandidates) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   transport_controller_->SetLocalDescription(SdpType::kOffer,
                                              description.get());
   transport_controller_->SetRemoteDescription(SdpType::kAnswer,
                                               description.get());
   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   ASSERT_NE(nullptr, fake_audio_dtls);
   Candidates candidates;
   candidates.push_back(
       CreateCandidate(kAudioMid1, cricket::ICE_CANDIDATE_COMPONENT_RTP));
   EXPECT_TRUE(
       transport_controller_->AddRemoteCandidates(kAudioMid1, candidates).ok());
   EXPECT_EQ(1U,
             fake_audio_dtls->fake_ice_transport()->remote_candidates().size());

   EXPECT_TRUE(transport_controller_->RemoveRemoteCandidates(candidates).ok());
   EXPECT_EQ(0U,
             fake_audio_dtls->fake_ice_transport()->remote_candidates().size());
 }

 TEST_F(JsepTransportControllerTest, SetAndGetLocalCertificate) {
   CreateJsepTransportController(JsepTransportController::Config());

   rtc::scoped_refptr<rtc::RTCCertificate> certificate1 =
       rtc::RTCCertificate::Create(
           rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT));
   rtc::scoped_refptr<rtc::RTCCertificate> returned_certificate;

   auto description = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(description.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   certificate1);

   // Apply the local certificate.
   EXPECT_TRUE(transport_controller_->SetLocalCertificate(certificate1));
   // Apply the local description.
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   returned_certificate = transport_controller_->GetLocalCertificate(kAudioMid1);
   EXPECT_TRUE(returned_certificate);
   EXPECT_EQ(certificate1->identity()->certificate().ToPEMString(),
             returned_certificate->identity()->certificate().ToPEMString());

   // Should fail if called for a nonexistant transport.
   EXPECT_EQ(nullptr, transport_controller_->GetLocalCertificate(kVideoMid1));

   // Shouldn't be able to change the identity once set.
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2 =
       rtc::RTCCertificate::Create(
           rtc::SSLIdentity::Create("session2", rtc::KT_DEFAULT));
   EXPECT_FALSE(transport_controller_->SetLocalCertificate(certificate2));
 }

 TEST_F(JsepTransportControllerTest, GetRemoteSSLCertChain) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithBundleGroup();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   rtc::FakeSSLCertificate fake_certificate("fake_data");

   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   fake_audio_dtls->SetRemoteSSLCertificate(&fake_certificate);
   std::unique_ptr<rtc::SSLCertChain> returned_cert_chain =
       transport_controller_->GetRemoteSSLCertChain(kAudioMid1);
   ASSERT_TRUE(returned_cert_chain);
   ASSERT_EQ(1u, returned_cert_chain->GetSize());
   EXPECT_EQ(fake_certificate.ToPEMString(),
             returned_cert_chain->Get(0).ToPEMString());

   // Should fail if called for a nonexistant transport.
   EXPECT_FALSE(transport_controller_->GetRemoteSSLCertChain(kAudioMid2));
 }

 TEST_F(JsepTransportControllerTest, GetDtlsRole) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto offer_certificate = rtc::RTCCertificate::Create(
       rtc::SSLIdentity::Create("offer", rtc::KT_DEFAULT));
   auto answer_certificate = rtc::RTCCertificate::Create(
       rtc::SSLIdentity::Create("answer", rtc::KT_DEFAULT));
   transport_controller_->SetLocalCertificate(offer_certificate);

   auto offer_desc = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(offer_desc.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   offer_certificate);
   auto answer_desc = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(answer_desc.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   answer_certificate);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, offer_desc.get())
                   .ok());

   absl::optional<rtc::SSLRole> role =
       transport_controller_->GetDtlsRole(kAudioMid1);
   // The DTLS role is not decided yet.
   EXPECT_FALSE(role);
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, answer_desc.get())
                   .ok());
   role = transport_controller_->GetDtlsRole(kAudioMid1);

   ASSERT_TRUE(role);
   EXPECT_EQ(rtc::SSL_CLIENT, *role);
 }

 TEST_F(JsepTransportControllerTest, GetStats) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithBundleGroup();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());

   cricket::TransportStats stats;
   EXPECT_TRUE(transport_controller_->GetStats(kAudioMid1, &stats));
   EXPECT_EQ(kAudioMid1, stats.transport_name);
   EXPECT_EQ(1u, stats.channel_stats.size());
   // Return false for non-existing transport.
   EXPECT_FALSE(transport_controller_->GetStats(kAudioMid2, &stats));
 }

 TEST_F(JsepTransportControllerTest, SignalConnectionStateFailed) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());

   auto fake_ice = static_cast<cricket::FakeIceTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1)->ice_transport());
   fake_ice->SetCandidatesGatheringComplete();
   fake_ice->SetConnectionCount(1);
   // The connection stats will be failed if there is no active connection.
   fake_ice->SetConnectionCount(0);
   EXPECT_EQ_WAIT(cricket::kIceConnectionFailed, connection_state_, kTimeout);
   EXPECT_EQ(1, connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionFailed,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(1, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kFailed,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(1, combined_connection_state_signal_count_);
 }

 TEST_F(JsepTransportControllerTest,
        SignalConnectionStateConnectedNoMediaTransport) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());

   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   auto fake_video_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kVideoMid1));

   // First, have one transport connect, and another fail, to ensure that
   // the first transport connecting didn't trigger a "connected" state signal.
   // We should only get a signal when all are connected.
   fake_audio_dtls->fake_ice_transport()->SetConnectionCount(1);
   fake_audio_dtls->SetWritable(true);
   fake_audio_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
   // Decrease the number of the connection to trigger the signal.
   fake_video_dtls->fake_ice_transport()->SetConnectionCount(1);
   fake_video_dtls->fake_ice_transport()->SetConnectionCount(0);
   fake_video_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();

   EXPECT_EQ_WAIT(cricket::kIceConnectionFailed, connection_state_, kTimeout);
   EXPECT_EQ(1, connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionFailed,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(2, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kFailed,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(2, combined_connection_state_signal_count_);

   fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
   fake_video_dtls->SetDtlsState(DtlsTransportState::kConnected);
   // Set the connection count to be 2 and the cricket::FakeIceTransport will set
   // the transport state to be STATE_CONNECTING.
   fake_video_dtls->fake_ice_transport()->SetConnectionCount(2);
   fake_video_dtls->SetWritable(true);
   EXPECT_EQ_WAIT(cricket::kIceConnectionConnected, connection_state_, kTimeout);
   EXPECT_EQ(2, connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(3, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kConnected,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(3, combined_connection_state_signal_count_);
 }

 TEST_F(JsepTransportControllerTest, SignalConnectionStateComplete) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());

   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   auto fake_video_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kVideoMid1));

   // First, have one transport connect, and another fail, to ensure that
   // the first transport connecting didn't trigger a "connected" state signal.
   // We should only get a signal when all are connected.
   fake_audio_dtls->fake_ice_transport()->SetTransportState(
       IceTransportState::kCompleted,
       cricket::IceTransportState::STATE_COMPLETED);
   fake_audio_dtls->SetWritable(true);
   fake_audio_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();

   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(1, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kConnecting,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(1, combined_connection_state_signal_count_);

   fake_video_dtls->fake_ice_transport()->SetTransportState(
       IceTransportState::kFailed, cricket::IceTransportState::STATE_FAILED);
   fake_video_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();

   EXPECT_EQ_WAIT(cricket::kIceConnectionFailed, connection_state_, kTimeout);
   EXPECT_EQ(1, connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionFailed,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(2, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kFailed,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(2, combined_connection_state_signal_count_);

   fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
   fake_video_dtls->SetDtlsState(DtlsTransportState::kConnected);
   // Set the connection count to be 1 and the cricket::FakeIceTransport will set
   // the transport state to be STATE_COMPLETED.
   fake_video_dtls->fake_ice_transport()->SetTransportState(
       IceTransportState::kCompleted,
       cricket::IceTransportState::STATE_COMPLETED);
   fake_video_dtls->SetWritable(true);
   EXPECT_EQ_WAIT(cricket::kIceConnectionCompleted, connection_state_, kTimeout);
   EXPECT_EQ(3, connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(3, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kConnected,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(3, combined_connection_state_signal_count_);
 }

 TEST_F(JsepTransportControllerTest, SignalIceGatheringStateGathering) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());

   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   fake_audio_dtls->fake_ice_transport()->MaybeStartGathering();
   // Should be in the gathering state as soon as any transport starts gathering.
   EXPECT_EQ_WAIT(cricket::kIceGatheringGathering, gathering_state_, kTimeout);
   EXPECT_EQ(1, gathering_state_signal_count_);
 }

 TEST_F(JsepTransportControllerTest, SignalIceGatheringStateComplete) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithoutBundle();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());

   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   auto fake_video_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kVideoMid1));

   fake_audio_dtls->fake_ice_transport()->MaybeStartGathering();
   EXPECT_EQ_WAIT(cricket::kIceGatheringGathering, gathering_state_, kTimeout);
   EXPECT_EQ(1, gathering_state_signal_count_);

   // Have one transport finish gathering, to make sure gathering
   // completion wasn't signalled if only one transport finished gathering.
   fake_audio_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
   EXPECT_EQ(1, gathering_state_signal_count_);

   fake_video_dtls->fake_ice_transport()->MaybeStartGathering();
   EXPECT_EQ_WAIT(cricket::kIceGatheringGathering, gathering_state_, kTimeout);
   EXPECT_EQ(1, gathering_state_signal_count_);

   fake_video_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
   EXPECT_EQ_WAIT(cricket::kIceGatheringComplete, gathering_state_, kTimeout);
   EXPECT_EQ(2, gathering_state_signal_count_);
 }

 // Test that when the last transport that hasn't finished connecting and/or
 // gathering is destroyed, the aggregate state jumps to "completed". This can
 // happen if, for example, we have an audio and video transport, the audio
 // transport completes, then we start bundling video on the audio transport.
 TEST_F(JsepTransportControllerTest,
        SignalingWhenLastIncompleteTransportDestroyed) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithBundleGroup();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());

   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   auto fake_video_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kVideoMid1));
   EXPECT_NE(fake_audio_dtls, fake_video_dtls);

   fake_audio_dtls->fake_ice_transport()->MaybeStartGathering();
   EXPECT_EQ_WAIT(cricket::kIceGatheringGathering, gathering_state_, kTimeout);
   EXPECT_EQ(1, gathering_state_signal_count_);

   // Let the audio transport complete.
   fake_audio_dtls->SetWritable(true);
   fake_audio_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
   fake_audio_dtls->fake_ice_transport()->SetConnectionCount(1);
   fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
   EXPECT_EQ(1, gathering_state_signal_count_);

   // Set the remote description and enable the bundle.
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, description.get())
                   .ok());
   // The BUNDLE should be enabled, the incomplete video transport should be
   // deleted and the states should be updated.
   fake_video_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kVideoMid1));
   EXPECT_EQ(fake_audio_dtls, fake_video_dtls);
   EXPECT_EQ_WAIT(cricket::kIceConnectionCompleted, connection_state_, kTimeout);
   EXPECT_EQ(PeerConnectionInterface::kIceConnectionCompleted,
             ice_connection_state_);
   EXPECT_EQ(PeerConnectionInterface::PeerConnectionState::kConnected,
             combined_connection_state_);
   EXPECT_EQ_WAIT(cricket::kIceGatheringComplete, gathering_state_, kTimeout);
   EXPECT_EQ(2, gathering_state_signal_count_);
 }

 // Test that states immediately return to "new" if all transports are
 // discarded. This should happen at offer time, even though the transport
 // controller may keep the transport alive in case of rollback.
 TEST_F(JsepTransportControllerTest,
        IceStatesReturnToNewWhenTransportsDiscarded) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(description.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, description.get())
                   .ok());

   // Trigger and verify initial non-new states.
   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   fake_audio_dtls->fake_ice_transport()->MaybeStartGathering();
   fake_audio_dtls->fake_ice_transport()->SetTransportState(
       webrtc::IceTransportState::kChecking,
       cricket::IceTransportState::STATE_CONNECTING);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(1, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kConnecting,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(1, combined_connection_state_signal_count_);
   EXPECT_EQ_WAIT(cricket::kIceGatheringGathering, gathering_state_, kTimeout);
   EXPECT_EQ(1, gathering_state_signal_count_);

   // Reject m= section which should disconnect the transport and return states
   // to "new".
   description->contents()[0].rejected = true;
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kOffer, description.get())
                   .ok());
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionNew,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(2, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kNew,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(2, combined_connection_state_signal_count_);
   EXPECT_EQ_WAIT(cricket::kIceGatheringNew, gathering_state_, kTimeout);
   EXPECT_EQ(2, gathering_state_signal_count_);

   // For good measure, rollback the offer and verify that states return to
   // their previous values.
   EXPECT_TRUE(transport_controller_->RollbackTransports().ok());
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
                  ice_connection_state_, kTimeout);
   EXPECT_EQ(3, ice_connection_state_signal_count_);
   EXPECT_EQ_WAIT(PeerConnectionInterface::PeerConnectionState::kConnecting,
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(3, combined_connection_state_signal_count_);
   EXPECT_EQ_WAIT(cricket::kIceGatheringGathering, gathering_state_, kTimeout);
   EXPECT_EQ(3, gathering_state_signal_count_);
 }

 TEST_F(JsepTransportControllerTest, SignalCandidatesGathered) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto description = CreateSessionDescriptionWithBundleGroup();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, description.get())
                   .ok());
   transport_controller_->MaybeStartGathering();

   auto fake_audio_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   fake_audio_dtls->fake_ice_transport()->SignalCandidateGathered(
       fake_audio_dtls->fake_ice_transport(), CreateCandidate(kAudioMid1, 1));
   EXPECT_EQ_WAIT(1, candidates_signal_count_, kTimeout);
   EXPECT_EQ(1u, candidates_[kAudioMid1].size());
 }

 TEST_F(JsepTransportControllerTest, IceSignalingOccursOnNetworkThread) {
   network_thread_ = rtc::Thread::CreateWithSocketServer();
   network_thread_->Start();
   EXPECT_EQ(ice_signaled_on_thread_, nullptr);
   CreateJsepTransportController(JsepTransportController::Config(),
                                 network_thread_.get(),
                                 /*port_allocator=*/nullptr);
   CreateLocalDescriptionAndCompleteConnectionOnNetworkThread();

   // connecting --> connected --> completed
   EXPECT_EQ_WAIT(cricket::kIceConnectionCompleted, connection_state_, kTimeout);
   EXPECT_EQ(2, connection_state_signal_count_);

   // new --> gathering --> complete
   EXPECT_EQ_WAIT(cricket::kIceGatheringComplete, gathering_state_, kTimeout);
   EXPECT_EQ(2, gathering_state_signal_count_);

   EXPECT_EQ_WAIT(1u, candidates_[kAudioMid1].size(), kTimeout);
   EXPECT_EQ_WAIT(1u, candidates_[kVideoMid1].size(), kTimeout);
   EXPECT_EQ(2, candidates_signal_count_);

   EXPECT_EQ(ice_signaled_on_thread_, network_thread_.get());

   SendTask(network_thread_.get(), [&] { transport_controller_.reset(); });
 }

 // Test that if the TransportController was created with the
 // `redetermine_role_on_ice_restart` parameter set to false, the role is *not*
 // redetermined on an ICE restart.
 TEST_F(JsepTransportControllerTest, IceRoleNotRedetermined) {
   JsepTransportController::Config config;
   config.redetermine_role_on_ice_restart = false;

   CreateJsepTransportController(std::move(config));
   // Let the `transport_controller_` be the controlled side initially.
   auto remote_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   auto local_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_answer.get(), kAudioMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);

   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kOffer, remote_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kAnswer, local_answer.get())
                   .ok());

   auto fake_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   EXPECT_EQ(cricket::ICEROLE_CONTROLLED,
             fake_dtls->fake_ice_transport()->GetIceRole());

   // New offer will trigger the ICE restart.
   auto restart_local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(restart_local_offer.get(), kAudioMid1, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   EXPECT_TRUE(
       transport_controller_
           ->SetLocalDescription(SdpType::kOffer, restart_local_offer.get())
           .ok());
   EXPECT_EQ(cricket::ICEROLE_CONTROLLED,
             fake_dtls->fake_ice_transport()->GetIceRole());
 }

 // Tests ICE-Lite mode in remote answer.
 TEST_F(JsepTransportControllerTest, SetIceRoleWhenIceLiteInRemoteAnswer) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   auto fake_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   EXPECT_EQ(cricket::ICEROLE_CONTROLLING,
             fake_dtls->fake_ice_transport()->GetIceRole());
   EXPECT_EQ(cricket::ICEMODE_FULL,
             fake_dtls->fake_ice_transport()->remote_ice_mode());

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kAudioMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_LITE, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());
   EXPECT_EQ(cricket::ICEROLE_CONTROLLING,
             fake_dtls->fake_ice_transport()->GetIceRole());
   EXPECT_EQ(cricket::ICEMODE_LITE,
             fake_dtls->fake_ice_transport()->remote_ice_mode());
 }

 // Tests that the ICE role remains "controlling" if a subsequent offer that
 // does an ICE restart is received from an ICE lite endpoint. Regression test
 // for: https://crbug.com/710760
 TEST_F(JsepTransportControllerTest,
        IceRoleIsControllingAfterIceRestartFromIceLiteEndpoint) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto remote_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_LITE, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   auto local_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_answer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   // Initial Offer/Answer exchange. If the remote offerer is ICE-Lite, then the
   // local side is the controlling.
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kOffer, remote_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kAnswer, local_answer.get())
                   .ok());
   auto fake_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   EXPECT_EQ(cricket::ICEROLE_CONTROLLING,
             fake_dtls->fake_ice_transport()->GetIceRole());

   // In the subsequence remote offer triggers an ICE restart.
   auto remote_offer2 = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_offer2.get(), kAudioMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_LITE, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   auto local_answer2 = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_answer2.get(), kAudioMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kOffer, remote_offer2.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kAnswer, local_answer2.get())
                   .ok());
   fake_dtls = static_cast<FakeDtlsTransport*>(
       transport_controller_->GetDtlsTransport(kAudioMid1));
   // The local side is still the controlling role since the remote side is using
   // ICE-Lite.
   EXPECT_EQ(cricket::ICEROLE_CONTROLLING,
             fake_dtls->fake_ice_transport()->GetIceRole());
 }

 // Tests that the SDP has more than one audio/video m= sections.
 TEST_F(JsepTransportControllerTest, MultipleMediaSectionsOfSameTypeWithBundle) {
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kAudioMid1);
   bundle_group.AddContentName(kAudioMid2);
   bundle_group.AddContentName(kVideoMid1);
   bundle_group.AddContentName(kDataMid1);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kAudioMid2, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kVideoMid1, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddDataSection(local_offer.get(), kDataMid1,
                  cricket::MediaProtocolType::kSctp, kIceUfrag1, kIcePwd1,
                  cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                  nullptr);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddAudioSection(remote_answer.get(), kAudioMid2, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddVideoSection(remote_answer.get(), kVideoMid1, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddDataSection(remote_answer.get(), kDataMid1,
                  cricket::MediaProtocolType::kSctp, kIceUfrag1, kIcePwd1,
                  cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                  nullptr);

   local_offer->AddGroup(bundle_group);
   remote_answer->AddGroup(bundle_group);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());
   // Verify that all the sections are bundled on kAudio1.
   auto transport1 = transport_controller_->GetRtpTransport(kAudioMid1);
   auto transport2 = transport_controller_->GetRtpTransport(kAudioMid2);
   auto transport3 = transport_controller_->GetRtpTransport(kVideoMid1);
   auto transport4 = transport_controller_->GetRtpTransport(kDataMid1);
   EXPECT_EQ(transport1, transport2);
   EXPECT_EQ(transport1, transport3);
   EXPECT_EQ(transport1, transport4);

   EXPECT_EQ(transport_controller_->LookupDtlsTransportByMid(kAudioMid1),
             transport_controller_->LookupDtlsTransportByMid(kVideoMid1));

   // Verify the OnRtpTransport/DtlsTransportChanged signals are fired correctly.
   auto it = changed_rtp_transport_by_mid_.find(kAudioMid2);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(transport1, it->second);
   it = changed_rtp_transport_by_mid_.find(kAudioMid2);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(transport1, it->second);
   it = changed_rtp_transport_by_mid_.find(kVideoMid1);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(transport1, it->second);
   // Verify the DtlsTransport for the SCTP data channel is reset correctly.
   auto it2 = changed_dtls_transport_by_mid_.find(kDataMid1);
   ASSERT_TRUE(it2 != changed_dtls_transport_by_mid_.end());
 }

 TEST_F(JsepTransportControllerTest, MultipleBundleGroups) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Video[] = "2_video";
   static const char kMid3Audio[] = "3_audio";
   static const char kMid4Video[] = "4_video";

   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   bundle_group1.AddContentName(kMid1Audio);
   bundle_group1.AddContentName(kMid2Video);
   cricket::ContentGroup bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   bundle_group2.AddContentName(kMid3Audio);
   bundle_group2.AddContentName(kMid4Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag4, kIcePwd4,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(bundle_group1);
   local_offer->AddGroup(bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag4, kIcePwd4,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(bundle_group1);
   remote_answer->AddGroup(bundle_group2);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Verify that (kMid1Audio,kMid2Video) and (kMid3Audio,kMid4Video) form two
   // distinct bundled groups.
   auto mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   auto mid2_transport = transport_controller_->GetRtpTransport(kMid2Video);
   auto mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   auto mid4_transport = transport_controller_->GetRtpTransport(kMid4Video);
   EXPECT_EQ(mid1_transport, mid2_transport);
   EXPECT_EQ(mid3_transport, mid4_transport);
   EXPECT_NE(mid1_transport, mid3_transport);

   auto it = changed_rtp_transport_by_mid_.find(kMid1Audio);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(it->second, mid1_transport);

   it = changed_rtp_transport_by_mid_.find(kMid2Video);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(it->second, mid2_transport);

   it = changed_rtp_transport_by_mid_.find(kMid3Audio);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(it->second, mid3_transport);

   it = changed_rtp_transport_by_mid_.find(kMid4Video);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(it->second, mid4_transport);
 }

 TEST_F(JsepTransportControllerTest,
        MultipleBundleGroupsInOfferButOnlyASingleGroupInAnswer) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Video[] = "2_video";
   static const char kMid3Audio[] = "3_audio";
   static const char kMid4Video[] = "4_video";

   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   bundle_group1.AddContentName(kMid1Audio);
   bundle_group1.AddContentName(kMid2Video);
   cricket::ContentGroup bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   bundle_group2.AddContentName(kMid3Audio);
   bundle_group2.AddContentName(kMid4Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag4, kIcePwd4,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   // The offer has both groups.
   local_offer->AddGroup(bundle_group1);
   local_offer->AddGroup(bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag4, kIcePwd4,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   // The answer only has a single group! This is what happens when talking to an
   // endpoint that does not have support for multiple BUNDLE groups.
   remote_answer->AddGroup(bundle_group1);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Verify that (kMid1Audio,kMid2Video) form a bundle group, but that
   // kMid3Audio and kMid4Video are unbundled.
   auto mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   auto mid2_transport = transport_controller_->GetRtpTransport(kMid2Video);
   auto mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   auto mid4_transport = transport_controller_->GetRtpTransport(kMid4Video);
   EXPECT_EQ(mid1_transport, mid2_transport);
   EXPECT_NE(mid3_transport, mid4_transport);
   EXPECT_NE(mid1_transport, mid3_transport);
   EXPECT_NE(mid1_transport, mid4_transport);
 }

 TEST_F(JsepTransportControllerTest, MultipleBundleGroupsIllegallyChangeGroup) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Video[] = "2_video";
   static const char kMid3Audio[] = "3_audio";
   static const char kMid4Video[] = "4_video";

   CreateJsepTransportController(JsepTransportController::Config());
   // Offer groups (kMid1Audio,kMid2Video) and (kMid3Audio,kMid4Video).
   cricket::ContentGroup offer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group1.AddContentName(kMid1Audio);
   offer_bundle_group1.AddContentName(kMid2Video);
   cricket::ContentGroup offer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group2.AddContentName(kMid3Audio);
   offer_bundle_group2.AddContentName(kMid4Video);
   // Answer groups (kMid1Audio,kMid4Video) and (kMid3Audio,kMid2Video), i.e. the
   // second group members have switched places. This should get rejected.
   cricket::ContentGroup answer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group1.AddContentName(kMid1Audio);
   answer_bundle_group1.AddContentName(kMid4Video);
   cricket::ContentGroup answer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group2.AddContentName(kMid3Audio);
   answer_bundle_group2.AddContentName(kMid2Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag4, kIcePwd4,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(offer_bundle_group1);
   local_offer->AddGroup(offer_bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag4, kIcePwd4,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(answer_bundle_group1);
   remote_answer->AddGroup(answer_bundle_group2);

   // Accept offer.
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   // Reject answer!
   EXPECT_FALSE(transport_controller_
                    ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                    .ok());
 }

 TEST_F(JsepTransportControllerTest, MultipleBundleGroupsInvalidSubsets) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Video[] = "2_video";
   static const char kMid3Audio[] = "3_audio";
   static const char kMid4Video[] = "4_video";

   CreateJsepTransportController(JsepTransportController::Config());
   // Offer groups (kMid1Audio,kMid2Video) and (kMid3Audio,kMid4Video).
   cricket::ContentGroup offer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group1.AddContentName(kMid1Audio);
   offer_bundle_group1.AddContentName(kMid2Video);
   cricket::ContentGroup offer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group2.AddContentName(kMid3Audio);
   offer_bundle_group2.AddContentName(kMid4Video);
   // Answer groups (kMid1Audio) and (kMid2Video), i.e. the second group was
   // moved from the first group. This should get rejected.
   cricket::ContentGroup answer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group1.AddContentName(kMid1Audio);
   cricket::ContentGroup answer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group2.AddContentName(kMid2Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag4, kIcePwd4,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(offer_bundle_group1);
   local_offer->AddGroup(offer_bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag4, kIcePwd4,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(answer_bundle_group1);
   remote_answer->AddGroup(answer_bundle_group2);

   // Accept offer.
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   // Reject answer!
   EXPECT_FALSE(transport_controller_
                    ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                    .ok());
 }

 TEST_F(JsepTransportControllerTest, MultipleBundleGroupsInvalidOverlap) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Video[] = "2_video";
   static const char kMid3Audio[] = "3_audio";

   CreateJsepTransportController(JsepTransportController::Config());
   // Offer groups (kMid1Audio,kMid3Audio) and (kMid2Video,kMid3Audio), i.e.
   // kMid3Audio is in both groups - this is illegal.
   cricket::ContentGroup offer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group1.AddContentName(kMid1Audio);
   offer_bundle_group1.AddContentName(kMid3Audio);
   cricket::ContentGroup offer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group2.AddContentName(kMid2Video);
   offer_bundle_group2.AddContentName(kMid3Audio);

   auto offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(offer.get(), kMid2Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(offer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   offer->AddGroup(offer_bundle_group1);
   offer->AddGroup(offer_bundle_group2);

   // Reject offer, both if set as local or remote.
   EXPECT_FALSE(
       transport_controller_->SetLocalDescription(SdpType::kOffer, offer.get())
           .ok());
   EXPECT_FALSE(
       transport_controller_->SetRemoteDescription(SdpType::kOffer, offer.get())
           .ok());
 }

 TEST_F(JsepTransportControllerTest, MultipleBundleGroupsUnbundleFirstMid) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Audio[] = "2_audio";
   static const char kMid3Audio[] = "3_audio";
   static const char kMid4Video[] = "4_video";
   static const char kMid5Video[] = "5_video";
   static const char kMid6Video[] = "6_video";

   CreateJsepTransportController(JsepTransportController::Config());
   // Offer groups (kMid1Audio,kMid2Audio,kMid3Audio) and
   // (kMid4Video,kMid5Video,kMid6Video).
   cricket::ContentGroup offer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group1.AddContentName(kMid1Audio);
   offer_bundle_group1.AddContentName(kMid2Audio);
   offer_bundle_group1.AddContentName(kMid3Audio);
   cricket::ContentGroup offer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group2.AddContentName(kMid4Video);
   offer_bundle_group2.AddContentName(kMid5Video);
   offer_bundle_group2.AddContentName(kMid6Video);
   // Answer groups (kMid2Audio,kMid3Audio) and (kMid5Video,kMid6Video), i.e.
   // we've moved the first MIDs out of the groups.
   cricket::ContentGroup answer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group1.AddContentName(kMid2Audio);
   answer_bundle_group1.AddContentName(kMid3Audio);
   cricket::ContentGroup answer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group2.AddContentName(kMid5Video);
   answer_bundle_group2.AddContentName(kMid6Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid3Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid5Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid6Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(offer_bundle_group1);
   local_offer->AddGroup(offer_bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid3Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid5Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid6Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(answer_bundle_group1);
   remote_answer->AddGroup(answer_bundle_group2);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   auto mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   auto mid2_transport = transport_controller_->GetRtpTransport(kMid2Audio);
   auto mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   auto mid4_transport = transport_controller_->GetRtpTransport(kMid4Video);
   auto mid5_transport = transport_controller_->GetRtpTransport(kMid5Video);
   auto mid6_transport = transport_controller_->GetRtpTransport(kMid6Video);
   EXPECT_NE(mid1_transport, mid2_transport);
   EXPECT_EQ(mid2_transport, mid3_transport);
   EXPECT_NE(mid4_transport, mid5_transport);
   EXPECT_EQ(mid5_transport, mid6_transport);
   EXPECT_NE(mid1_transport, mid4_transport);
   EXPECT_NE(mid2_transport, mid5_transport);
 }

 TEST_F(JsepTransportControllerTest, MultipleBundleGroupsChangeFirstMid) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Audio[] = "2_audio";
   static const char kMid3Audio[] = "3_audio";
   static const char kMid4Video[] = "4_video";
   static const char kMid5Video[] = "5_video";
   static const char kMid6Video[] = "6_video";

   CreateJsepTransportController(JsepTransportController::Config());
   // Offer groups (kMid1Audio,kMid2Audio,kMid3Audio) and
   // (kMid4Video,kMid5Video,kMid6Video).
   cricket::ContentGroup offer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group1.AddContentName(kMid1Audio);
   offer_bundle_group1.AddContentName(kMid2Audio);
   offer_bundle_group1.AddContentName(kMid3Audio);
   cricket::ContentGroup offer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group2.AddContentName(kMid4Video);
   offer_bundle_group2.AddContentName(kMid5Video);
   offer_bundle_group2.AddContentName(kMid6Video);
   // Answer groups (kMid2Audio,kMid1Audio,kMid3Audio) and
   // (kMid5Video,kMid6Video,kMid4Video), i.e. we've changed which MID is first
   // but accept the whole group.
   cricket::ContentGroup answer_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group1.AddContentName(kMid2Audio);
   answer_bundle_group1.AddContentName(kMid1Audio);
   answer_bundle_group1.AddContentName(kMid3Audio);
   cricket::ContentGroup answer_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group2.AddContentName(kMid5Video);
   answer_bundle_group2.AddContentName(kMid6Video);
   answer_bundle_group2.AddContentName(kMid4Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid3Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid5Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid6Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(offer_bundle_group1);
   local_offer->AddGroup(offer_bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid3Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid5Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid6Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(answer_bundle_group1);
   remote_answer->AddGroup(answer_bundle_group2);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());

   // The fact that we accept this answer is actually a bug. If we accept the
   // first MID to be in the group, we should also accept that it is the tagged
   // one.
   // TODO(https://crbug.com/webrtc/12699): When this issue is fixed, change this
   // to EXPECT_FALSE and remove the below expectations about transports.
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());
   auto mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   auto mid2_transport = transport_controller_->GetRtpTransport(kMid2Audio);
   auto mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   auto mid4_transport = transport_controller_->GetRtpTransport(kMid4Video);
   auto mid5_transport = transport_controller_->GetRtpTransport(kMid5Video);
   auto mid6_transport = transport_controller_->GetRtpTransport(kMid6Video);
   EXPECT_NE(mid1_transport, mid4_transport);
   EXPECT_EQ(mid1_transport, mid2_transport);
   EXPECT_EQ(mid2_transport, mid3_transport);
   EXPECT_EQ(mid4_transport, mid5_transport);
   EXPECT_EQ(mid5_transport, mid6_transport);
 }

 TEST_F(JsepTransportControllerTest,
        MultipleBundleGroupsSectionsAddedInSubsequentOffer) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Audio[] = "2_audio";
   static const char kMid3Audio[] = "3_audio";
   static const char kMid4Video[] = "4_video";
   static const char kMid5Video[] = "5_video";
   static const char kMid6Video[] = "6_video";

   CreateJsepTransportController(JsepTransportController::Config());
   // Start by grouping (kMid1Audio,kMid2Audio) and (kMid4Video,kMid4f5Video).
   cricket::ContentGroup bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   bundle_group1.AddContentName(kMid1Audio);
   bundle_group1.AddContentName(kMid2Audio);
   cricket::ContentGroup bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   bundle_group2.AddContentName(kMid4Video);
   bundle_group2.AddContentName(kMid5Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid5Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(bundle_group1);
   local_offer->AddGroup(bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid5Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(bundle_group1);
   remote_answer->AddGroup(bundle_group2);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Add kMid3Audio and kMid6Video to the respective audio/video bundle groups.
   cricket::ContentGroup new_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   bundle_group1.AddContentName(kMid3Audio);
   cricket::ContentGroup new_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   bundle_group2.AddContentName(kMid6Video);

   auto subsequent_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(subsequent_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(subsequent_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(subsequent_offer.get(), kMid3Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid5Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid6Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   subsequent_offer->AddGroup(bundle_group1);
   subsequent_offer->AddGroup(bundle_group2);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, subsequent_offer.get())
                   .ok());
   auto mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   auto mid2_transport = transport_controller_->GetRtpTransport(kMid2Audio);
   auto mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   auto mid4_transport = transport_controller_->GetRtpTransport(kMid4Video);
   auto mid5_transport = transport_controller_->GetRtpTransport(kMid5Video);
   auto mid6_transport = transport_controller_->GetRtpTransport(kMid6Video);
   EXPECT_NE(mid1_transport, mid4_transport);
   EXPECT_EQ(mid1_transport, mid2_transport);
   EXPECT_EQ(mid2_transport, mid3_transport);
   EXPECT_EQ(mid4_transport, mid5_transport);
   EXPECT_EQ(mid5_transport, mid6_transport);
 }

 TEST_F(JsepTransportControllerTest,
        MultipleBundleGroupsCombinedInSubsequentOffer) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Audio[] = "2_audio";
   static const char kMid3Video[] = "3_video";
   static const char kMid4Video[] = "4_video";

   CreateJsepTransportController(JsepTransportController::Config());
   // Start by grouping (kMid1Audio,kMid2Audio) and (kMid3Video,kMid4Video).
   cricket::ContentGroup bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   bundle_group1.AddContentName(kMid1Audio);
   bundle_group1.AddContentName(kMid2Audio);
   cricket::ContentGroup bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   bundle_group2.AddContentName(kMid3Video);
   bundle_group2.AddContentName(kMid4Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(bundle_group1);
   local_offer->AddGroup(bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(bundle_group1);
   remote_answer->AddGroup(bundle_group2);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Switch to grouping (kMid1Audio,kMid2Audio,kMid3Video,kMid4Video).
   // This is a illegal without first removing m= sections from their groups.
   cricket::ContentGroup new_bundle_group(cricket::GROUP_TYPE_BUNDLE);
   new_bundle_group.AddContentName(kMid1Audio);
   new_bundle_group.AddContentName(kMid2Audio);
   new_bundle_group.AddContentName(kMid3Video);
   new_bundle_group.AddContentName(kMid4Video);

   auto subsequent_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(subsequent_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(subsequent_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   subsequent_offer->AddGroup(new_bundle_group);
   EXPECT_FALSE(
       transport_controller_
           ->SetLocalDescription(SdpType::kOffer, subsequent_offer.get())
           .ok());
 }

 TEST_F(JsepTransportControllerTest,
        MultipleBundleGroupsSplitInSubsequentOffer) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Audio[] = "2_audio";
   static const char kMid3Video[] = "3_video";
   static const char kMid4Video[] = "4_video";

   CreateJsepTransportController(JsepTransportController::Config());
   // Start by grouping (kMid1Audio,kMid2Audio,kMid3Video,kMid4Video).
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kMid1Audio);
   bundle_group.AddContentName(kMid2Audio);
   bundle_group.AddContentName(kMid3Video);
   bundle_group.AddContentName(kMid4Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(bundle_group);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(bundle_group);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Switch to grouping (kMid1Audio,kMid2Audio) and (kMid3Video,kMid4Video).
   // This is a illegal without first removing m= sections from their groups.
   cricket::ContentGroup new_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   new_bundle_group1.AddContentName(kMid1Audio);
   new_bundle_group1.AddContentName(kMid2Audio);
   cricket::ContentGroup new_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   new_bundle_group2.AddContentName(kMid3Video);
   new_bundle_group2.AddContentName(kMid4Video);

   auto subsequent_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(subsequent_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(subsequent_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   subsequent_offer->AddGroup(new_bundle_group1);
   subsequent_offer->AddGroup(new_bundle_group2);
   EXPECT_FALSE(
       transport_controller_
           ->SetLocalDescription(SdpType::kOffer, subsequent_offer.get())
           .ok());
 }

 TEST_F(JsepTransportControllerTest,
        MultipleBundleGroupsShuffledInSubsequentOffer) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Audio[] = "2_audio";
   static const char kMid3Video[] = "3_video";
   static const char kMid4Video[] = "4_video";

   CreateJsepTransportController(JsepTransportController::Config());
   // Start by grouping (kMid1Audio,kMid2Audio) and (kMid3Video,kMid4Video).
   cricket::ContentGroup bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   bundle_group1.AddContentName(kMid1Audio);
   bundle_group1.AddContentName(kMid2Audio);
   cricket::ContentGroup bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   bundle_group2.AddContentName(kMid3Video);
   bundle_group2.AddContentName(kMid4Video);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(bundle_group1);
   local_offer->AddGroup(bundle_group2);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(remote_answer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   remote_answer->AddGroup(bundle_group1);
   remote_answer->AddGroup(bundle_group2);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Switch to grouping (kMid1Audio,kMid3Video) and (kMid2Audio,kMid3Video).
   // This is a illegal without first removing m= sections from their groups.
   cricket::ContentGroup new_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   new_bundle_group1.AddContentName(kMid1Audio);
   new_bundle_group1.AddContentName(kMid3Video);
   cricket::ContentGroup new_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   new_bundle_group2.AddContentName(kMid2Audio);
   new_bundle_group2.AddContentName(kMid4Video);

   auto subsequent_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(subsequent_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(subsequent_offer.get(), kMid2Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid3Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer.get(), kMid4Video, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   subsequent_offer->AddGroup(new_bundle_group1);
   subsequent_offer->AddGroup(new_bundle_group2);
   EXPECT_FALSE(
       transport_controller_
           ->SetLocalDescription(SdpType::kOffer, subsequent_offer.get())
           .ok());
 }

 // Tests that only a subset of all the m= sections are bundled.
 TEST_F(JsepTransportControllerTest, BundleSubsetOfMediaSections) {
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kAudioMid1);
   bundle_group.AddContentName(kVideoMid1);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kAudioMid2, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kVideoMid1, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddAudioSection(remote_answer.get(), kAudioMid2, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddVideoSection(remote_answer.get(), kVideoMid1, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);

   local_offer->AddGroup(bundle_group);
   remote_answer->AddGroup(bundle_group);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Verifiy that only `kAudio1` and `kVideo1` are bundled.
   auto transport1 = transport_controller_->GetRtpTransport(kAudioMid1);
   auto transport2 = transport_controller_->GetRtpTransport(kAudioMid2);
   auto transport3 = transport_controller_->GetRtpTransport(kVideoMid1);
   EXPECT_NE(transport1, transport2);
   EXPECT_EQ(transport1, transport3);

   auto it = changed_rtp_transport_by_mid_.find(kVideoMid1);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(transport1, it->second);
   it = changed_rtp_transport_by_mid_.find(kAudioMid2);
   EXPECT_TRUE(transport2 == it->second);
 }

 // Tests that the initial offer/answer only have data section and audio/video
 // sections are added in the subsequent offer.
 TEST_F(JsepTransportControllerTest, BundleOnDataSectionInSubsequentOffer) {
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kDataMid1);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddDataSection(local_offer.get(), kDataMid1,
                  cricket::MediaProtocolType::kSctp, kIceUfrag1, kIcePwd1,
                  cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                  nullptr);
   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddDataSection(remote_answer.get(), kDataMid1,
                  cricket::MediaProtocolType::kSctp, kIceUfrag1, kIcePwd1,
                  cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                  nullptr);
   local_offer->AddGroup(bundle_group);
   remote_answer->AddGroup(bundle_group);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());
   auto data_transport = transport_controller_->GetRtpTransport(kDataMid1);

   // Add audio/video sections in subsequent offer.
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kVideoMid1, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(remote_answer.get(), kAudioMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddVideoSection(remote_answer.get(), kVideoMid1, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);

   // Reset the bundle group and do another offer/answer exchange.
   bundle_group.AddContentName(kAudioMid1);
   bundle_group.AddContentName(kVideoMid1);
   local_offer->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
   remote_answer->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
   local_offer->AddGroup(bundle_group);
   remote_answer->AddGroup(bundle_group);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   auto audio_transport = transport_controller_->GetRtpTransport(kAudioMid1);
   auto video_transport = transport_controller_->GetRtpTransport(kVideoMid1);
   EXPECT_EQ(data_transport, audio_transport);
   EXPECT_EQ(data_transport, video_transport);
 }

 TEST_F(JsepTransportControllerTest, VideoDataRejectedInAnswer) {
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kAudioMid1);
   bundle_group.AddContentName(kVideoMid1);
   bundle_group.AddContentName(kDataMid1);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kVideoMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddDataSection(local_offer.get(), kDataMid1,
                  cricket::MediaProtocolType::kSctp, kIceUfrag3, kIcePwd3,
                  cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                  nullptr);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddVideoSection(remote_answer.get(), kVideoMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddDataSection(remote_answer.get(), kDataMid1,
                  cricket::MediaProtocolType::kSctp, kIceUfrag3, kIcePwd3,
                  cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                  nullptr);
   // Reject video and data section.
   remote_answer->contents()[1].rejected = true;
   remote_answer->contents()[2].rejected = true;

   local_offer->AddGroup(bundle_group);
   remote_answer->AddGroup(bundle_group);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Verify the RtpTransport/DtlsTransport is destroyed correctly.
   EXPECT_EQ(nullptr, transport_controller_->GetRtpTransport(kVideoMid1));
   EXPECT_EQ(nullptr, transport_controller_->GetDtlsTransport(kDataMid1));
   // Verify the signals are fired correctly.
   auto it = changed_rtp_transport_by_mid_.find(kVideoMid1);
   ASSERT_TRUE(it != changed_rtp_transport_by_mid_.end());
   EXPECT_EQ(nullptr, it->second);
   auto it2 = changed_dtls_transport_by_mid_.find(kDataMid1);
   ASSERT_TRUE(it2 != changed_dtls_transport_by_mid_.end());
   EXPECT_EQ(nullptr, it2->second);
 }

 // Tests that changing the bundled MID in subsequent offer/answer exchange is
 // not supported.
 // TODO(bugs.webrtc.org/6704): Change this test to expect success once issue is
 // fixed
 TEST_F(JsepTransportControllerTest, ChangeBundledMidNotSupported) {
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kAudioMid1);
   bundle_group.AddContentName(kVideoMid1);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kVideoMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddVideoSection(remote_answer.get(), kVideoMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);

   local_offer->AddGroup(bundle_group);
   remote_answer->AddGroup(bundle_group);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());
   EXPECT_EQ(transport_controller_->GetRtpTransport(kAudioMid1),
             transport_controller_->GetRtpTransport(kVideoMid1));

   // Reorder the bundle group.
   EXPECT_TRUE(bundle_group.RemoveContentName(kAudioMid1));
   bundle_group.AddContentName(kAudioMid1);
   // The answerer uses the new bundle group and now the bundle mid is changed to
   // `kVideo1`.
   remote_answer->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
   remote_answer->AddGroup(bundle_group);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_FALSE(transport_controller_
                    ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                    .ok());
 }
 // Test that rejecting only the first m= section of a BUNDLE group is treated as
 // an error, but rejecting all of them works as expected.
 TEST_F(JsepTransportControllerTest, RejectFirstContentInBundleGroup) {
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kAudioMid1);
   bundle_group.AddContentName(kVideoMid1);
   bundle_group.AddContentName(kDataMid1);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kVideoMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddDataSection(local_offer.get(), kDataMid1,
                  cricket::MediaProtocolType::kSctp, kIceUfrag3, kIcePwd3,
                  cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                  nullptr);

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddVideoSection(remote_answer.get(), kVideoMid1, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   AddDataSection(remote_answer.get(), kDataMid1,
                  cricket::MediaProtocolType::kSctp, kIceUfrag3, kIcePwd3,
                  cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                  nullptr);
   // Reject audio content in answer.
   remote_answer->contents()[0].rejected = true;

   local_offer->AddGroup(bundle_group);
   remote_answer->AddGroup(bundle_group);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_FALSE(transport_controller_
                    ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                    .ok());

   // Reject all the contents.
   remote_answer->contents()[1].rejected = true;
   remote_answer->contents()[2].rejected = true;
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());
   EXPECT_EQ(nullptr, transport_controller_->GetRtpTransport(kAudioMid1));
   EXPECT_EQ(nullptr, transport_controller_->GetRtpTransport(kVideoMid1));
   EXPECT_EQ(nullptr, transport_controller_->GetDtlsTransport(kDataMid1));
 }

 // Tests that applying non-RTCP-mux offer would fail when kRtcpMuxPolicyRequire
 // is used.
 TEST_F(JsepTransportControllerTest, ApplyNonRtcpMuxOfferWhenMuxingRequired) {
   JsepTransportController::Config config;
   config.rtcp_mux_policy = PeerConnectionInterface::kRtcpMuxPolicyRequire;
   CreateJsepTransportController(std::move(config));
   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);

   local_offer->contents()[0].media_description()->set_rtcp_mux(false);
   // Applying a non-RTCP-mux offer is expected to fail.
   EXPECT_FALSE(transport_controller_
                    ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                    .ok());
 }

 // Tests that applying non-RTCP-mux answer would fail when kRtcpMuxPolicyRequire
 // is used.
 TEST_F(JsepTransportControllerTest, ApplyNonRtcpMuxAnswerWhenMuxingRequired) {
   JsepTransportController::Config config;
   config.rtcp_mux_policy = PeerConnectionInterface::kRtcpMuxPolicyRequire;
   CreateJsepTransportController(std::move(config));
   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());

   auto remote_answer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(remote_answer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_PASSIVE,
                   nullptr);
   // Applying a non-RTCP-mux answer is expected to fail.
   remote_answer->contents()[0].media_description()->set_rtcp_mux(false);
   EXPECT_FALSE(transport_controller_
                    ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                    .ok());
 }

 // This tests that the BUNDLE group in answer should be a subset of the offered
 // group.
 TEST_F(JsepTransportControllerTest,
        AddContentToBundleGroupInAnswerNotSupported) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto local_offer = CreateSessionDescriptionWithoutBundle();
   auto remote_answer = CreateSessionDescriptionWithoutBundle();

   cricket::ContentGroup offer_bundle_group(cricket::GROUP_TYPE_BUNDLE);
   offer_bundle_group.AddContentName(kAudioMid1);
   local_offer->AddGroup(offer_bundle_group);

   cricket::ContentGroup answer_bundle_group(cricket::GROUP_TYPE_BUNDLE);
   answer_bundle_group.AddContentName(kAudioMid1);
   answer_bundle_group.AddContentName(kVideoMid1);
   remote_answer->AddGroup(answer_bundle_group);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_FALSE(transport_controller_
                    ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                    .ok());
 }

 // This tests that the BUNDLE group with non-existing MID should be rejectd.
 TEST_F(JsepTransportControllerTest, RejectBundleGroupWithNonExistingMid) {
   CreateJsepTransportController(JsepTransportController::Config());
   auto local_offer = CreateSessionDescriptionWithoutBundle();
   auto remote_answer = CreateSessionDescriptionWithoutBundle();

   cricket::ContentGroup invalid_bundle_group(cricket::GROUP_TYPE_BUNDLE);
   // The BUNDLE group is invalid because there is no data section in the
   // description.
   invalid_bundle_group.AddContentName(kDataMid1);
   local_offer->AddGroup(invalid_bundle_group);
   remote_answer->AddGroup(invalid_bundle_group);

   EXPECT_FALSE(transport_controller_
                    ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                    .ok());
   EXPECT_FALSE(transport_controller_
                    ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                    .ok());
 }

 // This tests that an answer shouldn't be able to remove an m= section from an
 // established group without rejecting it.
 TEST_F(JsepTransportControllerTest, RemoveContentFromBundleGroup) {
   CreateJsepTransportController(JsepTransportController::Config());

   auto local_offer = CreateSessionDescriptionWithBundleGroup();
   auto remote_answer = CreateSessionDescriptionWithBundleGroup();
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Do an re-offer/answer.
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   auto new_answer = CreateSessionDescriptionWithoutBundle();
   cricket::ContentGroup new_bundle_group(cricket::GROUP_TYPE_BUNDLE);
   //  The answer removes video from the BUNDLE group without rejecting it is
   //  invalid.
   new_bundle_group.AddContentName(kAudioMid1);
   new_answer->AddGroup(new_bundle_group);

   // Applying invalid answer is expected to fail.
   EXPECT_FALSE(transport_controller_
                    ->SetRemoteDescription(SdpType::kAnswer, new_answer.get())
                    .ok());

   // Rejected the video content.
   auto video_content = new_answer->GetContentByName(kVideoMid1);
   ASSERT_TRUE(video_content);
   video_content->rejected = true;
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, new_answer.get())
                   .ok());
 }

 // Test that the JsepTransportController can process a new local and remote
 // description that changes the tagged BUNDLE group with the max-bundle policy
 // specified.
 // This is a regression test for bugs.webrtc.org/9954
 TEST_F(JsepTransportControllerTest, ChangeTaggedMediaSectionMaxBundle) {
   CreateJsepTransportController(JsepTransportController::Config());

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kAudioMid1);
   local_offer->AddGroup(bundle_group);
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());

   std::unique_ptr<cricket::SessionDescription> remote_answer(
       local_offer->Clone());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   std::unique_ptr<cricket::SessionDescription> local_reoffer(
       local_offer->Clone());
   local_reoffer->contents()[0].rejected = true;
   AddVideoSection(local_reoffer.get(), kVideoMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_reoffer->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
   cricket::ContentGroup new_bundle_group(cricket::GROUP_TYPE_BUNDLE);
   new_bundle_group.AddContentName(kVideoMid1);
   local_reoffer->AddGroup(new_bundle_group);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_reoffer.get())
                   .ok());
   std::unique_ptr<cricket::SessionDescription> remote_reanswer(
       local_reoffer->Clone());
   EXPECT_TRUE(
       transport_controller_
           ->SetRemoteDescription(SdpType::kAnswer, remote_reanswer.get())
           .ok());
 }

 TEST_F(JsepTransportControllerTest, RollbackRestoresRejectedTransport) {
   static const char kMid1Audio[] = "1_audio";

   // Perform initial offer/answer.
   CreateJsepTransportController(JsepTransportController::Config());
   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   std::unique_ptr<cricket::SessionDescription> remote_answer(
       local_offer->Clone());
   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   auto mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);

   // Apply a reoffer which rejects the m= section, causing the transport to be
   // set to null.
   auto local_reoffer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_reoffer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_reoffer->contents()[0].rejected = true;

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_reoffer.get())
                   .ok());
   auto old_mid1_transport = mid1_transport;
   mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   EXPECT_EQ(nullptr, mid1_transport);

   // Rolling back shouldn't just create a new transport for MID 1, it should
   // restore the old transport.
   EXPECT_TRUE(transport_controller_->RollbackTransports().ok());
   mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   EXPECT_EQ(old_mid1_transport, mid1_transport);
 }

 // If an offer with a modified BUNDLE group causes a MID->transport mapping to
 // change, rollback should restore the previous mapping.
 TEST_F(JsepTransportControllerTest, RollbackRestoresPreviousTransportMapping) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Audio[] = "2_audio";
   static const char kMid3Audio[] = "3_audio";

   // Perform an initial offer/answer to establish a (kMid1Audio,kMid2Audio)
   // group.
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kMid1Audio);
   bundle_group.AddContentName(kMid2Audio);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid2Audio, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_offer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(bundle_group);

   std::unique_ptr<cricket::SessionDescription> remote_answer(
       local_offer->Clone());

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   auto mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   auto mid2_transport = transport_controller_->GetRtpTransport(kMid2Audio);
   auto mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   EXPECT_EQ(mid1_transport, mid2_transport);
   EXPECT_NE(mid1_transport, mid3_transport);

   // Apply a reoffer adding kMid3Audio to the group; transport mapping should
   // change, even without an answer, since this is an existing group.
   bundle_group.AddContentName(kMid3Audio);
   auto local_reoffer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_reoffer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_reoffer.get(), kMid2Audio, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddAudioSection(local_reoffer.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_reoffer->AddGroup(bundle_group);

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_reoffer.get())
                   .ok());

   // Store the old transport pointer and verify that the offer actually changed
   // transports.
   auto old_mid3_transport = mid3_transport;
   mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   mid2_transport = transport_controller_->GetRtpTransport(kMid2Audio);
   mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   EXPECT_EQ(mid1_transport, mid2_transport);
   EXPECT_EQ(mid1_transport, mid3_transport);

   // Rolling back shouldn't just create a new transport for MID 3, it should
   // restore the old transport.
   EXPECT_TRUE(transport_controller_->RollbackTransports().ok());
   mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   EXPECT_EQ(old_mid3_transport, mid3_transport);
 }

 // Test that if an offer adds a MID to a specific BUNDLE group and is then
 // rolled back, it can be added to a different BUNDLE group in a new offer.
 // This is effectively testing that rollback resets the BundleManager state.
 TEST_F(JsepTransportControllerTest, RollbackAndAddToDifferentBundleGroup) {
   static const char kMid1Audio[] = "1_audio";
   static const char kMid2Audio[] = "2_audio";
   static const char kMid3Audio[] = "3_audio";

   // Perform an initial offer/answer to establish two bundle groups, each with
   // one MID.
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   bundle_group1.AddContentName(kMid1Audio);
   cricket::ContentGroup bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   bundle_group2.AddContentName(kMid2Audio);

   auto local_offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(local_offer.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(local_offer.get(), kMid2Audio, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   local_offer->AddGroup(bundle_group1);
   local_offer->AddGroup(bundle_group2);

   std::unique_ptr<cricket::SessionDescription> remote_answer(
       local_offer->Clone());

   EXPECT_TRUE(transport_controller_
                   ->SetLocalDescription(SdpType::kOffer, local_offer.get())
                   .ok());
   EXPECT_TRUE(transport_controller_
                   ->SetRemoteDescription(SdpType::kAnswer, remote_answer.get())
                   .ok());

   // Apply an offer that adds kMid3Audio to the first BUNDLE group.,
   cricket::ContentGroup modified_bundle_group1(cricket::GROUP_TYPE_BUNDLE);
   modified_bundle_group1.AddContentName(kMid1Audio);
   modified_bundle_group1.AddContentName(kMid3Audio);
   auto subsequent_offer_1 = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(subsequent_offer_1.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer_1.get(), kMid2Audio, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer_1.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   subsequent_offer_1->AddGroup(modified_bundle_group1);
   subsequent_offer_1->AddGroup(bundle_group2);

   EXPECT_TRUE(
       transport_controller_
           ->SetLocalDescription(SdpType::kOffer, subsequent_offer_1.get())
           .ok());

   auto mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   auto mid2_transport = transport_controller_->GetRtpTransport(kMid2Audio);
   auto mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   EXPECT_NE(mid1_transport, mid2_transport);
   EXPECT_EQ(mid1_transport, mid3_transport);

   // Rollback and expect the transport to be reset.
   EXPECT_TRUE(transport_controller_->RollbackTransports().ok());
   EXPECT_EQ(nullptr, transport_controller_->GetRtpTransport(kMid3Audio));

   // Apply an offer that adds kMid3Audio to the second BUNDLE group.,
   cricket::ContentGroup modified_bundle_group2(cricket::GROUP_TYPE_BUNDLE);
   modified_bundle_group2.AddContentName(kMid2Audio);
   modified_bundle_group2.AddContentName(kMid3Audio);
   auto subsequent_offer_2 = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(subsequent_offer_2.get(), kMid1Audio, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer_2.get(), kMid2Audio, kIceUfrag2, kIcePwd2,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(subsequent_offer_2.get(), kMid3Audio, kIceUfrag3, kIcePwd3,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   subsequent_offer_2->AddGroup(bundle_group1);
   subsequent_offer_2->AddGroup(modified_bundle_group2);

   EXPECT_TRUE(
       transport_controller_
           ->SetLocalDescription(SdpType::kOffer, subsequent_offer_2.get())
           .ok());

   mid1_transport = transport_controller_->GetRtpTransport(kMid1Audio);
   mid2_transport = transport_controller_->GetRtpTransport(kMid2Audio);
   mid3_transport = transport_controller_->GetRtpTransport(kMid3Audio);
   EXPECT_NE(mid1_transport, mid2_transport);
   EXPECT_EQ(mid2_transport, mid3_transport);
 }

 // Test that a bundle-only offer without rtcp-mux in the bundle-only section
 // is accepted.
 TEST_F(JsepTransportControllerTest, BundleOnlySectionDoesNotNeedRtcpMux) {
   CreateJsepTransportController(JsepTransportController::Config());
   cricket::ContentGroup bundle_group(cricket::GROUP_TYPE_BUNDLE);
   bundle_group.AddContentName(kAudioMid1);
   bundle_group.AddContentName(kVideoMid1);

   auto offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   AddVideoSection(offer.get(), kVideoMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   offer->AddGroup(bundle_group);

   // Remove rtcp-mux and set bundle-only on the second content.
   offer->contents()[1].media_description()->set_rtcp_mux(false);
   offer->contents()[1].bundle_only = true;

   EXPECT_TRUE(
       transport_controller_->SetRemoteDescription(SdpType::kOffer, offer.get())
           .ok());
 }

 // Test that with max-bundle a single unbundled m-line is accepted.
 TEST_F(JsepTransportControllerTest,
        MaxBundleDoesNotRequireBundleForFirstMline) {
   auto config = JsepTransportController::Config();
   config.bundle_policy = PeerConnectionInterface::kBundlePolicyMaxBundle;
   CreateJsepTransportController(std::move(config));

   auto offer = std::make_unique<cricket::SessionDescription>();
   AddAudioSection(offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
                   cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
                   nullptr);
   EXPECT_TRUE(
       transport_controller_->SetRemoteDescription(SdpType::kOffer, offer.get())
           .ok());
 }

 }  // namespace webrtc