Add m-esr52 at 52.6.0

1 files changed, 1269 insertions, 0 deletions

diff --git a/media/webrtc/signaling/test/jsep_track_unittest.cpp b/media/webrtc/signaling/test/jsep_track_unittest.cpp
new file mode 100644
index 000000000..a09d47276
--- /dev/null
+++ b/media/webrtc/signaling/test/jsep_track_unittest.cpp
@@ -0,0 +1,1269 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+// Magic linker includes :(
+#include "FakeMediaStreams.h"
+#include "FakeMediaStreamsImpl.h"
+#include "FakeLogging.h"
+
+#include "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/sdp/SipccSdp.h"
+#include "signaling/src/sdp/SdpHelper.h"
+
+#include "mtransport_test_utils.h"
+
+#include "FakeIPC.h"
+#include "FakeIPC.cpp"
+
+#include "TestHarness.h"
+
+namespace mozilla {
+
+class JsepTrackTest : public ::testing::Test
+{
+  public:
+    JsepTrackTest() {}
+
+    std::vector<JsepCodecDescription*>
+    MakeCodecs(bool addFecCodecs = false,
+               bool preferRed = false,
+               bool addDtmfCodec = false) const
+    {
+      std::vector<JsepCodecDescription*> results;
+      results.push_back(
+          new JsepAudioCodecDescription("1", "opus", 48000, 2, 960, 40000));
+      results.push_back(
+          new JsepAudioCodecDescription("9", "G722", 8000, 1, 320, 64000));
+      if (addDtmfCodec) {
+        results.push_back(
+            new JsepAudioCodecDescription("101", "telephone-event",
+                                          8000, 1, 0, 0));
+      }
+
+      JsepVideoCodecDescription* red = nullptr;
+      if (addFecCodecs && preferRed) {
+        red = new JsepVideoCodecDescription(
+            "122",
+            "red",
+            90000
+            );
+        results.push_back(red);
+      }
+
+      JsepVideoCodecDescription* vp8 =
+          new JsepVideoCodecDescription("120", "VP8", 90000);
+      vp8->mConstraints.maxFs = 12288;
+      vp8->mConstraints.maxFps = 60;
+      results.push_back(vp8);
+
+      JsepVideoCodecDescription* h264 =
+          new JsepVideoCodecDescription("126", "H264", 90000);
+      h264->mPacketizationMode = 1;
+      h264->mProfileLevelId = 0x42E00D;
+      results.push_back(h264);
+
+      if (addFecCodecs) {
+        if (!preferRed) {
+          red = new JsepVideoCodecDescription(
+              "122",
+              "red",
+              90000
+              );
+          results.push_back(red);
+        }
+        JsepVideoCodecDescription* ulpfec = new JsepVideoCodecDescription(
+            "123",
+            "ulpfec",
+            90000
+            );
+        results.push_back(ulpfec);
+      }
+
+      results.push_back(
+          new JsepApplicationCodecDescription(
+            "5000",
+            "webrtc-datachannel",
+            16
+            ));
+
+      // if we're doing something with red, it needs
+      // to update the redundant encodings list
+      if (red) {
+        red->UpdateRedundantEncodings(results);
+      }
+
+      return results;
+    }
+
+    void Init(SdpMediaSection::MediaType type) {
+      InitCodecs();
+      InitTracks(type);
+      InitSdp(type);
+    }
+
+    void InitCodecs() {
+      mOffCodecs.values = MakeCodecs();
+      mAnsCodecs.values = MakeCodecs();
+    }
+
+    void InitTracks(SdpMediaSection::MediaType type)
+    {
+      mSendOff = new JsepTrack(type, "stream_id", "track_id", sdp::kSend);
+      mRecvOff = new JsepTrack(type, "stream_id", "track_id", sdp::kRecv);
+      mSendOff->PopulateCodecs(mOffCodecs.values);
+      mRecvOff->PopulateCodecs(mOffCodecs.values);
+
+      mSendAns = new JsepTrack(type, "stream_id", "track_id", sdp::kSend);
+      mRecvAns = new JsepTrack(type, "stream_id", "track_id", sdp::kRecv);
+      mSendAns->PopulateCodecs(mAnsCodecs.values);
+      mRecvAns->PopulateCodecs(mAnsCodecs.values);
+    }
+
+    void InitSdp(SdpMediaSection::MediaType type)
+    {
+      mOffer.reset(new SipccSdp(SdpOrigin("", 0, 0, sdp::kIPv4, "")));
+      mOffer->AddMediaSection(
+          type,
+          SdpDirectionAttribute::kInactive,
+          0,
+          SdpHelper::GetProtocolForMediaType(type),
+          sdp::kIPv4,
+          "0.0.0.0");
+      mAnswer.reset(new SipccSdp(SdpOrigin("", 0, 0, sdp::kIPv4, "")));
+      mAnswer->AddMediaSection(
+          type,
+          SdpDirectionAttribute::kInactive,
+          0,
+          SdpHelper::GetProtocolForMediaType(type),
+          sdp::kIPv4,
+          "0.0.0.0");
+    }
+
+    SdpMediaSection& GetOffer()
+    {
+      return mOffer->GetMediaSection(0);
+    }
+
+    SdpMediaSection& GetAnswer()
+    {
+      return mAnswer->GetMediaSection(0);
+    }
+
+    void CreateOffer()
+    {
+      if (mSendOff) {
+        mSendOff->AddToOffer(&GetOffer());
+      }
+
+      if (mRecvOff) {
+        mRecvOff->AddToOffer(&GetOffer());
+      }
+    }
+
+    void CreateAnswer()
+    {
+      if (mSendAns && GetOffer().IsReceiving()) {
+        mSendAns->AddToAnswer(GetOffer(), &GetAnswer());
+      }
+
+      if (mRecvAns && GetOffer().IsSending()) {
+        mRecvAns->AddToAnswer(GetOffer(), &GetAnswer());
+      }
+    }
+
+    void Negotiate()
+    {
+      std::cerr << "Offer SDP: " << std::endl;
+      mOffer->Serialize(std::cerr);
+
+      std::cerr << "Answer SDP: " << std::endl;
+      mAnswer->Serialize(std::cerr);
+
+      if (mSendAns && GetAnswer().IsSending()) {
+        mSendAns->Negotiate(GetAnswer(), GetOffer());
+      }
+
+      if (mRecvAns && GetAnswer().IsReceiving()) {
+        mRecvAns->Negotiate(GetAnswer(), GetOffer());
+      }
+
+      if (mSendOff && GetAnswer().IsReceiving()) {
+        mSendOff->Negotiate(GetAnswer(), GetAnswer());
+      }
+
+      if (mRecvOff && GetAnswer().IsSending()) {
+        mRecvOff->Negotiate(GetAnswer(), GetAnswer());
+      }
+    }
+
+    void OfferAnswer()
+    {
+      CreateOffer();
+      CreateAnswer();
+      Negotiate();
+      SanityCheck();
+    }
+
+    static size_t EncodingCount(const RefPtr<JsepTrack>& track)
+    {
+      return track->GetNegotiatedDetails()->GetEncodingCount();
+    }
+
+    // TODO: Look into writing a macro that wraps an ASSERT_ and returns false
+    // if it fails (probably requires writing a bool-returning function that
+    // takes a void-returning lambda with a bool outparam, which will in turn
+    // invokes the ASSERT_)
+    static void CheckEncodingCount(size_t expected,
+                                   const RefPtr<JsepTrack>& send,
+                                   const RefPtr<JsepTrack>& recv)
+    {
+      if (expected) {
+        ASSERT_TRUE(!!send);
+        ASSERT_TRUE(send->GetNegotiatedDetails());
+        ASSERT_TRUE(!!recv);
+        ASSERT_TRUE(recv->GetNegotiatedDetails());
+      }
+
+      if (send && send->GetNegotiatedDetails()) {
+        ASSERT_EQ(expected, send->GetNegotiatedDetails()->GetEncodingCount());
+      }
+
+      if (recv && recv->GetNegotiatedDetails()) {
+        ASSERT_EQ(expected, recv->GetNegotiatedDetails()->GetEncodingCount());
+      }
+    }
+
+    void CheckOffEncodingCount(size_t expected) const
+    {
+      CheckEncodingCount(expected, mSendOff, mRecvAns);
+    }
+
+    void CheckAnsEncodingCount(size_t expected) const
+    {
+      CheckEncodingCount(expected, mSendAns, mRecvOff);
+    }
+
+    const JsepCodecDescription*
+    GetCodec(const JsepTrack& track,
+             SdpMediaSection::MediaType type,
+             size_t expectedSize,
+             size_t codecIndex) const
+    {
+      if (!track.GetNegotiatedDetails() ||
+          track.GetNegotiatedDetails()->GetEncodingCount() != 1U ||
+          track.GetMediaType() != type) {
+        return nullptr;
+      }
+      const std::vector<JsepCodecDescription*>& codecs =
+        track.GetNegotiatedDetails()->GetEncoding(0).GetCodecs();
+      // it should not be possible for codecs to have a different type
+      // than the track, but we'll check the codec here just in case.
+      if (codecs.size() != expectedSize || codecIndex >= expectedSize ||
+          codecs[codecIndex]->mType != type) {
+        return nullptr;
+      }
+      return codecs[codecIndex];
+    }
+
+    const JsepVideoCodecDescription*
+    GetVideoCodec(const JsepTrack& track,
+                  size_t expectedSize = 1,
+                  size_t codecIndex = 0) const
+    {
+      return static_cast<const JsepVideoCodecDescription*>
+        (GetCodec(track, SdpMediaSection::kVideo, expectedSize, codecIndex));
+    }
+
+    const JsepAudioCodecDescription*
+    GetAudioCodec(const JsepTrack& track,
+                  size_t expectedSize = 1,
+                  size_t codecIndex = 0) const
+    {
+      return static_cast<const JsepAudioCodecDescription*>
+        (GetCodec(track, SdpMediaSection::kAudio, expectedSize, codecIndex));
+    }
+
+    void CheckOtherFbsSize(const JsepTrack& track, size_t expected) const
+    {
+      const JsepVideoCodecDescription* videoCodec = GetVideoCodec(track);
+      ASSERT_NE(videoCodec, nullptr);
+      ASSERT_EQ(videoCodec->mOtherFbTypes.size(), expected);
+    }
+
+    void CheckOtherFbExists(const JsepTrack& track,
+                            SdpRtcpFbAttributeList::Type type) const
+    {
+      const JsepVideoCodecDescription* videoCodec = GetVideoCodec(track);
+      ASSERT_NE(videoCodec, nullptr);
+      for (const auto& fb : videoCodec->mOtherFbTypes) {
+          if (fb.type == type) {
+            return; // found the RtcpFb type, so stop looking
+          }
+      }
+      FAIL();  // RtcpFb type not found
+    }
+
+    void SanityCheckRtcpFbs(const JsepVideoCodecDescription& a,
+                            const JsepVideoCodecDescription& b) const
+    {
+      ASSERT_EQ(a.mNackFbTypes.size(), b.mNackFbTypes.size());
+      ASSERT_EQ(a.mAckFbTypes.size(), b.mAckFbTypes.size());
+      ASSERT_EQ(a.mCcmFbTypes.size(), b.mCcmFbTypes.size());
+      ASSERT_EQ(a.mOtherFbTypes.size(), b.mOtherFbTypes.size());
+    }
+
+    void SanityCheckCodecs(const JsepCodecDescription& a,
+                           const JsepCodecDescription& b) const
+    {
+      ASSERT_EQ(a.mType, b.mType);
+      ASSERT_EQ(a.mDefaultPt, b.mDefaultPt);
+      ASSERT_EQ(a.mName, b.mName);
+      ASSERT_EQ(a.mClock, b.mClock);
+      ASSERT_EQ(a.mChannels, b.mChannels);
+      ASSERT_NE(a.mDirection, b.mDirection);
+      // These constraints are for fmtp and rid, which _are_ signaled
+      ASSERT_EQ(a.mConstraints, b.mConstraints);
+
+      if (a.mType == SdpMediaSection::kVideo) {
+        SanityCheckRtcpFbs(static_cast<const JsepVideoCodecDescription&>(a),
+                           static_cast<const JsepVideoCodecDescription&>(b));
+      }
+    }
+
+    void SanityCheckEncodings(const JsepTrackEncoding& a,
+                              const JsepTrackEncoding& b) const
+    {
+      ASSERT_EQ(a.GetCodecs().size(), b.GetCodecs().size());
+      for (size_t i = 0; i < a.GetCodecs().size(); ++i) {
+        SanityCheckCodecs(*a.GetCodecs()[i], *b.GetCodecs()[i]);
+      }
+
+      ASSERT_EQ(a.mRid, b.mRid);
+      // mConstraints will probably differ, since they are not signaled to the
+      // other side.
+    }
+
+    void SanityCheckNegotiatedDetails(const JsepTrackNegotiatedDetails& a,
+                                      const JsepTrackNegotiatedDetails& b) const
+    {
+      ASSERT_EQ(a.GetEncodingCount(), b.GetEncodingCount());
+      for (size_t i = 0; i < a.GetEncodingCount(); ++i) {
+        SanityCheckEncodings(a.GetEncoding(i), b.GetEncoding(i));
+      }
+
+      ASSERT_EQ(a.GetUniquePayloadTypes().size(),
+                b.GetUniquePayloadTypes().size());
+      for (size_t i = 0; i < a.GetUniquePayloadTypes().size(); ++i) {
+        ASSERT_EQ(a.GetUniquePayloadTypes()[i], b.GetUniquePayloadTypes()[i]);
+      }
+    }
+
+    void SanityCheckTracks(const JsepTrack& a, const JsepTrack& b) const
+    {
+      if (!a.GetNegotiatedDetails()) {
+        ASSERT_FALSE(!!b.GetNegotiatedDetails());
+        return;
+      }
+
+      ASSERT_TRUE(!!a.GetNegotiatedDetails());
+      ASSERT_TRUE(!!b.GetNegotiatedDetails());
+      ASSERT_EQ(a.GetMediaType(), b.GetMediaType());
+      ASSERT_EQ(a.GetStreamId(), b.GetStreamId());
+      ASSERT_EQ(a.GetTrackId(), b.GetTrackId());
+      ASSERT_EQ(a.GetCNAME(), b.GetCNAME());
+      ASSERT_NE(a.GetDirection(), b.GetDirection());
+      ASSERT_EQ(a.GetSsrcs().size(), b.GetSsrcs().size());
+      for (size_t i = 0; i < a.GetSsrcs().size(); ++i) {
+        ASSERT_EQ(a.GetSsrcs()[i], b.GetSsrcs()[i]);
+      }
+
+      SanityCheckNegotiatedDetails(*a.GetNegotiatedDetails(),
+                                   *b.GetNegotiatedDetails());
+    }
+
+    void SanityCheck() const
+    {
+      if (mSendOff && mRecvAns) {
+        SanityCheckTracks(*mSendOff, *mRecvAns);
+      }
+      if (mRecvOff && mSendAns) {
+        SanityCheckTracks(*mRecvOff, *mSendAns);
+      }
+    }
+
+  protected:
+    RefPtr<JsepTrack> mSendOff;
+    RefPtr<JsepTrack> mRecvOff;
+    RefPtr<JsepTrack> mSendAns;
+    RefPtr<JsepTrack> mRecvAns;
+    PtrVector<JsepCodecDescription> mOffCodecs;
+    PtrVector<JsepCodecDescription> mAnsCodecs;
+    UniquePtr<Sdp> mOffer;
+    UniquePtr<Sdp> mAnswer;
+};
+
+TEST_F(JsepTrackTest, CreateDestroy)
+{
+  Init(SdpMediaSection::kAudio);
+}
+
+TEST_F(JsepTrackTest, AudioNegotiation)
+{
+  Init(SdpMediaSection::kAudio);
+  OfferAnswer();
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+}
+
+TEST_F(JsepTrackTest, VideoNegotiation)
+{
+  Init(SdpMediaSection::kVideo);
+  OfferAnswer();
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+}
+
+class CheckForCodecType
+{
+public:
+  explicit CheckForCodecType(SdpMediaSection::MediaType type,
+                             bool *result) :
+    mResult(result),
+    mType(type) {}
+
+  void operator()(JsepCodecDescription* codec) {
+    if (codec->mType == mType) {
+      *mResult = true;
+    }
+  }
+
+private:
+  bool *mResult;
+  SdpMediaSection::MediaType mType;
+};
+
+TEST_F(JsepTrackTest, CheckForMismatchedAudioCodecAndVideoTrack)
+{
+  PtrVector<JsepCodecDescription> offerCodecs;
+
+  // make codecs including telephone-event (an audio codec)
+  offerCodecs.values = MakeCodecs(false, false, true);
+  RefPtr<JsepTrack> videoTrack = new JsepTrack(SdpMediaSection::kVideo,
+                                               "stream_id",
+                                               "track_id",
+                                               sdp::kSend);
+  // populate codecs and then make sure we don't have any audio codecs
+  // in the video track
+  videoTrack->PopulateCodecs(offerCodecs.values);
+
+  bool found = false;
+  videoTrack->ForEachCodec(CheckForCodecType(SdpMediaSection::kAudio, &found));
+  ASSERT_FALSE(found);
+
+  found = false;
+  videoTrack->ForEachCodec(CheckForCodecType(SdpMediaSection::kVideo, &found));
+  ASSERT_TRUE(found); // for sanity, make sure we did find video codecs
+}
+
+TEST_F(JsepTrackTest, CheckVideoTrackWithHackedDtmfSdp)
+{
+  Init(SdpMediaSection::kVideo);
+  CreateOffer();
+  // make sure we don't find sdp containing telephone-event in video track
+  ASSERT_EQ(mOffer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+  // force audio codec telephone-event into video m= section of offer
+  GetOffer().AddCodec("101", "telephone-event", 8000, 1);
+  // make sure we _do_ find sdp containing telephone-event in video track
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+
+  CreateAnswer();
+  // make sure we don't find sdp containing telephone-event in video track
+  ASSERT_EQ(mAnswer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+  // force audio codec telephone-event into video m= section of answer
+  GetAnswer().AddCodec("101", "telephone-event", 8000, 1);
+  // make sure we _do_ find sdp containing telephone-event in video track
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+
+  Negotiate();
+  SanityCheck();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_TRUE(mSendOff.get());
+  ASSERT_TRUE(mRecvOff.get());
+  ASSERT_TRUE(mSendAns.get());
+  ASSERT_TRUE(mRecvAns.get());
+
+  // make sure we still don't find any audio codecs in the video track after
+  // hacking the sdp
+  bool found = false;
+  mSendOff->ForEachCodec(CheckForCodecType(SdpMediaSection::kAudio, &found));
+  ASSERT_FALSE(found);
+  mRecvOff->ForEachCodec(CheckForCodecType(SdpMediaSection::kAudio, &found));
+  ASSERT_FALSE(found);
+  mSendAns->ForEachCodec(CheckForCodecType(SdpMediaSection::kAudio, &found));
+  ASSERT_FALSE(found);
+  mRecvAns->ForEachCodec(CheckForCodecType(SdpMediaSection::kAudio, &found));
+  ASSERT_FALSE(found);
+}
+
+TEST_F(JsepTrackTest, AudioNegotiationOffererDtmf)
+{
+  mOffCodecs.values = MakeCodecs(false, false, true);
+  mAnsCodecs.values = MakeCodecs(false, false, false);
+
+  InitTracks(SdpMediaSection::kAudio);
+  InitSdp(SdpMediaSection::kAudio);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+
+  ASSERT_NE(mOffer->ToString().find("a=fmtp:101 0-15"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=fmtp:101"), std::string::npos);
+
+  const JsepAudioCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns)));
+  ASSERT_EQ("1", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, AudioNegotiationAnswererDtmf)
+{
+  mOffCodecs.values = MakeCodecs(false, false, false);
+  mAnsCodecs.values = MakeCodecs(false, false, true);
+
+  InitTracks(SdpMediaSection::kAudio);
+  InitSdp(SdpMediaSection::kAudio);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_EQ(mOffer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+
+  ASSERT_EQ(mOffer->ToString().find("a=fmtp:101 0-15"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=fmtp:101"), std::string::npos);
+
+  const JsepAudioCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns)));
+  ASSERT_EQ("1", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, AudioNegotiationOffererAnswererDtmf)
+{
+  mOffCodecs.values = MakeCodecs(false, false, true);
+  mAnsCodecs.values = MakeCodecs(false, false, true);
+
+  InitTracks(SdpMediaSection::kAudio);
+  InitSdp(SdpMediaSection::kAudio);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+
+  ASSERT_NE(mOffer->ToString().find("a=fmtp:101 0-15"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=fmtp:101 0-15"), std::string::npos);
+
+  const JsepAudioCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, AudioNegotiationDtmfOffererNoFmtpAnswererFmtp)
+{
+  mOffCodecs.values = MakeCodecs(false, false, true);
+  mAnsCodecs.values = MakeCodecs(false, false, true);
+
+  InitTracks(SdpMediaSection::kAudio);
+  InitSdp(SdpMediaSection::kAudio);
+
+  CreateOffer();
+  GetOffer().RemoveFmtp("101");
+
+  CreateAnswer();
+
+  Negotiate();
+  SanityCheck();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+
+  ASSERT_EQ(mOffer->ToString().find("a=fmtp:101"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=fmtp:101 0-15"), std::string::npos);
+
+  const JsepAudioCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, AudioNegotiationDtmfOffererFmtpAnswererNoFmtp)
+{
+  mOffCodecs.values = MakeCodecs(false, false, true);
+  mAnsCodecs.values = MakeCodecs(false, false, true);
+
+  InitTracks(SdpMediaSection::kAudio);
+  InitSdp(SdpMediaSection::kAudio);
+
+  CreateOffer();
+
+  CreateAnswer();
+  GetAnswer().RemoveFmtp("101");
+
+  Negotiate();
+  SanityCheck();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+
+  ASSERT_NE(mOffer->ToString().find("a=fmtp:101 0-15"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=fmtp:101"), std::string::npos);
+
+  const JsepAudioCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, AudioNegotiationDtmfOffererNoFmtpAnswererNoFmtp)
+{
+  mOffCodecs.values = MakeCodecs(false, false, true);
+  mAnsCodecs.values = MakeCodecs(false, false, true);
+
+  InitTracks(SdpMediaSection::kAudio);
+  InitSdp(SdpMediaSection::kAudio);
+
+  CreateOffer();
+  GetOffer().RemoveFmtp("101");
+
+  CreateAnswer();
+  GetAnswer().RemoveFmtp("101");
+
+  Negotiate();
+  SanityCheck();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:101 telephone-event"),
+            std::string::npos);
+
+  ASSERT_EQ(mOffer->ToString().find("a=fmtp:101"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=fmtp:101"), std::string::npos);
+
+  const JsepAudioCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns, 2)));
+  ASSERT_EQ("1", track->mDefaultPt);
+
+  ASSERT_TRUE((track = GetAudioCodec(*mSendOff, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvOff, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mSendAns, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+  ASSERT_TRUE((track = GetAudioCodec(*mRecvAns, 2, 1)));
+  ASSERT_EQ("101", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, VideoNegotationOffererFEC)
+{
+  mOffCodecs.values = MakeCodecs(true);
+  mAnsCodecs.values = MakeCodecs(false);
+
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+
+  ASSERT_NE(mOffer->ToString().find("a=fmtp:122 120/126/123"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=fmtp:122"), std::string::npos);
+
+  const JsepVideoCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetVideoCodec(*mSendOff)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvOff)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mSendAns)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvAns)));
+  ASSERT_EQ("120", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, VideoNegotationAnswererFEC)
+{
+  mOffCodecs.values = MakeCodecs(false);
+  mAnsCodecs.values = MakeCodecs(true);
+
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_EQ(mOffer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_EQ(mOffer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+
+  ASSERT_EQ(mOffer->ToString().find("a=fmtp:122"), std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=fmtp:122"), std::string::npos);
+
+  const JsepVideoCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetVideoCodec(*mSendOff)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvOff)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mSendAns)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvAns)));
+  ASSERT_EQ("120", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, VideoNegotationOffererAnswererFEC)
+{
+  mOffCodecs.values = MakeCodecs(true);
+  mAnsCodecs.values = MakeCodecs(true);
+
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+
+  ASSERT_NE(mOffer->ToString().find("a=fmtp:122 120/126/123"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=fmtp:122 120/126/123"), std::string::npos);
+
+  const JsepVideoCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetVideoCodec(*mSendOff, 4)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvOff, 4)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mSendAns, 4)));
+  ASSERT_EQ("120", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvAns, 4)));
+  ASSERT_EQ("120", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, VideoNegotationOffererAnswererFECPreferred)
+{
+  mOffCodecs.values = MakeCodecs(true, true);
+  mAnsCodecs.values = MakeCodecs(true);
+
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+
+  ASSERT_NE(mOffer->ToString().find("a=fmtp:122 120/126/123"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=fmtp:122 120/126/123"), std::string::npos);
+
+  const JsepVideoCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetVideoCodec(*mSendOff, 4)));
+  ASSERT_EQ("122", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvOff, 4)));
+  ASSERT_EQ("122", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mSendAns, 4)));
+  ASSERT_EQ("122", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvAns, 4)));
+  ASSERT_EQ("122", track->mDefaultPt);
+}
+
+// Make sure we only put the right things in the fmtp:122 120/.... line
+TEST_F(JsepTrackTest, VideoNegotationOffererAnswererFECMismatch)
+{
+  mOffCodecs.values = MakeCodecs(true, true);
+  mAnsCodecs.values = MakeCodecs(true);
+  // remove h264 from answer codecs
+  ASSERT_EQ("H264", mAnsCodecs.values[3]->mName);
+  mAnsCodecs.values.erase(mAnsCodecs.values.begin()+3);
+
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+
+  ASSERT_NE(mOffer->ToString().find("a=fmtp:122 120/126/123"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=fmtp:122 120/123"), std::string::npos);
+
+  const JsepVideoCodecDescription* track = nullptr;
+  ASSERT_TRUE((track = GetVideoCodec(*mSendOff, 3)));
+  ASSERT_EQ("122", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvOff, 3)));
+  ASSERT_EQ("122", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mSendAns, 3)));
+  ASSERT_EQ("122", track->mDefaultPt);
+  ASSERT_TRUE((track = GetVideoCodec(*mRecvAns, 3)));
+  ASSERT_EQ("122", track->mDefaultPt);
+}
+
+TEST_F(JsepTrackTest, VideoNegotationOffererAnswererFECZeroVP9Codec)
+{
+  mOffCodecs.values = MakeCodecs(true);
+  JsepVideoCodecDescription* vp9 =
+    new JsepVideoCodecDescription("0", "VP9", 90000);
+  vp9->mConstraints.maxFs = 12288;
+  vp9->mConstraints.maxFps = 60;
+  mOffCodecs.values.push_back(vp9);
+
+  ASSERT_EQ(8U, mOffCodecs.values.size());
+  JsepVideoCodecDescription* red =
+      static_cast<JsepVideoCodecDescription*>(mOffCodecs.values[4]);
+  ASSERT_EQ("red", red->mName);
+  // rebuild the redundant encodings with our newly added "wacky" VP9
+  red->mRedundantEncodings.clear();
+  red->UpdateRedundantEncodings(mOffCodecs.values);
+
+  mAnsCodecs.values = MakeCodecs(true);
+
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mOffer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:122 red"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtpmap:123 ulpfec"), std::string::npos);
+
+  ASSERT_NE(mOffer->ToString().find("a=fmtp:122 120/126/123/0"), std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=fmtp:122 120/126/123\r\n"), std::string::npos);
+}
+
+TEST_F(JsepTrackTest, VideoNegotiationOfferRemb)
+{
+  InitCodecs();
+  // enable remb on the offer codecs
+  ((JsepVideoCodecDescription*)mOffCodecs.values[2])->EnableRemb();
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  // make sure REMB is on offer and not on answer
+  ASSERT_NE(mOffer->ToString().find("a=rtcp-fb:120 goog-remb"),
+            std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=rtcp-fb:120 goog-remb"),
+            std::string::npos);
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  CheckOtherFbsSize(*mSendOff, 0);
+  CheckOtherFbsSize(*mRecvAns, 0);
+
+  CheckOtherFbsSize(*mSendAns, 0);
+  CheckOtherFbsSize(*mRecvOff, 0);
+}
+
+TEST_F(JsepTrackTest, VideoNegotiationAnswerRemb)
+{
+  InitCodecs();
+  // enable remb on the answer codecs
+  ((JsepVideoCodecDescription*)mAnsCodecs.values[2])->EnableRemb();
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  // make sure REMB is not on offer and not on answer
+  ASSERT_EQ(mOffer->ToString().find("a=rtcp-fb:120 goog-remb"),
+            std::string::npos);
+  ASSERT_EQ(mAnswer->ToString().find("a=rtcp-fb:120 goog-remb"),
+            std::string::npos);
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  CheckOtherFbsSize(*mSendOff, 0);
+  CheckOtherFbsSize(*mRecvAns, 0);
+
+  CheckOtherFbsSize(*mSendAns, 0);
+  CheckOtherFbsSize(*mRecvOff, 0);
+}
+
+TEST_F(JsepTrackTest, VideoNegotiationOfferAnswerRemb)
+{
+  InitCodecs();
+  // enable remb on the offer and answer codecs
+  ((JsepVideoCodecDescription*)mOffCodecs.values[2])->EnableRemb();
+  ((JsepVideoCodecDescription*)mAnsCodecs.values[2])->EnableRemb();
+  InitTracks(SdpMediaSection::kVideo);
+  InitSdp(SdpMediaSection::kVideo);
+  OfferAnswer();
+
+  // make sure REMB is on offer and on answer
+  ASSERT_NE(mOffer->ToString().find("a=rtcp-fb:120 goog-remb"),
+            std::string::npos);
+  ASSERT_NE(mAnswer->ToString().find("a=rtcp-fb:120 goog-remb"),
+            std::string::npos);
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+
+  CheckOtherFbsSize(*mSendOff, 1);
+  CheckOtherFbsSize(*mRecvAns, 1);
+  CheckOtherFbExists(*mSendOff, SdpRtcpFbAttributeList::kRemb);
+  CheckOtherFbExists(*mRecvAns, SdpRtcpFbAttributeList::kRemb);
+
+  CheckOtherFbsSize(*mSendAns, 1);
+  CheckOtherFbsSize(*mRecvOff, 1);
+  CheckOtherFbExists(*mSendAns, SdpRtcpFbAttributeList::kRemb);
+  CheckOtherFbExists(*mRecvOff, SdpRtcpFbAttributeList::kRemb);
+}
+
+TEST_F(JsepTrackTest, AudioOffSendonlyAnsRecvonly)
+{
+  Init(SdpMediaSection::kAudio);
+  mRecvOff = nullptr;
+  mSendAns = nullptr;
+  OfferAnswer();
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(0);
+}
+
+TEST_F(JsepTrackTest, VideoOffSendonlyAnsRecvonly)
+{
+  Init(SdpMediaSection::kVideo);
+  mRecvOff = nullptr;
+  mSendAns = nullptr;
+  OfferAnswer();
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(0);
+}
+
+TEST_F(JsepTrackTest, AudioOffSendrecvAnsRecvonly)
+{
+  Init(SdpMediaSection::kAudio);
+  mSendAns = nullptr;
+  OfferAnswer();
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(0);
+}
+
+TEST_F(JsepTrackTest, VideoOffSendrecvAnsRecvonly)
+{
+  Init(SdpMediaSection::kVideo);
+  mSendAns = nullptr;
+  OfferAnswer();
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(0);
+}
+
+TEST_F(JsepTrackTest, AudioOffRecvonlyAnsSendrecv)
+{
+  Init(SdpMediaSection::kAudio);
+  mSendOff = nullptr;
+  OfferAnswer();
+  CheckOffEncodingCount(0);
+  CheckAnsEncodingCount(1);
+}
+
+TEST_F(JsepTrackTest, VideoOffRecvonlyAnsSendrecv)
+{
+  Init(SdpMediaSection::kVideo);
+  mSendOff = nullptr;
+  OfferAnswer();
+  CheckOffEncodingCount(0);
+  CheckAnsEncodingCount(1);
+}
+
+TEST_F(JsepTrackTest, AudioOffSendrecvAnsSendonly)
+{
+  Init(SdpMediaSection::kAudio);
+  mRecvAns = nullptr;
+  OfferAnswer();
+  CheckOffEncodingCount(0);
+  CheckAnsEncodingCount(1);
+}
+
+TEST_F(JsepTrackTest, VideoOffSendrecvAnsSendonly)
+{
+  Init(SdpMediaSection::kVideo);
+  mRecvAns = nullptr;
+  OfferAnswer();
+  CheckOffEncodingCount(0);
+  CheckAnsEncodingCount(1);
+}
+
+static JsepTrack::JsConstraints
+MakeConstraints(const std::string& rid, uint32_t maxBitrate)
+{
+  JsepTrack::JsConstraints constraints;
+  constraints.rid = rid;
+  constraints.constraints.maxBr = maxBitrate;
+  return constraints;
+}
+
+TEST_F(JsepTrackTest, SimulcastRejected)
+{
+  Init(SdpMediaSection::kVideo);
+  std::vector<JsepTrack::JsConstraints> constraints;
+  constraints.push_back(MakeConstraints("foo", 40000));
+  constraints.push_back(MakeConstraints("bar", 10000));
+  mSendOff->SetJsConstraints(constraints);
+  OfferAnswer();
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+}
+
+TEST_F(JsepTrackTest, SimulcastPrevented)
+{
+  Init(SdpMediaSection::kVideo);
+  std::vector<JsepTrack::JsConstraints> constraints;
+  constraints.push_back(MakeConstraints("foo", 40000));
+  constraints.push_back(MakeConstraints("bar", 10000));
+  mSendAns->SetJsConstraints(constraints);
+  OfferAnswer();
+  CheckOffEncodingCount(1);
+  CheckAnsEncodingCount(1);
+}
+
+TEST_F(JsepTrackTest, SimulcastOfferer)
+{
+  Init(SdpMediaSection::kVideo);
+  std::vector<JsepTrack::JsConstraints> constraints;
+  constraints.push_back(MakeConstraints("foo", 40000));
+  constraints.push_back(MakeConstraints("bar", 10000));
+  mSendOff->SetJsConstraints(constraints);
+  CreateOffer();
+  CreateAnswer();
+  // Add simulcast/rid to answer
+  JsepTrack::AddToMsection(constraints, sdp::kRecv, &GetAnswer());
+  Negotiate();
+  ASSERT_TRUE(mSendOff->GetNegotiatedDetails());
+  ASSERT_EQ(2U, mSendOff->GetNegotiatedDetails()->GetEncodingCount());
+  ASSERT_EQ("foo", mSendOff->GetNegotiatedDetails()->GetEncoding(0).mRid);
+  ASSERT_EQ(40000U,
+      mSendOff->GetNegotiatedDetails()->GetEncoding(0).mConstraints.maxBr);
+  ASSERT_EQ("bar", mSendOff->GetNegotiatedDetails()->GetEncoding(1).mRid);
+  ASSERT_EQ(10000U,
+      mSendOff->GetNegotiatedDetails()->GetEncoding(1).mConstraints.maxBr);
+}
+
+TEST_F(JsepTrackTest, SimulcastAnswerer)
+{
+  Init(SdpMediaSection::kVideo);
+  std::vector<JsepTrack::JsConstraints> constraints;
+  constraints.push_back(MakeConstraints("foo", 40000));
+  constraints.push_back(MakeConstraints("bar", 10000));
+  mSendAns->SetJsConstraints(constraints);
+  CreateOffer();
+  // Add simulcast/rid to offer
+  JsepTrack::AddToMsection(constraints, sdp::kRecv, &GetOffer());
+  CreateAnswer();
+  Negotiate();
+  ASSERT_TRUE(mSendAns->GetNegotiatedDetails());
+  ASSERT_EQ(2U, mSendAns->GetNegotiatedDetails()->GetEncodingCount());
+  ASSERT_EQ("foo", mSendAns->GetNegotiatedDetails()->GetEncoding(0).mRid);
+  ASSERT_EQ(40000U,
+      mSendAns->GetNegotiatedDetails()->GetEncoding(0).mConstraints.maxBr);
+  ASSERT_EQ("bar", mSendAns->GetNegotiatedDetails()->GetEncoding(1).mRid);
+  ASSERT_EQ(10000U,
+      mSendAns->GetNegotiatedDetails()->GetEncoding(1).mConstraints.maxBr);
+}
+
+#define VERIFY_OPUS_MAX_PLAYBACK_RATE(track, expectedRate)  \
+{  \
+  JsepTrack& copy(track); \
+  ASSERT_TRUE(copy.GetNegotiatedDetails());  \
+  ASSERT_TRUE(copy.GetNegotiatedDetails()->GetEncodingCount());  \
+  for (auto codec : copy.GetNegotiatedDetails()->GetEncoding(0).GetCodecs()) {\
+    if (codec->mName == "opus") {  \
+      JsepAudioCodecDescription* audioCodec =  \
+        static_cast<JsepAudioCodecDescription*>(codec);  \
+      ASSERT_EQ((expectedRate), audioCodec->mMaxPlaybackRate);  \
+    }  \
+  };  \
+}
+
+#define VERIFY_OPUS_FORCE_MONO(track, expected) \
+{ \
+  JsepTrack& copy(track); \
+  ASSERT_TRUE(copy.GetNegotiatedDetails());  \
+  ASSERT_TRUE(copy.GetNegotiatedDetails()->GetEncodingCount());  \
+  for (auto codec : copy.GetNegotiatedDetails()->GetEncoding(0).GetCodecs()) {\
+    if (codec->mName == "opus") {  \
+      JsepAudioCodecDescription* audioCodec =  \
+        static_cast<JsepAudioCodecDescription*>(codec);  \
+      /* gtest has some compiler warnings when using ASSERT_EQ with booleans. */ \
+      ASSERT_EQ((int)(expected), (int)audioCodec->mForceMono);  \
+    }  \
+  };  \
+}
+
+TEST_F(JsepTrackTest, DefaultOpusParameters)
+{
+  Init(SdpMediaSection::kAudio);
+  OfferAnswer();
+
+  VERIFY_OPUS_MAX_PLAYBACK_RATE(*mSendOff,
+      SdpFmtpAttributeList::OpusParameters::kDefaultMaxPlaybackRate);
+  VERIFY_OPUS_MAX_PLAYBACK_RATE(*mSendAns,
+      SdpFmtpAttributeList::OpusParameters::kDefaultMaxPlaybackRate);
+  VERIFY_OPUS_MAX_PLAYBACK_RATE(*mRecvOff, 0U);
+  VERIFY_OPUS_FORCE_MONO(*mRecvOff, false);
+  VERIFY_OPUS_MAX_PLAYBACK_RATE(*mRecvAns, 0U);
+  VERIFY_OPUS_FORCE_MONO(*mRecvAns, false);
+}
+
+TEST_F(JsepTrackTest, NonDefaultOpusParameters)
+{
+  InitCodecs();
+  for (auto& codec : mAnsCodecs.values) {
+    if (codec->mName == "opus") {
+      JsepAudioCodecDescription* audioCodec =
+        static_cast<JsepAudioCodecDescription*>(codec);
+      audioCodec->mMaxPlaybackRate = 16000;
+      audioCodec->mForceMono = true;
+    }
+  }
+  InitTracks(SdpMediaSection::kAudio);
+  InitSdp(SdpMediaSection::kAudio);
+  OfferAnswer();
+
+  VERIFY_OPUS_MAX_PLAYBACK_RATE(*mSendOff, 16000U);
+  VERIFY_OPUS_FORCE_MONO(*mSendOff, true);
+  VERIFY_OPUS_MAX_PLAYBACK_RATE(*mSendAns,
+      SdpFmtpAttributeList::OpusParameters::kDefaultMaxPlaybackRate);
+  VERIFY_OPUS_FORCE_MONO(*mSendAns, false);
+  VERIFY_OPUS_MAX_PLAYBACK_RATE(*mRecvOff, 0U);
+  VERIFY_OPUS_FORCE_MONO(*mRecvOff, false);
+  VERIFY_OPUS_MAX_PLAYBACK_RATE(*mRecvAns, 16000U);
+  VERIFY_OPUS_FORCE_MONO(*mRecvAns, true);
+}
+
+} // namespace mozilla
+
+int
+main(int argc, char** argv)
+{
+  // Prevents some log spew
+  ScopedXPCOM xpcom("jsep_track_unittest");
+
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+