Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1907 insertions, 0 deletions

diff --git a/dom/media/webrtc/sdp/SdpAttribute.h b/dom/media/webrtc/sdp/SdpAttribute.h
new file mode 100644
index 0000000000..6af497ac18
--- /dev/null
+++ b/dom/media/webrtc/sdp/SdpAttribute.h
@@ -0,0 +1,1907 @@
+/* -*- 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/. */
+
+#ifndef _SDPATTRIBUTE_H_
+#define _SDPATTRIBUTE_H_
+
+#include <algorithm>
+#include <cctype>
+#include <vector>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+#include <iomanip>
+#include <string>
+
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Maybe.h"
+
+#include "sdp/SdpEnum.h"
+#include "common/EncodingConstraints.h"
+
+namespace mozilla {
+
+/**
+ * Base class for SDP attributes
+ */
+class SdpAttribute {
+ public:
+  enum AttributeType {
+    kFirstAttribute = 0,
+    kBundleOnlyAttribute = 0,
+    kCandidateAttribute,
+    kConnectionAttribute,
+    kDirectionAttribute,
+    kDtlsMessageAttribute,
+    kEndOfCandidatesAttribute,
+    kExtmapAttribute,
+    kFingerprintAttribute,
+    kFmtpAttribute,
+    kGroupAttribute,
+    kIceLiteAttribute,
+    kIceMismatchAttribute,
+    kIceOptionsAttribute,
+    kIcePwdAttribute,
+    kIceUfragAttribute,
+    kIdentityAttribute,
+    kImageattrAttribute,
+    kLabelAttribute,
+    kMaxptimeAttribute,
+    kMidAttribute,
+    kMsidAttribute,
+    kMsidSemanticAttribute,
+    kPtimeAttribute,
+    kRemoteCandidatesAttribute,
+    kRidAttribute,
+    kRtcpAttribute,
+    kRtcpFbAttribute,
+    kRtcpMuxAttribute,
+    kRtcpRsizeAttribute,
+    kRtpmapAttribute,
+    kSctpmapAttribute,
+    kSetupAttribute,
+    kSimulcastAttribute,
+    kSsrcAttribute,
+    kSsrcGroupAttribute,
+    kSctpPortAttribute,
+    kMaxMessageSizeAttribute,
+    kLastAttribute = kMaxMessageSizeAttribute
+  };
+
+  explicit SdpAttribute(AttributeType type) : mType(type) {}
+  virtual ~SdpAttribute() {}
+
+  virtual SdpAttribute* Clone() const = 0;
+
+  AttributeType GetType() const { return mType; }
+
+  virtual void Serialize(std::ostream&) const = 0;
+
+  static bool IsAllowedAtSessionLevel(AttributeType type);
+  static bool IsAllowedAtMediaLevel(AttributeType type);
+  static const std::string GetAttributeTypeString(AttributeType type);
+
+ protected:
+  AttributeType mType;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const SdpAttribute& attr) {
+  attr.Serialize(os);
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os,
+                                const SdpAttribute::AttributeType type) {
+  os << SdpAttribute::GetAttributeTypeString(type);
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=candidate, RFC5245
+//-------------------------------------------------------------------------
+//
+// candidate-attribute   = "candidate" ":" foundation SP component-id SP
+//                          transport SP
+//                          priority SP
+//                          connection-address SP     ;from RFC 4566
+//                          port         ;port from RFC 4566
+//                          SP cand-type
+//                          [SP rel-addr]
+//                          [SP rel-port]
+//                          *(SP extension-att-name SP
+//                               extension-att-value)
+// foundation            = 1*32ice-char
+// component-id          = 1*5DIGIT
+// transport             = "UDP" / transport-extension
+// transport-extension   = token              ; from RFC 3261
+// priority              = 1*10DIGIT
+// cand-type             = "typ" SP candidate-types
+// candidate-types       = "host" / "srflx" / "prflx" / "relay" / token
+// rel-addr              = "raddr" SP connection-address
+// rel-port              = "rport" SP port
+// extension-att-name    = byte-string    ;from RFC 4566
+// extension-att-value   = byte-string
+// ice-char              = ALPHA / DIGIT / "+" / "/"
+
+// We use a SdpMultiStringAttribute for candidates
+
+///////////////////////////////////////////////////////////////////////////
+// a=connection, RFC4145
+//-------------------------------------------------------------------------
+//         connection-attr        = "a=connection:" conn-value
+//         conn-value             = "new" / "existing"
+class SdpConnectionAttribute : public SdpAttribute {
+ public:
+  enum ConnValue { kNew, kExisting };
+
+  explicit SdpConnectionAttribute(SdpConnectionAttribute::ConnValue value)
+      : SdpAttribute(kConnectionAttribute), mValue(value) {}
+
+  SdpAttribute* Clone() const override {
+    return new SdpConnectionAttribute(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  ConnValue mValue;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+                                SdpConnectionAttribute::ConnValue c) {
+  switch (c) {
+    case SdpConnectionAttribute::kNew:
+      os << "new";
+      break;
+    case SdpConnectionAttribute::kExisting:
+      os << "existing";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=sendrecv / a=sendonly / a=recvonly / a=inactive, RFC 4566
+//-------------------------------------------------------------------------
+class SdpDirectionAttribute : public SdpAttribute {
+ public:
+  enum Direction {
+    kInactive = 0,
+    kSendonly = sdp::kSend,
+    kRecvonly = sdp::kRecv,
+    kSendrecv = sdp::kSend | sdp::kRecv
+  };
+
+  explicit SdpDirectionAttribute(Direction value)
+      : SdpAttribute(kDirectionAttribute), mValue(value) {}
+
+  SdpAttribute* Clone() const override {
+    return new SdpDirectionAttribute(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  Direction mValue;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+                                SdpDirectionAttribute::Direction d) {
+  switch (d) {
+    case SdpDirectionAttribute::kSendonly:
+      os << "sendonly";
+      break;
+    case SdpDirectionAttribute::kRecvonly:
+      os << "recvonly";
+      break;
+    case SdpDirectionAttribute::kSendrecv:
+      os << "sendrecv";
+      break;
+    case SdpDirectionAttribute::kInactive:
+      os << "inactive";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+inline SdpDirectionAttribute::Direction reverse(
+    SdpDirectionAttribute::Direction d) {
+  switch (d) {
+    case SdpDirectionAttribute::Direction::kInactive:
+      return SdpDirectionAttribute::Direction::kInactive;
+    case SdpDirectionAttribute::Direction::kSendonly:
+      return SdpDirectionAttribute::Direction::kRecvonly;
+    case SdpDirectionAttribute::Direction::kRecvonly:
+      return SdpDirectionAttribute::Direction::kSendonly;
+    case SdpDirectionAttribute::Direction::kSendrecv:
+      return SdpDirectionAttribute::Direction::kSendrecv;
+  }
+  MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Invalid direction!");
+  MOZ_RELEASE_ASSERT(false);
+}
+
+inline SdpDirectionAttribute::Direction operator|(
+    SdpDirectionAttribute::Direction d1, SdpDirectionAttribute::Direction d2) {
+  return (SdpDirectionAttribute::Direction)((unsigned)d1 | (unsigned)d2);
+}
+
+inline SdpDirectionAttribute::Direction operator&(
+    SdpDirectionAttribute::Direction d1, SdpDirectionAttribute::Direction d2) {
+  return (SdpDirectionAttribute::Direction)((unsigned)d1 & (unsigned)d2);
+}
+
+inline SdpDirectionAttribute::Direction operator|=(
+    SdpDirectionAttribute::Direction& d1, SdpDirectionAttribute::Direction d2) {
+  d1 = d1 | d2;
+  return d1;
+}
+
+inline SdpDirectionAttribute::Direction operator&=(
+    SdpDirectionAttribute::Direction& d1, SdpDirectionAttribute::Direction d2) {
+  d1 = d1 & d2;
+  return d1;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=dtls-message, draft-rescorla-dtls-in-sdp
+//-------------------------------------------------------------------------
+//   attribute               =/   dtls-message-attribute
+//
+//   dtls-message-attribute  =    "dtls-message" ":" role SP value
+//
+//   role                    =    "client" / "server"
+//
+//   value                   =    1*(ALPHA / DIGIT / "+" / "/" / "=" )
+//                                ; base64 encoded message
+class SdpDtlsMessageAttribute : public SdpAttribute {
+ public:
+  enum Role { kClient, kServer };
+
+  explicit SdpDtlsMessageAttribute(Role role, const std::string& value)
+      : SdpAttribute(kDtlsMessageAttribute), mRole(role), mValue(value) {}
+
+  // TODO: remove this, Bug 1469702
+  explicit SdpDtlsMessageAttribute(const std::string& unparsed)
+      : SdpAttribute(kDtlsMessageAttribute), mRole(kClient) {
+    std::istringstream is(unparsed);
+    std::string error;
+    // We're not really worried about errors here if we don't parse;
+    // this attribute is a pure optimization.
+    Parse(is, &error);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpDtlsMessageAttribute(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  // TODO: remove this, Bug 1469702
+  bool Parse(std::istream& is, std::string* error);
+
+  Role mRole;
+  std::string mValue;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+                                SdpDtlsMessageAttribute::Role r) {
+  switch (r) {
+    case SdpDtlsMessageAttribute::kClient:
+      os << "client";
+      break;
+    case SdpDtlsMessageAttribute::kServer:
+      os << "server";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=extmap, RFC5285
+//-------------------------------------------------------------------------
+// RFC5285
+//        extmap = mapentry SP extensionname [SP extensionattributes]
+//
+//        extensionname = URI
+//
+//        direction = "sendonly" / "recvonly" / "sendrecv" / "inactive"
+//
+//        mapentry = "extmap:" 1*5DIGIT ["/" direction]
+//
+//        extensionattributes = byte-string
+//
+//        URI = <Defined in RFC 3986>
+//
+//        byte-string = <Defined in RFC 4566>
+//
+//        SP = <Defined in RFC 5234>
+//
+//        DIGIT = <Defined in RFC 5234>
+class SdpExtmapAttributeList : public SdpAttribute {
+ public:
+  SdpExtmapAttributeList() : SdpAttribute(kExtmapAttribute) {}
+
+  struct Extmap {
+    uint16_t entry;
+    SdpDirectionAttribute::Direction direction;
+    bool direction_specified;
+    std::string extensionname;
+    std::string extensionattributes;
+  };
+
+  void PushEntry(uint16_t entry, SdpDirectionAttribute::Direction direction,
+                 bool direction_specified, const std::string& extensionname,
+                 const std::string& extensionattributes = "") {
+    Extmap value = {entry, direction, direction_specified, extensionname,
+                    extensionattributes};
+    mExtmaps.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpExtmapAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<Extmap> mExtmaps;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=fingerprint, RFC4572
+//-------------------------------------------------------------------------
+//   fingerprint-attribute  =  "fingerprint" ":" hash-func SP fingerprint
+//
+//   hash-func              =  "sha-1" / "sha-224" / "sha-256" /
+//                             "sha-384" / "sha-512" /
+//                             "md5" / "md2" / token
+//                             ; Additional hash functions can only come
+//                             ; from updates to RFC 3279
+//
+//   fingerprint            =  2UHEX *(":" 2UHEX)
+//                             ; Each byte in upper-case hex, separated
+//                             ; by colons.
+//
+//   UHEX                   =  DIGIT / %x41-46 ; A-F uppercase
+class SdpFingerprintAttributeList : public SdpAttribute {
+ public:
+  SdpFingerprintAttributeList() : SdpAttribute(kFingerprintAttribute) {}
+
+  enum HashAlgorithm {
+    kSha1,
+    kSha224,
+    kSha256,
+    kSha384,
+    kSha512,
+    kMd5,
+    kMd2,
+    kUnknownAlgorithm
+  };
+
+  struct Fingerprint {
+    HashAlgorithm hashFunc;
+    std::vector<uint8_t> fingerprint;
+  };
+
+  // For use by application programmers. Enforces that it's a known and
+  // reasonable algorithm.
+  void PushEntry(std::string algorithm_str,
+                 const std::vector<uint8_t>& fingerprint,
+                 bool enforcePlausible = true) {
+    std::transform(algorithm_str.begin(), algorithm_str.end(),
+                   algorithm_str.begin(), ::tolower);
+
+    SdpFingerprintAttributeList::HashAlgorithm algorithm =
+        SdpFingerprintAttributeList::kUnknownAlgorithm;
+
+    if (algorithm_str == "sha-1") {
+      algorithm = SdpFingerprintAttributeList::kSha1;
+    } else if (algorithm_str == "sha-224") {
+      algorithm = SdpFingerprintAttributeList::kSha224;
+    } else if (algorithm_str == "sha-256") {
+      algorithm = SdpFingerprintAttributeList::kSha256;
+    } else if (algorithm_str == "sha-384") {
+      algorithm = SdpFingerprintAttributeList::kSha384;
+    } else if (algorithm_str == "sha-512") {
+      algorithm = SdpFingerprintAttributeList::kSha512;
+    } else if (algorithm_str == "md5") {
+      algorithm = SdpFingerprintAttributeList::kMd5;
+    } else if (algorithm_str == "md2") {
+      algorithm = SdpFingerprintAttributeList::kMd2;
+    }
+
+    if ((algorithm == SdpFingerprintAttributeList::kUnknownAlgorithm) ||
+        fingerprint.empty()) {
+      if (enforcePlausible) {
+        MOZ_ASSERT(false, "Unknown fingerprint algorithm");
+      } else {
+        return;
+      }
+    }
+
+    PushEntry(algorithm, fingerprint);
+  }
+
+  void PushEntry(HashAlgorithm hashFunc,
+                 const std::vector<uint8_t>& fingerprint) {
+    Fingerprint value = {hashFunc, fingerprint};
+    mFingerprints.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpFingerprintAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<Fingerprint> mFingerprints;
+
+  static std::string FormatFingerprint(const std::vector<uint8_t>& fp);
+  static std::vector<uint8_t> ParseFingerprint(const std::string& str);
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+                                SdpFingerprintAttributeList::HashAlgorithm a) {
+  switch (a) {
+    case SdpFingerprintAttributeList::kSha1:
+      os << "sha-1";
+      break;
+    case SdpFingerprintAttributeList::kSha224:
+      os << "sha-224";
+      break;
+    case SdpFingerprintAttributeList::kSha256:
+      os << "sha-256";
+      break;
+    case SdpFingerprintAttributeList::kSha384:
+      os << "sha-384";
+      break;
+    case SdpFingerprintAttributeList::kSha512:
+      os << "sha-512";
+      break;
+    case SdpFingerprintAttributeList::kMd5:
+      os << "md5";
+      break;
+    case SdpFingerprintAttributeList::kMd2:
+      os << "md2";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=group, RFC5888
+//-------------------------------------------------------------------------
+//         group-attribute     = "a=group:" semantics
+//                               *(SP identification-tag)
+//         semantics           = "LS" / "FID" / semantics-extension
+//         semantics-extension = token
+//         identification-tag  = token
+class SdpGroupAttributeList : public SdpAttribute {
+ public:
+  SdpGroupAttributeList() : SdpAttribute(kGroupAttribute) {}
+
+  enum Semantics {
+    kLs,     // RFC5888
+    kFid,    // RFC5888
+    kSrf,    // RFC3524
+    kAnat,   // RFC4091
+    kFec,    // RFC5956
+    kFecFr,  // RFC5956
+    kCs,     // draft-mehta-rmt-flute-sdp-05
+    kDdp,    // RFC5583
+    kDup,    // RFC7104
+    kBundle  // draft-ietf-mmusic-bundle
+  };
+
+  struct Group {
+    Semantics semantics;
+    std::vector<std::string> tags;
+  };
+
+  void PushEntry(Semantics semantics, const std::vector<std::string>& tags) {
+    Group value = {semantics, tags};
+    mGroups.push_back(value);
+  }
+
+  void RemoveMid(const std::string& mid) {
+    for (auto i = mGroups.begin(); i != mGroups.end();) {
+      auto tag = std::find(i->tags.begin(), i->tags.end(), mid);
+      if (tag != i->tags.end()) {
+        i->tags.erase(tag);
+      }
+
+      if (i->tags.empty()) {
+        i = mGroups.erase(i);
+      } else {
+        ++i;
+      }
+    }
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpGroupAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<Group> mGroups;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+                                SdpGroupAttributeList::Semantics s) {
+  switch (s) {
+    case SdpGroupAttributeList::kLs:
+      os << "LS";
+      break;
+    case SdpGroupAttributeList::kFid:
+      os << "FID";
+      break;
+    case SdpGroupAttributeList::kSrf:
+      os << "SRF";
+      break;
+    case SdpGroupAttributeList::kAnat:
+      os << "ANAT";
+      break;
+    case SdpGroupAttributeList::kFec:
+      os << "FEC";
+      break;
+    case SdpGroupAttributeList::kFecFr:
+      os << "FEC-FR";
+      break;
+    case SdpGroupAttributeList::kCs:
+      os << "CS";
+      break;
+    case SdpGroupAttributeList::kDdp:
+      os << "DDP";
+      break;
+    case SdpGroupAttributeList::kDup:
+      os << "DUP";
+      break;
+    case SdpGroupAttributeList::kBundle:
+      os << "BUNDLE";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=identity, draft-ietf-rtcweb-security-arch
+//-------------------------------------------------------------------------
+//   identity-attribute  = "identity:" identity-assertion
+//                         [ SP identity-extension
+//                           *(";" [ SP ] identity-extension) ]
+//   identity-assertion  = base64
+//   base64              = 1*(ALPHA / DIGIT / "+" / "/" / "=" )
+//   identity-extension  = extension-att-name [ "=" extension-att-value ]
+//   extension-att-name  = token
+//   extension-att-value = 1*(%x01-09 / %x0b-0c / %x0e-3a / %x3c-ff)
+//                         ; byte-string from [RFC4566] omitting ";"
+
+// We're just using an SdpStringAttribute for this right now
+#if 0
+class SdpIdentityAttribute : public SdpAttribute
+{
+public:
+  explicit SdpIdentityAttribute(const std::string &assertion,
+                                const std::vector<std::string> &extensions =
+                                    std::vector<std::string>()) :
+    SdpAttribute(kIdentityAttribute),
+    mAssertion(assertion),
+    mExtensions(extensions) {}
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::string mAssertion;
+  std::vector<std::string> mExtensions;
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////
+// a=imageattr, RFC6236
+//-------------------------------------------------------------------------
+//     image-attr = "imageattr:" PT 1*2( 1*WSP ( "send" / "recv" )
+//                                       1*WSP attr-list )
+//     PT = 1*DIGIT / "*"
+//     attr-list = ( set *(1*WSP set) ) / "*"
+//       ;  WSP and DIGIT defined in [RFC5234]
+//
+//     set= "[" "x=" xyrange "," "y=" xyrange *( "," key-value ) "]"
+//                ; x is the horizontal image size range (pixel count)
+//                ; y is the vertical image size range (pixel count)
+//
+//     key-value = ( "sar=" srange )
+//               / ( "par=" prange )
+//               / ( "q=" qvalue )
+//                ; Key-value MAY be extended with other keyword
+//                ;  parameters.
+//                ; At most, one instance each of sar, par, or q
+//                ;  is allowed in a set.
+//                ;
+//                ; sar (sample aspect ratio) is the sample aspect ratio
+//                ;  associated with the set (optional, MAY be ignored)
+//                ; par (picture aspect ratio) is the allowed
+//                ;  ratio between the display's x and y physical
+//                ;  size (optional)
+//                ; q (optional, range [0.0..1.0], default value 0.5)
+//                ;  is the preference for the given set,
+//                ;  a higher value means a higher preference
+//
+//     onetonine = "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9"
+//                ; Digit between 1 and 9
+//     xyvalue = onetonine *5DIGIT
+//                ; Digit between 1 and 9 that is
+//                ; followed by 0 to 5 other digits
+//     step = xyvalue
+//     xyrange = ( "[" xyvalue ":" [ step ":" ] xyvalue "]" )
+//                ; Range between a lower and an upper value
+//                ; with an optional step, default step = 1
+//                ; The rightmost occurrence of xyvalue MUST have a
+//                ; higher value than the leftmost occurrence.
+//             / ( "[" xyvalue 1*( "," xyvalue ) "]" )
+//                ; Discrete values separated by ','
+//             / ( xyvalue )
+//                ; A single value
+//     spvalue = ( "0" "." onetonine *3DIGIT )
+//                ; Values between 0.1000 and 0.9999
+//             / ( onetonine "." 1*4DIGIT )
+//                ; Values between 1.0000 and 9.9999
+//     srange =  ( "[" spvalue 1*( "," spvalue ) "]" )
+//                ; Discrete values separated by ','.
+//                ; Each occurrence of spvalue MUST be
+//                ; greater than the previous occurrence.
+//             / ( "[" spvalue "-" spvalue "]" )
+//                ; Range between a lower and an upper level (inclusive)
+//                ; The second occurrence of spvalue MUST have a higher
+//                ; value than the first
+//             / ( spvalue )
+//                ; A single value
+//
+//     prange =  ( "[" spvalue "-" spvalue "]" )
+//                ; Range between a lower and an upper level (inclusive)
+//                ; The second occurrence of spvalue MUST have a higher
+//                ; value than the first
+//
+//     qvalue  = ( "0" "." 1*2DIGIT )
+//             / ( "1" "." 1*2("0") )
+//                ; Values between 0.00 and 1.00
+//
+//  XXX TBD -- We don't use this yet, and it's a project unto itself.
+//
+
+class SdpImageattrAttributeList : public SdpAttribute {
+ public:
+  SdpImageattrAttributeList() : SdpAttribute(kImageattrAttribute) {}
+
+  class XYRange {
+   public:
+    XYRange() : min(0), max(0), step(1) {}
+    void Serialize(std::ostream& os) const;
+    // TODO: Remove this Bug 1469702
+    bool Parse(std::istream& is, std::string* error);
+    // TODO: Remove this Bug 1469702
+    bool ParseAfterBracket(std::istream& is, std::string* error);
+    // TODO: Remove this Bug 1469702
+    bool ParseAfterMin(std::istream& is, std::string* error);
+    // TODO: Remove this Bug 1469702
+    bool ParseDiscreteValues(std::istream& is, std::string* error);
+    std::vector<uint32_t> discreteValues;
+    // min/max are used iff discreteValues is empty
+    uint32_t min;
+    uint32_t max;
+    uint32_t step;
+  };
+
+  class SRange {
+   public:
+    SRange() : min(0), max(0) {}
+    void Serialize(std::ostream& os) const;
+    // TODO: Remove this Bug 1469702
+    bool Parse(std::istream& is, std::string* error);
+    // TODO: Remove this Bug 1469702
+    bool ParseAfterBracket(std::istream& is, std::string* error);
+    // TODO: Remove this Bug 1469702
+    bool ParseAfterMin(std::istream& is, std::string* error);
+    // TODO: Remove this Bug 1469702
+    bool ParseDiscreteValues(std::istream& is, std::string* error);
+    bool IsSet() const { return !discreteValues.empty() || (min && max); }
+    std::vector<float> discreteValues;
+    // min/max are used iff discreteValues is empty
+    float min;
+    float max;
+  };
+
+  class PRange {
+   public:
+    PRange() : min(0), max(0) {}
+    void Serialize(std::ostream& os) const;
+    // TODO: Remove this Bug 1469702
+    bool Parse(std::istream& is, std::string* error);
+    bool IsSet() const { return min && max; }
+    float min;
+    float max;
+  };
+
+  class Set {
+   public:
+    Set() : qValue(-1) {}
+    void Serialize(std::ostream& os) const;
+    // TODO: Remove this Bug 1469702
+    bool Parse(std::istream& is, std::string* error);
+    XYRange xRange;
+    XYRange yRange;
+    SRange sRange;
+    PRange pRange;
+    float qValue;
+  };
+
+  class Imageattr {
+   public:
+    Imageattr() : pt(), sendAll(false), recvAll(false) {}
+    void Serialize(std::ostream& os) const;
+    // TODO: Remove this Bug 1469702
+    bool Parse(std::istream& is, std::string* error);
+    // TODO: Remove this Bug 1469702
+    bool ParseSets(std::istream& is, std::string* error);
+    // If not set, this means all payload types
+    Maybe<uint16_t> pt;
+    bool sendAll;
+    std::vector<Set> sendSets;
+    bool recvAll;
+    std::vector<Set> recvSets;
+  };
+
+  SdpAttribute* Clone() const override {
+    return new SdpImageattrAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  // TODO: Remove this Bug 1469702
+  bool PushEntry(const std::string& raw, std::string* error, size_t* errorPos);
+
+  std::vector<Imageattr> mImageattrs;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=msid, draft-ietf-mmusic-msid
+//-------------------------------------------------------------------------
+//   msid-attr = "msid:" identifier [ SP appdata ]
+//   identifier = 1*64token-char ; see RFC 4566
+//   appdata = 1*64token-char  ; see RFC 4566
+class SdpMsidAttributeList : public SdpAttribute {
+ public:
+  SdpMsidAttributeList() : SdpAttribute(kMsidAttribute) {}
+
+  struct Msid {
+    std::string identifier;
+    std::string appdata;
+  };
+
+  void PushEntry(const std::string& identifier,
+                 const std::string& appdata = "") {
+    Msid value = {identifier, appdata};
+    mMsids.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpMsidAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<Msid> mMsids;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=msid-semantic, draft-ietf-mmusic-msid
+//-------------------------------------------------------------------------
+//   msid-semantic-attr = "msid-semantic:" msid-semantic msid-list
+//   msid-semantic = token ; see RFC 4566
+//   msid-list = *(" " msid-id) / " *"
+class SdpMsidSemanticAttributeList : public SdpAttribute {
+ public:
+  SdpMsidSemanticAttributeList() : SdpAttribute(kMsidSemanticAttribute) {}
+
+  struct MsidSemantic {
+    // TODO: Once we have some more of these, we might want to make an enum
+    std::string semantic;
+    std::vector<std::string> msids;
+  };
+
+  void PushEntry(const std::string& semantic,
+                 const std::vector<std::string>& msids) {
+    MsidSemantic value = {semantic, msids};
+    mMsidSemantics.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpMsidSemanticAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<MsidSemantic> mMsidSemantics;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=remote-candiate, RFC5245
+//-------------------------------------------------------------------------
+//   remote-candidate-att = "remote-candidates" ":" remote-candidate
+//                           0*(SP remote-candidate)
+//   remote-candidate = component-ID SP connection-address SP port
+class SdpRemoteCandidatesAttribute : public SdpAttribute {
+ public:
+  struct Candidate {
+    std::string id;
+    std::string address;
+    uint16_t port;
+  };
+
+  explicit SdpRemoteCandidatesAttribute(
+      const std::vector<Candidate>& candidates)
+      : SdpAttribute(kRemoteCandidatesAttribute), mCandidates(candidates) {}
+
+  SdpAttribute* Clone() const override {
+    return new SdpRemoteCandidatesAttribute(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<Candidate> mCandidates;
+};
+
+/*
+a=rid, draft-pthatcher-mmusic-rid-01
+
+   rid-syntax        = "a=rid:" rid-identifier SP rid-dir
+                       [ rid-pt-param-list / rid-param-list ]
+
+   rid-identifier    = 1*(alpha-numeric / "-" / "_")
+
+   rid-dir           = "send" / "recv"
+
+   rid-pt-param-list = SP rid-fmt-list *(";" rid-param)
+
+   rid-param-list    = SP rid-param *(";" rid-param)
+
+   rid-fmt-list      = "pt=" fmt *( "," fmt )
+                        ; fmt defined in {{RFC4566}}
+
+   rid-param         = rid-width-param
+                       / rid-height-param
+                       / rid-fps-param
+                       / rid-fs-param
+                       / rid-br-param
+                       / rid-pps-param
+                       / rid-depend-param
+                       / rid-param-other
+
+   rid-width-param   = "max-width" [ "=" int-param-val ]
+
+   rid-height-param  = "max-height" [ "=" int-param-val ]
+
+   rid-fps-param     = "max-fps" [ "=" int-param-val ]
+
+   rid-fs-param      = "max-fs" [ "=" int-param-val ]
+
+   rid-br-param      = "max-br" [ "=" int-param-val ]
+
+   rid-pps-param     = "max-pps" [ "=" int-param-val ]
+
+   rid-depend-param  = "depend=" rid-list
+
+   rid-param-other   = 1*(alpha-numeric / "-") [ "=" param-val ]
+
+   rid-list          = rid-identifier *( "," rid-identifier )
+
+   int-param-val     = 1*DIGIT
+
+   param-val         = *( %x20-58 / %x60-7E )
+                       ; Any printable character except semicolon
+*/
+class SdpRidAttributeList : public SdpAttribute {
+ public:
+  explicit SdpRidAttributeList() : SdpAttribute(kRidAttribute) {}
+
+  struct Rid {
+    Rid() : direction(sdp::kSend) {}
+
+    // Remove this function. See Bug 1469702
+    bool Parse(std::istream& is, std::string* error);
+    // Remove this function. See Bug 1469702
+    bool ParseParameters(std::istream& is, std::string* error);
+    // Remove this function. See Bug 1469702
+    bool ParseDepend(std::istream& is, std::string* error);
+    // Remove this function. See Bug 1469702
+    bool ParseFormats(std::istream& is, std::string* error);
+
+    void Serialize(std::ostream& os) const;
+    void SerializeParameters(std::ostream& os) const;
+    bool HasFormat(const std::string& format) const;
+    bool HasParameters() const {
+      return !formats.empty() || constraints.maxWidth ||
+             constraints.maxHeight || constraints.maxFps || constraints.maxFs ||
+             constraints.maxBr || constraints.maxPps || !dependIds.empty();
+    }
+
+    std::string id;
+    sdp::Direction direction;
+    std::vector<uint16_t> formats;  // Empty implies all
+    EncodingConstraints constraints;
+    std::vector<std::string> dependIds;
+  };
+
+  SdpAttribute* Clone() const override {
+    return new SdpRidAttributeList(*this);
+  }
+
+  static bool CheckRidValidity(const std::string& aRid, std::string* aError);
+  static size_t kMaxRidLength;
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  // Remove this function. See Bug 1469702
+  bool PushEntry(const std::string& raw, std::string* error, size_t* errorPos);
+
+  void PushEntry(const std::string& id, sdp::Direction dir,
+                 const std::vector<uint16_t>& formats,
+                 const EncodingConstraints& constraints,
+                 const std::vector<std::string>& dependIds);
+
+  std::vector<Rid> mRids;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=rtcp, RFC3605
+//-------------------------------------------------------------------------
+//   rtcp-attribute =  "a=rtcp:" port  [nettype space addrtype space
+//                         connection-address] CRLF
+class SdpRtcpAttribute : public SdpAttribute {
+ public:
+  explicit SdpRtcpAttribute(uint16_t port)
+      : SdpAttribute(kRtcpAttribute),
+        mPort(port),
+        mNetType(sdp::kNetTypeNone),
+        mAddrType(sdp::kAddrTypeNone) {}
+
+  SdpRtcpAttribute(uint16_t port, sdp::NetType netType, sdp::AddrType addrType,
+                   const std::string& address)
+      : SdpAttribute(kRtcpAttribute),
+        mPort(port),
+        mNetType(netType),
+        mAddrType(addrType),
+        mAddress(address) {
+    MOZ_ASSERT(netType != sdp::kNetTypeNone);
+    MOZ_ASSERT(addrType != sdp::kAddrTypeNone);
+    MOZ_ASSERT(!address.empty());
+  }
+
+  SdpAttribute* Clone() const override { return new SdpRtcpAttribute(*this); }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  uint16_t mPort;
+  sdp::NetType mNetType;
+  sdp::AddrType mAddrType;
+  std::string mAddress;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=rtcp-fb, RFC4585
+//-------------------------------------------------------------------------
+//    rtcp-fb-syntax = "a=rtcp-fb:" rtcp-fb-pt SP rtcp-fb-val CRLF
+//
+//    rtcp-fb-pt         = "*"   ; wildcard: applies to all formats
+//                       / fmt   ; as defined in SDP spec
+//
+//    rtcp-fb-val        = "ack" rtcp-fb-ack-param
+//                       / "nack" rtcp-fb-nack-param
+//                       / "trr-int" SP 1*DIGIT
+//                       / rtcp-fb-id rtcp-fb-param
+//
+//    rtcp-fb-id         = 1*(alpha-numeric / "-" / "_")
+//
+//    rtcp-fb-param      = SP "app" [SP byte-string]
+//                       / SP token [SP byte-string]
+//                       / ; empty
+//
+//    rtcp-fb-ack-param  = SP "rpsi"
+//                       / SP "app" [SP byte-string]
+//                       / SP token [SP byte-string]
+//                       / ; empty
+//
+//    rtcp-fb-nack-param = SP "pli"
+//                       / SP "sli"
+//                       / SP "rpsi"
+//                       / SP "app" [SP byte-string]
+//                       / SP token [SP byte-string]
+//                       / ; empty
+//
+class SdpRtcpFbAttributeList : public SdpAttribute {
+ public:
+  SdpRtcpFbAttributeList() : SdpAttribute(kRtcpFbAttribute) {}
+
+  enum Type { kAck, kApp, kCcm, kNack, kTrrInt, kRemb, kTransportCC };
+
+  static const char* pli;
+  static const char* sli;
+  static const char* rpsi;
+  static const char* app;
+
+  static const char* fir;
+  static const char* tmmbr;
+  static const char* tstr;
+  static const char* vbcm;
+
+  struct Feedback {
+    std::string pt;
+    Type type;
+    std::string parameter;
+    std::string extra;
+    // TODO(bug 1744307): Use =default here once it is supported
+    bool operator==(const Feedback& aOther) const {
+      return pt == aOther.pt && type == aOther.type &&
+             parameter == aOther.parameter && extra == aOther.extra;
+    }
+  };
+
+  void PushEntry(const std::string& pt, Type type,
+                 const std::string& parameter = "",
+                 const std::string& extra = "") {
+    Feedback value = {pt, type, parameter, extra};
+    mFeedbacks.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpRtcpFbAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<Feedback> mFeedbacks;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+                                SdpRtcpFbAttributeList::Type type) {
+  switch (type) {
+    case SdpRtcpFbAttributeList::kAck:
+      os << "ack";
+      break;
+    case SdpRtcpFbAttributeList::kApp:
+      os << "app";
+      break;
+    case SdpRtcpFbAttributeList::kCcm:
+      os << "ccm";
+      break;
+    case SdpRtcpFbAttributeList::kNack:
+      os << "nack";
+      break;
+    case SdpRtcpFbAttributeList::kTrrInt:
+      os << "trr-int";
+      break;
+    case SdpRtcpFbAttributeList::kRemb:
+      os << "goog-remb";
+      break;
+    case SdpRtcpFbAttributeList::kTransportCC:
+      os << "transport-cc";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=rtpmap, RFC4566
+//-------------------------------------------------------------------------
+// a=rtpmap:<payload type> <encoding name>/<clock rate> [/<encoding parameters>]
+class SdpRtpmapAttributeList : public SdpAttribute {
+ public:
+  SdpRtpmapAttributeList() : SdpAttribute(kRtpmapAttribute) {}
+
+  // Minimal set to get going
+  enum CodecType {
+    kOpus,
+    kG722,
+    kPCMU,
+    kPCMA,
+    kVP8,
+    kVP9,
+    kiLBC,
+    kiSAC,
+    kH264,
+    kRed,
+    kUlpfec,
+    kTelephoneEvent,
+    kRtx,
+    kOtherCodec
+  };
+
+  struct Rtpmap {
+    std::string pt;
+    CodecType codec;
+    std::string name;
+    uint32_t clock;
+    // Technically, this could mean something else in the future.
+    // In practice, that's probably not going to happen.
+    uint32_t channels;
+  };
+
+  void PushEntry(const std::string& pt, CodecType codec,
+                 const std::string& name, uint32_t clock,
+                 uint32_t channels = 0) {
+    Rtpmap value = {pt, codec, name, clock, channels};
+    mRtpmaps.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpRtpmapAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  bool HasEntry(const std::string& pt) const {
+    for (auto it = mRtpmaps.begin(); it != mRtpmaps.end(); ++it) {
+      if (it->pt == pt) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const Rtpmap& GetEntry(const std::string& pt) const {
+    for (auto it = mRtpmaps.begin(); it != mRtpmaps.end(); ++it) {
+      if (it->pt == pt) {
+        return *it;
+      }
+    }
+    MOZ_CRASH();
+  }
+
+  std::vector<Rtpmap> mRtpmaps;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+                                SdpRtpmapAttributeList::CodecType c) {
+  switch (c) {
+    case SdpRtpmapAttributeList::kOpus:
+      os << "opus";
+      break;
+    case SdpRtpmapAttributeList::kG722:
+      os << "G722";
+      break;
+    case SdpRtpmapAttributeList::kPCMU:
+      os << "PCMU";
+      break;
+    case SdpRtpmapAttributeList::kPCMA:
+      os << "PCMA";
+      break;
+    case SdpRtpmapAttributeList::kVP8:
+      os << "VP8";
+      break;
+    case SdpRtpmapAttributeList::kVP9:
+      os << "VP9";
+      break;
+    case SdpRtpmapAttributeList::kiLBC:
+      os << "iLBC";
+      break;
+    case SdpRtpmapAttributeList::kiSAC:
+      os << "iSAC";
+      break;
+    case SdpRtpmapAttributeList::kH264:
+      os << "H264";
+      break;
+    case SdpRtpmapAttributeList::kRed:
+      os << "red";
+      break;
+    case SdpRtpmapAttributeList::kUlpfec:
+      os << "ulpfec";
+      break;
+    case SdpRtpmapAttributeList::kTelephoneEvent:
+      os << "telephone-event";
+      break;
+    case SdpRtpmapAttributeList::kRtx:
+      os << "rtx";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=fmtp, RFC4566, RFC5576
+//-------------------------------------------------------------------------
+//       a=fmtp:<format> <format specific parameters>
+//
+class SdpFmtpAttributeList : public SdpAttribute {
+ public:
+  SdpFmtpAttributeList() : SdpAttribute(kFmtpAttribute) {}
+
+  // Base class for format parameters
+  class Parameters {
+   public:
+    explicit Parameters(SdpRtpmapAttributeList::CodecType aCodec)
+        : codec_type(aCodec) {}
+
+    virtual ~Parameters() {}
+    virtual Parameters* Clone() const = 0;
+    virtual void Serialize(std::ostream& os) const = 0;
+    virtual bool CompareEq(const Parameters& other) const = 0;
+
+    bool operator==(const Parameters& other) const {
+      return codec_type == other.codec_type && CompareEq(other);
+    }
+
+    SdpRtpmapAttributeList::CodecType codec_type;
+  };
+
+  class RedParameters : public Parameters {
+   public:
+    RedParameters() : Parameters(SdpRtpmapAttributeList::kRed) {}
+
+    virtual Parameters* Clone() const override {
+      return new RedParameters(*this);
+    }
+
+    virtual void Serialize(std::ostream& os) const override {
+      for (size_t i = 0; i < encodings.size(); ++i) {
+        os << (i != 0 ? "/" : "") << std::to_string(encodings[i]);
+      }
+    }
+
+    virtual bool CompareEq(const Parameters& other) const override {
+      return encodings == static_cast<const RedParameters&>(other).encodings;
+    }
+
+    std::vector<uint8_t> encodings;
+  };
+
+  class RtxParameters : public Parameters {
+   public:
+    uint8_t apt = 255;  // Valid payload types are 0 - 127, use 255 to represent
+                        // unset value.
+    Maybe<uint32_t> rtx_time;
+
+    RtxParameters() : Parameters(SdpRtpmapAttributeList::kRtx) {}
+
+    virtual ~RtxParameters() {}
+
+    virtual Parameters* Clone() const override {
+      return new RtxParameters(*this);
+    }
+
+    virtual void Serialize(std::ostream& os) const override {
+      if (apt <= 127) {
+        os << "apt=" << static_cast<uint32_t>(apt);
+        rtx_time.apply([&](const auto& time) { os << ";rtx-time=" << time; });
+      }
+    }
+
+    virtual bool CompareEq(const Parameters& aOther) const override {
+      if (aOther.codec_type != codec_type) {
+        return false;
+      }
+      auto other = static_cast<const RtxParameters&>(aOther);
+      return other.apt == apt && other.rtx_time == rtx_time;
+    }
+  };
+
+  class H264Parameters : public Parameters {
+   public:
+    static const uint32_t kDefaultProfileLevelId = 0x420010;
+
+    H264Parameters()
+        : Parameters(SdpRtpmapAttributeList::kH264),
+          packetization_mode(0),
+          level_asymmetry_allowed(false),
+          profile_level_id(kDefaultProfileLevelId),
+          max_mbps(0),
+          max_fs(0),
+          max_cpb(0),
+          max_dpb(0),
+          max_br(0) {
+      memset(sprop_parameter_sets, 0, sizeof(sprop_parameter_sets));
+    }
+
+    virtual Parameters* Clone() const override {
+      return new H264Parameters(*this);
+    }
+
+    virtual void Serialize(std::ostream& os) const override {
+      // Note: don't move this, since having an unconditional param up top
+      // lets us avoid a whole bunch of conditional streaming of ';' below
+      os << "profile-level-id=" << std::hex << std::setfill('0') << std::setw(6)
+         << profile_level_id << std::dec << std::setfill(' ');
+
+      os << ";level-asymmetry-allowed=" << (level_asymmetry_allowed ? 1 : 0);
+
+      if (strlen(sprop_parameter_sets)) {
+        os << ";sprop-parameter-sets=" << sprop_parameter_sets;
+      }
+
+      if (packetization_mode != 0) {
+        os << ";packetization-mode=" << packetization_mode;
+      }
+
+      if (max_mbps != 0) {
+        os << ";max-mbps=" << max_mbps;
+      }
+
+      if (max_fs != 0) {
+        os << ";max-fs=" << max_fs;
+      }
+
+      if (max_cpb != 0) {
+        os << ";max-cpb=" << max_cpb;
+      }
+
+      if (max_dpb != 0) {
+        os << ";max-dpb=" << max_dpb;
+      }
+
+      if (max_br != 0) {
+        os << ";max-br=" << max_br;
+      }
+    }
+
+    virtual bool CompareEq(const Parameters& other) const override {
+      const auto& otherH264 = static_cast<const H264Parameters&>(other);
+
+      // sprop is not comapred here as it does not get parsed in the rsdparsa
+      return packetization_mode == otherH264.packetization_mode &&
+             level_asymmetry_allowed == otherH264.level_asymmetry_allowed &&
+             profile_level_id == otherH264.profile_level_id &&
+             max_mbps == otherH264.max_mbps && max_fs == otherH264.max_fs &&
+             max_cpb == otherH264.max_cpb && max_dpb == otherH264.max_dpb &&
+             max_br == otherH264.max_br;
+    }
+
+    static const size_t max_sprop_len = 128;
+    char sprop_parameter_sets[max_sprop_len];
+    unsigned int packetization_mode;
+    bool level_asymmetry_allowed;
+    unsigned int profile_level_id;
+    unsigned int max_mbps;
+    unsigned int max_fs;
+    unsigned int max_cpb;
+    unsigned int max_dpb;
+    unsigned int max_br;
+  };
+
+  // Also used for VP9 since they share parameters
+  class VP8Parameters : public Parameters {
+   public:
+    explicit VP8Parameters(SdpRtpmapAttributeList::CodecType type)
+        : Parameters(type), max_fs(0), max_fr(0) {}
+
+    virtual Parameters* Clone() const override {
+      return new VP8Parameters(*this);
+    }
+
+    virtual void Serialize(std::ostream& os) const override {
+      // draft-ietf-payload-vp8-11 says these are mandatory, upper layer
+      // needs to ensure they're set properly.
+      os << "max-fs=" << max_fs;
+      os << ";max-fr=" << max_fr;
+    }
+
+    virtual bool CompareEq(const Parameters& other) const override {
+      const auto& otherVP8 = static_cast<const VP8Parameters&>(other);
+
+      return max_fs == otherVP8.max_fs && max_fr == otherVP8.max_fr;
+    }
+
+    unsigned int max_fs;
+    unsigned int max_fr;
+  };
+
+  class OpusParameters : public Parameters {
+   public:
+    enum {
+      kDefaultMaxPlaybackRate = 48000,
+      kDefaultStereo = 0,
+      kDefaultUseInBandFec = 0,
+      kDefaultMaxAverageBitrate = 0,
+      kDefaultUseDTX = 0,
+      kDefaultFrameSize = 0,
+      kDefaultMinFrameSize = 0,
+      kDefaultMaxFrameSize = 0,
+      kDefaultUseCbr = 0
+    };
+    OpusParameters()
+        : Parameters(SdpRtpmapAttributeList::kOpus),
+          maxplaybackrate(kDefaultMaxPlaybackRate),
+          stereo(kDefaultStereo),
+          useInBandFec(kDefaultUseInBandFec),
+          maxAverageBitrate(kDefaultMaxAverageBitrate),
+          useDTX(kDefaultUseDTX),
+          frameSizeMs(kDefaultFrameSize),
+          minFrameSizeMs(kDefaultMinFrameSize),
+          maxFrameSizeMs(kDefaultMaxFrameSize),
+          useCbr(kDefaultUseCbr) {}
+
+    Parameters* Clone() const override { return new OpusParameters(*this); }
+
+    void Serialize(std::ostream& os) const override {
+      os << "maxplaybackrate=" << maxplaybackrate << ";stereo=" << stereo
+         << ";useinbandfec=" << useInBandFec;
+
+      if (useDTX) {
+        os << ";usedtx=1";
+      }
+      if (maxAverageBitrate) {
+        os << ";maxaveragebitrate=" << maxAverageBitrate;
+      }
+      if (frameSizeMs) {
+        os << ";ptime=" << frameSizeMs;
+      }
+      if (minFrameSizeMs) {
+        os << ";minptime=" << minFrameSizeMs;
+      }
+      if (maxFrameSizeMs) {
+        os << ";maxptime=" << maxFrameSizeMs;
+      }
+      if (useCbr) {
+        os << ";cbr=1";
+      }
+    }
+
+    virtual bool CompareEq(const Parameters& other) const override {
+      const auto& otherOpus = static_cast<const OpusParameters&>(other);
+
+      bool maxplaybackrateIsEq = (maxplaybackrate == otherOpus.maxplaybackrate);
+
+      // This is due to a bug in sipcc that causes maxplaybackrate to
+      // always be 0 if it appears in the fmtp
+      if (((maxplaybackrate == 0) && (otherOpus.maxplaybackrate != 0)) ||
+          ((maxplaybackrate != 0) && (otherOpus.maxplaybackrate == 0))) {
+        maxplaybackrateIsEq = true;
+      }
+
+      return maxplaybackrateIsEq && stereo == otherOpus.stereo &&
+             useInBandFec == otherOpus.useInBandFec &&
+             maxAverageBitrate == otherOpus.maxAverageBitrate &&
+             useDTX == otherOpus.useDTX &&
+             frameSizeMs == otherOpus.frameSizeMs &&
+             minFrameSizeMs == otherOpus.minFrameSizeMs &&
+             maxFrameSizeMs == otherOpus.maxFrameSizeMs &&
+             useCbr == otherOpus.useCbr;
+    }
+
+    unsigned int maxplaybackrate;
+    unsigned int stereo;
+    unsigned int useInBandFec;
+    uint32_t maxAverageBitrate;
+    bool useDTX;
+    uint32_t frameSizeMs;
+    uint32_t minFrameSizeMs;
+    uint32_t maxFrameSizeMs;
+    bool useCbr;
+  };
+
+  class TelephoneEventParameters : public Parameters {
+   public:
+    TelephoneEventParameters()
+        : Parameters(SdpRtpmapAttributeList::kTelephoneEvent),
+          dtmfTones("0-15") {}
+
+    virtual Parameters* Clone() const override {
+      return new TelephoneEventParameters(*this);
+    }
+
+    void Serialize(std::ostream& os) const override { os << dtmfTones; }
+
+    virtual bool CompareEq(const Parameters& other) const override {
+      return dtmfTones ==
+             static_cast<const TelephoneEventParameters&>(other).dtmfTones;
+    }
+
+    std::string dtmfTones;
+  };
+
+  class Fmtp {
+   public:
+    Fmtp(const std::string& aFormat, const Parameters& aParameters)
+        : format(aFormat), parameters(aParameters.Clone()) {}
+
+    // TODO: Rip all of this out when we have move semantics in the stl.
+    Fmtp(const Fmtp& orig) { *this = orig; }
+
+    Fmtp& operator=(const Fmtp& rhs) {
+      if (this != &rhs) {
+        format = rhs.format;
+        parameters.reset(rhs.parameters ? rhs.parameters->Clone() : nullptr);
+      }
+      return *this;
+    }
+
+    bool operator==(const Fmtp& other) const {
+      return format == other.format && *parameters == *other.parameters;
+    }
+
+    // The contract around these is as follows:
+    // * |parameters| is only set if we recognized the media type and had
+    //   a subclass of Parameters to represent that type of parameters
+    // * |parameters| is a best-effort representation; it might be missing
+    //   stuff
+    // * Parameters::codec_type tells you the concrete class, eg
+    //   kH264 -> H264Parameters
+    std::string format;
+    UniquePtr<Parameters> parameters;
+  };
+
+  bool operator==(const SdpFmtpAttributeList& other) const;
+
+  SdpAttribute* Clone() const override {
+    return new SdpFmtpAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  void PushEntry(const std::string& format, const Parameters& parameters) {
+    mFmtps.push_back(Fmtp(format, parameters));
+  }
+
+  std::vector<Fmtp> mFmtps;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=sctpmap, draft-ietf-mmusic-sctp-sdp-05
+//-------------------------------------------------------------------------
+//      sctpmap-attr        =  "a=sctpmap:" sctpmap-number media-subtypes
+// [streams]
+//      sctpmap-number      =  1*DIGIT
+//      protocol            =  labelstring
+//        labelstring         =  text
+//        text                =  byte-string
+//      streams      =  1*DIGIT
+//
+// We're going to pretend that there are spaces where they make sense.
+class SdpSctpmapAttributeList : public SdpAttribute {
+ public:
+  SdpSctpmapAttributeList() : SdpAttribute(kSctpmapAttribute) {}
+
+  struct Sctpmap {
+    std::string pt;
+    std::string name;
+    uint32_t streams;
+  };
+
+  void PushEntry(const std::string& pt, const std::string& name,
+                 uint32_t streams = 0) {
+    Sctpmap value = {pt, name, streams};
+    mSctpmaps.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpSctpmapAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  bool HasEntry(const std::string& pt) const {
+    for (auto it = mSctpmaps.begin(); it != mSctpmaps.end(); ++it) {
+      if (it->pt == pt) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const Sctpmap& GetFirstEntry() const { return mSctpmaps[0]; }
+
+  std::vector<Sctpmap> mSctpmaps;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=setup, RFC4145
+//-------------------------------------------------------------------------
+//       setup-attr           =  "a=setup:" role
+//       role                 =  "active" / "passive" / "actpass" / "holdconn"
+class SdpSetupAttribute : public SdpAttribute {
+ public:
+  enum Role { kActive, kPassive, kActpass, kHoldconn };
+
+  explicit SdpSetupAttribute(Role role)
+      : SdpAttribute(kSetupAttribute), mRole(role) {}
+
+  SdpAttribute* Clone() const override { return new SdpSetupAttribute(*this); }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  Role mRole;
+};
+
+inline std::ostream& operator<<(std::ostream& os, SdpSetupAttribute::Role r) {
+  switch (r) {
+    case SdpSetupAttribute::kActive:
+      os << "active";
+      break;
+    case SdpSetupAttribute::kPassive:
+      os << "passive";
+      break;
+    case SdpSetupAttribute::kActpass:
+      os << "actpass";
+      break;
+    case SdpSetupAttribute::kHoldconn:
+      os << "holdconn";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+// Old draft-04
+// sc-attr     = "a=simulcast:" 1*2( WSP sc-str-list ) [WSP sc-pause-list]
+// sc-str-list = sc-dir WSP sc-id-type "=" sc-alt-list *( ";" sc-alt-list )
+// sc-pause-list = "paused=" sc-alt-list
+// sc-dir      = "send" / "recv"
+// sc-id-type  = "pt" / "rid" / token
+// sc-alt-list = sc-id *( "," sc-id )
+// sc-id       = fmt / rid-identifier / token
+// ; WSP defined in [RFC5234]
+// ; fmt, token defined in [RFC4566]
+// ; rid-identifier defined in [I-D.pthatcher-mmusic-rid]
+//
+// New draft 14, need to parse this for now, will eventually emit it
+// sc-value     = ( sc-send [SP sc-recv] ) / ( sc-recv [SP sc-send] )
+// sc-send      = %s"send" SP sc-str-list
+// sc-recv      = %s"recv" SP sc-str-list
+// sc-str-list  = sc-alt-list *( ";" sc-alt-list )
+// sc-alt-list  = sc-id *( "," sc-id )
+// sc-id-paused = "~"
+// sc-id        = [sc-id-paused] rid-id
+// ; SP defined in [RFC5234]
+// ; rid-id defined in [I-D.ietf-mmusic-rid]
+
+class SdpSimulcastAttribute : public SdpAttribute {
+ public:
+  SdpSimulcastAttribute() : SdpAttribute(kSimulcastAttribute) {}
+
+  SdpAttribute* Clone() const override {
+    return new SdpSimulcastAttribute(*this);
+  }
+
+  void Serialize(std::ostream& os) const override;
+  bool Parse(std::istream& is, std::string* error);
+
+  class Encoding {
+   public:
+    Encoding(const std::string& aRid, bool aPaused)
+        : rid(aRid), paused(aPaused) {}
+    std::string rid;
+    bool paused = false;
+  };
+
+  class Version {
+   public:
+    void Serialize(std::ostream& os) const;
+    bool IsSet() const { return !choices.empty(); }
+    bool Parse(std::istream& is, std::string* error);
+
+    std::vector<Encoding> choices;
+  };
+
+  class Versions : public std::vector<Version> {
+   public:
+    void Serialize(std::ostream& os) const;
+    bool IsSet() const {
+      if (empty()) {
+        return false;
+      }
+
+      for (const Version& version : *this) {
+        if (version.IsSet()) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    bool Parse(std::istream& is, std::string* error);
+  };
+
+  Versions sendVersions;
+  Versions recvVersions;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=ssrc, RFC5576
+//-------------------------------------------------------------------------
+// ssrc-attr = "ssrc:" ssrc-id SP attribute
+// ; The base definition of "attribute" is in RFC 4566.
+// ; (It is the content of "a=" lines.)
+//
+// ssrc-id = integer ; 0 .. 2**32 - 1
+//-------------------------------------------------------------------------
+// TODO -- In the future, it might be nice if we ran a parse on the
+// attribute section of this so that we could interpret it semantically.
+// For WebRTC, the key use case for a=ssrc is assocaiting SSRCs with
+// media sections, and we're not really going to care about the attribute
+// itself. So we're just going to store it as a string for the time being.
+// Issue 187.
+class SdpSsrcAttributeList : public SdpAttribute {
+ public:
+  SdpSsrcAttributeList() : SdpAttribute(kSsrcAttribute) {}
+
+  struct Ssrc {
+    uint32_t ssrc;
+    std::string attribute;
+  };
+
+  void PushEntry(uint32_t ssrc, const std::string& attribute) {
+    Ssrc value = {ssrc, attribute};
+    mSsrcs.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpSsrcAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<Ssrc> mSsrcs;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=ssrc-group, RFC5576
+//-------------------------------------------------------------------------
+// ssrc-group-attr = "ssrc-group:" semantics *(SP ssrc-id)
+//
+// semantics       = "FEC" / "FID" / token
+//
+// ssrc-id = integer ; 0 .. 2**32 - 1
+class SdpSsrcGroupAttributeList : public SdpAttribute {
+ public:
+  enum Semantics {
+    kFec,    // RFC5576
+    kFid,    // RFC5576
+    kFecFr,  // RFC5956
+    kDup,    // RFC7104
+    kSim     // non-standard, used by hangouts
+  };
+
+  struct SsrcGroup {
+    Semantics semantics;
+    std::vector<uint32_t> ssrcs;
+  };
+
+  SdpSsrcGroupAttributeList() : SdpAttribute(kSsrcGroupAttribute) {}
+
+  void PushEntry(Semantics semantics, const std::vector<uint32_t>& ssrcs) {
+    SsrcGroup value = {semantics, ssrcs};
+    mSsrcGroups.push_back(value);
+  }
+
+  SdpAttribute* Clone() const override {
+    return new SdpSsrcGroupAttributeList(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<SsrcGroup> mSsrcGroups;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+                                SdpSsrcGroupAttributeList::Semantics s) {
+  switch (s) {
+    case SdpSsrcGroupAttributeList::kFec:
+      os << "FEC";
+      break;
+    case SdpSsrcGroupAttributeList::kFid:
+      os << "FID";
+      break;
+    case SdpSsrcGroupAttributeList::kFecFr:
+      os << "FEC-FR";
+      break;
+    case SdpSsrcGroupAttributeList::kDup:
+      os << "DUP";
+      break;
+    case SdpSsrcGroupAttributeList::kSim:
+      os << "SIM";
+      break;
+    default:
+      MOZ_ASSERT(false);
+      os << "?";
+  }
+  return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+class SdpMultiStringAttribute : public SdpAttribute {
+ public:
+  explicit SdpMultiStringAttribute(AttributeType type) : SdpAttribute(type) {}
+
+  void PushEntry(const std::string& entry) { mValues.push_back(entry); }
+
+  SdpAttribute* Clone() const override {
+    return new SdpMultiStringAttribute(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<std::string> mValues;
+};
+
+// otherwise identical to SdpMultiStringAttribute, this is used for
+// ice-options and other places where the value is serialized onto
+// a single line with space separating tokens
+class SdpOptionsAttribute : public SdpAttribute {
+ public:
+  explicit SdpOptionsAttribute(AttributeType type) : SdpAttribute(type) {}
+
+  void PushEntry(const std::string& entry) { mValues.push_back(entry); }
+
+  void Load(const std::string& value);
+
+  SdpAttribute* Clone() const override {
+    return new SdpOptionsAttribute(*this);
+  }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::vector<std::string> mValues;
+};
+
+// Used for attributes that take no value (eg; a=ice-lite)
+class SdpFlagAttribute : public SdpAttribute {
+ public:
+  explicit SdpFlagAttribute(AttributeType type) : SdpAttribute(type) {}
+
+  SdpAttribute* Clone() const override { return new SdpFlagAttribute(*this); }
+
+  virtual void Serialize(std::ostream& os) const override;
+};
+
+// Used for any other kind of single-valued attribute not otherwise specialized
+class SdpStringAttribute : public SdpAttribute {
+ public:
+  explicit SdpStringAttribute(AttributeType type, const std::string& value)
+      : SdpAttribute(type), mValue(value) {}
+
+  SdpAttribute* Clone() const override { return new SdpStringAttribute(*this); }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  std::string mValue;
+};
+
+// Used for any purely (non-negative) numeric attribute
+class SdpNumberAttribute : public SdpAttribute {
+ public:
+  explicit SdpNumberAttribute(AttributeType type, uint32_t value = 0)
+      : SdpAttribute(type), mValue(value) {}
+
+  SdpAttribute* Clone() const override { return new SdpNumberAttribute(*this); }
+
+  virtual void Serialize(std::ostream& os) const override;
+
+  uint32_t mValue;
+};
+
+}  // namespace mozilla
+
+#endif