Add m-esr52 at 52.6.0

15 files changed, 18882 insertions, 0 deletions

diff --git a/media/webrtc/signaling/test/FakeIPC.cpp b/media/webrtc/signaling/test/FakeIPC.cpp
new file mode 100644
index 000000000..767082c29
--- /dev/null
+++ b/media/webrtc/signaling/test/FakeIPC.cpp
@@ -0,0 +1,35 @@
+/* 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/. */
+
+#include "FakeIPC.h"
+#include <unistd.h>
+
+// The implementations can't be in the .h file for some annoying reason
+
+/* static */ void
+PlatformThread:: YieldCurrentThread()
+{
+  sleep(1);
+}
+
+namespace base {
+
+void AtExitManager::RegisterCallback(AtExitCallbackType func, void* param)
+{
+}
+
+}
+
+// see atomicops_internals_x86_gcc.h
+// This cheats to get the unittests to build
+
+struct AtomicOps_x86CPUFeatureStruct {
+  bool field1;
+  bool field2;
+};
+
+struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures = {
+  false,
+  false,
+};
diff --git a/media/webrtc/signaling/test/FakeIPC.h b/media/webrtc/signaling/test/FakeIPC.h
new file mode 100644
index 000000000..e13fc271d
--- /dev/null
+++ b/media/webrtc/signaling/test/FakeIPC.h
@@ -0,0 +1,22 @@
+/* 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 FAKE_IPC_H_
+#define FAKE_IPC_H_
+#include <unistd.h>
+
+class PlatformThread {
+public:
+  static void YieldCurrentThread();
+};
+
+namespace base {
+class AtExitManager {
+public:
+  typedef void (*AtExitCallbackType)(void*);
+
+  static void RegisterCallback(AtExitCallbackType func, void* param);
+};
+}
+#endif
diff --git a/media/webrtc/signaling/test/FakeLogging.h b/media/webrtc/signaling/test/FakeLogging.h
new file mode 100644
index 000000000..2620ddd01
--- /dev/null
+++ b/media/webrtc/signaling/test/FakeLogging.h
@@ -0,0 +1,26 @@
+/* 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 FakeLogging_h
+#define FakeLogging_h
+
+namespace mozilla {
+namespace detail {
+void log_print(const PRLogModuleInfo* aModule,
+                      LogLevel aLevel,
+                      const char* aFmt, ...)
+  {
+    // copied from Logging.cpp:#48-53
+    va_list ap;
+    va_start(ap, aFmt);
+    char* buff = PR_vsmprintf(aFmt, ap);
+    PR_LogPrint("%s", buff);
+    PR_smprintf_free(buff);
+    va_end(ap);
+  }
+
+}
+}
+
+#endif
diff --git a/media/webrtc/signaling/test/FakeMediaStreams.h b/media/webrtc/signaling/test/FakeMediaStreams.h
new file mode 100644
index 000000000..117d26905
--- /dev/null
+++ b/media/webrtc/signaling/test/FakeMediaStreams.h
@@ -0,0 +1,656 @@
+/* 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 FAKE_MEDIA_STREAM_H_
+#define FAKE_MEDIA_STREAM_H_
+
+#include <set>
+#include <string>
+#include <sstream>
+#include <vector>
+
+#include "nsNetCID.h"
+#include "nsITimer.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIComponentManager.h"
+#include "nsIComponentRegistrar.h"
+#include "nsISupportsImpl.h"
+#include "nsServiceManagerUtils.h"
+
+// #includes from MediaStream.h
+#include "mozilla/Mutex.h"
+#include "AudioSegment.h"
+#include "MediaSegment.h"
+#include "StreamTracks.h"
+#include "VideoSegment.h"
+#include "nsTArray.h"
+#include "nsIRunnable.h"
+#include "nsISupportsImpl.h"
+
+class nsPIDOMWindowInner;
+
+namespace mozilla {
+   class MediaStreamGraphImpl;
+   class MediaSegment;
+   class PeerConnectionImpl;
+   class PeerConnectionMedia;
+   class RemoteSourceStreamInfo;
+};
+
+
+namespace mozilla {
+
+class MediaStreamGraph;
+
+static MediaStreamGraph* gGraph;
+
+struct AudioChannel {
+  enum {
+    Normal
+  };
+};
+
+enum MediaStreamGraphEvent : uint32_t;
+enum TrackEventCommand : uint32_t;
+
+class MediaStreamGraph {
+public:
+  // Keep this in sync with the enum in MediaStreamGraph.h
+  enum GraphDriverType {
+    AUDIO_THREAD_DRIVER,
+    SYSTEM_THREAD_DRIVER,
+    OFFLINE_THREAD_DRIVER
+  };
+  static MediaStreamGraph* GetInstance(GraphDriverType aDriverType,
+                                       uint32_t aType) {
+    if (gGraph) {
+      return gGraph;
+    }
+    gGraph = new MediaStreamGraph();
+    return gGraph;
+  }
+};
+}
+
+class Fake_VideoSink {
+public:
+  Fake_VideoSink() {}
+  virtual void SegmentReady(mozilla::MediaSegment* aSegment) = 0;
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Fake_VideoSink)
+protected:
+  virtual ~Fake_VideoSink() {}
+};
+
+class Fake_MediaStream;
+class Fake_SourceMediaStream;
+
+class Fake_MediaStreamListener
+{
+protected:
+  virtual ~Fake_MediaStreamListener() {}
+
+public:
+  virtual void NotifyQueuedTrackChanges(mozilla::MediaStreamGraph* aGraph, mozilla::TrackID aID,
+                                        mozilla::StreamTime aTrackOffset,
+                                        mozilla::TrackEventCommand  aTrackEvents,
+                                        const mozilla::MediaSegment& aQueuedMedia,
+                                        Fake_MediaStream* aInputStream,
+                                        mozilla::TrackID aInputTrackID) {}
+  virtual void NotifyPull(mozilla::MediaStreamGraph* aGraph, mozilla::StreamTime aDesiredTime) = 0;
+  virtual void NotifyQueuedAudioData(mozilla::MediaStreamGraph* aGraph, mozilla::TrackID aID,
+                                       mozilla::StreamTime aTrackOffset,
+                                       const mozilla::AudioSegment& aQueuedMedia,
+                                       Fake_MediaStream* aInputStream,
+                                       mozilla::TrackID aInputTrackID) {}
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Fake_MediaStreamListener)
+};
+
+class Fake_DirectMediaStreamListener : public Fake_MediaStreamListener
+{
+protected:
+  virtual ~Fake_DirectMediaStreamListener() {}
+
+public:
+  virtual void NotifyRealtimeData(mozilla::MediaStreamGraph* graph, mozilla::TrackID tid,
+                                  mozilla::StreamTime offset,
+                                  const mozilla::MediaSegment& media) = 0;
+};
+
+class Fake_MediaStreamTrackListener
+{
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Fake_MediaStreamTrackListener)
+
+protected:
+  virtual ~Fake_MediaStreamTrackListener() {}
+
+public:
+  virtual void NotifyQueuedChanges(mozilla::MediaStreamGraph* aGraph,
+                                   mozilla::StreamTime aTrackOffset,
+                                   const mozilla::MediaSegment& aQueuedMedia) = 0;
+};
+
+class Fake_DirectMediaStreamTrackListener : public Fake_MediaStreamTrackListener
+{
+protected:
+  virtual ~Fake_DirectMediaStreamTrackListener() {}
+
+public:
+  virtual void NotifyRealtimeTrackData(mozilla::MediaStreamGraph* aGraph,
+                                       mozilla::StreamTime aTrackOffset,
+                                       const mozilla::MediaSegment& aMedia) = 0;
+  enum class InstallationResult {
+    STREAM_NOT_SUPPORTED,
+    SUCCESS
+  };
+  virtual void NotifyDirectListenerInstalled(InstallationResult aResult) = 0;
+  virtual void NotifyDirectListenerUninstalled() = 0;
+};
+
+class Fake_MediaStreamVideoSink : public Fake_DirectMediaStreamTrackListener{
+public:
+  Fake_MediaStreamVideoSink() {}
+
+  void NotifyQueuedChanges(mozilla::MediaStreamGraph* aGraph,
+                           mozilla::StreamTime aTrackOffset,
+                           const mozilla::MediaSegment& aQueuedMedia) override {}
+
+  void NotifyRealtimeTrackData(mozilla::MediaStreamGraph* aGraph,
+                               mozilla::StreamTime aTrackOffset,
+                               const mozilla::MediaSegment& aMedia) override {}
+  void NotifyDirectListenerInstalled(InstallationResult aResult) override {}
+  void NotifyDirectListenerUninstalled() override {}
+
+  virtual void SetCurrentFrames(const mozilla::VideoSegment& aSegment) {};
+  virtual void ClearFrames() {};
+
+protected:
+  virtual ~Fake_MediaStreamVideoSink() {}
+};
+
+// Note: only one listener supported
+class Fake_MediaStream {
+ protected:
+  virtual ~Fake_MediaStream() { Stop(); }
+
+  struct BoundTrackListener
+  {
+    BoundTrackListener(Fake_MediaStreamTrackListener* aListener,
+                       mozilla::TrackID aTrackID)
+      : mListener(aListener), mTrackID(aTrackID) {}
+    RefPtr<Fake_MediaStreamTrackListener> mListener;
+    mozilla::TrackID mTrackID;
+  };
+
+ public:
+  Fake_MediaStream () : mListeners(), mTrackListeners(), mMutex("Fake MediaStream") {}
+
+  static uint32_t GraphRate() { return 16000; }
+
+  void AddListener(Fake_MediaStreamListener *aListener) {
+    mozilla::MutexAutoLock lock(mMutex);
+    mListeners.insert(aListener);
+  }
+
+  void RemoveListener(Fake_MediaStreamListener *aListener) {
+    mozilla::MutexAutoLock lock(mMutex);
+    mListeners.erase(aListener);
+  }
+
+  void AddTrackListener(Fake_MediaStreamTrackListener *aListener,
+                        mozilla::TrackID aTrackID) {
+    mozilla::MutexAutoLock lock(mMutex);
+    mTrackListeners.push_back(BoundTrackListener(aListener, aTrackID));
+  }
+
+  void RemoveTrackListener(Fake_MediaStreamTrackListener *aListener,
+                           mozilla::TrackID aTrackID) {
+    mozilla::MutexAutoLock lock(mMutex);
+    for (std::vector<BoundTrackListener>::iterator it = mTrackListeners.begin();
+         it != mTrackListeners.end(); ++it) {
+      if (it->mListener == aListener && it->mTrackID == aTrackID) {
+        mTrackListeners.erase(it);
+        return;
+      }
+    }
+  }
+
+  void NotifyPull(mozilla::MediaStreamGraph* graph,
+                  mozilla::StreamTime aDesiredTime) {
+
+    mozilla::MutexAutoLock lock(mMutex);
+    std::set<RefPtr<Fake_MediaStreamListener>>::iterator it;
+    for (it = mListeners.begin(); it != mListeners.end(); ++it) {
+      (*it)->NotifyPull(graph, aDesiredTime);
+    }
+  }
+
+  virtual Fake_SourceMediaStream *AsSourceStream() { return nullptr; }
+
+  virtual mozilla::MediaStreamGraphImpl *GraphImpl() { return nullptr; }
+  virtual nsresult Start() { return NS_OK; }
+  virtual nsresult Stop() { return NS_OK; }
+  virtual void StopStream() {}
+
+  virtual void Periodic() {}
+
+  double StreamTimeToSeconds(mozilla::StreamTime aTime);
+  mozilla::StreamTime
+  TicksToTimeRoundDown(mozilla::TrackRate aRate, mozilla::TrackTicks aTicks);
+  mozilla::TrackTicks TimeToTicksRoundUp(mozilla::TrackRate aRate,
+                                         mozilla::StreamTime aTime);
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Fake_MediaStream);
+
+ protected:
+  std::set<RefPtr<Fake_MediaStreamListener>> mListeners;
+  std::vector<BoundTrackListener> mTrackListeners;
+  mozilla::Mutex mMutex;  // Lock to prevent the listener list from being modified while
+                          // executing Periodic().
+};
+
+class Fake_MediaPeriodic : public nsITimerCallback {
+public:
+  explicit Fake_MediaPeriodic(Fake_MediaStream *aStream) : mStream(aStream),
+                                                           mCount(0) {}
+  void Detach() {
+    mStream = nullptr;
+  }
+
+  int GetTimesCalled() { return mCount; }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSITIMERCALLBACK
+
+protected:
+  virtual ~Fake_MediaPeriodic() {}
+
+  Fake_MediaStream *mStream;
+  int mCount;
+};
+
+
+class Fake_SourceMediaStream : public Fake_MediaStream {
+ public:
+  Fake_SourceMediaStream() : mSegmentsAdded(0),
+                             mDesiredTime(0),
+                             mPullEnabled(false),
+                             mStop(false),
+                             mPeriodic(new Fake_MediaPeriodic(this)) {}
+
+  enum {
+    ADDTRACK_QUEUED    = 0x01 // Queue track add until FinishAddTracks()
+  };
+
+  void AddVideoSink(const RefPtr<Fake_VideoSink>& aSink) {
+    mSink  = aSink;
+  }
+
+  void AddTrack(mozilla::TrackID aID, mozilla::StreamTime aStart,
+                mozilla::MediaSegment* aSegment, uint32_t aFlags = 0) {
+    delete aSegment;
+  }
+  void AddAudioTrack(mozilla::TrackID aID, mozilla::TrackRate aRate, mozilla::StreamTime aStart,
+                     mozilla::AudioSegment* aSegment, uint32_t aFlags = 0) {
+    delete aSegment;
+  }
+  void FinishAddTracks() {}
+  void EndTrack(mozilla::TrackID aID) {}
+
+  bool AppendToTrack(mozilla::TrackID aID, mozilla::MediaSegment* aSegment,
+                     mozilla::MediaSegment *aRawSegment) {
+    return AppendToTrack(aID, aSegment);
+  }
+
+  bool AppendToTrack(mozilla::TrackID aID, mozilla::MediaSegment* aSegment) {
+    bool nonZeroSample = false;
+    MOZ_ASSERT(aSegment);
+    if(aSegment->GetType() == mozilla::MediaSegment::AUDIO) {
+      //On audio segment append, we verify for validity
+      //of the audio samples.
+      mozilla::AudioSegment* audio =
+              static_cast<mozilla::AudioSegment*>(aSegment);
+      mozilla::AudioSegment::ChunkIterator iter(*audio);
+      while(!iter.IsEnded()) {
+        mozilla::AudioChunk& chunk = *(iter);
+        MOZ_ASSERT(chunk.mBuffer);
+        const int16_t* buf =
+          static_cast<const int16_t*>(chunk.mChannelData[0]);
+        for(int i=0; i<chunk.mDuration; i++) {
+          if(buf[i]) {
+            //atleast one non-zero sample found.
+            nonZeroSample = true;
+            break;
+          }
+        }
+        //process next chunk
+        iter.Next();
+      }
+      if(nonZeroSample) {
+          //we increment segments count if
+          //atleast one non-zero samples was found.
+          ++mSegmentsAdded;
+      }
+    } else {
+      //in the case of video segment appended, we just increase the
+      //segment count.
+      if (mSink.get()) {
+        mSink->SegmentReady(aSegment);
+      }
+      ++mSegmentsAdded;
+    }
+    return true;
+  }
+
+  void AdvanceKnownTracksTime(mozilla::StreamTime aKnownTime) {}
+
+  void SetPullEnabled(bool aEnabled) {
+    mPullEnabled = aEnabled;
+  }
+  void AddDirectListener(Fake_MediaStreamListener* aListener) {}
+  void RemoveDirectListener(Fake_MediaStreamListener* aListener) {}
+
+  //Don't pull anymore data,if mStop is true.
+  virtual void StopStream() {
+   mStop = true;
+  }
+
+  virtual Fake_SourceMediaStream *AsSourceStream() { return this; }
+
+  virtual nsresult Start();
+  virtual nsresult Stop();
+
+  virtual void Periodic();
+
+  virtual int GetSegmentsAdded() {
+    return mSegmentsAdded;
+  }
+
+ protected:
+  int mSegmentsAdded;
+  uint64_t mDesiredTime;
+  bool mPullEnabled;
+  bool mStop;
+  RefPtr<Fake_MediaPeriodic> mPeriodic;
+  RefPtr<Fake_VideoSink> mSink;
+  nsCOMPtr<nsITimer> mTimer;
+};
+
+class Fake_DOMMediaStream;
+
+class Fake_MediaStreamTrackSource
+{
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Fake_MediaStreamTrackSource)
+
+protected:
+  virtual ~Fake_MediaStreamTrackSource() {}
+};
+
+class Fake_MediaStreamTrack
+{
+  friend class mozilla::PeerConnectionImpl;
+  friend class mozilla::PeerConnectionMedia;
+  friend class mozilla::RemoteSourceStreamInfo;
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Fake_MediaStreamTrack)
+
+  Fake_MediaStreamTrack(bool aIsVideo, Fake_DOMMediaStream* aOwningStream) :
+    mIsVideo (aIsVideo),
+    mOwningStream (aOwningStream),
+    mTrackID(mIsVideo ? 1 : 0)
+  {
+    static size_t counter = 0;
+    std::ostringstream os;
+    os << counter++;
+    mID = os.str();
+  }
+
+  std::string GetId() const { return mID; }
+  void AssignId(const std::string& id) { mID = id; }
+  mozilla::MediaStreamGraphImpl* GraphImpl() { return nullptr; }
+  const Fake_MediaStreamTrack* AsVideoStreamTrack() const
+  {
+    return mIsVideo? this : nullptr;
+  }
+  const Fake_MediaStreamTrack* AsAudioStreamTrack() const
+  {
+    return mIsVideo? nullptr : this;
+  }
+  uint32_t typeSize () const
+  {
+    return sizeof(Fake_MediaStreamTrack);
+  }
+  const char* typeName () const
+  {
+    return "Fake_MediaStreamTrack";
+  }
+  void AddListener(Fake_MediaStreamTrackListener *aListener);
+  void RemoveListener(Fake_MediaStreamTrackListener *aListener);
+  void AddDirectListener(Fake_DirectMediaStreamTrackListener *aListener)
+  {
+    AddListener(aListener);
+    aListener->NotifyDirectListenerInstalled(
+      Fake_DirectMediaStreamTrackListener::InstallationResult::STREAM_NOT_SUPPORTED);
+  }
+  void RemoveDirectListener(Fake_DirectMediaStreamTrackListener *aListener)
+  {
+    RemoveListener(aListener);
+  }
+
+  class PrincipalChangeObserver
+  {
+  public:
+    virtual void PrincipalChanged(Fake_MediaStreamTrack* aMediaStreamTrack) = 0;
+  };
+  void AddPrincipalChangeObserver(void* ignoredObserver) {}
+  void RemovePrincipalChangeObserver(void* ignoredObserver) {}
+
+private:
+  ~Fake_MediaStreamTrack() {}
+
+  const bool mIsVideo;
+  Fake_DOMMediaStream* mOwningStream;
+  mozilla::TrackID mTrackID;
+  std::string mID;
+};
+
+class Fake_DOMMediaStream : public nsISupports
+{
+  friend class mozilla::PeerConnectionMedia;
+protected:
+  virtual ~Fake_DOMMediaStream() {
+    // Note: memory leak
+    mMediaStream->Stop();
+  }
+
+public:
+  explicit Fake_DOMMediaStream(Fake_MediaStream *stream = nullptr)
+    : mMediaStream(stream ? stream : new Fake_MediaStream())
+    , mVideoTrack(new Fake_MediaStreamTrack(true, this))
+    , mAudioTrack(new Fake_MediaStreamTrack(false, this))
+    {
+      static size_t counter = 0;
+      std::ostringstream os;
+      os << counter++;
+      mID = os.str();
+    }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  static already_AddRefed<Fake_DOMMediaStream>
+  CreateSourceStreamAsInput(nsPIDOMWindowInner* aWindow,
+                            mozilla::MediaStreamGraph* aGraph,
+                            uint32_t aHintContents = 0) {
+    Fake_SourceMediaStream *source = new Fake_SourceMediaStream();
+
+    RefPtr<Fake_DOMMediaStream> ds = new Fake_DOMMediaStream(source);
+    ds->SetHintContents(aHintContents);
+
+    return ds.forget();
+  }
+
+  virtual void Stop() {} // Really DOMLocalMediaStream
+
+  virtual bool AddDirectListener(Fake_MediaStreamListener *aListener) { return false; }
+  virtual void RemoveDirectListener(Fake_MediaStreamListener *aListener) {}
+
+  Fake_MediaStream *GetInputStream() { return mMediaStream; }
+  Fake_MediaStream *GetOwnedStream() { return mMediaStream; }
+  Fake_MediaStream *GetPlaybackStream() { return mMediaStream; }
+  Fake_MediaStream *GetStream() { return mMediaStream; }
+  std::string GetId() const { return mID; }
+  void AssignId(const std::string& id) { mID = id; }
+  Fake_MediaStreamTrack* GetTrackById(const std::string& aId)
+  {
+    if (mHintContents & HINT_CONTENTS_AUDIO) {
+      if (mAudioTrack && mAudioTrack->GetId() == aId) {
+        return mAudioTrack;
+      }
+    }
+    if (mHintContents & HINT_CONTENTS_VIDEO) {
+      if (mVideoTrack && mVideoTrack->GetId() == aId) {
+        return mVideoTrack;
+      }
+    }
+    return nullptr;
+  }
+  Fake_MediaStreamTrack* GetOwnedTrackById(const std::string& aId)
+  {
+    return GetTrackById(aId);
+  }
+
+  // Hints to tell the SDP generator about whether this
+  // MediaStream probably has audio and/or video
+  typedef uint8_t TrackTypeHints;
+  enum {
+    HINT_CONTENTS_AUDIO = 0x01,
+    HINT_CONTENTS_VIDEO = 0x02
+  };
+  uint32_t GetHintContents() const { return mHintContents; }
+  void SetHintContents(uint32_t aHintContents) { mHintContents = aHintContents; }
+
+  void
+  GetTracks(nsTArray<RefPtr<Fake_MediaStreamTrack> >& aTracks)
+  {
+    GetAudioTracks(aTracks);
+    GetVideoTracks(aTracks);
+  }
+
+  void GetAudioTracks(nsTArray<RefPtr<Fake_MediaStreamTrack> >& aTracks)
+  {
+    if (mHintContents & HINT_CONTENTS_AUDIO) {
+      aTracks.AppendElement(mAudioTrack);
+    }
+  }
+
+  void
+  GetVideoTracks(nsTArray<RefPtr<Fake_MediaStreamTrack> >& aTracks)
+  {
+    if (mHintContents & HINT_CONTENTS_VIDEO) {
+      aTracks.AppendElement(mVideoTrack);
+    }
+  }
+
+  bool
+  HasTrack(const Fake_MediaStreamTrack& aTrack) const
+  {
+    return ((mHintContents & HINT_CONTENTS_AUDIO) && aTrack.AsAudioStreamTrack()) ||
+           ((mHintContents & HINT_CONTENTS_VIDEO) && aTrack.AsVideoStreamTrack());
+  }
+
+  bool
+  OwnsTrack(const Fake_MediaStreamTrack& aTrack) const
+  {
+    return HasTrack(aTrack);
+  }
+
+  void SetTrackEnabled(mozilla::TrackID aTrackID, bool aEnabled) {}
+
+  void AddTrackInternal(Fake_MediaStreamTrack* aTrack) {}
+
+  already_AddRefed<Fake_MediaStreamTrack>
+  CreateDOMTrack(mozilla::TrackID aTrackID, mozilla::MediaSegment::Type aType,
+                 Fake_MediaStreamTrackSource* aSource)
+  {
+    switch(aType) {
+      case mozilla::MediaSegment::AUDIO: {
+        return do_AddRef(mAudioTrack);
+      }
+      case mozilla::MediaSegment::VIDEO: {
+        return do_AddRef(mVideoTrack);
+      }
+      default: {
+        MOZ_CRASH("Unkown media type");
+      }
+    }
+  }
+
+private:
+  RefPtr<Fake_MediaStream> mMediaStream;
+
+  // tells the SDP generator about whether this
+  // MediaStream probably has audio and/or video
+  uint32_t mHintContents;
+  RefPtr<Fake_MediaStreamTrack> mVideoTrack;
+  RefPtr<Fake_MediaStreamTrack> mAudioTrack;
+
+  std::string mID;
+};
+
+class Fake_MediaStreamBase : public Fake_MediaStream {
+ public:
+  Fake_MediaStreamBase() : mPeriodic(new Fake_MediaPeriodic(this)) {}
+
+  virtual nsresult Start();
+  virtual nsresult Stop();
+
+  virtual int GetSegmentsAdded() {
+    return mPeriodic->GetTimesCalled();
+  }
+
+ private:
+  nsCOMPtr<nsITimer> mTimer;
+  RefPtr<Fake_MediaPeriodic> mPeriodic;
+};
+
+
+class Fake_AudioStreamSource : public Fake_MediaStreamBase {
+ public:
+  Fake_AudioStreamSource() : Fake_MediaStreamBase(),
+                             mCount(0),
+                             mStop(false) {}
+  //Signaling Agent indicates us to stop generating
+  //further audio.
+  void StopStream() {
+    mStop = true;
+  }
+  virtual void Periodic();
+  int mCount;
+  bool mStop;
+};
+
+class Fake_VideoStreamSource : public Fake_MediaStreamBase {
+ public:
+  Fake_VideoStreamSource() : Fake_MediaStreamBase() {}
+};
+
+
+namespace mozilla {
+typedef Fake_MediaStream MediaStream;
+typedef Fake_SourceMediaStream SourceMediaStream;
+typedef Fake_MediaStreamListener MediaStreamListener;
+typedef Fake_DirectMediaStreamListener DirectMediaStreamListener;
+typedef Fake_MediaStreamTrackListener MediaStreamTrackListener;
+typedef Fake_DirectMediaStreamTrackListener DirectMediaStreamTrackListener;
+typedef Fake_DOMMediaStream DOMMediaStream;
+typedef Fake_DOMMediaStream DOMLocalMediaStream;
+typedef Fake_MediaStreamVideoSink MediaStreamVideoSink;
+
+namespace dom {
+typedef Fake_MediaStreamTrack MediaStreamTrack;
+typedef Fake_MediaStreamTrackSource MediaStreamTrackSource;
+}
+}
+
+#endif
diff --git a/media/webrtc/signaling/test/FakeMediaStreamsImpl.h b/media/webrtc/signaling/test/FakeMediaStreamsImpl.h
new file mode 100644
index 000000000..da0e81416
--- /dev/null
+++ b/media/webrtc/signaling/test/FakeMediaStreamsImpl.h
@@ -0,0 +1,236 @@
+/* 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 FAKE_MEDIA_STREAMIMPL_H_
+#define FAKE_MEDIA_STREAMIMPL_H_
+
+#include "FakeMediaStreams.h"
+
+#include "nspr.h"
+#include "nsError.h"
+
+void LogTime(AsyncLatencyLogger::LatencyLogIndex index, uint64_t b, int64_t c) {}
+void LogLatency(AsyncLatencyLogger::LatencyLogIndex index, uint64_t b, int64_t c) {}
+
+static const int AUDIO_BUFFER_SIZE = 1600;
+static const int NUM_CHANNELS      = 2;
+static const int GRAPH_RATE        = 16000;
+
+NS_IMPL_ISUPPORTS0(Fake_DOMMediaStream)
+
+// Fake_MediaStream
+double Fake_MediaStream::StreamTimeToSeconds(mozilla::StreamTime aTime) {
+  return static_cast<double>(aTime)/GRAPH_RATE;
+}
+
+mozilla::TrackTicks Fake_MediaStream::TimeToTicksRoundUp(mozilla::TrackRate aRate,
+                                                         mozilla::StreamTime aTime) {
+  return (aTime * aRate) / GRAPH_RATE;
+}
+
+mozilla::StreamTime
+Fake_MediaStream::TicksToTimeRoundDown(mozilla::TrackRate aRate,
+                                       mozilla::TrackTicks aTicks) {
+  return aTicks * GRAPH_RATE / aRate;
+}
+
+// Fake_SourceMediaStream
+nsresult Fake_SourceMediaStream::Start() {
+  mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+  if (!mTimer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mTimer->InitWithCallback(mPeriodic, 100, nsITimer::TYPE_REPEATING_SLACK);
+
+  return NS_OK;
+}
+
+nsresult Fake_SourceMediaStream::Stop() {
+  mozilla::MutexAutoLock lock(mMutex);
+  if (mTimer)
+    mTimer->Cancel();
+  mPeriodic->Detach();
+  return NS_OK;
+}
+
+void Fake_SourceMediaStream::Periodic() {
+  mozilla::MutexAutoLock lock(mMutex);
+  // Pull more audio-samples iff pulling is enabled
+  // and we are not asked by the signaling agent to stop
+  //pulling data.
+  if (mPullEnabled && !mStop) {
+    // 100 ms matches timer interval and AUDIO_BUFFER_SIZE @ 16000 Hz
+    mDesiredTime += 100;
+    for (std::set<RefPtr<Fake_MediaStreamListener>>::iterator it =
+             mListeners.begin(); it != mListeners.end(); ++it) {
+      (*it)->NotifyPull(nullptr, TicksToTimeRoundDown(1000 /* ms per s */,
+                                                      mDesiredTime));
+    }
+  }
+}
+
+// Fake_MediaStreamTrack
+void Fake_MediaStreamTrack::AddListener(Fake_MediaStreamTrackListener *aListener)
+{
+  mOwningStream->GetInputStream()->AddTrackListener(aListener, mTrackID);
+}
+void Fake_MediaStreamTrack::RemoveListener(Fake_MediaStreamTrackListener *aListener)
+{
+  mOwningStream->GetInputStream()->RemoveTrackListener(aListener, mTrackID);
+}
+
+// Fake_MediaStreamBase
+nsresult Fake_MediaStreamBase::Start() {
+  mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+  if (!mTimer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mTimer->InitWithCallback(mPeriodic, 100, nsITimer::TYPE_REPEATING_SLACK);
+
+  return NS_OK;
+}
+
+nsresult Fake_MediaStreamBase::Stop() {
+  // Lock the mutex so that we know that after this
+  // has returned, periodic will not be firing again
+  // and so it's safe to destruct.
+  mozilla::MutexAutoLock lock(mMutex);
+  mTimer->Cancel();
+
+  return NS_OK;
+}
+
+// Fake_AudioStreamSource
+void Fake_AudioStreamSource::Periodic() {
+  mozilla::MutexAutoLock lock(mMutex);
+  //Are we asked to stop pumping audio samples ?
+  if(mStop) {
+    return;
+  }
+  //Generate Signed 16 Bit Audio samples
+  RefPtr<mozilla::SharedBuffer> samples =
+    mozilla::SharedBuffer::Create(AUDIO_BUFFER_SIZE * NUM_CHANNELS * sizeof(int16_t));
+  int16_t* data = reinterpret_cast<int16_t *>(samples->Data());
+  for(int i=0; i<(1600*2); i++) {
+    //saw tooth audio sample
+    data[i] = ((mCount % 8) * 4000) - (7*4000)/2;
+    mCount++;
+  }
+
+  mozilla::AudioSegment segment;
+  AutoTArray<const int16_t *,1> channels;
+  channels.AppendElement(data);
+  segment.AppendFrames(samples.forget(),
+                       channels,
+                       AUDIO_BUFFER_SIZE,
+                       PRINCIPAL_HANDLE_NONE);
+
+  for(std::set<RefPtr<Fake_MediaStreamListener>>::iterator it = mListeners.begin();
+       it != mListeners.end(); ++it) {
+    (*it)->NotifyQueuedTrackChanges(nullptr, // Graph
+                                    0, // TrackID
+                                    0, // Offset TODO(ekr@rtfm.com) fix
+                                    static_cast<mozilla::TrackEventCommand>(0), // ???
+                                    segment,
+                                    nullptr, // Input stream
+                                    -1);     // Input track id
+  }
+  for(std::vector<BoundTrackListener>::iterator it = mTrackListeners.begin();
+       it != mTrackListeners.end(); ++it) {
+    it->mListener->NotifyQueuedChanges(nullptr, // Graph
+                                       0, // Offset TODO(ekr@rtfm.com) fix
+                                       segment);
+  }
+}
+
+
+// Fake_MediaPeriodic
+NS_IMPL_ISUPPORTS(Fake_MediaPeriodic, nsITimerCallback)
+
+NS_IMETHODIMP
+Fake_MediaPeriodic::Notify(nsITimer *timer) {
+  if (mStream)
+    mStream->Periodic();
+  ++mCount;
+  return NS_OK;
+}
+
+
+#if 0
+#define WIDTH 320
+#define HEIGHT 240
+#define RATE USECS_PER_S
+#define USECS_PER_S 1000000
+#define FPS 10
+
+NS_IMETHODIMP
+Fake_VideoStreamSource::Notify(nsITimer* aTimer)
+{
+#if 0
+  mozilla::layers::BufferRecycleBin bin;
+
+  RefPtr<mozilla::layers::PlanarYCbCrImage> image = new
+    mozilla::layers::PlanarYCbCrImage(&bin);
+
+  const uint8_t lumaBpp = 8;
+  const uint8_t chromaBpp = 4;
+
+  int len = ((WIDTH * HEIGHT) * 3 / 2);
+  uint8_t* frame = (uint8_t*) PR_Malloc(len);
+  memset(frame, 0x80, len); // Gray
+
+  mozilla::layers::PlanarYCbCrData data;
+  data.mYChannel = frame;
+  data.mYSize = mozilla::gfx::IntSize(WIDTH, HEIGHT);
+  data.mYStride = WIDTH * lumaBpp / 8.0;
+  data.mCbCrStride = WIDTH * chromaBpp / 8.0;
+  data.mCbChannel = frame + HEIGHT * data.mYStride;
+  data.mCrChannel = data.mCbChannel + HEIGHT * data.mCbCrStride / 2;
+  data.mCbCrSize = mozilla::gfx::IntSize(WIDTH / 2, HEIGHT / 2);
+  data.mPicX = 0;
+  data.mPicY = 0;
+  data.mPicSize = mozilla::gfx::IntSize(WIDTH, HEIGHT);
+  data.mStereoMode = mozilla::layers::StereoMode::MONO;
+
+  mozilla::VideoSegment segment;
+  segment.AppendFrame(image.forget(), USECS_PER_S / FPS,
+                      mozilla::gfx::IntSize(WIDTH, HEIGHT));
+
+  // TODO(ekr@rtfm.com): are we leaking?
+#endif
+
+  return NS_OK;
+}
+
+
+#if 0
+// Fake up buffer recycle bin
+mozilla::layers::BufferRecycleBin::BufferRecycleBin() :
+ mLock("mozilla.layers.BufferRecycleBin.mLock") {
+}
+
+void mozilla::layers::BufferRecycleBin::RecycleBuffer(uint8_t* buffer, uint32_t size) {
+  PR_Free(buffer);
+}
+
+uint8_t *mozilla::layers::BufferRecycleBin::GetBuffer(uint32_t size) {
+  return (uint8_t *)PR_MALLOC(size);
+}
+
+// YCbCrImage constructor (from ImageLayers.cpp)
+mozilla::layers::PlanarYCbCrImage::PlanarYCbCrImage(BufferRecycleBin *aRecycleBin)
+  : Image(nsnull, ImageFormat::PLANAR_YCBCR)
+  , mBufferSize(0)
+  , mRecycleBin(aRecycleBin)
+{
+}
+
+
+#endif
+#endif
+
+
+#endif
diff --git a/media/webrtc/signaling/test/FakePCObserver.h b/media/webrtc/signaling/test/FakePCObserver.h
new file mode 100644
index 000000000..460059b7f
--- /dev/null
+++ b/media/webrtc/signaling/test/FakePCObserver.h
@@ -0,0 +1,112 @@
+/* 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 TEST_PCOBSERVER_H_
+#define TEST_PCOBSERVER_H_
+
+#include "nsNetCID.h"
+#include "nsITimer.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIComponentManager.h"
+#include "nsIComponentRegistrar.h"
+
+#include "mozilla/Mutex.h"
+#include "AudioSegment.h"
+#include "MediaSegment.h"
+#include "StreamTracks.h"
+#include "nsTArray.h"
+#include "nsIRunnable.h"
+#include "nsISupportsImpl.h"
+#include "mozilla/dom/PeerConnectionObserverEnumsBinding.h"
+#include "PeerConnectionImpl.h"
+#include "nsWeakReference.h"
+
+namespace mozilla {
+class PeerConnectionImpl;
+}
+
+class nsIDOMWindow;
+class nsIDOMDataChannel;
+
+namespace test {
+
+class AFakePCObserver : public nsSupportsWeakReference
+{
+protected:
+  typedef mozilla::ErrorResult ER;
+public:
+  enum Action {
+    OFFER,
+    ANSWER
+  };
+
+  enum ResponseState {
+    stateNoResponse,
+    stateSuccess,
+    stateError
+  };
+
+  AFakePCObserver(mozilla::PeerConnectionImpl *peerConnection,
+                  const std::string &aName) :
+    state(stateNoResponse), addIceSuccessCount(0),
+    onAddStreamCalled(false),
+    name(aName),
+    pc(peerConnection) {
+  }
+
+  AFakePCObserver() :
+    state(stateNoResponse), addIceSuccessCount(0),
+    onAddStreamCalled(false),
+    name(""),
+    pc(nullptr) {
+  }
+
+  virtual ~AFakePCObserver() {}
+
+  std::vector<mozilla::DOMMediaStream *> GetStreams() { return streams; }
+
+  ResponseState state;
+  std::string lastString;
+  mozilla::PeerConnectionImpl::Error lastStatusCode;
+  mozilla::dom::PCObserverStateType lastStateType;
+  int addIceSuccessCount;
+  bool onAddStreamCalled;
+  std::string name;
+  std::vector<std::string> candidates;
+
+  NS_IMETHOD OnCreateOfferSuccess(const char* offer, ER&) = 0;
+  NS_IMETHOD OnCreateOfferError(uint32_t code, const char *msg, ER&) = 0;
+  NS_IMETHOD OnCreateAnswerSuccess(const char* answer, ER&) = 0;
+  NS_IMETHOD OnCreateAnswerError(uint32_t code, const char *msg, ER&) = 0;
+  NS_IMETHOD OnSetLocalDescriptionSuccess(ER&) = 0;
+  NS_IMETHOD OnSetRemoteDescriptionSuccess(ER&) = 0;
+  NS_IMETHOD OnSetLocalDescriptionError(uint32_t code, const char *msg, ER&) = 0;
+  NS_IMETHOD OnSetRemoteDescriptionError(uint32_t code, const char *msg, ER&) = 0;
+  NS_IMETHOD NotifyDataChannel(nsIDOMDataChannel *channel, ER&) = 0;
+  NS_IMETHOD OnStateChange(mozilla::dom::PCObserverStateType state_type, ER&,
+                                      void* = nullptr) = 0;
+  NS_IMETHOD OnAddStream(mozilla::DOMMediaStream &stream, ER&) = 0;
+  NS_IMETHOD OnRemoveStream(mozilla::DOMMediaStream &stream, ER&) = 0;
+  NS_IMETHOD OnAddTrack(mozilla::dom::MediaStreamTrack &track, ER&) = 0;
+  NS_IMETHOD OnRemoveTrack(mozilla::dom::MediaStreamTrack &track, ER&) = 0;
+  NS_IMETHOD OnReplaceTrackSuccess(ER&) = 0;
+  NS_IMETHOD OnReplaceTrackError(uint32_t code, const char *msg, ER&) = 0;
+  NS_IMETHOD OnAddIceCandidateSuccess(ER&) = 0;
+  NS_IMETHOD OnAddIceCandidateError(uint32_t code, const char *msg, ER&) = 0;
+  NS_IMETHOD OnIceCandidate(uint16_t level, const char *mid,
+                                       const char *candidate, ER&) = 0;
+  NS_IMETHOD OnNegotiationNeeded(ER&) = 0;
+protected:
+  mozilla::PeerConnectionImpl *pc;
+  std::vector<mozilla::DOMMediaStream *> streams;
+};
+}
+
+namespace mozilla {
+namespace dom {
+typedef test::AFakePCObserver PeerConnectionObserver;
+}
+}
+
+#endif
diff --git a/media/webrtc/signaling/test/common.build b/media/webrtc/signaling/test/common.build
new file mode 100644
index 000000000..3e5450f5d
--- /dev/null
+++ b/media/webrtc/signaling/test/common.build
@@ -0,0 +1,134 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+if CONFIG['OS_TARGET'] in ('Darwin', 'Android'):
+    DEFINES['GTEST_USE_OWN_TR1_TUPLE'] = 1
+
+for var in ('MOZILLA_EXTERNAL_LINKAGE', 'USE_FAKE_MEDIA_STREAMS', 'USE_FAKE_PCOBSERVER',
+            'NR_SOCKET_IS_VOID_PTR', 'HAVE_STRDUP'):
+    DEFINES[var] = True
+
+LOCAL_INCLUDES += [
+    '!/dist/include/mozilla/dom', # Binding headers (because binding
+                                  # implementations include them).
+    '!/dom/bindings', # Binding implementations (urk).
+    '/dom/media/',
+    '/ipc/chromium/src',
+    '/media/mtransport',
+    '/media/mtransport/test',
+    '/media/mtransport/third_party/nICEr/src/ice',
+    '/media/mtransport/third_party/nICEr/src/net',
+    '/media/mtransport/third_party/nICEr/src/stun',
+    '/media/mtransport/third_party/nrappkit/src/event',
+    '/media/mtransport/third_party/nrappkit/src/log',
+    '/media/mtransport/third_party/nrappkit/src/plugin',
+    '/media/mtransport/third_party/nrappkit/src/port/generic/include',
+    '/media/mtransport/third_party/nrappkit/src/registry',
+    '/media/mtransport/third_party/nrappkit/src/share',
+    '/media/mtransport/third_party/nrappkit/src/stats',
+    '/media/mtransport/third_party/nrappkit/src/util/libekr',
+    '/media/webrtc',
+    '/media/webrtc/signaling/src/common/browser_logging',
+    '/media/webrtc/signaling/src/common/time_profiling',
+    '/media/webrtc/signaling/src/media',
+    '/media/webrtc/signaling/src/media-conduit',
+    '/media/webrtc/signaling/src/mediapipeline',
+    '/media/webrtc/signaling/src/peerconnection',
+    '/media/webrtc/signaling/src/sdp/sipcc',
+    '/media/webrtc/trunk',
+    '/media/webrtc/trunk/testing/gtest/include',
+    '/xpcom/base',
+]
+
+if CONFIG['OS_TARGET'] == 'Android':
+    LOCAL_INCLUDES += [
+        '/media/mtransport/third_party/nrappkit/src/port/android/include',
+    ]
+
+if CONFIG['OS_TARGET'] == 'Linux':
+    LOCAL_INCLUDES += [
+        '/media/mtransport/third_party/nrappkit/src/port/linux/include',
+    ]
+
+if CONFIG['OS_TARGET'] == 'Darwin':
+    LOCAL_INCLUDES += [
+        '/media/mtransport/third_party/nrappkit/src/port/darwin/include',
+    ]
+    OS_LIBS += [
+        '-framework AudioToolbox',
+        '-framework AudioUnit',
+        '-framework Carbon',
+        '-framework CoreAudio',
+        '-framework OpenGL',
+        '-framework AVFoundation',
+        '-framework CoreMedia',
+        '-framework QuartzCore',
+        '-framework Security',
+        '-framework SystemConfiguration',
+        '-framework IOKit',
+        '-F%s' % CONFIG['MACOS_PRIVATE_FRAMEWORKS_DIR'],
+        '-framework CoreUI',
+    ]
+
+if CONFIG['OS_TARGET'] in ('DragonFly', 'FreeBSD', 'NetBSD', 'OpenBSD'):
+    LOCAL_INCLUDES += [
+        '/media/mtransport/third_party/nrappkit/src/port/darwin/include',
+    ]
+
+USE_LIBS += [
+    '/media/webrtc/trunk/testing/gtest_gtest/gtest',
+    'chromium_atomics',
+    'gkmedias',
+    'nksrtp_s',
+    'nss',
+    'webrtc',
+    'yuv',
+    'zlib',
+]
+
+if CONFIG['JS_SHARED_LIBRARY']:
+    USE_LIBS += [
+        'js',
+    ]
+
+USE_LIBS += ['mozglue']
+
+OS_LIBS += CONFIG['MOZ_WEBRTC_X11_LIBS']
+OS_LIBS += CONFIG['REALTIME_LIBS']
+
+if CONFIG['MOZ_ALSA']:
+    OS_LIBS += CONFIG['MOZ_ALSA_LIBS']
+
+if CONFIG['MOZ_SYSTEM_JPEG']:
+    OS_LIBS += CONFIG['MOZ_JPEG_LIBS']
+
+if CONFIG['MOZ_SYSTEM_LIBVPX']:
+    OS_LIBS += CONFIG['MOZ_LIBVPX_LIBS']
+
+if not CONFIG['MOZ_TREE_PIXMAN']:
+    OS_LIBS += CONFIG['MOZ_PIXMAN_LIBS']
+
+if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gtk2':
+    OS_LIBS += CONFIG['XLIBS']
+    OS_LIBS += CONFIG['MOZ_GTK2_LIBS']
+    OS_LIBS += [
+        'gmodule-2.0',
+        'gthread-2.0',
+    ]
+
+if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gtk3':
+    OS_LIBS += CONFIG['XLIBS']
+    OS_LIBS += CONFIG['MOZ_GTK3_LIBS']
+    USE_LIBS += [
+        'freetype',
+    ]
+
+if CONFIG['OS_TARGET'] in ('Linux', 'DragonFly', 'FreeBSD', 'NetBSD',
+        'OpenBSD'):
+    OS_LIBS += CONFIG['MOZ_CAIRO_OSLIBS']
+
+if CONFIG['OS_TARGET'] == 'Darwin':
+    OS_LIBS += CONFIG['TK_LIBS']
diff --git a/media/webrtc/signaling/test/jsep_session_unittest.cpp b/media/webrtc/signaling/test/jsep_session_unittest.cpp
new file mode 100644
index 000000000..d29400771
--- /dev/null
+++ b/media/webrtc/signaling/test/jsep_session_unittest.cpp
@@ -0,0 +1,4235 @@
+/* -*- 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/. */
+
+#include <iostream>
+#include <map>
+
+#include "nspr.h"
+#include "nss.h"
+#include "ssl.h"
+
+#include "mozilla/RefPtr.h"
+#include "mozilla/Tuple.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+#include "FakeMediaStreams.h"
+#include "FakeMediaStreamsImpl.h"
+#include "FakeLogging.h"
+
+#include "signaling/src/sdp/SdpMediaSection.h"
+#include "signaling/src/sdp/SipccSdpParser.h"
+#include "signaling/src/jsep/JsepCodecDescription.h"
+#include "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/jsep/JsepSession.h"
+#include "signaling/src/jsep/JsepSessionImpl.h"
+#include "signaling/src/jsep/JsepTrack.h"
+
+#include "mtransport_test_utils.h"
+
+#include "FakeIPC.h"
+#include "FakeIPC.cpp"
+
+#include "TestHarness.h"
+
+namespace mozilla {
+static std::string kAEqualsCandidate("a=candidate:");
+const static size_t kNumCandidatesPerComponent = 3;
+
+class JsepSessionTestBase : public ::testing::Test
+{
+};
+
+class FakeUuidGenerator : public mozilla::JsepUuidGenerator
+{
+public:
+  bool
+  Generate(std::string* str)
+  {
+    std::ostringstream os;
+    os << "FAKE_UUID_" << ++ctr;
+    *str = os.str();
+
+    return true;
+  }
+
+private:
+  static uint64_t ctr;
+};
+
+uint64_t FakeUuidGenerator::ctr = 1000;
+
+class JsepSessionTest : public JsepSessionTestBase,
+                        public ::testing::WithParamInterface<std::string>
+{
+public:
+  JsepSessionTest()
+      : mSessionOff("Offerer", MakeUnique<FakeUuidGenerator>()),
+        mSessionAns("Answerer", MakeUnique<FakeUuidGenerator>())
+  {
+    EXPECT_EQ(NS_OK, mSessionOff.Init());
+    EXPECT_EQ(NS_OK, mSessionAns.Init());
+
+    AddTransportData(&mSessionOff, &mOffererTransport);
+    AddTransportData(&mSessionAns, &mAnswererTransport);
+  }
+
+protected:
+  struct TransportData {
+    std::string mIceUfrag;
+    std::string mIcePwd;
+    std::map<std::string, std::vector<uint8_t> > mFingerprints;
+  };
+
+  void
+  AddDtlsFingerprint(const std::string& alg, JsepSessionImpl* session,
+                     TransportData* tdata)
+  {
+    std::vector<uint8_t> fp;
+    fp.assign((alg == "sha-1") ? 20 : 32,
+              (session->GetName() == "Offerer") ? 0x4f : 0x41);
+    session->AddDtlsFingerprint(alg, fp);
+    tdata->mFingerprints[alg] = fp;
+  }
+
+  void
+  AddTransportData(JsepSessionImpl* session, TransportData* tdata)
+  {
+    // Values here semi-borrowed from JSEP draft.
+    tdata->mIceUfrag = session->GetName() + "-ufrag";
+    tdata->mIcePwd = session->GetName() + "-1234567890";
+    session->SetIceCredentials(tdata->mIceUfrag, tdata->mIcePwd);
+    AddDtlsFingerprint("sha-1", session, tdata);
+    AddDtlsFingerprint("sha-256", session, tdata);
+  }
+
+  std::string
+  CreateOffer(const Maybe<JsepOfferOptions> options = Nothing())
+  {
+    JsepOfferOptions defaultOptions;
+    const JsepOfferOptions& optionsRef = options ? *options : defaultOptions;
+    std::string offer;
+    nsresult rv = mSessionOff.CreateOffer(optionsRef, &offer);
+    EXPECT_EQ(NS_OK, rv) << mSessionOff.GetLastError();
+
+    std::cerr << "OFFER: " << offer << std::endl;
+
+    ValidateTransport(mOffererTransport, offer);
+
+    return offer;
+  }
+
+  void
+  AddTracks(JsepSessionImpl& side)
+  {
+    // Add tracks.
+    if (types.empty()) {
+      types = BuildTypes(GetParam());
+    }
+    AddTracks(side, types);
+
+    // Now that we have added streams, we expect audio, then video, then
+    // application in the SDP, regardless of the order in which the streams were
+    // added.
+    std::sort(types.begin(), types.end());
+  }
+
+  void
+  AddTracks(JsepSessionImpl& side, const std::string& mediatypes)
+  {
+    AddTracks(side, BuildTypes(mediatypes));
+  }
+
+  std::vector<SdpMediaSection::MediaType>
+  BuildTypes(const std::string& mediatypes)
+  {
+    std::vector<SdpMediaSection::MediaType> result;
+    size_t ptr = 0;
+
+    for (;;) {
+      size_t comma = mediatypes.find(',', ptr);
+      std::string chunk = mediatypes.substr(ptr, comma - ptr);
+
+      SdpMediaSection::MediaType type;
+      if (chunk == "audio") {
+        type = SdpMediaSection::kAudio;
+      } else if (chunk == "video") {
+        type = SdpMediaSection::kVideo;
+      } else if (chunk == "datachannel") {
+        type = SdpMediaSection::kApplication;
+      } else {
+        MOZ_CRASH();
+      }
+      result.push_back(type);
+
+      if (comma == std::string::npos)
+        break;
+      ptr = comma + 1;
+    }
+
+    return result;
+  }
+
+  void
+  AddTracks(JsepSessionImpl& side,
+            const std::vector<SdpMediaSection::MediaType>& mediatypes)
+  {
+    FakeUuidGenerator uuid_gen;
+    std::string stream_id;
+    std::string track_id;
+
+    ASSERT_TRUE(uuid_gen.Generate(&stream_id));
+
+    AddTracksToStream(side, stream_id, mediatypes);
+  }
+
+  void
+  AddTracksToStream(JsepSessionImpl& side,
+                    const std::string stream_id,
+                    const std::string& mediatypes)
+  {
+    AddTracksToStream(side, stream_id, BuildTypes(mediatypes));
+  }
+
+  void
+  AddTracksToStream(JsepSessionImpl& side,
+                    const std::string stream_id,
+                    const std::vector<SdpMediaSection::MediaType>& mediatypes)
+
+  {
+    FakeUuidGenerator uuid_gen;
+    std::string track_id;
+
+    for (auto track = mediatypes.begin(); track != mediatypes.end(); ++track) {
+      ASSERT_TRUE(uuid_gen.Generate(&track_id));
+
+      RefPtr<JsepTrack> mst(new JsepTrack(*track, stream_id, track_id));
+      side.AddTrack(mst);
+    }
+  }
+
+  bool HasMediaStream(std::vector<RefPtr<JsepTrack>> tracks) const {
+    for (auto i = tracks.begin(); i != tracks.end(); ++i) {
+      if ((*i)->GetMediaType() != SdpMediaSection::kApplication) {
+        return 1;
+      }
+    }
+    return 0;
+  }
+
+  const std::string GetFirstLocalStreamId(JsepSessionImpl& side) const {
+    auto tracks = side.GetLocalTracks();
+    return (*tracks.begin())->GetStreamId();
+  }
+
+  std::vector<std::string>
+  GetMediaStreamIds(std::vector<RefPtr<JsepTrack>> tracks) const {
+    std::vector<std::string> ids;
+    for (auto i = tracks.begin(); i != tracks.end(); ++i) {
+      // data channels don't have msid's
+      if ((*i)->GetMediaType() == SdpMediaSection::kApplication) {
+        continue;
+      }
+      ids.push_back((*i)->GetStreamId());
+    }
+    return ids;
+  }
+
+  std::vector<std::string>
+  GetLocalMediaStreamIds(JsepSessionImpl& side) const {
+    return GetMediaStreamIds(side.GetLocalTracks());
+  }
+
+  std::vector<std::string>
+  GetRemoteMediaStreamIds(JsepSessionImpl& side) const {
+    return GetMediaStreamIds(side.GetRemoteTracks());
+  }
+
+  std::vector<std::string>
+  sortUniqueStrVector(std::vector<std::string> in) const {
+    std::sort(in.begin(), in.end());
+    auto it = std::unique(in.begin(), in.end());
+    in.resize( std::distance(in.begin(), it));
+    return in;
+  }
+
+  std::vector<std::string>
+  GetLocalUniqueStreamIds(JsepSessionImpl& side) const {
+    return sortUniqueStrVector(GetLocalMediaStreamIds(side));
+  }
+
+  std::vector<std::string>
+  GetRemoteUniqueStreamIds(JsepSessionImpl& side) const {
+    return sortUniqueStrVector(GetRemoteMediaStreamIds(side));
+  }
+
+  RefPtr<JsepTrack> GetTrack(JsepSessionImpl& side,
+                             SdpMediaSection::MediaType type,
+                             size_t index) const {
+    auto tracks = side.GetLocalTracks();
+
+    for (auto i = tracks.begin(); i != tracks.end(); ++i) {
+      if ((*i)->GetMediaType() != type) {
+        continue;
+      }
+
+      if (index != 0) {
+        --index;
+        continue;
+      }
+
+      return *i;
+    }
+
+    return RefPtr<JsepTrack>(nullptr);
+  }
+
+  RefPtr<JsepTrack> GetTrackOff(size_t index,
+                                SdpMediaSection::MediaType type) {
+    return GetTrack(mSessionOff, type, index);
+  }
+
+  RefPtr<JsepTrack> GetTrackAns(size_t index,
+                                SdpMediaSection::MediaType type) {
+    return GetTrack(mSessionAns, type, index);
+  }
+
+  class ComparePairsByLevel {
+    public:
+      bool operator()(const JsepTrackPair& lhs,
+                      const JsepTrackPair& rhs) const {
+        return lhs.mLevel < rhs.mLevel;
+      }
+  };
+
+  std::vector<JsepTrackPair> GetTrackPairsByLevel(JsepSessionImpl& side) const {
+    auto pairs = side.GetNegotiatedTrackPairs();
+    std::sort(pairs.begin(), pairs.end(), ComparePairsByLevel());
+    return pairs;
+  }
+
+  bool Equals(const SdpFingerprintAttributeList::Fingerprint& f1,
+              const SdpFingerprintAttributeList::Fingerprint& f2) const {
+    if (f1.hashFunc != f2.hashFunc) {
+      return false;
+    }
+
+    if (f1.fingerprint != f2.fingerprint) {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Equals(const SdpFingerprintAttributeList& f1,
+              const SdpFingerprintAttributeList& f2) const {
+    if (f1.mFingerprints.size() != f2.mFingerprints.size()) {
+      return false;
+    }
+
+    for (size_t i=0; i<f1.mFingerprints.size(); ++i) {
+      if (!Equals(f1.mFingerprints[i], f2.mFingerprints[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  bool Equals(const UniquePtr<JsepDtlsTransport>& t1,
+              const UniquePtr<JsepDtlsTransport>& t2) const {
+    if (!t1 && !t2) {
+      return true;
+    }
+
+    if (!t1 || !t2) {
+      return false;
+    }
+
+    if (!Equals(t1->GetFingerprints(),  t2->GetFingerprints())) {
+      return false;
+    }
+
+    if (t1->GetRole() != t2->GetRole()) {
+      return false;
+    }
+
+    return true;
+  }
+
+
+  bool Equals(const UniquePtr<JsepIceTransport>& t1,
+              const UniquePtr<JsepIceTransport>& t2) const {
+    if (!t1 && !t2) {
+      return true;
+    }
+
+    if (!t1 || !t2) {
+      return false;
+    }
+
+    if (t1->GetUfrag() != t2->GetUfrag()) {
+      return false;
+    }
+
+    if (t1->GetPassword() != t2->GetPassword()) {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Equals(const RefPtr<JsepTransport>& t1,
+              const RefPtr<JsepTransport>& t2) const {
+    if (!t1 && !t2) {
+      return true;
+    }
+
+    if (!t1 || !t2) {
+      return false;
+    }
+
+    if (t1->mTransportId != t2->mTransportId) {
+      return false;
+    }
+
+    if (t1->mComponents != t2->mComponents) {
+      return false;
+    }
+
+    if (!Equals(t1->mIce, t2->mIce)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Equals(const JsepTrackPair& p1,
+              const JsepTrackPair& p2) const {
+    if (p1.mLevel != p2.mLevel) {
+      return false;
+    }
+
+    // We don't check things like mBundleLevel, since that can change without
+    // any changes to the transport, which is what we're really interested in.
+
+    if (p1.mSending.get() != p2.mSending.get()) {
+      return false;
+    }
+
+    if (p1.mReceiving.get() != p2.mReceiving.get()) {
+      return false;
+    }
+
+    if (!Equals(p1.mRtpTransport, p2.mRtpTransport)) {
+      return false;
+    }
+
+    if (!Equals(p1.mRtcpTransport, p2.mRtcpTransport)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  size_t GetTrackCount(JsepSessionImpl& side,
+                       SdpMediaSection::MediaType type) const {
+    auto tracks = side.GetLocalTracks();
+    size_t result = 0;
+    for (auto i = tracks.begin(); i != tracks.end(); ++i) {
+      if ((*i)->GetMediaType() == type) {
+        ++result;
+      }
+    }
+    return result;
+  }
+
+  UniquePtr<Sdp> GetParsedLocalDescription(const JsepSessionImpl& side) const {
+    return Parse(side.GetLocalDescription());
+  }
+
+  SdpMediaSection* GetMsection(Sdp& sdp,
+                               SdpMediaSection::MediaType type,
+                               size_t index) const {
+    for (size_t i = 0; i < sdp.GetMediaSectionCount(); ++i) {
+      auto& msection = sdp.GetMediaSection(i);
+      if (msection.GetMediaType() != type) {
+        continue;
+      }
+
+      if (index) {
+        --index;
+        continue;
+      }
+
+      return &msection;
+    }
+
+    return nullptr;
+  }
+
+  void
+  SetPayloadTypeNumber(JsepSession& session,
+                       const std::string& codecName,
+                       const std::string& payloadType)
+  {
+    for (auto* codec : session.Codecs()) {
+      if (codec->mName == codecName) {
+        codec->mDefaultPt = payloadType;
+      }
+    }
+  }
+
+  void
+  SetCodecEnabled(JsepSession& session,
+                  const std::string& codecName,
+                  bool enabled)
+  {
+    for (auto* codec : session.Codecs()) {
+      if (codec->mName == codecName) {
+        codec->mEnabled = enabled;
+      }
+    }
+  }
+
+  void
+  EnsureNegotiationFailure(SdpMediaSection::MediaType type,
+                           const std::string& codecName)
+  {
+    for (auto i = mSessionOff.Codecs().begin(); i != mSessionOff.Codecs().end();
+         ++i) {
+      auto* codec = *i;
+      if (codec->mType == type && codec->mName != codecName) {
+        codec->mEnabled = false;
+      }
+    }
+
+    for (auto i = mSessionAns.Codecs().begin(); i != mSessionAns.Codecs().end();
+         ++i) {
+      auto* codec = *i;
+      if (codec->mType == type && codec->mName == codecName) {
+        codec->mEnabled = false;
+      }
+    }
+  }
+
+  std::string
+  CreateAnswer()
+  {
+    JsepAnswerOptions options;
+    std::string answer;
+    nsresult rv = mSessionAns.CreateAnswer(options, &answer);
+    EXPECT_EQ(NS_OK, rv);
+
+    std::cerr << "ANSWER: " << answer << std::endl;
+
+    ValidateTransport(mAnswererTransport, answer);
+
+    return answer;
+  }
+
+  static const uint32_t NO_CHECKS = 0;
+  static const uint32_t CHECK_SUCCESS = 1;
+  static const uint32_t CHECK_TRACKS = 1 << 2;
+  static const uint32_t ALL_CHECKS = CHECK_SUCCESS | CHECK_TRACKS;
+
+  void OfferAnswer(uint32_t checkFlags = ALL_CHECKS,
+                   const Maybe<JsepOfferOptions> options = Nothing()) {
+    std::string offer = CreateOffer(options);
+    SetLocalOffer(offer, checkFlags);
+    SetRemoteOffer(offer, checkFlags);
+
+    std::string answer = CreateAnswer();
+    SetLocalAnswer(answer, checkFlags);
+    SetRemoteAnswer(answer, checkFlags);
+  }
+
+  void
+  SetLocalOffer(const std::string& offer, uint32_t checkFlags = ALL_CHECKS)
+  {
+    nsresult rv = mSessionOff.SetLocalDescription(kJsepSdpOffer, offer);
+
+    if (checkFlags & CHECK_SUCCESS) {
+      ASSERT_EQ(NS_OK, rv);
+    }
+
+    if (checkFlags & CHECK_TRACKS) {
+      // Check that the transports exist.
+      ASSERT_EQ(types.size(), mSessionOff.GetTransports().size());
+      auto tracks = mSessionOff.GetLocalTracks();
+      for (size_t i = 0; i < types.size(); ++i) {
+        ASSERT_NE("", tracks[i]->GetStreamId());
+        ASSERT_NE("", tracks[i]->GetTrackId());
+        if (tracks[i]->GetMediaType() != SdpMediaSection::kApplication) {
+          std::string msidAttr("a=msid:");
+          msidAttr += tracks[i]->GetStreamId();
+          msidAttr += " ";
+          msidAttr += tracks[i]->GetTrackId();
+          ASSERT_NE(std::string::npos, offer.find(msidAttr))
+            << "Did not find " << msidAttr << " in offer";
+        }
+      }
+    }
+  }
+
+  void
+  SetRemoteOffer(const std::string& offer, uint32_t checkFlags = ALL_CHECKS)
+  {
+    nsresult rv = mSessionAns.SetRemoteDescription(kJsepSdpOffer, offer);
+
+    if (checkFlags & CHECK_SUCCESS) {
+      ASSERT_EQ(NS_OK, rv);
+    }
+
+    if (checkFlags & CHECK_TRACKS) {
+      auto tracks = mSessionAns.GetRemoteTracks();
+      // Now verify that the right stuff is in the tracks.
+      ASSERT_EQ(types.size(), tracks.size());
+      for (size_t i = 0; i < tracks.size(); ++i) {
+        ASSERT_EQ(types[i], tracks[i]->GetMediaType());
+        ASSERT_NE("", tracks[i]->GetStreamId());
+        ASSERT_NE("", tracks[i]->GetTrackId());
+        if (tracks[i]->GetMediaType() != SdpMediaSection::kApplication) {
+          std::string msidAttr("a=msid:");
+          msidAttr += tracks[i]->GetStreamId();
+          msidAttr += " ";
+          msidAttr += tracks[i]->GetTrackId();
+          ASSERT_NE(std::string::npos, offer.find(msidAttr))
+            << "Did not find " << msidAttr << " in offer";
+        }
+      }
+    }
+  }
+
+  void
+  SetLocalAnswer(const std::string& answer, uint32_t checkFlags = ALL_CHECKS)
+  {
+    nsresult rv = mSessionAns.SetLocalDescription(kJsepSdpAnswer, answer);
+    if (checkFlags & CHECK_SUCCESS) {
+      ASSERT_EQ(NS_OK, rv);
+    }
+
+    if (checkFlags & CHECK_TRACKS) {
+      // Verify that the right stuff is in the tracks.
+      auto pairs = mSessionAns.GetNegotiatedTrackPairs();
+      ASSERT_EQ(types.size(), pairs.size());
+      for (size_t i = 0; i < types.size(); ++i) {
+        ASSERT_TRUE(pairs[i].mSending);
+        ASSERT_EQ(types[i], pairs[i].mSending->GetMediaType());
+        ASSERT_TRUE(pairs[i].mReceiving);
+        ASSERT_EQ(types[i], pairs[i].mReceiving->GetMediaType());
+        ASSERT_NE("", pairs[i].mSending->GetStreamId());
+        ASSERT_NE("", pairs[i].mSending->GetTrackId());
+        // These might have been in the SDP, or might have been randomly
+        // chosen by JsepSessionImpl
+        ASSERT_NE("", pairs[i].mReceiving->GetStreamId());
+        ASSERT_NE("", pairs[i].mReceiving->GetTrackId());
+
+        if (pairs[i].mReceiving->GetMediaType() != SdpMediaSection::kApplication) {
+          std::string msidAttr("a=msid:");
+          msidAttr += pairs[i].mSending->GetStreamId();
+          msidAttr += " ";
+          msidAttr += pairs[i].mSending->GetTrackId();
+          ASSERT_NE(std::string::npos, answer.find(msidAttr))
+            << "Did not find " << msidAttr << " in offer";
+        }
+      }
+    }
+    std::cerr << "OFFER pairs:" << std::endl;
+    DumpTrackPairs(mSessionOff);
+  }
+
+  void
+  SetRemoteAnswer(const std::string& answer, uint32_t checkFlags = ALL_CHECKS)
+  {
+    nsresult rv = mSessionOff.SetRemoteDescription(kJsepSdpAnswer, answer);
+    if (checkFlags & CHECK_SUCCESS) {
+      ASSERT_EQ(NS_OK, rv);
+    }
+
+    if (checkFlags & CHECK_TRACKS) {
+      // Verify that the right stuff is in the tracks.
+      auto pairs = mSessionOff.GetNegotiatedTrackPairs();
+      ASSERT_EQ(types.size(), pairs.size());
+      for (size_t i = 0; i < types.size(); ++i) {
+        ASSERT_TRUE(pairs[i].mSending);
+        ASSERT_EQ(types[i], pairs[i].mSending->GetMediaType());
+        ASSERT_TRUE(pairs[i].mReceiving);
+        ASSERT_EQ(types[i], pairs[i].mReceiving->GetMediaType());
+        ASSERT_NE("", pairs[i].mSending->GetStreamId());
+        ASSERT_NE("", pairs[i].mSending->GetTrackId());
+        // These might have been in the SDP, or might have been randomly
+        // chosen by JsepSessionImpl
+        ASSERT_NE("", pairs[i].mReceiving->GetStreamId());
+        ASSERT_NE("", pairs[i].mReceiving->GetTrackId());
+
+        if (pairs[i].mReceiving->GetMediaType() != SdpMediaSection::kApplication) {
+          std::string msidAttr("a=msid:");
+          msidAttr += pairs[i].mReceiving->GetStreamId();
+          msidAttr += " ";
+          msidAttr += pairs[i].mReceiving->GetTrackId();
+          ASSERT_NE(std::string::npos, answer.find(msidAttr))
+            << "Did not find " << msidAttr << " in answer";
+        }
+      }
+    }
+    std::cerr << "ANSWER pairs:" << std::endl;
+    DumpTrackPairs(mSessionAns);
+  }
+
+  typedef enum {
+    RTP = 1,
+    RTCP = 2
+  } ComponentType;
+
+  class CandidateSet {
+    public:
+      CandidateSet() {}
+
+      void Gather(JsepSession& session,
+                  const std::vector<SdpMediaSection::MediaType>& types,
+                  ComponentType maxComponent = RTCP)
+      {
+        for (size_t level = 0; level < types.size(); ++level) {
+          Gather(session, level, RTP);
+          if (types[level] != SdpMediaSection::kApplication &&
+              maxComponent == RTCP) {
+            Gather(session, level, RTCP);
+          }
+        }
+        FinishGathering(session);
+      }
+
+      void Gather(JsepSession& session, size_t level, ComponentType component)
+      {
+        static uint16_t port = 1000;
+        std::vector<std::string> candidates;
+        for (size_t i = 0; i < kNumCandidatesPerComponent; ++i) {
+          ++port;
+          std::ostringstream candidate;
+          candidate << "0 " << static_cast<uint16_t>(component)
+                    << " UDP 9999 192.168.0.1 " << port << " typ host";
+          std::string mid;
+          bool skipped;
+          session.AddLocalIceCandidate(kAEqualsCandidate + candidate.str(),
+                                       level, &mid, &skipped);
+          if (!skipped) {
+            mCandidatesToTrickle.push_back(
+                Tuple<Level, Mid, Candidate>(
+                  level, mid, kAEqualsCandidate + candidate.str()));
+            candidates.push_back(candidate.str());
+          }
+        }
+
+        // Stomp existing candidates
+        mCandidates[level][component] = candidates;
+
+        // Stomp existing defaults
+        mDefaultCandidates[level][component] =
+          std::make_pair("192.168.0.1", port);
+        session.UpdateDefaultCandidate(
+            mDefaultCandidates[level][RTP].first,
+            mDefaultCandidates[level][RTP].second,
+            // Will be empty string if not present, which is how we indicate
+            // that there is no default for RTCP
+            mDefaultCandidates[level][RTCP].first,
+            mDefaultCandidates[level][RTCP].second,
+            level);
+      }
+
+      void FinishGathering(JsepSession& session) const
+      {
+        // Copy so we can be terse and use []
+        for (auto levelAndCandidates : mDefaultCandidates) {
+          ASSERT_EQ(1U, levelAndCandidates.second.count(RTP));
+          // do a final UpdateDefaultCandidate here in case candidates were
+          // cleared during renegotiation.
+          session.UpdateDefaultCandidate(
+              levelAndCandidates.second[RTP].first,
+              levelAndCandidates.second[RTP].second,
+              // Will be empty string if not present, which is how we indicate
+              // that there is no default for RTCP
+              levelAndCandidates.second[RTCP].first,
+              levelAndCandidates.second[RTCP].second,
+              levelAndCandidates.first);
+          session.EndOfLocalCandidates(levelAndCandidates.first);
+        }
+      }
+
+      void Trickle(JsepSession& session)
+      {
+        for (const auto& levelMidAndCandidate : mCandidatesToTrickle) {
+          Level level;
+          Mid mid;
+          Candidate candidate;
+          Tie(level, mid, candidate) = levelMidAndCandidate;
+          session.AddRemoteIceCandidate(candidate, mid, level);
+        }
+        mCandidatesToTrickle.clear();
+      }
+
+      void CheckRtpCandidates(bool expectRtpCandidates,
+                              const SdpMediaSection& msection,
+                              size_t transportLevel,
+                              const std::string& context) const
+      {
+        auto& attrs = msection.GetAttributeList();
+
+        ASSERT_EQ(expectRtpCandidates,
+                  attrs.HasAttribute(SdpAttribute::kCandidateAttribute))
+          << context << " (level " << msection.GetLevel() << ")";
+
+        if (expectRtpCandidates) {
+          // Copy so we can be terse and use []
+          auto expectedCandidates = mCandidates;
+          ASSERT_LE(kNumCandidatesPerComponent,
+                    expectedCandidates[transportLevel][RTP].size());
+
+          auto& candidates = attrs.GetCandidate();
+          ASSERT_LE(kNumCandidatesPerComponent, candidates.size())
+            << context << " (level " << msection.GetLevel() << ")";
+          for (size_t i = 0; i < kNumCandidatesPerComponent; ++i) {
+            ASSERT_EQ(expectedCandidates[transportLevel][RTP][i], candidates[i])
+              << context << " (level " << msection.GetLevel() << ")";
+          }
+        }
+      }
+
+      void CheckRtcpCandidates(bool expectRtcpCandidates,
+                               const SdpMediaSection& msection,
+                               size_t transportLevel,
+                               const std::string& context) const
+      {
+        auto& attrs = msection.GetAttributeList();
+
+        if (expectRtcpCandidates) {
+          // Copy so we can be terse and use []
+          auto expectedCandidates = mCandidates;
+          ASSERT_LE(kNumCandidatesPerComponent,
+                    expectedCandidates[transportLevel][RTCP].size());
+
+          ASSERT_TRUE(attrs.HasAttribute(SdpAttribute::kCandidateAttribute))
+            << context << " (level " << msection.GetLevel() << ")";
+          auto& candidates = attrs.GetCandidate();
+          ASSERT_EQ(kNumCandidatesPerComponent * 2, candidates.size())
+            << context << " (level " << msection.GetLevel() << ")";
+          for (size_t i = 0; i < kNumCandidatesPerComponent; ++i) {
+            ASSERT_EQ(expectedCandidates[transportLevel][RTCP][i],
+                      candidates[i + kNumCandidatesPerComponent])
+              << context << " (level " << msection.GetLevel() << ")";
+          }
+        }
+      }
+
+      void CheckDefaultRtpCandidate(bool expectDefault,
+                                    const SdpMediaSection& msection,
+                                    size_t transportLevel,
+                                    const std::string& context) const
+      {
+        if (expectDefault) {
+          // Copy so we can be terse and use []
+          auto defaultCandidates = mDefaultCandidates;
+          ASSERT_EQ(defaultCandidates[transportLevel][RTP].first,
+                    msection.GetConnection().GetAddress())
+            << context << " (level " << msection.GetLevel() << ")";
+          ASSERT_EQ(defaultCandidates[transportLevel][RTP].second,
+                    msection.GetPort())
+            << context << " (level " << msection.GetLevel() << ")";
+        } else {
+          ASSERT_EQ("0.0.0.0", msection.GetConnection().GetAddress())
+            << context << " (level " << msection.GetLevel() << ")";
+          ASSERT_EQ(9U, msection.GetPort())
+            << context << " (level " << msection.GetLevel() << ")";
+        }
+      }
+
+      void CheckDefaultRtcpCandidate(bool expectDefault,
+                                     const SdpMediaSection& msection,
+                                     size_t transportLevel,
+                                     const std::string& context) const
+      {
+        if (expectDefault) {
+          // Copy so we can be terse and use []
+          auto defaultCandidates = mDefaultCandidates;
+          ASSERT_TRUE(msection.GetAttributeList().HasAttribute(
+                SdpAttribute::kRtcpAttribute))
+            << context << " (level " << msection.GetLevel() << ")";
+          auto& rtcpAttr = msection.GetAttributeList().GetRtcp();
+          ASSERT_EQ(defaultCandidates[transportLevel][RTCP].second,
+                    rtcpAttr.mPort)
+            << context << " (level " << msection.GetLevel() << ")";
+          ASSERT_EQ(sdp::kInternet, rtcpAttr.mNetType)
+            << context << " (level " << msection.GetLevel() << ")";
+          ASSERT_EQ(sdp::kIPv4, rtcpAttr.mAddrType)
+            << context << " (level " << msection.GetLevel() << ")";
+          ASSERT_EQ(defaultCandidates[transportLevel][RTCP].first,
+                    rtcpAttr.mAddress)
+            << context << " (level " << msection.GetLevel() << ")";
+        } else {
+          ASSERT_FALSE(msection.GetAttributeList().HasAttribute(
+                SdpAttribute::kRtcpAttribute))
+            << context << " (level " << msection.GetLevel() << ")";
+        }
+      }
+
+    private:
+      typedef size_t Level;
+      typedef std::string Mid;
+      typedef std::string Candidate;
+      typedef std::string Address;
+      typedef uint16_t Port;
+      // Default candidates are put into the m-line, c-line, and rtcp
+      // attribute for endpoints that don't support ICE.
+      std::map<Level,
+               std::map<ComponentType,
+                        std::pair<Address, Port>>> mDefaultCandidates;
+      std::map<Level,
+               std::map<ComponentType,
+                        std::vector<Candidate>>> mCandidates;
+      // Level/mid/candidate tuples that need to be trickled
+      std::vector<Tuple<Level, Mid, Candidate>> mCandidatesToTrickle;
+  };
+
+  // For streaming parse errors
+  std::string
+  GetParseErrors(const SipccSdpParser& parser) const
+  {
+    std::stringstream output;
+    for (auto e = parser.GetParseErrors().begin();
+         e != parser.GetParseErrors().end();
+         ++e) {
+      output << e->first << ": " << e->second << std::endl;
+    }
+    return output.str();
+  }
+
+  void CheckEndOfCandidates(bool expectEoc,
+                            const SdpMediaSection& msection,
+                            const std::string& context)
+  {
+    if (expectEoc) {
+      ASSERT_TRUE(msection.GetAttributeList().HasAttribute(
+            SdpAttribute::kEndOfCandidatesAttribute))
+        << context << " (level " << msection.GetLevel() << ")";
+    } else {
+      ASSERT_FALSE(msection.GetAttributeList().HasAttribute(
+            SdpAttribute::kEndOfCandidatesAttribute))
+        << context << " (level " << msection.GetLevel() << ")";
+    }
+  }
+
+  void CheckPairs(const JsepSession& session, const std::string& context)
+  {
+    auto pairs = session.GetNegotiatedTrackPairs();
+
+    for (JsepTrackPair& pair : pairs) {
+      if (types.size() == 1) {
+        ASSERT_FALSE(pair.mBundleLevel.isSome()) << context;
+      } else {
+        ASSERT_TRUE(pair.mBundleLevel.isSome()) << context;
+        ASSERT_EQ(0U, *pair.mBundleLevel) << context;
+      }
+    }
+  }
+
+  void
+  DisableMsid(std::string* sdp) const {
+    size_t pos = sdp->find("a=msid-semantic");
+    ASSERT_NE(std::string::npos, pos);
+    (*sdp)[pos + 2] = 'X'; // garble, a=Xsid-semantic
+  }
+
+  void
+  DisableBundle(std::string* sdp) const {
+    size_t pos = sdp->find("a=group:BUNDLE");
+    ASSERT_NE(std::string::npos, pos);
+    (*sdp)[pos + 11] = 'G'; // garble, a=group:BUNGLE
+  }
+
+  void
+  DisableMsection(std::string* sdp, size_t level) const {
+    UniquePtr<Sdp> parsed(Parse(*sdp));
+    ASSERT_TRUE(parsed.get());
+    ASSERT_LT(level, parsed->GetMediaSectionCount());
+    SdpHelper::DisableMsection(parsed.get(), &parsed->GetMediaSection(level));
+    (*sdp) = parsed->ToString();
+  }
+
+  void
+  ReplaceInSdp(std::string* sdp,
+               const char* searchStr,
+               const char* replaceStr) const
+  {
+    if (searchStr[0] == '\0') return;
+    size_t pos;
+    while ((pos = sdp->find(searchStr)) != std::string::npos) {
+      sdp->replace(pos, strlen(searchStr), replaceStr);
+    }
+  }
+
+  void
+  ValidateDisabledMSection(const SdpMediaSection* msection)
+  {
+    ASSERT_EQ(1U, msection->GetFormats().size());
+    // Maybe validate that no attributes are present except rtpmap and
+    // inactive? How?
+    ASSERT_EQ(SdpDirectionAttribute::kInactive,
+              msection->GetDirectionAttribute().mValue);
+    if (msection->GetMediaType() == SdpMediaSection::kAudio) {
+      ASSERT_EQ("0", msection->GetFormats()[0]);
+      const SdpRtpmapAttributeList::Rtpmap* rtpmap(msection->FindRtpmap("0"));
+      ASSERT_TRUE(rtpmap);
+      ASSERT_EQ("0", rtpmap->pt);
+      ASSERT_EQ("PCMU", rtpmap->name);
+    } else if (msection->GetMediaType() == SdpMediaSection::kVideo) {
+      ASSERT_EQ("120", msection->GetFormats()[0]);
+      const SdpRtpmapAttributeList::Rtpmap* rtpmap(msection->FindRtpmap("120"));
+      ASSERT_TRUE(rtpmap);
+      ASSERT_EQ("120", rtpmap->pt);
+      ASSERT_EQ("VP8", rtpmap->name);
+    } else if (msection->GetMediaType() == SdpMediaSection::kApplication) {
+      ASSERT_EQ("5000", msection->GetFormats()[0]);
+      const SdpSctpmapAttributeList::Sctpmap* sctpmap(msection->FindSctpmap("5000"));
+      ASSERT_TRUE(sctpmap);
+      ASSERT_EQ("5000", sctpmap->pt);
+      ASSERT_EQ("rejected", sctpmap->name);
+      ASSERT_EQ(0U, sctpmap->streams);
+    } else {
+      // Not that we would have any test which tests this...
+      ASSERT_EQ("19", msection->GetFormats()[0]);
+      const SdpRtpmapAttributeList::Rtpmap* rtpmap(msection->FindRtpmap("19"));
+      ASSERT_TRUE(rtpmap);
+      ASSERT_EQ("19", rtpmap->pt);
+      ASSERT_EQ("reserved", rtpmap->name);
+    }
+  }
+
+  void
+  DumpTrack(const JsepTrack& track)
+  {
+    const JsepTrackNegotiatedDetails* details = track.GetNegotiatedDetails();
+    std::cerr << "  type=" << track.GetMediaType() << std::endl;
+    std::cerr << "  encodings=" << std::endl;
+    for (size_t i = 0; i < details->GetEncodingCount(); ++i) {
+      const JsepTrackEncoding& encoding = details->GetEncoding(i);
+      std::cerr << "    id=" << encoding.mRid << std::endl;
+      for (const JsepCodecDescription* codec : encoding.GetCodecs()) {
+        std::cerr << "      " << codec->mName
+                  << " enabled(" << (codec->mEnabled?"yes":"no") << ")";
+        if (track.GetMediaType() == SdpMediaSection::kAudio) {
+          const JsepAudioCodecDescription* audioCodec =
+              static_cast<const JsepAudioCodecDescription*>(codec);
+          std::cerr << " dtmf(" << (audioCodec->mDtmfEnabled?"yes":"no") << ")";
+        }
+        std::cerr << std::endl;
+      }
+    }
+  }
+
+  void
+  DumpTrackPairs(const JsepSessionImpl& session)
+  {
+    auto pairs = mSessionAns.GetNegotiatedTrackPairs();
+    for (auto i = pairs.begin(); i != pairs.end(); ++i) {
+      std::cerr << "Track pair " << i->mLevel << std::endl;
+      if (i->mSending) {
+        std::cerr << "Sending-->" << std::endl;
+        DumpTrack(*i->mSending);
+      }
+      if (i->mReceiving) {
+        std::cerr << "Receiving-->" << std::endl;
+        DumpTrack(*i->mReceiving);
+      }
+    }
+  }
+
+  UniquePtr<Sdp>
+  Parse(const std::string& sdp) const
+  {
+    SipccSdpParser parser;
+    UniquePtr<Sdp> parsed = parser.Parse(sdp);
+    EXPECT_TRUE(parsed.get()) << "Should have valid SDP" << std::endl
+                              << "Errors were: " << GetParseErrors(parser);
+    return parsed;
+  }
+
+  JsepSessionImpl mSessionOff;
+  CandidateSet mOffCandidates;
+  JsepSessionImpl mSessionAns;
+  CandidateSet mAnsCandidates;
+  std::vector<SdpMediaSection::MediaType> types;
+  std::vector<std::pair<std::string, uint16_t>> mGatheredCandidates;
+
+private:
+  void
+  ValidateTransport(TransportData& source, const std::string& sdp_str)
+  {
+    UniquePtr<Sdp> sdp(Parse(sdp_str));
+    ASSERT_TRUE(!!sdp);
+    size_t num_m_sections = sdp->GetMediaSectionCount();
+    for (size_t i = 0; i < num_m_sections; ++i) {
+      auto& msection = sdp->GetMediaSection(i);
+
+      if (msection.GetMediaType() == SdpMediaSection::kApplication) {
+        ASSERT_EQ(SdpMediaSection::kDtlsSctp, msection.GetProtocol());
+      } else {
+        ASSERT_EQ(SdpMediaSection::kUdpTlsRtpSavpf, msection.GetProtocol());
+      }
+
+      if (msection.GetPort() == 0) {
+        ValidateDisabledMSection(&msection);
+        continue;
+      }
+      const SdpAttributeList& attrs = msection.GetAttributeList();
+      ASSERT_EQ(source.mIceUfrag, attrs.GetIceUfrag());
+      ASSERT_EQ(source.mIcePwd, attrs.GetIcePwd());
+      const SdpFingerprintAttributeList& fps = attrs.GetFingerprint();
+      for (auto fp = fps.mFingerprints.begin(); fp != fps.mFingerprints.end();
+           ++fp) {
+        std::string alg_str = "None";
+
+        if (fp->hashFunc == SdpFingerprintAttributeList::kSha1) {
+          alg_str = "sha-1";
+        } else if (fp->hashFunc == SdpFingerprintAttributeList::kSha256) {
+          alg_str = "sha-256";
+        }
+
+        ASSERT_EQ(source.mFingerprints[alg_str], fp->fingerprint);
+      }
+      ASSERT_EQ(source.mFingerprints.size(), fps.mFingerprints.size());
+    }
+  }
+
+  TransportData mOffererTransport;
+  TransportData mAnswererTransport;
+};
+
+TEST_F(JsepSessionTestBase, CreateDestroy) {}
+
+TEST_P(JsepSessionTest, CreateOffer)
+{
+  AddTracks(mSessionOff);
+  CreateOffer();
+}
+
+TEST_P(JsepSessionTest, CreateOfferSetLocal)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+}
+
+TEST_P(JsepSessionTest, CreateOfferSetLocalSetRemote)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+}
+
+TEST_P(JsepSessionTest, CreateOfferSetLocalSetRemoteCreateAnswer)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+}
+
+TEST_P(JsepSessionTest, CreateOfferSetLocalSetRemoteCreateAnswerSetLocal)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+}
+
+TEST_P(JsepSessionTest, FullCall)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer);
+}
+
+TEST_P(JsepSessionTest, RenegotiationNoChange)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(types.size(), added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer);
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(types.size(), added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  std::string reoffer = CreateOffer();
+  SetLocalOffer(reoffer);
+  SetRemoteOffer(reoffer);
+
+  added = mSessionAns.GetRemoteTracksAdded();
+  removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  std::string reanswer = CreateAnswer();
+  SetLocalAnswer(reanswer);
+  SetRemoteAnswer(reanswer);
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size());
+  for (size_t i = 0; i < answererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(answererPairs[i], newAnswererPairs[i]));
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationOffererAddsTrack)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  std::vector<SdpMediaSection::MediaType> extraTypes;
+  extraTypes.push_back(SdpMediaSection::kAudio);
+  extraTypes.push_back(SdpMediaSection::kVideo);
+  AddTracks(mSessionOff, extraTypes);
+  types.insert(types.end(), extraTypes.begin(), extraTypes.end());
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(2U, added.size());
+  ASSERT_EQ(0U, removed.size());
+  ASSERT_EQ(SdpMediaSection::kAudio, added[0]->GetMediaType());
+  ASSERT_EQ(SdpMediaSection::kVideo, added[1]->GetMediaType());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(offererPairs.size() + 2, newOffererPairs.size());
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+
+  ASSERT_EQ(answererPairs.size() + 2, newAnswererPairs.size());
+  for (size_t i = 0; i < answererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(answererPairs[i], newAnswererPairs[i]));
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationAnswererAddsTrack)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  std::vector<SdpMediaSection::MediaType> extraTypes;
+  extraTypes.push_back(SdpMediaSection::kAudio);
+  extraTypes.push_back(SdpMediaSection::kVideo);
+  AddTracks(mSessionAns, extraTypes);
+  types.insert(types.end(), extraTypes.begin(), extraTypes.end());
+
+  // We need to add a recvonly m-section to the offer for this to work
+  JsepOfferOptions options;
+  options.mOfferToReceiveAudio =
+    Some(GetTrackCount(mSessionOff, SdpMediaSection::kAudio) + 1);
+  options.mOfferToReceiveVideo =
+    Some(GetTrackCount(mSessionOff, SdpMediaSection::kVideo) + 1);
+
+  std::string offer = CreateOffer(Some(options));
+  SetLocalOffer(offer, CHECK_SUCCESS);
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(2U, added.size());
+  ASSERT_EQ(0U, removed.size());
+  ASSERT_EQ(SdpMediaSection::kAudio, added[0]->GetMediaType());
+  ASSERT_EQ(SdpMediaSection::kVideo, added[1]->GetMediaType());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(offererPairs.size() + 2, newOffererPairs.size());
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+
+  ASSERT_EQ(answererPairs.size() + 2, newAnswererPairs.size());
+  for (size_t i = 0; i < answererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(answererPairs[i], newAnswererPairs[i]));
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationBothAddTrack)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  std::vector<SdpMediaSection::MediaType> extraTypes;
+  extraTypes.push_back(SdpMediaSection::kAudio);
+  extraTypes.push_back(SdpMediaSection::kVideo);
+  AddTracks(mSessionAns, extraTypes);
+  AddTracks(mSessionOff, extraTypes);
+  types.insert(types.end(), extraTypes.begin(), extraTypes.end());
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(2U, added.size());
+  ASSERT_EQ(0U, removed.size());
+  ASSERT_EQ(SdpMediaSection::kAudio, added[0]->GetMediaType());
+  ASSERT_EQ(SdpMediaSection::kVideo, added[1]->GetMediaType());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(2U, added.size());
+  ASSERT_EQ(0U, removed.size());
+  ASSERT_EQ(SdpMediaSection::kAudio, added[0]->GetMediaType());
+  ASSERT_EQ(SdpMediaSection::kVideo, added[1]->GetMediaType());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(offererPairs.size() + 2, newOffererPairs.size());
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+
+  ASSERT_EQ(answererPairs.size() + 2, newAnswererPairs.size());
+  for (size_t i = 0; i < answererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(answererPairs[i], newAnswererPairs[i]));
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationBothAddTracksToExistingStream)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  if (GetParam() == "datachannel") {
+    return;
+  }
+
+  OfferAnswer();
+
+  auto oHasStream = HasMediaStream(mSessionOff.GetLocalTracks());
+  auto aHasStream = HasMediaStream(mSessionAns.GetLocalTracks());
+  ASSERT_EQ(oHasStream, GetLocalUniqueStreamIds(mSessionOff).size());
+  ASSERT_EQ(aHasStream, GetLocalUniqueStreamIds(mSessionAns).size());
+  ASSERT_EQ(aHasStream, GetRemoteUniqueStreamIds(mSessionOff).size());
+  ASSERT_EQ(oHasStream, GetRemoteUniqueStreamIds(mSessionAns).size());
+
+  auto firstOffId = GetFirstLocalStreamId(mSessionOff);
+  auto firstAnsId = GetFirstLocalStreamId(mSessionAns);
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  std::vector<SdpMediaSection::MediaType> extraTypes;
+  extraTypes.push_back(SdpMediaSection::kAudio);
+  extraTypes.push_back(SdpMediaSection::kVideo);
+  AddTracksToStream(mSessionOff, firstOffId, extraTypes);
+  AddTracksToStream(mSessionAns, firstAnsId, extraTypes);
+  types.insert(types.end(), extraTypes.begin(), extraTypes.end());
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  oHasStream = HasMediaStream(mSessionOff.GetLocalTracks());
+  aHasStream = HasMediaStream(mSessionAns.GetLocalTracks());
+
+  ASSERT_EQ(oHasStream, GetLocalUniqueStreamIds(mSessionOff).size());
+  ASSERT_EQ(aHasStream, GetLocalUniqueStreamIds(mSessionAns).size());
+  ASSERT_EQ(aHasStream, GetRemoteUniqueStreamIds(mSessionOff).size());
+  ASSERT_EQ(oHasStream, GetRemoteUniqueStreamIds(mSessionAns).size());
+  if (oHasStream) {
+    ASSERT_STREQ(firstOffId.c_str(),
+                 GetFirstLocalStreamId(mSessionOff).c_str());
+  }
+  if (aHasStream) {
+    ASSERT_STREQ(firstAnsId.c_str(),
+                 GetFirstLocalStreamId(mSessionAns).c_str());
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationOffererRemovesTrack)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  if (types.front() == SdpMediaSection::kApplication) {
+    return;
+  }
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  RefPtr<JsepTrack> removedTrack = GetTrackOff(0, types.front());
+  ASSERT_TRUE(removedTrack);
+  ASSERT_EQ(NS_OK, mSessionOff.RemoveTrack(removedTrack->GetStreamId(),
+                                           removedTrack->GetTrackId()));
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(1U, removed.size());
+
+  ASSERT_EQ(removedTrack->GetMediaType(), removed[0]->GetMediaType());
+  ASSERT_EQ(removedTrack->GetStreamId(), removed[0]->GetStreamId());
+  ASSERT_EQ(removedTrack->GetTrackId(), removed[0]->GetTrackId());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  // First m-section should be recvonly
+  auto offer = GetParsedLocalDescription(mSessionOff);
+  auto* msection = GetMsection(*offer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_TRUE(msection->IsReceiving());
+  ASSERT_FALSE(msection->IsSending());
+
+  // First audio m-section should be sendonly
+  auto answer = GetParsedLocalDescription(mSessionAns);
+  msection = GetMsection(*answer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_FALSE(msection->IsReceiving());
+  ASSERT_TRUE(msection->IsSending());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  // Will be the same size since we still have a track on one side.
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+
+  // This should be the only difference.
+  ASSERT_TRUE(offererPairs[0].mSending);
+  ASSERT_FALSE(newOffererPairs[0].mSending);
+
+  // Remove this difference, let loop below take care of the rest
+  offererPairs[0].mSending = nullptr;
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+
+  // Will be the same size since we still have a track on one side.
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size());
+
+  // This should be the only difference.
+  ASSERT_TRUE(answererPairs[0].mReceiving);
+  ASSERT_FALSE(newAnswererPairs[0].mReceiving);
+
+  // Remove this difference, let loop below take care of the rest
+  answererPairs[0].mReceiving = nullptr;
+  for (size_t i = 0; i < answererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(answererPairs[i], newAnswererPairs[i]));
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationAnswererRemovesTrack)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  if (types.front() == SdpMediaSection::kApplication) {
+    return;
+  }
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  RefPtr<JsepTrack> removedTrack = GetTrackAns(0, types.front());
+  ASSERT_TRUE(removedTrack);
+  ASSERT_EQ(NS_OK, mSessionAns.RemoveTrack(removedTrack->GetStreamId(),
+                                           removedTrack->GetTrackId()));
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(1U, removed.size());
+
+  ASSERT_EQ(removedTrack->GetMediaType(), removed[0]->GetMediaType());
+  ASSERT_EQ(removedTrack->GetStreamId(), removed[0]->GetStreamId());
+  ASSERT_EQ(removedTrack->GetTrackId(), removed[0]->GetTrackId());
+
+  // First m-section should be sendrecv
+  auto offer = GetParsedLocalDescription(mSessionOff);
+  auto* msection = GetMsection(*offer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_TRUE(msection->IsReceiving());
+  ASSERT_TRUE(msection->IsSending());
+
+  // First audio m-section should be recvonly
+  auto answer = GetParsedLocalDescription(mSessionAns);
+  msection = GetMsection(*answer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_TRUE(msection->IsReceiving());
+  ASSERT_FALSE(msection->IsSending());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  // Will be the same size since we still have a track on one side.
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+
+  // This should be the only difference.
+  ASSERT_TRUE(offererPairs[0].mReceiving);
+  ASSERT_FALSE(newOffererPairs[0].mReceiving);
+
+  // Remove this difference, let loop below take care of the rest
+  offererPairs[0].mReceiving = nullptr;
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+
+  // Will be the same size since we still have a track on one side.
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size());
+
+  // This should be the only difference.
+  ASSERT_TRUE(answererPairs[0].mSending);
+  ASSERT_FALSE(newAnswererPairs[0].mSending);
+
+  // Remove this difference, let loop below take care of the rest
+  answererPairs[0].mSending = nullptr;
+  for (size_t i = 0; i < answererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(answererPairs[i], newAnswererPairs[i]));
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationBothRemoveTrack)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  if (types.front() == SdpMediaSection::kApplication) {
+    return;
+  }
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  RefPtr<JsepTrack> removedTrackAnswer = GetTrackAns(0, types.front());
+  ASSERT_TRUE(removedTrackAnswer);
+  ASSERT_EQ(NS_OK, mSessionAns.RemoveTrack(removedTrackAnswer->GetStreamId(),
+                                           removedTrackAnswer->GetTrackId()));
+
+  RefPtr<JsepTrack> removedTrackOffer = GetTrackOff(0, types.front());
+  ASSERT_TRUE(removedTrackOffer);
+  ASSERT_EQ(NS_OK, mSessionOff.RemoveTrack(removedTrackOffer->GetStreamId(),
+                                           removedTrackOffer->GetTrackId()));
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(1U, removed.size());
+
+  ASSERT_EQ(removedTrackOffer->GetMediaType(), removed[0]->GetMediaType());
+  ASSERT_EQ(removedTrackOffer->GetStreamId(), removed[0]->GetStreamId());
+  ASSERT_EQ(removedTrackOffer->GetTrackId(), removed[0]->GetTrackId());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(1U, removed.size());
+
+  ASSERT_EQ(removedTrackAnswer->GetMediaType(), removed[0]->GetMediaType());
+  ASSERT_EQ(removedTrackAnswer->GetStreamId(), removed[0]->GetStreamId());
+  ASSERT_EQ(removedTrackAnswer->GetTrackId(), removed[0]->GetTrackId());
+
+  // First m-section should be recvonly
+  auto offer = GetParsedLocalDescription(mSessionOff);
+  auto* msection = GetMsection(*offer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_TRUE(msection->IsReceiving());
+  ASSERT_FALSE(msection->IsSending());
+
+  // First m-section should be inactive, and rejected
+  auto answer = GetParsedLocalDescription(mSessionAns);
+  msection = GetMsection(*answer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_FALSE(msection->IsReceiving());
+  ASSERT_FALSE(msection->IsSending());
+  ASSERT_FALSE(msection->GetPort());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size() + 1);
+
+  for (size_t i = 0; i < newOffererPairs.size(); ++i) {
+    JsepTrackPair oldPair(offererPairs[i + 1]);
+    JsepTrackPair newPair(newOffererPairs[i]);
+    ASSERT_EQ(oldPair.mLevel, newPair.mLevel);
+    ASSERT_EQ(oldPair.mSending.get(), newPair.mSending.get());
+    ASSERT_EQ(oldPair.mReceiving.get(), newPair.mReceiving.get());
+    ASSERT_TRUE(oldPair.mBundleLevel.isSome());
+    ASSERT_TRUE(newPair.mBundleLevel.isSome());
+    ASSERT_EQ(0U, *oldPair.mBundleLevel);
+    ASSERT_EQ(1U, *newPair.mBundleLevel);
+  }
+
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size() + 1);
+
+  for (size_t i = 0; i < newAnswererPairs.size(); ++i) {
+    JsepTrackPair oldPair(answererPairs[i + 1]);
+    JsepTrackPair newPair(newAnswererPairs[i]);
+    ASSERT_EQ(oldPair.mLevel, newPair.mLevel);
+    ASSERT_EQ(oldPair.mSending.get(), newPair.mSending.get());
+    ASSERT_EQ(oldPair.mReceiving.get(), newPair.mReceiving.get());
+    ASSERT_TRUE(oldPair.mBundleLevel.isSome());
+    ASSERT_TRUE(newPair.mBundleLevel.isSome());
+    ASSERT_EQ(0U, *oldPair.mBundleLevel);
+    ASSERT_EQ(1U, *newPair.mBundleLevel);
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationBothRemoveThenAddTrack)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  if (types.front() == SdpMediaSection::kApplication) {
+    return;
+  }
+
+  SdpMediaSection::MediaType removedType = types.front();
+
+  OfferAnswer();
+
+  RefPtr<JsepTrack> removedTrackAnswer = GetTrackAns(0, removedType);
+  ASSERT_TRUE(removedTrackAnswer);
+  ASSERT_EQ(NS_OK, mSessionAns.RemoveTrack(removedTrackAnswer->GetStreamId(),
+                                           removedTrackAnswer->GetTrackId()));
+
+  RefPtr<JsepTrack> removedTrackOffer = GetTrackOff(0, removedType);
+  ASSERT_TRUE(removedTrackOffer);
+  ASSERT_EQ(NS_OK, mSessionOff.RemoveTrack(removedTrackOffer->GetStreamId(),
+                                           removedTrackOffer->GetTrackId()));
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  std::vector<SdpMediaSection::MediaType> extraTypes;
+  extraTypes.push_back(removedType);
+  AddTracks(mSessionAns, extraTypes);
+  AddTracks(mSessionOff, extraTypes);
+  types.insert(types.end(), extraTypes.begin(), extraTypes.end());
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(1U, added.size());
+  ASSERT_EQ(0U, removed.size());
+  ASSERT_EQ(removedType, added[0]->GetMediaType());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(1U, added.size());
+  ASSERT_EQ(0U, removed.size());
+  ASSERT_EQ(removedType, added[0]->GetMediaType());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(offererPairs.size() + 1, newOffererPairs.size());
+  ASSERT_EQ(answererPairs.size() + 1, newAnswererPairs.size());
+
+  // Ensure that the m-section was re-used; no gaps
+  for (size_t i = 0; i < newOffererPairs.size(); ++i) {
+    ASSERT_EQ(i, newOffererPairs[i].mLevel);
+  }
+  for (size_t i = 0; i < newAnswererPairs.size(); ++i) {
+    ASSERT_EQ(i, newAnswererPairs[i].mLevel);
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationBothRemoveTrackDifferentMsection)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  if (types.front() == SdpMediaSection::kApplication) {
+    return;
+  }
+
+  if (types.size() < 2 || types[0] != types[1]) {
+    // For simplicity, just run in cases where we have two of the same type
+    return;
+  }
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  RefPtr<JsepTrack> removedTrackAnswer = GetTrackAns(0, types.front());
+  ASSERT_TRUE(removedTrackAnswer);
+  ASSERT_EQ(NS_OK, mSessionAns.RemoveTrack(removedTrackAnswer->GetStreamId(),
+                                           removedTrackAnswer->GetTrackId()));
+
+  // Second instance of the same type
+  RefPtr<JsepTrack> removedTrackOffer = GetTrackOff(1, types.front());
+  ASSERT_TRUE(removedTrackOffer);
+  ASSERT_EQ(NS_OK, mSessionOff.RemoveTrack(removedTrackOffer->GetStreamId(),
+                                           removedTrackOffer->GetTrackId()));
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(1U, removed.size());
+
+  ASSERT_EQ(removedTrackOffer->GetMediaType(), removed[0]->GetMediaType());
+  ASSERT_EQ(removedTrackOffer->GetStreamId(), removed[0]->GetStreamId());
+  ASSERT_EQ(removedTrackOffer->GetTrackId(), removed[0]->GetTrackId());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(1U, removed.size());
+
+  ASSERT_EQ(removedTrackAnswer->GetMediaType(), removed[0]->GetMediaType());
+  ASSERT_EQ(removedTrackAnswer->GetStreamId(), removed[0]->GetStreamId());
+  ASSERT_EQ(removedTrackAnswer->GetTrackId(), removed[0]->GetTrackId());
+
+  // Second m-section should be recvonly
+  auto offer = GetParsedLocalDescription(mSessionOff);
+  auto* msection = GetMsection(*offer, types.front(), 1);
+  ASSERT_TRUE(msection);
+  ASSERT_TRUE(msection->IsReceiving());
+  ASSERT_FALSE(msection->IsSending());
+
+  // First m-section should be recvonly
+  auto answer = GetParsedLocalDescription(mSessionAns);
+  msection = GetMsection(*answer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_TRUE(msection->IsReceiving());
+  ASSERT_FALSE(msection->IsSending());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+
+  // This should be the only difference.
+  ASSERT_TRUE(offererPairs[0].mReceiving);
+  ASSERT_FALSE(newOffererPairs[0].mReceiving);
+
+  // Remove this difference, let loop below take care of the rest
+  offererPairs[0].mReceiving = nullptr;
+
+  // This should be the only difference.
+  ASSERT_TRUE(offererPairs[1].mSending);
+  ASSERT_FALSE(newOffererPairs[1].mSending);
+
+  // Remove this difference, let loop below take care of the rest
+  offererPairs[1].mSending = nullptr;
+
+  for (size_t i = 0; i < newOffererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size());
+
+  // This should be the only difference.
+  ASSERT_TRUE(answererPairs[0].mSending);
+  ASSERT_FALSE(newAnswererPairs[0].mSending);
+
+  // Remove this difference, let loop below take care of the rest
+  answererPairs[0].mSending = nullptr;
+
+  // This should be the only difference.
+  ASSERT_TRUE(answererPairs[1].mReceiving);
+  ASSERT_FALSE(newAnswererPairs[1].mReceiving);
+
+  // Remove this difference, let loop below take care of the rest
+  answererPairs[1].mReceiving = nullptr;
+
+  for (size_t i = 0; i < newAnswererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(answererPairs[i], newAnswererPairs[i]));
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationOffererReplacesTrack)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  if (types.front() == SdpMediaSection::kApplication) {
+    return;
+  }
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  RefPtr<JsepTrack> removedTrack = GetTrackOff(0, types.front());
+  ASSERT_TRUE(removedTrack);
+  ASSERT_EQ(NS_OK, mSessionOff.RemoveTrack(removedTrack->GetStreamId(),
+                                           removedTrack->GetTrackId()));
+  RefPtr<JsepTrack> addedTrack(
+      new JsepTrack(types.front(), "newstream", "newtrack"));
+  ASSERT_EQ(NS_OK, mSessionOff.AddTrack(addedTrack));
+
+  OfferAnswer(CHECK_SUCCESS);
+
+  auto added = mSessionAns.GetRemoteTracksAdded();
+  auto removed = mSessionAns.GetRemoteTracksRemoved();
+  ASSERT_EQ(1U, added.size());
+  ASSERT_EQ(1U, removed.size());
+
+  ASSERT_EQ(removedTrack->GetMediaType(), removed[0]->GetMediaType());
+  ASSERT_EQ(removedTrack->GetStreamId(), removed[0]->GetStreamId());
+  ASSERT_EQ(removedTrack->GetTrackId(), removed[0]->GetTrackId());
+
+  ASSERT_EQ(addedTrack->GetMediaType(), added[0]->GetMediaType());
+  ASSERT_EQ(addedTrack->GetStreamId(), added[0]->GetStreamId());
+  ASSERT_EQ(addedTrack->GetTrackId(), added[0]->GetTrackId());
+
+  added = mSessionOff.GetRemoteTracksAdded();
+  removed = mSessionOff.GetRemoteTracksRemoved();
+  ASSERT_EQ(0U, added.size());
+  ASSERT_EQ(0U, removed.size());
+
+  // First audio m-section should be sendrecv
+  auto offer = GetParsedLocalDescription(mSessionOff);
+  auto* msection = GetMsection(*offer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_TRUE(msection->IsReceiving());
+  ASSERT_TRUE(msection->IsSending());
+
+  // First audio m-section should be sendrecv
+  auto answer = GetParsedLocalDescription(mSessionAns);
+  msection = GetMsection(*answer, types.front(), 0);
+  ASSERT_TRUE(msection);
+  ASSERT_TRUE(msection->IsReceiving());
+  ASSERT_TRUE(msection->IsSending());
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+
+  ASSERT_NE(offererPairs[0].mSending->GetStreamId(),
+            newOffererPairs[0].mSending->GetStreamId());
+  ASSERT_NE(offererPairs[0].mSending->GetTrackId(),
+            newOffererPairs[0].mSending->GetTrackId());
+
+  // Skip first pair
+  for (size_t i = 1; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size());
+
+  ASSERT_NE(answererPairs[0].mReceiving->GetStreamId(),
+            newAnswererPairs[0].mReceiving->GetStreamId());
+  ASSERT_NE(answererPairs[0].mReceiving->GetTrackId(),
+            newAnswererPairs[0].mReceiving->GetTrackId());
+
+  // Skip first pair
+  for (size_t i = 1; i < newAnswererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(answererPairs[i], newAnswererPairs[i]));
+  }
+}
+
+// Tests whether auto-assigned remote msids (ie; what happens when the other
+// side doesn't use msid attributes) are stable across renegotiation.
+TEST_P(JsepSessionTest, RenegotiationAutoAssignedMsidIsStable)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+
+  DisableMsid(&answer);
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+
+  // Make sure that DisableMsid actually worked, since it is kinda hacky
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+  ASSERT_EQ(offererPairs.size(), answererPairs.size());
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(offererPairs[i].mReceiving);
+    ASSERT_TRUE(answererPairs[i].mSending);
+    // These should not match since we've monkeyed with the msid
+    ASSERT_NE(offererPairs[i].mReceiving->GetStreamId(),
+              answererPairs[i].mSending->GetStreamId());
+    ASSERT_NE(offererPairs[i].mReceiving->GetTrackId(),
+              answererPairs[i].mSending->GetTrackId());
+  }
+
+  offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  answer = CreateAnswer();
+  SetLocalAnswer(answer);
+
+  DisableMsid(&answer);
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  auto newOffererPairs = mSessionOff.GetNegotiatedTrackPairs();
+
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_TRUE(Equals(offererPairs[i], newOffererPairs[i]));
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationOffererDisablesTelephoneEvent)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+
+  // check all the audio tracks to make sure they have 2 codecs (109 and 101),
+  // and dtmf is enabled on all audio tracks
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    std::vector<JsepTrack*> tracks;
+    tracks.push_back(offererPairs[i].mSending.get());
+    tracks.push_back(offererPairs[i].mReceiving.get());
+    for (JsepTrack *track : tracks) {
+      if (track->GetMediaType() != SdpMediaSection::kAudio) {
+        continue;
+      }
+      const JsepTrackNegotiatedDetails* details = track->GetNegotiatedDetails();
+      ASSERT_EQ(1U, details->GetEncodingCount());
+      const JsepTrackEncoding& encoding = details->GetEncoding(0);
+      ASSERT_EQ(2U, encoding.GetCodecs().size());
+      ASSERT_TRUE(encoding.HasFormat("109"));
+      ASSERT_TRUE(encoding.HasFormat("101"));
+      for (JsepCodecDescription* codec: encoding.GetCodecs()) {
+        ASSERT_TRUE(codec);
+        // we can cast here because we've already checked for audio track
+        JsepAudioCodecDescription *audioCodec =
+            static_cast<JsepAudioCodecDescription*>(codec);
+        ASSERT_TRUE(audioCodec->mDtmfEnabled);
+      }
+    }
+  }
+
+  std::string offer = CreateOffer();
+  ReplaceInSdp(&offer, " 109 101 ", " 109 ");
+  ReplaceInSdp(&offer, "a=fmtp:101 0-15\r\n", "");
+  ReplaceInSdp(&offer, "a=rtpmap:101 telephone-event/8000/1\r\n", "");
+  std::cerr << "modified OFFER: " << offer << std::endl;
+
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer);
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+
+  // check all the audio tracks to make sure they have 1 codec (109),
+  // and dtmf is disabled on all audio tracks
+  for (size_t i = 0; i < newOffererPairs.size(); ++i) {
+    std::vector<JsepTrack*> tracks;
+    tracks.push_back(newOffererPairs[i].mSending.get());
+    tracks.push_back(newOffererPairs[i].mReceiving.get());
+    for (JsepTrack* track : tracks) {
+      if (track->GetMediaType() != SdpMediaSection::kAudio) {
+        continue;
+      }
+      const JsepTrackNegotiatedDetails* details = track->GetNegotiatedDetails();
+      ASSERT_EQ(1U, details->GetEncodingCount());
+      const JsepTrackEncoding& encoding = details->GetEncoding(0);
+      ASSERT_EQ(1U, encoding.GetCodecs().size());
+      ASSERT_TRUE(encoding.HasFormat("109"));
+      // we can cast here because we've already checked for audio track
+      JsepAudioCodecDescription *audioCodec =
+          static_cast<JsepAudioCodecDescription*>(encoding.GetCodecs()[0]);
+      ASSERT_TRUE(audioCodec);
+      ASSERT_FALSE(audioCodec->mDtmfEnabled);
+    }
+  }
+}
+
+// Tests behavior when the answerer does not use msid in the initial exchange,
+// but does on renegotiation.
+TEST_P(JsepSessionTest, RenegotiationAnswererEnablesMsid)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+
+  DisableMsid(&answer);
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+
+  offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  auto newOffererPairs = mSessionOff.GetNegotiatedTrackPairs();
+
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_EQ(offererPairs[i].mReceiving->GetMediaType(),
+              newOffererPairs[i].mReceiving->GetMediaType());
+
+    ASSERT_EQ(offererPairs[i].mSending, newOffererPairs[i].mSending);
+    ASSERT_TRUE(Equals(offererPairs[i].mRtpTransport,
+                       newOffererPairs[i].mRtpTransport));
+    ASSERT_TRUE(Equals(offererPairs[i].mRtcpTransport,
+                       newOffererPairs[i].mRtcpTransport));
+
+    if (offererPairs[i].mReceiving->GetMediaType() ==
+        SdpMediaSection::kApplication) {
+      ASSERT_EQ(offererPairs[i].mReceiving, newOffererPairs[i].mReceiving);
+    } else {
+      // This should be the only difference
+      ASSERT_NE(offererPairs[i].mReceiving, newOffererPairs[i].mReceiving);
+    }
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationAnswererDisablesMsid)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+
+  offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  AddTracks(mSessionAns);
+  answer = CreateAnswer();
+  SetLocalAnswer(answer);
+
+  DisableMsid(&answer);
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  auto newOffererPairs = mSessionOff.GetNegotiatedTrackPairs();
+
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+  for (size_t i = 0; i < offererPairs.size(); ++i) {
+    ASSERT_EQ(offererPairs[i].mReceiving->GetMediaType(),
+              newOffererPairs[i].mReceiving->GetMediaType());
+
+    ASSERT_EQ(offererPairs[i].mSending, newOffererPairs[i].mSending);
+    ASSERT_TRUE(Equals(offererPairs[i].mRtpTransport,
+                       newOffererPairs[i].mRtpTransport));
+    ASSERT_TRUE(Equals(offererPairs[i].mRtcpTransport,
+                       newOffererPairs[i].mRtcpTransport));
+
+    if (offererPairs[i].mReceiving->GetMediaType() ==
+        SdpMediaSection::kApplication) {
+      ASSERT_EQ(offererPairs[i].mReceiving, newOffererPairs[i].mReceiving);
+    } else {
+      // This should be the only difference
+      ASSERT_NE(offererPairs[i].mReceiving, newOffererPairs[i].mReceiving);
+    }
+  }
+}
+
+// Tests behavior when offerer does not use bundle on the initial offer/answer,
+// but does on renegotiation.
+TEST_P(JsepSessionTest, RenegotiationOffererEnablesBundle)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  if (types.size() < 2) {
+    // No bundle will happen here.
+    return;
+  }
+
+  std::string offer = CreateOffer();
+
+  DisableBundle(&offer);
+
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer);
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  OfferAnswer();
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(newOffererPairs.size(), newAnswererPairs.size());
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size());
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size());
+
+  for (size_t i = 0; i < newOffererPairs.size(); ++i) {
+    // No bundle initially
+    ASSERT_FALSE(offererPairs[i].mBundleLevel.isSome());
+    ASSERT_FALSE(answererPairs[i].mBundleLevel.isSome());
+    if (i != 0) {
+      ASSERT_NE(offererPairs[0].mRtpTransport.get(),
+                offererPairs[i].mRtpTransport.get());
+      if (offererPairs[0].mRtcpTransport) {
+        ASSERT_NE(offererPairs[0].mRtcpTransport.get(),
+                  offererPairs[i].mRtcpTransport.get());
+      }
+      ASSERT_NE(answererPairs[0].mRtpTransport.get(),
+                answererPairs[i].mRtpTransport.get());
+      if (answererPairs[0].mRtcpTransport) {
+        ASSERT_NE(answererPairs[0].mRtcpTransport.get(),
+                  answererPairs[i].mRtcpTransport.get());
+      }
+    }
+
+    // Verify that bundle worked after renegotiation
+    ASSERT_TRUE(newOffererPairs[i].mBundleLevel.isSome());
+    ASSERT_TRUE(newAnswererPairs[i].mBundleLevel.isSome());
+    ASSERT_EQ(newOffererPairs[0].mRtpTransport.get(),
+              newOffererPairs[i].mRtpTransport.get());
+    ASSERT_EQ(newOffererPairs[0].mRtcpTransport.get(),
+              newOffererPairs[i].mRtcpTransport.get());
+    ASSERT_EQ(newAnswererPairs[0].mRtpTransport.get(),
+              newAnswererPairs[i].mRtpTransport.get());
+    ASSERT_EQ(newAnswererPairs[0].mRtcpTransport.get(),
+              newAnswererPairs[i].mRtcpTransport.get());
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationOffererDisablesBundleTransport)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  if (types.size() < 2) {
+    return;
+  }
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  std::string reoffer = CreateOffer();
+
+  DisableMsection(&reoffer, 0);
+
+  SetLocalOffer(reoffer, CHECK_SUCCESS);
+  SetRemoteOffer(reoffer, CHECK_SUCCESS);
+  std::string reanswer = CreateAnswer();
+  SetLocalAnswer(reanswer, CHECK_SUCCESS);
+  SetRemoteAnswer(reanswer, CHECK_SUCCESS);
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(newOffererPairs.size(), newAnswererPairs.size());
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size() + 1);
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size() + 1);
+
+  for (size_t i = 0; i < newOffererPairs.size(); ++i) {
+    ASSERT_TRUE(newOffererPairs[i].mBundleLevel.isSome());
+    ASSERT_TRUE(newAnswererPairs[i].mBundleLevel.isSome());
+    ASSERT_EQ(1U, *newOffererPairs[i].mBundleLevel);
+    ASSERT_EQ(1U, *newAnswererPairs[i].mBundleLevel);
+    ASSERT_EQ(newOffererPairs[0].mRtpTransport.get(),
+              newOffererPairs[i].mRtpTransport.get());
+    ASSERT_EQ(newOffererPairs[0].mRtcpTransport.get(),
+              newOffererPairs[i].mRtcpTransport.get());
+    ASSERT_EQ(newAnswererPairs[0].mRtpTransport.get(),
+              newAnswererPairs[i].mRtpTransport.get());
+    ASSERT_EQ(newAnswererPairs[0].mRtcpTransport.get(),
+              newAnswererPairs[i].mRtcpTransport.get());
+  }
+
+  ASSERT_NE(newOffererPairs[0].mRtpTransport.get(),
+            offererPairs[0].mRtpTransport.get());
+  ASSERT_NE(newAnswererPairs[0].mRtpTransport.get(),
+            answererPairs[0].mRtpTransport.get());
+
+  ASSERT_LE(1U, mSessionOff.GetTransports().size());
+  ASSERT_LE(1U, mSessionAns.GetTransports().size());
+
+  ASSERT_EQ(0U, mSessionOff.GetTransports()[0]->mComponents);
+  ASSERT_EQ(0U, mSessionAns.GetTransports()[0]->mComponents);
+}
+
+TEST_P(JsepSessionTest, RenegotiationAnswererDisablesBundleTransport)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  if (types.size() < 2) {
+    return;
+  }
+
+  OfferAnswer();
+
+  auto offererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto answererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  std::string reoffer = CreateOffer();
+  SetLocalOffer(reoffer, CHECK_SUCCESS);
+  SetRemoteOffer(reoffer, CHECK_SUCCESS);
+  std::string reanswer = CreateAnswer();
+
+  DisableMsection(&reanswer, 0);
+
+  SetLocalAnswer(reanswer, CHECK_SUCCESS);
+  SetRemoteAnswer(reanswer, CHECK_SUCCESS);
+
+  auto newOffererPairs = GetTrackPairsByLevel(mSessionOff);
+  auto newAnswererPairs = GetTrackPairsByLevel(mSessionAns);
+
+  ASSERT_EQ(newOffererPairs.size(), newAnswererPairs.size());
+  ASSERT_EQ(offererPairs.size(), newOffererPairs.size() + 1);
+  ASSERT_EQ(answererPairs.size(), newAnswererPairs.size() + 1);
+
+  for (size_t i = 0; i < newOffererPairs.size(); ++i) {
+    ASSERT_TRUE(newOffererPairs[i].mBundleLevel.isSome());
+    ASSERT_TRUE(newAnswererPairs[i].mBundleLevel.isSome());
+    ASSERT_EQ(1U, *newOffererPairs[i].mBundleLevel);
+    ASSERT_EQ(1U, *newAnswererPairs[i].mBundleLevel);
+    ASSERT_EQ(newOffererPairs[0].mRtpTransport.get(),
+              newOffererPairs[i].mRtpTransport.get());
+    ASSERT_EQ(newOffererPairs[0].mRtcpTransport.get(),
+              newOffererPairs[i].mRtcpTransport.get());
+    ASSERT_EQ(newAnswererPairs[0].mRtpTransport.get(),
+              newAnswererPairs[i].mRtpTransport.get());
+    ASSERT_EQ(newAnswererPairs[0].mRtcpTransport.get(),
+              newAnswererPairs[i].mRtcpTransport.get());
+  }
+
+  ASSERT_NE(newOffererPairs[0].mRtpTransport.get(),
+            offererPairs[0].mRtpTransport.get());
+  ASSERT_NE(newAnswererPairs[0].mRtpTransport.get(),
+            answererPairs[0].mRtpTransport.get());
+}
+
+TEST_P(JsepSessionTest, ParseRejectsBadMediaFormat)
+{
+  if (GetParam() == "datachannel") {
+    return;
+  }
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  UniquePtr<Sdp> munge(Parse(offer));
+  SdpMediaSection& mediaSection = munge->GetMediaSection(0);
+  mediaSection.AddCodec("75", "DummyFormatVal", 8000, 1);
+  std::string sdpString = munge->ToString();
+  nsresult rv = mSessionOff.SetLocalDescription(kJsepSdpOffer, sdpString);
+  ASSERT_EQ(NS_ERROR_INVALID_ARG, rv);
+}
+
+TEST_P(JsepSessionTest, FullCallWithCandidates)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  mOffCandidates.Gather(mSessionOff, types);
+
+  UniquePtr<Sdp> localOffer(Parse(mSessionOff.GetLocalDescription()));
+  for (size_t i = 0; i < localOffer->GetMediaSectionCount(); ++i) {
+    mOffCandidates.CheckRtpCandidates(
+        true, localOffer->GetMediaSection(i), i,
+        "Local offer after gathering should have RTP candidates.");
+    mOffCandidates.CheckDefaultRtpCandidate(
+        true, localOffer->GetMediaSection(i), i,
+        "Local offer after gathering should have a default RTP candidate.");
+    mOffCandidates.CheckRtcpCandidates(
+        types[i] != SdpMediaSection::kApplication,
+        localOffer->GetMediaSection(i), i,
+        "Local offer after gathering should have RTCP candidates "
+        "(unless m=application)");
+    mOffCandidates.CheckDefaultRtcpCandidate(
+        types[i] != SdpMediaSection::kApplication,
+        localOffer->GetMediaSection(i), i,
+        "Local offer after gathering should have a default RTCP candidate "
+        "(unless m=application)");
+    CheckEndOfCandidates(true, localOffer->GetMediaSection(i),
+        "Local offer after gathering should have an end-of-candidates.");
+  }
+
+  SetRemoteOffer(offer);
+  mOffCandidates.Trickle(mSessionAns);
+
+  UniquePtr<Sdp> remoteOffer(Parse(mSessionAns.GetRemoteDescription()));
+  for (size_t i = 0; i < remoteOffer->GetMediaSectionCount(); ++i) {
+    mOffCandidates.CheckRtpCandidates(
+        true, remoteOffer->GetMediaSection(i), i,
+        "Remote offer after trickle should have RTP candidates.");
+    mOffCandidates.CheckDefaultRtpCandidate(
+        false, remoteOffer->GetMediaSection(i), i,
+        "Initial remote offer should not have a default RTP candidate.");
+    mOffCandidates.CheckRtcpCandidates(
+        types[i] != SdpMediaSection::kApplication,
+        remoteOffer->GetMediaSection(i), i,
+        "Remote offer after trickle should have RTCP candidates "
+        "(unless m=application)");
+    mOffCandidates.CheckDefaultRtcpCandidate(
+        false, remoteOffer->GetMediaSection(i), i,
+        "Initial remote offer should not have a default RTCP candidate.");
+    CheckEndOfCandidates(false, remoteOffer->GetMediaSection(i),
+        "Initial remote offer should not have an end-of-candidates.");
+  }
+
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  // This will gather candidates that mSessionAns knows it doesn't need.
+  // They should not be present in the SDP.
+  mAnsCandidates.Gather(mSessionAns, types);
+
+  UniquePtr<Sdp> localAnswer(Parse(mSessionAns.GetLocalDescription()));
+  for (size_t i = 0; i < localAnswer->GetMediaSectionCount(); ++i) {
+    mAnsCandidates.CheckRtpCandidates(
+        i == 0, localAnswer->GetMediaSection(i), i,
+        "Local answer after gathering should have RTP candidates on level 0.");
+    mAnsCandidates.CheckDefaultRtpCandidate(
+        true, localAnswer->GetMediaSection(i), 0,
+        "Local answer after gathering should have a default RTP candidate "
+        "on all levels that matches transport level 0.");
+    mAnsCandidates.CheckRtcpCandidates(
+        false, localAnswer->GetMediaSection(i), i,
+        "Local answer after gathering should not have RTCP candidates "
+        "(because we're answering with rtcp-mux)");
+    mAnsCandidates.CheckDefaultRtcpCandidate(
+        false, localAnswer->GetMediaSection(i), i,
+        "Local answer after gathering should not have a default RTCP candidate "
+        "(because we're answering with rtcp-mux)");
+    CheckEndOfCandidates(i == 0, localAnswer->GetMediaSection(i),
+        "Local answer after gathering should have an end-of-candidates only for"
+        " level 0.");
+  }
+
+  SetRemoteAnswer(answer);
+  mAnsCandidates.Trickle(mSessionOff);
+
+  UniquePtr<Sdp> remoteAnswer(Parse(mSessionOff.GetRemoteDescription()));
+  for (size_t i = 0; i < remoteAnswer->GetMediaSectionCount(); ++i) {
+    mAnsCandidates.CheckRtpCandidates(
+        i == 0, remoteAnswer->GetMediaSection(i), i,
+        "Remote answer after trickle should have RTP candidates on level 0.");
+    mAnsCandidates.CheckDefaultRtpCandidate(
+        false, remoteAnswer->GetMediaSection(i), i,
+        "Remote answer after trickle should not have a default RTP candidate.");
+    mAnsCandidates.CheckRtcpCandidates(
+        false, remoteAnswer->GetMediaSection(i), i,
+        "Remote answer after trickle should not have RTCP candidates "
+        "(because we're answering with rtcp-mux)");
+    mAnsCandidates.CheckDefaultRtcpCandidate(
+        false, remoteAnswer->GetMediaSection(i), i,
+        "Remote answer after trickle should not have a default RTCP "
+        "candidate.");
+    CheckEndOfCandidates(false, remoteAnswer->GetMediaSection(i),
+        "Remote answer after trickle should not have an end-of-candidates.");
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationWithCandidates)
+{
+  AddTracks(mSessionOff);
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  mOffCandidates.Gather(mSessionOff, types);
+  SetRemoteOffer(offer);
+  mOffCandidates.Trickle(mSessionAns);
+  AddTracks(mSessionAns);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  mAnsCandidates.Gather(mSessionAns, types);
+  SetRemoteAnswer(answer);
+  mAnsCandidates.Trickle(mSessionOff);
+
+  offer = CreateOffer();
+  SetLocalOffer(offer);
+
+  UniquePtr<Sdp> parsedOffer(Parse(offer));
+  for (size_t i = 0; i < parsedOffer->GetMediaSectionCount(); ++i) {
+    mOffCandidates.CheckRtpCandidates(
+        i == 0, parsedOffer->GetMediaSection(i), i,
+        "Local reoffer before gathering should have RTP candidates on level 0"
+        " only.");
+    mOffCandidates.CheckDefaultRtpCandidate(
+        i == 0, parsedOffer->GetMediaSection(i), 0,
+        "Local reoffer before gathering should have a default RTP candidate "
+        "on level 0 only.");
+    mOffCandidates.CheckRtcpCandidates(
+        false, parsedOffer->GetMediaSection(i), i,
+        "Local reoffer before gathering should not have RTCP candidates.");
+    mOffCandidates.CheckDefaultRtcpCandidate(
+        false, parsedOffer->GetMediaSection(i), i,
+        "Local reoffer before gathering should not have a default RTCP "
+        "candidate.");
+    CheckEndOfCandidates(false, parsedOffer->GetMediaSection(i),
+        "Local reoffer before gathering should not have an end-of-candidates.");
+  }
+
+  // mSessionAns should generate a reoffer that is similar
+  std::string otherOffer;
+  JsepOfferOptions defaultOptions;
+  nsresult rv = mSessionAns.CreateOffer(defaultOptions, &otherOffer);
+  ASSERT_EQ(NS_OK, rv);
+  parsedOffer = Parse(otherOffer);
+  for (size_t i = 0; i < parsedOffer->GetMediaSectionCount(); ++i) {
+    mAnsCandidates.CheckRtpCandidates(
+        i == 0, parsedOffer->GetMediaSection(i), i,
+        "Local reoffer before gathering should have RTP candidates on level 0"
+        " only. (previous answerer)");
+    mAnsCandidates.CheckDefaultRtpCandidate(
+        i == 0, parsedOffer->GetMediaSection(i), 0,
+        "Local reoffer before gathering should have a default RTP candidate "
+        "on level 0 only. (previous answerer)");
+    mAnsCandidates.CheckRtcpCandidates(
+        false, parsedOffer->GetMediaSection(i), i,
+        "Local reoffer before gathering should not have RTCP candidates."
+        " (previous answerer)");
+    mAnsCandidates.CheckDefaultRtcpCandidate(
+        false, parsedOffer->GetMediaSection(i), i,
+        "Local reoffer before gathering should not have a default RTCP "
+        "candidate. (previous answerer)");
+    CheckEndOfCandidates(false, parsedOffer->GetMediaSection(i),
+        "Local reoffer before gathering should not have an end-of-candidates. "
+        "(previous answerer)");
+  }
+
+  // Ok, let's continue with the renegotiation
+  SetRemoteOffer(offer);
+
+  // PeerConnection will not re-gather for RTP, but it will for RTCP in case
+  // the answerer decides to turn off rtcp-mux.
+  if (types[0] != SdpMediaSection::kApplication) {
+    mOffCandidates.Gather(mSessionOff, 0, RTCP);
+  }
+
+  // Since the remaining levels were bundled, PeerConnection will re-gather for
+  // both RTP and RTCP, in case the answerer rejects bundle.
+  for (size_t level = 1; level < types.size(); ++level) {
+    mOffCandidates.Gather(mSessionOff, level, RTP);
+    if (types[level] != SdpMediaSection::kApplication) {
+      mOffCandidates.Gather(mSessionOff, level, RTCP);
+    }
+  }
+  mOffCandidates.FinishGathering(mSessionOff);
+
+  mOffCandidates.Trickle(mSessionAns);
+
+  UniquePtr<Sdp> localOffer(Parse(mSessionOff.GetLocalDescription()));
+  for (size_t i = 0; i < localOffer->GetMediaSectionCount(); ++i) {
+    mOffCandidates.CheckRtpCandidates(
+        true, localOffer->GetMediaSection(i), i,
+        "Local reoffer after gathering should have RTP candidates.");
+    mOffCandidates.CheckDefaultRtpCandidate(
+        true, localOffer->GetMediaSection(i), i,
+        "Local reoffer after gathering should have a default RTP candidate.");
+    mOffCandidates.CheckRtcpCandidates(
+        types[i] != SdpMediaSection::kApplication,
+        localOffer->GetMediaSection(i), i,
+        "Local reoffer after gathering should have RTCP candidates "
+        "(unless m=application)");
+    mOffCandidates.CheckDefaultRtcpCandidate(
+        types[i] != SdpMediaSection::kApplication,
+        localOffer->GetMediaSection(i), i,
+        "Local reoffer after gathering should have a default RTCP candidate "
+        "(unless m=application)");
+    CheckEndOfCandidates(true, localOffer->GetMediaSection(i),
+        "Local reoffer after gathering should have an end-of-candidates.");
+  }
+
+  UniquePtr<Sdp> remoteOffer(Parse(mSessionAns.GetRemoteDescription()));
+  for (size_t i = 0; i < remoteOffer->GetMediaSectionCount(); ++i) {
+    mOffCandidates.CheckRtpCandidates(
+        true, remoteOffer->GetMediaSection(i), i,
+        "Remote reoffer after trickle should have RTP candidates.");
+    mOffCandidates.CheckDefaultRtpCandidate(
+        i == 0, remoteOffer->GetMediaSection(i), i,
+        "Remote reoffer should have a default RTP candidate on level 0 "
+        "(because it was gathered last offer/answer).");
+    mOffCandidates.CheckRtcpCandidates(
+        types[i] != SdpMediaSection::kApplication,
+        remoteOffer->GetMediaSection(i), i,
+        "Remote reoffer after trickle should have RTCP candidates.");
+    mOffCandidates.CheckDefaultRtcpCandidate(
+        false, remoteOffer->GetMediaSection(i), i,
+        "Remote reoffer should not have a default RTCP candidate.");
+    CheckEndOfCandidates(false, remoteOffer->GetMediaSection(i),
+        "Remote reoffer should not have an end-of-candidates.");
+  }
+
+  answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer);
+  // No candidates should be gathered at the answerer, but default candidates
+  // should be set.
+  mAnsCandidates.FinishGathering(mSessionAns);
+
+  UniquePtr<Sdp> localAnswer(Parse(mSessionAns.GetLocalDescription()));
+  for (size_t i = 0; i < localAnswer->GetMediaSectionCount(); ++i) {
+    mAnsCandidates.CheckRtpCandidates(
+        i == 0, localAnswer->GetMediaSection(i), i,
+        "Local reanswer after gathering should have RTP candidates on level "
+        "0.");
+    mAnsCandidates.CheckDefaultRtpCandidate(
+        true, localAnswer->GetMediaSection(i), 0,
+        "Local reanswer after gathering should have a default RTP candidate "
+        "on all levels that matches transport level 0.");
+    mAnsCandidates.CheckRtcpCandidates(
+        false, localAnswer->GetMediaSection(i), i,
+        "Local reanswer after gathering should not have RTCP candidates "
+        "(because we're reanswering with rtcp-mux)");
+    mAnsCandidates.CheckDefaultRtcpCandidate(
+        false, localAnswer->GetMediaSection(i), i,
+        "Local reanswer after gathering should not have a default RTCP "
+        "candidate (because we're reanswering with rtcp-mux)");
+    CheckEndOfCandidates(i == 0, localAnswer->GetMediaSection(i),
+        "Local reanswer after gathering should have an end-of-candidates only "
+        "for level 0.");
+  }
+
+  UniquePtr<Sdp> remoteAnswer(Parse(mSessionOff.GetRemoteDescription()));
+  for (size_t i = 0; i < localAnswer->GetMediaSectionCount(); ++i) {
+    mAnsCandidates.CheckRtpCandidates(
+        i == 0, remoteAnswer->GetMediaSection(i), i,
+        "Remote reanswer after trickle should have RTP candidates on level 0.");
+    mAnsCandidates.CheckDefaultRtpCandidate(
+        i == 0, remoteAnswer->GetMediaSection(i), i,
+        "Remote reanswer should have a default RTP candidate on level 0 "
+        "(because it was gathered last offer/answer).");
+    mAnsCandidates.CheckRtcpCandidates(
+        false, remoteAnswer->GetMediaSection(i), i,
+        "Remote reanswer after trickle should not have RTCP candidates "
+        "(because we're reanswering with rtcp-mux)");
+    mAnsCandidates.CheckDefaultRtcpCandidate(
+        false, remoteAnswer->GetMediaSection(i), i,
+        "Remote reanswer after trickle should not have a default RTCP "
+        "candidate.");
+    CheckEndOfCandidates(false, remoteAnswer->GetMediaSection(i),
+        "Remote reanswer after trickle should not have an end-of-candidates.");
+  }
+}
+
+TEST_P(JsepSessionTest, RenegotiationAnswererSendonly)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  OfferAnswer();
+
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+
+  UniquePtr<Sdp> parsedAnswer(Parse(answer));
+  for (size_t i = 0; i < parsedAnswer->GetMediaSectionCount(); ++i) {
+    SdpMediaSection& msection = parsedAnswer->GetMediaSection(i);
+    if (msection.GetMediaType() != SdpMediaSection::kApplication) {
+      msection.SetReceiving(false);
+    }
+  }
+
+  answer = parsedAnswer->ToString();
+
+  SetRemoteAnswer(answer);
+
+  for (const RefPtr<JsepTrack>& track : mSessionOff.GetLocalTracks()) {
+    if (track->GetMediaType() != SdpMediaSection::kApplication) {
+      ASSERT_FALSE(track->GetActive());
+    }
+  }
+
+  ASSERT_EQ(types.size(), mSessionOff.GetNegotiatedTrackPairs().size());
+}
+
+TEST_P(JsepSessionTest, RenegotiationAnswererInactive)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  OfferAnswer();
+
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+
+  UniquePtr<Sdp> parsedAnswer(Parse(answer));
+  for (size_t i = 0; i < parsedAnswer->GetMediaSectionCount(); ++i) {
+    SdpMediaSection& msection = parsedAnswer->GetMediaSection(i);
+    if (msection.GetMediaType() != SdpMediaSection::kApplication) {
+      msection.SetReceiving(false);
+      msection.SetSending(false);
+    }
+  }
+
+  answer = parsedAnswer->ToString();
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS); // Won't have answerer tracks
+
+  for (const RefPtr<JsepTrack>& track : mSessionOff.GetLocalTracks()) {
+    if (track->GetMediaType() != SdpMediaSection::kApplication) {
+      ASSERT_FALSE(track->GetActive());
+    }
+  }
+
+  ASSERT_EQ(types.size(), mSessionOff.GetNegotiatedTrackPairs().size());
+}
+
+
+INSTANTIATE_TEST_CASE_P(
+    Variants,
+    JsepSessionTest,
+    ::testing::Values("audio",
+                      "video",
+                      "datachannel",
+                      "audio,video",
+                      "video,audio",
+                      "audio,datachannel",
+                      "video,datachannel",
+                      "video,audio,datachannel",
+                      "audio,video,datachannel",
+                      "datachannel,audio",
+                      "datachannel,video",
+                      "datachannel,audio,video",
+                      "datachannel,video,audio",
+                      "audio,datachannel,video",
+                      "video,datachannel,audio",
+                      "audio,audio",
+                      "video,video",
+                      "audio,audio,video",
+                      "audio,video,video",
+                      "audio,audio,video,video",
+                      "audio,audio,video,video,datachannel"));
+
+// offerToReceiveXxx variants
+
+TEST_F(JsepSessionTest, OfferAnswerRecvOnlyLines)
+{
+  JsepOfferOptions options;
+  options.mOfferToReceiveAudio = Some(static_cast<size_t>(1U));
+  options.mOfferToReceiveVideo = Some(static_cast<size_t>(2U));
+  options.mDontOfferDataChannel = Some(true);
+  std::string offer = CreateOffer(Some(options));
+
+  UniquePtr<Sdp> parsedOffer(Parse(offer));
+  ASSERT_TRUE(!!parsedOffer);
+
+  ASSERT_EQ(3U, parsedOffer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kAudio,
+            parsedOffer->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
+            parsedOffer->GetMediaSection(0).GetAttributeList().GetDirection());
+  ASSERT_TRUE(parsedOffer->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kSsrcAttribute));
+
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            parsedOffer->GetMediaSection(1).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
+            parsedOffer->GetMediaSection(1).GetAttributeList().GetDirection());
+  ASSERT_TRUE(parsedOffer->GetMediaSection(1).GetAttributeList().HasAttribute(
+        SdpAttribute::kSsrcAttribute));
+
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            parsedOffer->GetMediaSection(2).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
+            parsedOffer->GetMediaSection(2).GetAttributeList().GetDirection());
+  ASSERT_TRUE(parsedOffer->GetMediaSection(2).GetAttributeList().HasAttribute(
+        SdpAttribute::kSsrcAttribute));
+
+  ASSERT_TRUE(parsedOffer->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kRtcpMuxAttribute));
+  ASSERT_TRUE(parsedOffer->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kRtcpMuxAttribute));
+  ASSERT_TRUE(parsedOffer->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kRtcpMuxAttribute));
+
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  AddTracks(mSessionAns, "audio,video");
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+
+  std::string answer = CreateAnswer();
+  UniquePtr<Sdp> parsedAnswer(Parse(answer));
+
+  ASSERT_EQ(3U, parsedAnswer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kAudio,
+            parsedAnswer->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kSendonly,
+            parsedAnswer->GetMediaSection(0).GetAttributeList().GetDirection());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            parsedAnswer->GetMediaSection(1).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kSendonly,
+            parsedAnswer->GetMediaSection(1).GetAttributeList().GetDirection());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            parsedAnswer->GetMediaSection(2).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kInactive,
+            parsedAnswer->GetMediaSection(2).GetAttributeList().GetDirection());
+
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  std::vector<JsepTrackPair> trackPairs(mSessionOff.GetNegotiatedTrackPairs());
+  ASSERT_EQ(2U, trackPairs.size());
+  for (auto pair : trackPairs) {
+    auto ssrcs = parsedOffer->GetMediaSection(pair.mLevel).GetAttributeList()
+                 .GetSsrc().mSsrcs;
+    ASSERT_EQ(1U, ssrcs.size());
+    ASSERT_EQ(pair.mRecvonlySsrc, ssrcs.front().ssrc);
+  }
+}
+
+TEST_F(JsepSessionTest, OfferAnswerSendOnlyLines)
+{
+  AddTracks(mSessionOff, "audio,video,video");
+
+  JsepOfferOptions options;
+  options.mOfferToReceiveAudio = Some(static_cast<size_t>(0U));
+  options.mOfferToReceiveVideo = Some(static_cast<size_t>(1U));
+  options.mDontOfferDataChannel = Some(true);
+  std::string offer = CreateOffer(Some(options));
+
+  UniquePtr<Sdp> outputSdp(Parse(offer));
+  ASSERT_TRUE(!!outputSdp);
+
+  ASSERT_EQ(3U, outputSdp->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kAudio,
+            outputSdp->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kSendonly,
+            outputSdp->GetMediaSection(0).GetAttributeList().GetDirection());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            outputSdp->GetMediaSection(1).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kSendrecv,
+            outputSdp->GetMediaSection(1).GetAttributeList().GetDirection());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            outputSdp->GetMediaSection(2).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kSendonly,
+            outputSdp->GetMediaSection(2).GetAttributeList().GetDirection());
+
+  ASSERT_TRUE(outputSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kRtcpMuxAttribute));
+  ASSERT_TRUE(outputSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kRtcpMuxAttribute));
+  ASSERT_TRUE(outputSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kRtcpMuxAttribute));
+
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  AddTracks(mSessionAns, "audio,video");
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+
+  std::string answer = CreateAnswer();
+  outputSdp = Parse(answer);
+
+  ASSERT_EQ(3U, outputSdp->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kAudio,
+            outputSdp->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
+            outputSdp->GetMediaSection(0).GetAttributeList().GetDirection());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            outputSdp->GetMediaSection(1).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kSendrecv,
+            outputSdp->GetMediaSection(1).GetAttributeList().GetDirection());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            outputSdp->GetMediaSection(2).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
+            outputSdp->GetMediaSection(2).GetAttributeList().GetDirection());
+}
+
+TEST_F(JsepSessionTest, OfferToReceiveAudioNotUsed)
+{
+  JsepOfferOptions options;
+  options.mOfferToReceiveAudio = Some<size_t>(1);
+
+  OfferAnswer(CHECK_SUCCESS, Some(options));
+
+  UniquePtr<Sdp> offer(Parse(mSessionOff.GetLocalDescription()));
+  ASSERT_TRUE(offer.get());
+  ASSERT_EQ(1U, offer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kAudio,
+            offer->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
+            offer->GetMediaSection(0).GetAttributeList().GetDirection());
+
+  UniquePtr<Sdp> answer(Parse(mSessionAns.GetLocalDescription()));
+  ASSERT_TRUE(answer.get());
+  ASSERT_EQ(1U, answer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kAudio,
+            answer->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kInactive,
+            answer->GetMediaSection(0).GetAttributeList().GetDirection());
+}
+
+TEST_F(JsepSessionTest, OfferToReceiveVideoNotUsed)
+{
+  JsepOfferOptions options;
+  options.mOfferToReceiveVideo = Some<size_t>(1);
+
+  OfferAnswer(CHECK_SUCCESS, Some(options));
+
+  UniquePtr<Sdp> offer(Parse(mSessionOff.GetLocalDescription()));
+  ASSERT_TRUE(offer.get());
+  ASSERT_EQ(1U, offer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            offer->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
+            offer->GetMediaSection(0).GetAttributeList().GetDirection());
+
+  UniquePtr<Sdp> answer(Parse(mSessionAns.GetLocalDescription()));
+  ASSERT_TRUE(answer.get());
+  ASSERT_EQ(1U, answer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            answer->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpDirectionAttribute::kInactive,
+            answer->GetMediaSection(0).GetAttributeList().GetDirection());
+}
+
+TEST_F(JsepSessionTest, CreateOfferNoDatachannelDefault)
+{
+  RefPtr<JsepTrack> msta(
+      new JsepTrack(SdpMediaSection::kAudio, "offerer_stream", "a1"));
+  mSessionOff.AddTrack(msta);
+
+  RefPtr<JsepTrack> mstv1(
+      new JsepTrack(SdpMediaSection::kVideo, "offerer_stream", "v1"));
+  mSessionOff.AddTrack(mstv1);
+
+  std::string offer = CreateOffer();
+
+  UniquePtr<Sdp> outputSdp(Parse(offer));
+  ASSERT_TRUE(!!outputSdp);
+
+  ASSERT_EQ(2U, outputSdp->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kAudio,
+            outputSdp->GetMediaSection(0).GetMediaType());
+  ASSERT_EQ(SdpMediaSection::kVideo,
+            outputSdp->GetMediaSection(1).GetMediaType());
+}
+
+TEST_F(JsepSessionTest, ValidateOfferedVideoCodecParams)
+{
+  types.push_back(SdpMediaSection::kAudio);
+  types.push_back(SdpMediaSection::kVideo);
+
+  RefPtr<JsepTrack> msta(
+      new JsepTrack(SdpMediaSection::kAudio, "offerer_stream", "a1"));
+  mSessionOff.AddTrack(msta);
+  RefPtr<JsepTrack> mstv1(
+      new JsepTrack(SdpMediaSection::kVideo, "offerer_stream", "v2"));
+  mSessionOff.AddTrack(mstv1);
+
+  std::string offer = CreateOffer();
+
+  UniquePtr<Sdp> outputSdp(Parse(offer));
+  ASSERT_TRUE(!!outputSdp);
+
+  ASSERT_EQ(2U, outputSdp->GetMediaSectionCount());
+  auto& video_section = outputSdp->GetMediaSection(1);
+  ASSERT_EQ(SdpMediaSection::kVideo, video_section.GetMediaType());
+  auto& video_attrs = video_section.GetAttributeList();
+  ASSERT_EQ(SdpDirectionAttribute::kSendrecv, video_attrs.GetDirection());
+
+  ASSERT_EQ(6U, video_section.GetFormats().size());
+  ASSERT_EQ("120", video_section.GetFormats()[0]);
+  ASSERT_EQ("121", video_section.GetFormats()[1]);
+  ASSERT_EQ("126", video_section.GetFormats()[2]);
+  ASSERT_EQ("97", video_section.GetFormats()[3]);
+  ASSERT_EQ("122", video_section.GetFormats()[4]);
+  ASSERT_EQ("123", video_section.GetFormats()[5]);
+
+  // Validate rtpmap
+  ASSERT_TRUE(video_attrs.HasAttribute(SdpAttribute::kRtpmapAttribute));
+  auto& rtpmaps = video_attrs.GetRtpmap();
+  ASSERT_TRUE(rtpmaps.HasEntry("120"));
+  ASSERT_TRUE(rtpmaps.HasEntry("121"));
+  ASSERT_TRUE(rtpmaps.HasEntry("126"));
+  ASSERT_TRUE(rtpmaps.HasEntry("97"));
+  ASSERT_TRUE(rtpmaps.HasEntry("122"));
+  ASSERT_TRUE(rtpmaps.HasEntry("123"));
+
+  auto& vp8_entry = rtpmaps.GetEntry("120");
+  auto& vp9_entry = rtpmaps.GetEntry("121");
+  auto& h264_1_entry = rtpmaps.GetEntry("126");
+  auto& h264_0_entry = rtpmaps.GetEntry("97");
+  auto& red_0_entry = rtpmaps.GetEntry("122");
+  auto& ulpfec_0_entry = rtpmaps.GetEntry("123");
+
+  ASSERT_EQ("VP8", vp8_entry.name);
+  ASSERT_EQ("VP9", vp9_entry.name);
+  ASSERT_EQ("H264", h264_1_entry.name);
+  ASSERT_EQ("H264", h264_0_entry.name);
+  ASSERT_EQ("red", red_0_entry.name);
+  ASSERT_EQ("ulpfec", ulpfec_0_entry.name);
+
+  // Validate fmtps
+  ASSERT_TRUE(video_attrs.HasAttribute(SdpAttribute::kFmtpAttribute));
+  auto& fmtps = video_attrs.GetFmtp().mFmtps;
+
+  ASSERT_EQ(5U, fmtps.size());
+
+  // VP8
+  const SdpFmtpAttributeList::Parameters* vp8_params =
+    video_section.FindFmtp("120");
+  ASSERT_TRUE(vp8_params);
+  ASSERT_EQ(SdpRtpmapAttributeList::kVP8, vp8_params->codec_type);
+
+  auto& parsed_vp8_params =
+      *static_cast<const SdpFmtpAttributeList::VP8Parameters*>(vp8_params);
+
+  ASSERT_EQ((uint32_t)12288, parsed_vp8_params.max_fs);
+  ASSERT_EQ((uint32_t)60, parsed_vp8_params.max_fr);
+
+  // VP9
+  const SdpFmtpAttributeList::Parameters* vp9_params =
+    video_section.FindFmtp("121");
+  ASSERT_TRUE(vp9_params);
+  ASSERT_EQ(SdpRtpmapAttributeList::kVP9, vp9_params->codec_type);
+
+  auto& parsed_vp9_params =
+      *static_cast<const SdpFmtpAttributeList::VP8Parameters*>(vp9_params);
+
+  ASSERT_EQ((uint32_t)12288, parsed_vp9_params.max_fs);
+  ASSERT_EQ((uint32_t)60, parsed_vp9_params.max_fr);
+
+  // H264 packetization mode 1
+  const SdpFmtpAttributeList::Parameters* h264_1_params =
+    video_section.FindFmtp("126");
+  ASSERT_TRUE(h264_1_params);
+  ASSERT_EQ(SdpRtpmapAttributeList::kH264, h264_1_params->codec_type);
+
+  auto& parsed_h264_1_params =
+      *static_cast<const SdpFmtpAttributeList::H264Parameters*>(h264_1_params);
+
+  ASSERT_EQ((uint32_t)0x42e00d, parsed_h264_1_params.profile_level_id);
+  ASSERT_TRUE(parsed_h264_1_params.level_asymmetry_allowed);
+  ASSERT_EQ(1U, parsed_h264_1_params.packetization_mode);
+
+  // H264 packetization mode 0
+  const SdpFmtpAttributeList::Parameters* h264_0_params =
+    video_section.FindFmtp("97");
+  ASSERT_TRUE(h264_0_params);
+  ASSERT_EQ(SdpRtpmapAttributeList::kH264, h264_0_params->codec_type);
+
+  auto& parsed_h264_0_params =
+      *static_cast<const SdpFmtpAttributeList::H264Parameters*>(h264_0_params);
+
+  ASSERT_EQ((uint32_t)0x42e00d, parsed_h264_0_params.profile_level_id);
+  ASSERT_TRUE(parsed_h264_0_params.level_asymmetry_allowed);
+  ASSERT_EQ(0U, parsed_h264_0_params.packetization_mode);
+
+  // red
+  const SdpFmtpAttributeList::Parameters* red_params =
+    video_section.FindFmtp("122");
+  ASSERT_TRUE(red_params);
+  ASSERT_EQ(SdpRtpmapAttributeList::kRed, red_params->codec_type);
+
+  auto& parsed_red_params =
+      *static_cast<const SdpFmtpAttributeList::RedParameters*>(red_params);
+  ASSERT_EQ(5U, parsed_red_params.encodings.size());
+  ASSERT_EQ(120, parsed_red_params.encodings[0]);
+  ASSERT_EQ(121, parsed_red_params.encodings[1]);
+  ASSERT_EQ(126, parsed_red_params.encodings[2]);
+  ASSERT_EQ(97, parsed_red_params.encodings[3]);
+  ASSERT_EQ(123, parsed_red_params.encodings[4]);
+}
+
+TEST_F(JsepSessionTest, ValidateOfferedAudioCodecParams)
+{
+  types.push_back(SdpMediaSection::kAudio);
+  types.push_back(SdpMediaSection::kVideo);
+
+  RefPtr<JsepTrack> msta(
+      new JsepTrack(SdpMediaSection::kAudio, "offerer_stream", "a1"));
+  mSessionOff.AddTrack(msta);
+  RefPtr<JsepTrack> mstv1(
+      new JsepTrack(SdpMediaSection::kVideo, "offerer_stream", "v2"));
+  mSessionOff.AddTrack(mstv1);
+
+  std::string offer = CreateOffer();
+
+  UniquePtr<Sdp> outputSdp(Parse(offer));
+  ASSERT_TRUE(!!outputSdp);
+
+  ASSERT_EQ(2U, outputSdp->GetMediaSectionCount());
+  auto& audio_section = outputSdp->GetMediaSection(0);
+  ASSERT_EQ(SdpMediaSection::kAudio, audio_section.GetMediaType());
+  auto& audio_attrs = audio_section.GetAttributeList();
+  ASSERT_EQ(SdpDirectionAttribute::kSendrecv, audio_attrs.GetDirection());
+  ASSERT_EQ(5U, audio_section.GetFormats().size());
+  ASSERT_EQ("109", audio_section.GetFormats()[0]);
+  ASSERT_EQ("9", audio_section.GetFormats()[1]);
+  ASSERT_EQ("0", audio_section.GetFormats()[2]);
+  ASSERT_EQ("8", audio_section.GetFormats()[3]);
+  ASSERT_EQ("101", audio_section.GetFormats()[4]);
+
+  // Validate rtpmap
+  ASSERT_TRUE(audio_attrs.HasAttribute(SdpAttribute::kRtpmapAttribute));
+  auto& rtpmaps = audio_attrs.GetRtpmap();
+  ASSERT_TRUE(rtpmaps.HasEntry("109"));
+  ASSERT_TRUE(rtpmaps.HasEntry("9"));
+  ASSERT_TRUE(rtpmaps.HasEntry("0"));
+  ASSERT_TRUE(rtpmaps.HasEntry("8"));
+  ASSERT_TRUE(rtpmaps.HasEntry("101"));
+
+  auto& opus_entry = rtpmaps.GetEntry("109");
+  auto& g722_entry = rtpmaps.GetEntry("9");
+  auto& pcmu_entry = rtpmaps.GetEntry("0");
+  auto& pcma_entry = rtpmaps.GetEntry("8");
+  auto& telephone_event_entry = rtpmaps.GetEntry("101");
+
+  ASSERT_EQ("opus", opus_entry.name);
+  ASSERT_EQ("G722", g722_entry.name);
+  ASSERT_EQ("PCMU", pcmu_entry.name);
+  ASSERT_EQ("PCMA", pcma_entry.name);
+  ASSERT_EQ("telephone-event", telephone_event_entry.name);
+
+  // Validate fmtps
+  ASSERT_TRUE(audio_attrs.HasAttribute(SdpAttribute::kFmtpAttribute));
+  auto& fmtps = audio_attrs.GetFmtp().mFmtps;
+
+  ASSERT_EQ(2U, fmtps.size());
+
+  // opus
+  const SdpFmtpAttributeList::Parameters* opus_params =
+    audio_section.FindFmtp("109");
+  ASSERT_TRUE(opus_params);
+  ASSERT_EQ(SdpRtpmapAttributeList::kOpus, opus_params->codec_type);
+
+  auto& parsed_opus_params =
+      *static_cast<const SdpFmtpAttributeList::OpusParameters*>(opus_params);
+
+  ASSERT_EQ((uint32_t)48000, parsed_opus_params.maxplaybackrate);
+  ASSERT_EQ((uint32_t)1, parsed_opus_params.stereo);
+  ASSERT_EQ((uint32_t)0, parsed_opus_params.useInBandFec);
+
+  // dtmf
+  const SdpFmtpAttributeList::Parameters* dtmf_params =
+    audio_section.FindFmtp("101");
+  ASSERT_TRUE(dtmf_params);
+  ASSERT_EQ(SdpRtpmapAttributeList::kTelephoneEvent, dtmf_params->codec_type);
+
+  auto& parsed_dtmf_params =
+      *static_cast<const SdpFmtpAttributeList::TelephoneEventParameters*>
+          (dtmf_params);
+
+  ASSERT_EQ("0-15", parsed_dtmf_params.dtmfTones);
+}
+
+TEST_F(JsepSessionTest, ValidateAnsweredCodecParams)
+{
+  // TODO(bug 1099351): Once fixed, we can allow red in this offer,
+  // which will also cause multiple codecs in answer.  For now,
+  // red/ulpfec for video are behind a pref to mitigate potential for
+  // errors.
+  SetCodecEnabled(mSessionOff, "red", false);
+  for (auto i = mSessionAns.Codecs().begin(); i != mSessionAns.Codecs().end();
+       ++i) {
+    auto* codec = *i;
+    if (codec->mName == "H264") {
+      JsepVideoCodecDescription* h264 =
+          static_cast<JsepVideoCodecDescription*>(codec);
+      h264->mProfileLevelId = 0x42a00d;
+      // Switch up the pts
+      if (h264->mDefaultPt == "126") {
+        h264->mDefaultPt = "97";
+      } else {
+        h264->mDefaultPt = "126";
+      }
+    }
+  }
+
+  types.push_back(SdpMediaSection::kAudio);
+  types.push_back(SdpMediaSection::kVideo);
+
+  RefPtr<JsepTrack> msta(
+      new JsepTrack(SdpMediaSection::kAudio, "offerer_stream", "a1"));
+  mSessionOff.AddTrack(msta);
+  RefPtr<JsepTrack> mstv1(
+      new JsepTrack(SdpMediaSection::kVideo, "offerer_stream", "v1"));
+  mSessionOff.AddTrack(mstv1);
+
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+
+  RefPtr<JsepTrack> msta_ans(
+      new JsepTrack(SdpMediaSection::kAudio, "answerer_stream", "a1"));
+  mSessionAns.AddTrack(msta);
+  RefPtr<JsepTrack> mstv1_ans(
+      new JsepTrack(SdpMediaSection::kVideo, "answerer_stream", "v1"));
+  mSessionAns.AddTrack(mstv1);
+
+  std::string answer = CreateAnswer();
+
+  UniquePtr<Sdp> outputSdp(Parse(answer));
+  ASSERT_TRUE(!!outputSdp);
+
+  ASSERT_EQ(2U, outputSdp->GetMediaSectionCount());
+  auto& video_section = outputSdp->GetMediaSection(1);
+  ASSERT_EQ(SdpMediaSection::kVideo, video_section.GetMediaType());
+  auto& video_attrs = video_section.GetAttributeList();
+  ASSERT_EQ(SdpDirectionAttribute::kSendrecv, video_attrs.GetDirection());
+
+  // TODO(bug 1099351): Once fixed, this stuff will need to be updated.
+  ASSERT_EQ(1U, video_section.GetFormats().size());
+  // ASSERT_EQ(3U, video_section.GetFormats().size());
+  ASSERT_EQ("120", video_section.GetFormats()[0]);
+  // ASSERT_EQ("121", video_section.GetFormats()[1]);
+  // ASSERT_EQ("126", video_section.GetFormats()[2]);
+  // ASSERT_EQ("97", video_section.GetFormats()[3]);
+
+  // Validate rtpmap
+  ASSERT_TRUE(video_attrs.HasAttribute(SdpAttribute::kRtpmapAttribute));
+  auto& rtpmaps = video_attrs.GetRtpmap();
+  ASSERT_TRUE(rtpmaps.HasEntry("120"));
+  //ASSERT_TRUE(rtpmaps.HasEntry("121"));
+  // ASSERT_TRUE(rtpmaps.HasEntry("126"));
+  // ASSERT_TRUE(rtpmaps.HasEntry("97"));
+
+  auto& vp8_entry = rtpmaps.GetEntry("120");
+  //auto& vp9_entry = rtpmaps.GetEntry("121");
+  // auto& h264_1_entry = rtpmaps.GetEntry("126");
+  // auto& h264_0_entry = rtpmaps.GetEntry("97");
+
+  ASSERT_EQ("VP8", vp8_entry.name);
+  //ASSERT_EQ("VP9", vp9_entry.name);
+  // ASSERT_EQ("H264", h264_1_entry.name);
+  // ASSERT_EQ("H264", h264_0_entry.name);
+
+  // Validate fmtps
+  ASSERT_TRUE(video_attrs.HasAttribute(SdpAttribute::kFmtpAttribute));
+  auto& fmtps = video_attrs.GetFmtp().mFmtps;
+
+  ASSERT_EQ(1U, fmtps.size());
+  // ASSERT_EQ(3U, fmtps.size());
+
+  // VP8
+  ASSERT_EQ("120", fmtps[0].format);
+  ASSERT_TRUE(!!fmtps[0].parameters);
+  ASSERT_EQ(SdpRtpmapAttributeList::kVP8, fmtps[0].parameters->codec_type);
+
+  auto& parsed_vp8_params =
+      *static_cast<const SdpFmtpAttributeList::VP8Parameters*>(
+          fmtps[0].parameters.get());
+
+  ASSERT_EQ((uint32_t)12288, parsed_vp8_params.max_fs);
+  ASSERT_EQ((uint32_t)60, parsed_vp8_params.max_fr);
+
+
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer);
+
+  auto offerPairs = mSessionOff.GetNegotiatedTrackPairs();
+  ASSERT_EQ(2U, offerPairs.size());
+  ASSERT_TRUE(offerPairs[1].mSending);
+  ASSERT_TRUE(offerPairs[1].mReceiving);
+  ASSERT_TRUE(offerPairs[1].mSending->GetNegotiatedDetails());
+  ASSERT_TRUE(offerPairs[1].mReceiving->GetNegotiatedDetails());
+  ASSERT_EQ(1U,
+      offerPairs[1].mSending->GetNegotiatedDetails()->GetEncoding(0)
+      .GetCodecs().size());
+  ASSERT_EQ(1U,
+      offerPairs[1].mReceiving->GetNegotiatedDetails()->GetEncoding(0)
+      .GetCodecs().size());
+
+  auto answerPairs = mSessionAns.GetNegotiatedTrackPairs();
+  ASSERT_EQ(2U, answerPairs.size());
+  ASSERT_TRUE(answerPairs[1].mSending);
+  ASSERT_TRUE(answerPairs[1].mReceiving);
+  ASSERT_TRUE(answerPairs[1].mSending->GetNegotiatedDetails());
+  ASSERT_TRUE(answerPairs[1].mReceiving->GetNegotiatedDetails());
+  ASSERT_EQ(1U,
+      answerPairs[1].mSending->GetNegotiatedDetails()->GetEncoding(0)
+      .GetCodecs().size());
+  ASSERT_EQ(1U,
+      answerPairs[1].mReceiving->GetNegotiatedDetails()->GetEncoding(0)
+      .GetCodecs().size());
+
+#if 0
+  // H264 packetization mode 1
+  ASSERT_EQ("126", fmtps[1].format);
+  ASSERT_TRUE(fmtps[1].parameters);
+  ASSERT_EQ(SdpRtpmapAttributeList::kH264, fmtps[1].parameters->codec_type);
+
+  auto& parsed_h264_1_params =
+    *static_cast<const SdpFmtpAttributeList::H264Parameters*>(
+        fmtps[1].parameters.get());
+
+  ASSERT_EQ((uint32_t)0x42a00d, parsed_h264_1_params.profile_level_id);
+  ASSERT_TRUE(parsed_h264_1_params.level_asymmetry_allowed);
+  ASSERT_EQ(1U, parsed_h264_1_params.packetization_mode);
+
+  // H264 packetization mode 0
+  ASSERT_EQ("97", fmtps[2].format);
+  ASSERT_TRUE(fmtps[2].parameters);
+  ASSERT_EQ(SdpRtpmapAttributeList::kH264, fmtps[2].parameters->codec_type);
+
+  auto& parsed_h264_0_params =
+    *static_cast<const SdpFmtpAttributeList::H264Parameters*>(
+        fmtps[2].parameters.get());
+
+  ASSERT_EQ((uint32_t)0x42a00d, parsed_h264_0_params.profile_level_id);
+  ASSERT_TRUE(parsed_h264_0_params.level_asymmetry_allowed);
+  ASSERT_EQ(0U, parsed_h264_0_params.packetization_mode);
+#endif
+}
+
+static void
+Replace(const std::string& toReplace,
+        const std::string& with,
+        std::string* in)
+{
+  size_t pos = in->find(toReplace);
+  ASSERT_NE(std::string::npos, pos);
+  in->replace(pos, toReplace.size(), with);
+}
+
+static void ReplaceAll(const std::string& toReplace,
+                       const std::string& with,
+                       std::string* in)
+{
+  while (in->find(toReplace) != std::string::npos) {
+    Replace(toReplace, with, in);
+  }
+}
+
+static void
+GetCodec(JsepSession& session,
+         size_t pairIndex,
+         sdp::Direction direction,
+         size_t encodingIndex,
+         size_t codecIndex,
+         const JsepCodecDescription** codecOut)
+{
+  *codecOut = nullptr;
+  ASSERT_LT(pairIndex, session.GetNegotiatedTrackPairs().size());
+  JsepTrackPair pair(session.GetNegotiatedTrackPairs().front());
+  RefPtr<JsepTrack> track(
+      (direction == sdp::kSend) ? pair.mSending : pair.mReceiving);
+  ASSERT_TRUE(track);
+  ASSERT_TRUE(track->GetNegotiatedDetails());
+  ASSERT_LT(encodingIndex, track->GetNegotiatedDetails()->GetEncodingCount());
+  ASSERT_LT(codecIndex,
+      track->GetNegotiatedDetails()->GetEncoding(encodingIndex)
+      .GetCodecs().size());
+  *codecOut =
+      track->GetNegotiatedDetails()->GetEncoding(encodingIndex)
+      .GetCodecs()[codecIndex];
+}
+
+static void
+ForceH264(JsepSession& session, uint32_t profileLevelId)
+{
+  for (JsepCodecDescription* codec : session.Codecs()) {
+    if (codec->mName == "H264") {
+      JsepVideoCodecDescription* h264 =
+          static_cast<JsepVideoCodecDescription*>(codec);
+      h264->mProfileLevelId = profileLevelId;
+    } else {
+      codec->mEnabled = false;
+    }
+  }
+}
+
+TEST_F(JsepSessionTest, TestH264Negotiation)
+{
+  ForceH264(mSessionOff, 0x42e00b);
+  ForceH264(mSessionAns, 0x42e00d);
+
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer(CreateAnswer());
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+
+  const JsepCodecDescription* offererSendCodec;
+  GetCodec(mSessionOff, 0, sdp::kSend, 0, 0, &offererSendCodec);
+  ASSERT_TRUE(offererSendCodec);
+  ASSERT_EQ("H264", offererSendCodec->mName);
+  const JsepVideoCodecDescription* offererVideoSendCodec(
+      static_cast<const JsepVideoCodecDescription*>(offererSendCodec));
+  ASSERT_EQ((uint32_t)0x42e00d, offererVideoSendCodec->mProfileLevelId);
+
+  const JsepCodecDescription* offererRecvCodec;
+  GetCodec(mSessionOff, 0, sdp::kRecv, 0, 0, &offererRecvCodec);
+  ASSERT_EQ("H264", offererRecvCodec->mName);
+  const JsepVideoCodecDescription* offererVideoRecvCodec(
+      static_cast<const JsepVideoCodecDescription*>(offererRecvCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, offererVideoRecvCodec->mProfileLevelId);
+
+  const JsepCodecDescription* answererSendCodec;
+  GetCodec(mSessionAns, 0, sdp::kSend, 0, 0, &answererSendCodec);
+  ASSERT_TRUE(answererSendCodec);
+  ASSERT_EQ("H264", answererSendCodec->mName);
+  const JsepVideoCodecDescription* answererVideoSendCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererSendCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, answererVideoSendCodec->mProfileLevelId);
+
+  const JsepCodecDescription* answererRecvCodec;
+  GetCodec(mSessionAns, 0, sdp::kRecv, 0, 0, &answererRecvCodec);
+  ASSERT_EQ("H264", answererRecvCodec->mName);
+  const JsepVideoCodecDescription* answererVideoRecvCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererRecvCodec));
+  ASSERT_EQ((uint32_t)0x42e00d, answererVideoRecvCodec->mProfileLevelId);
+}
+
+TEST_F(JsepSessionTest, TestH264NegotiationFails)
+{
+  ForceH264(mSessionOff, 0x42000b);
+  ForceH264(mSessionAns, 0x42e00d);
+
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer(CreateAnswer());
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+
+  ASSERT_EQ(0U, mSessionOff.GetNegotiatedTrackPairs().size());
+  ASSERT_EQ(0U, mSessionAns.GetNegotiatedTrackPairs().size());
+}
+
+TEST_F(JsepSessionTest, TestH264NegotiationOffererDefault)
+{
+  ForceH264(mSessionOff, 0x42000d);
+  ForceH264(mSessionAns, 0x42000d);
+
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  Replace("profile-level-id=42000d",
+          "some-unknown-param=0",
+          &offer);
+
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer(CreateAnswer());
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+
+  const JsepCodecDescription* answererSendCodec;
+  GetCodec(mSessionAns, 0, sdp::kSend, 0, 0, &answererSendCodec);
+  ASSERT_TRUE(answererSendCodec);
+  ASSERT_EQ("H264", answererSendCodec->mName);
+  const JsepVideoCodecDescription* answererVideoSendCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererSendCodec));
+  ASSERT_EQ((uint32_t)0x420010, answererVideoSendCodec->mProfileLevelId);
+}
+
+TEST_F(JsepSessionTest, TestH264NegotiationOffererNoFmtp)
+{
+  ForceH264(mSessionOff, 0x42000d);
+  ForceH264(mSessionAns, 0x42001e);
+
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  Replace("a=fmtp", "a=oops", &offer);
+
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer(CreateAnswer());
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+
+  const JsepCodecDescription* answererSendCodec;
+  GetCodec(mSessionAns, 0, sdp::kSend, 0, 0, &answererSendCodec);
+  ASSERT_TRUE(answererSendCodec);
+  ASSERT_EQ("H264", answererSendCodec->mName);
+  const JsepVideoCodecDescription* answererVideoSendCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererSendCodec));
+  ASSERT_EQ((uint32_t)0x420010, answererVideoSendCodec->mProfileLevelId);
+
+  const JsepCodecDescription* answererRecvCodec;
+  GetCodec(mSessionAns, 0, sdp::kRecv, 0, 0, &answererRecvCodec);
+  ASSERT_EQ("H264", answererRecvCodec->mName);
+  const JsepVideoCodecDescription* answererVideoRecvCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererRecvCodec));
+  ASSERT_EQ((uint32_t)0x420010, answererVideoRecvCodec->mProfileLevelId);
+}
+
+TEST_F(JsepSessionTest, TestH264LevelAsymmetryDisallowedByOffererWithLowLevel)
+{
+  ForceH264(mSessionOff, 0x42e00b);
+  ForceH264(mSessionAns, 0x42e00d);
+
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  Replace("level-asymmetry-allowed=1",
+          "level-asymmetry-allowed=0",
+          &offer);
+
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer(CreateAnswer());
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+
+  // Offerer doesn't know about the shenanigans we've pulled here, so will
+  // behave normally, and we test the normal behavior elsewhere.
+
+  const JsepCodecDescription* answererSendCodec;
+  GetCodec(mSessionAns, 0, sdp::kSend, 0, 0, &answererSendCodec);
+  ASSERT_TRUE(answererSendCodec);
+  ASSERT_EQ("H264", answererSendCodec->mName);
+  const JsepVideoCodecDescription* answererVideoSendCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererSendCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, answererVideoSendCodec->mProfileLevelId);
+
+  const JsepCodecDescription* answererRecvCodec;
+  GetCodec(mSessionAns, 0, sdp::kRecv, 0, 0, &answererRecvCodec);
+  ASSERT_EQ("H264", answererRecvCodec->mName);
+  const JsepVideoCodecDescription* answererVideoRecvCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererRecvCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, answererVideoRecvCodec->mProfileLevelId);
+}
+
+TEST_F(JsepSessionTest, TestH264LevelAsymmetryDisallowedByOffererWithHighLevel)
+{
+  ForceH264(mSessionOff, 0x42e00d);
+  ForceH264(mSessionAns, 0x42e00b);
+
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  Replace("level-asymmetry-allowed=1",
+          "level-asymmetry-allowed=0",
+          &offer);
+
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer(CreateAnswer());
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+
+  // Offerer doesn't know about the shenanigans we've pulled here, so will
+  // behave normally, and we test the normal behavior elsewhere.
+
+  const JsepCodecDescription* answererSendCodec;
+  GetCodec(mSessionAns, 0, sdp::kSend, 0, 0, &answererSendCodec);
+  ASSERT_TRUE(answererSendCodec);
+  ASSERT_EQ("H264", answererSendCodec->mName);
+  const JsepVideoCodecDescription* answererVideoSendCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererSendCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, answererVideoSendCodec->mProfileLevelId);
+
+  const JsepCodecDescription* answererRecvCodec;
+  GetCodec(mSessionAns, 0, sdp::kRecv, 0, 0, &answererRecvCodec);
+  ASSERT_EQ("H264", answererRecvCodec->mName);
+  const JsepVideoCodecDescription* answererVideoRecvCodec(
+      static_cast<const JsepVideoCodecDescription*>(answererRecvCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, answererVideoRecvCodec->mProfileLevelId);
+}
+
+TEST_F(JsepSessionTest, TestH264LevelAsymmetryDisallowedByAnswererWithLowLevel)
+{
+  ForceH264(mSessionOff, 0x42e00d);
+  ForceH264(mSessionAns, 0x42e00b);
+
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer, CHECK_SUCCESS);
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer(CreateAnswer());
+
+  Replace("level-asymmetry-allowed=1",
+          "level-asymmetry-allowed=0",
+          &answer);
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+
+  const JsepCodecDescription* offererSendCodec;
+  GetCodec(mSessionOff, 0, sdp::kSend, 0, 0, &offererSendCodec);
+  ASSERT_TRUE(offererSendCodec);
+  ASSERT_EQ("H264", offererSendCodec->mName);
+  const JsepVideoCodecDescription* offererVideoSendCodec(
+      static_cast<const JsepVideoCodecDescription*>(offererSendCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, offererVideoSendCodec->mProfileLevelId);
+
+  const JsepCodecDescription* offererRecvCodec;
+  GetCodec(mSessionOff, 0, sdp::kRecv, 0, 0, &offererRecvCodec);
+  ASSERT_EQ("H264", offererRecvCodec->mName);
+  const JsepVideoCodecDescription* offererVideoRecvCodec(
+      static_cast<const JsepVideoCodecDescription*>(offererRecvCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, offererVideoRecvCodec->mProfileLevelId);
+
+  // Answerer doesn't know we've pulled these shenanigans, it should act as if
+  // it did not set level-asymmetry-required, and we already check that
+  // elsewhere
+}
+
+TEST_F(JsepSessionTest, TestH264LevelAsymmetryDisallowedByAnswererWithHighLevel)
+{
+  ForceH264(mSessionOff, 0x42e00b);
+  ForceH264(mSessionAns, 0x42e00d);
+
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer, CHECK_SUCCESS);
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer(CreateAnswer());
+
+  Replace("level-asymmetry-allowed=1",
+          "level-asymmetry-allowed=0",
+          &answer);
+
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+
+  const JsepCodecDescription* offererSendCodec;
+  GetCodec(mSessionOff, 0, sdp::kSend, 0, 0, &offererSendCodec);
+  ASSERT_TRUE(offererSendCodec);
+  ASSERT_EQ("H264", offererSendCodec->mName);
+  const JsepVideoCodecDescription* offererVideoSendCodec(
+      static_cast<const JsepVideoCodecDescription*>(offererSendCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, offererVideoSendCodec->mProfileLevelId);
+
+  const JsepCodecDescription* offererRecvCodec;
+  GetCodec(mSessionOff, 0, sdp::kRecv, 0, 0, &offererRecvCodec);
+  ASSERT_EQ("H264", offererRecvCodec->mName);
+  const JsepVideoCodecDescription* offererVideoRecvCodec(
+      static_cast<const JsepVideoCodecDescription*>(offererRecvCodec));
+  ASSERT_EQ((uint32_t)0x42e00b, offererVideoRecvCodec->mProfileLevelId);
+
+  // Answerer doesn't know we've pulled these shenanigans, it should act as if
+  // it did not set level-asymmetry-required, and we already check that
+  // elsewhere
+}
+
+TEST_P(JsepSessionTest, TestRejectMline)
+{
+  // We need to do this before adding tracks
+  types = BuildTypes(GetParam());
+  std::sort(types.begin(), types.end());
+
+  switch (types.front()) {
+    case SdpMediaSection::kAudio:
+      // Sabotage audio
+      EnsureNegotiationFailure(types.front(), "opus");
+      break;
+    case SdpMediaSection::kVideo:
+      // Sabotage video
+      EnsureNegotiationFailure(types.front(), "H264");
+      break;
+    case SdpMediaSection::kApplication:
+      // Sabotage datachannel
+      EnsureNegotiationFailure(types.front(), "webrtc-datachannel");
+      break;
+    default:
+      ASSERT_TRUE(false) << "Unknown media type";
+  }
+
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  std::string offer = CreateOffer();
+  mSessionOff.SetLocalDescription(kJsepSdpOffer, offer);
+  mSessionAns.SetRemoteDescription(kJsepSdpOffer, offer);
+
+  std::string answer = CreateAnswer();
+
+  UniquePtr<Sdp> outputSdp(Parse(answer));
+  ASSERT_TRUE(!!outputSdp);
+
+  ASSERT_NE(0U, outputSdp->GetMediaSectionCount());
+  SdpMediaSection* failed_section = nullptr;
+
+  for (size_t i = 0; i < outputSdp->GetMediaSectionCount(); ++i) {
+    if (outputSdp->GetMediaSection(i).GetMediaType() == types.front()) {
+      failed_section = &outputSdp->GetMediaSection(i);
+    }
+  }
+
+  ASSERT_TRUE(failed_section) << "Failed type was entirely absent from SDP";
+  auto& failed_attrs = failed_section->GetAttributeList();
+  ASSERT_EQ(SdpDirectionAttribute::kInactive, failed_attrs.GetDirection());
+  ASSERT_EQ(0U, failed_section->GetPort());
+
+  mSessionAns.SetLocalDescription(kJsepSdpAnswer, answer);
+  mSessionOff.SetRemoteDescription(kJsepSdpAnswer, answer);
+
+  size_t numRejected = std::count(types.begin(), types.end(), types.front());
+  size_t numAccepted = types.size() - numRejected;
+
+  ASSERT_EQ(numAccepted, mSessionOff.GetNegotiatedTrackPairs().size());
+  ASSERT_EQ(numAccepted, mSessionAns.GetNegotiatedTrackPairs().size());
+
+  ASSERT_EQ(types.size(), mSessionOff.GetTransports().size());
+  ASSERT_EQ(types.size(), mSessionOff.GetLocalTracks().size());
+  ASSERT_EQ(numAccepted, mSessionOff.GetRemoteTracks().size());
+
+  ASSERT_EQ(types.size(), mSessionAns.GetTransports().size());
+  ASSERT_EQ(types.size(), mSessionAns.GetLocalTracks().size());
+  ASSERT_EQ(types.size(), mSessionAns.GetRemoteTracks().size());
+}
+
+TEST_F(JsepSessionTest, CreateOfferNoMlines)
+{
+  JsepOfferOptions options;
+  std::string offer;
+  nsresult rv = mSessionOff.CreateOffer(options, &offer);
+  ASSERT_NE(NS_OK, rv);
+  ASSERT_NE("", mSessionOff.GetLastError());
+}
+
+TEST_F(JsepSessionTest, TestIceLite)
+{
+  AddTracks(mSessionOff, "audio");
+  AddTracks(mSessionAns, "audio");
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer, CHECK_SUCCESS);
+
+  UniquePtr<Sdp> parsedOffer(Parse(offer));
+  parsedOffer->GetAttributeList().SetAttribute(
+      new SdpFlagAttribute(SdpAttribute::kIceLiteAttribute));
+
+  std::ostringstream os;
+  parsedOffer->Serialize(os);
+  SetRemoteOffer(os.str(), CHECK_SUCCESS);
+
+  ASSERT_TRUE(mSessionAns.RemoteIsIceLite());
+  ASSERT_FALSE(mSessionOff.RemoteIsIceLite());
+}
+
+TEST_F(JsepSessionTest, TestIceOptions)
+{
+  AddTracks(mSessionOff, "audio");
+  AddTracks(mSessionAns, "audio");
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer, CHECK_SUCCESS);
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  ASSERT_EQ(1U, mSessionOff.GetIceOptions().size());
+  ASSERT_EQ("trickle", mSessionOff.GetIceOptions()[0]);
+
+  ASSERT_EQ(1U, mSessionAns.GetIceOptions().size());
+  ASSERT_EQ("trickle", mSessionAns.GetIceOptions()[0]);
+}
+
+TEST_F(JsepSessionTest, TestExtmap)
+{
+  AddTracks(mSessionOff, "audio");
+  AddTracks(mSessionAns, "audio");
+  // ssrc-audio-level will be extmap 1 for both
+  mSessionOff.AddAudioRtpExtension("foo"); // Default mapping of 2
+  mSessionOff.AddAudioRtpExtension("bar"); // Default mapping of 3
+  mSessionAns.AddAudioRtpExtension("bar"); // Default mapping of 2
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer, CHECK_SUCCESS);
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  UniquePtr<Sdp> parsedOffer(Parse(offer));
+  ASSERT_EQ(1U, parsedOffer->GetMediaSectionCount());
+
+  auto& offerMediaAttrs = parsedOffer->GetMediaSection(0).GetAttributeList();
+  ASSERT_TRUE(offerMediaAttrs.HasAttribute(SdpAttribute::kExtmapAttribute));
+  auto& offerExtmap = offerMediaAttrs.GetExtmap().mExtmaps;
+  ASSERT_EQ(3U, offerExtmap.size());
+  ASSERT_EQ("urn:ietf:params:rtp-hdrext:ssrc-audio-level",
+      offerExtmap[0].extensionname);
+  ASSERT_EQ(1U, offerExtmap[0].entry);
+  ASSERT_EQ("foo", offerExtmap[1].extensionname);
+  ASSERT_EQ(2U, offerExtmap[1].entry);
+  ASSERT_EQ("bar", offerExtmap[2].extensionname);
+  ASSERT_EQ(3U, offerExtmap[2].entry);
+
+  UniquePtr<Sdp> parsedAnswer(Parse(answer));
+  ASSERT_EQ(1U, parsedAnswer->GetMediaSectionCount());
+
+  auto& answerMediaAttrs = parsedAnswer->GetMediaSection(0).GetAttributeList();
+  ASSERT_TRUE(answerMediaAttrs.HasAttribute(SdpAttribute::kExtmapAttribute));
+  auto& answerExtmap = answerMediaAttrs.GetExtmap().mExtmaps;
+  ASSERT_EQ(1U, answerExtmap.size());
+  // We ensure that the entry for "bar" matches what was in the offer
+  ASSERT_EQ("bar", answerExtmap[0].extensionname);
+  ASSERT_EQ(3U, answerExtmap[0].entry);
+}
+
+TEST_F(JsepSessionTest, TestRtcpFbStar)
+{
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  std::string offer = CreateOffer();
+
+  UniquePtr<Sdp> parsedOffer(Parse(offer));
+  auto* rtcpfbs = new SdpRtcpFbAttributeList;
+  rtcpfbs->PushEntry("*", SdpRtcpFbAttributeList::kNack);
+  parsedOffer->GetMediaSection(0).GetAttributeList().SetAttribute(rtcpfbs);
+  offer = parsedOffer->ToString();
+
+  SetLocalOffer(offer, CHECK_SUCCESS);
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  ASSERT_EQ(1U, mSessionAns.GetRemoteTracks().size());
+  RefPtr<JsepTrack> track = mSessionAns.GetRemoteTracks()[0];
+  ASSERT_TRUE(track->GetNegotiatedDetails());
+  auto* details = track->GetNegotiatedDetails();
+  for (const JsepCodecDescription* codec :
+       details->GetEncoding(0).GetCodecs()) {
+    const JsepVideoCodecDescription* videoCodec =
+      static_cast<const JsepVideoCodecDescription*>(codec);
+    ASSERT_EQ(1U, videoCodec->mNackFbTypes.size());
+    ASSERT_EQ("", videoCodec->mNackFbTypes[0]);
+  }
+}
+
+TEST_F(JsepSessionTest, TestUniquePayloadTypes)
+{
+  // The audio payload types will all appear more than once, but the video
+  // payload types will be unique.
+  AddTracks(mSessionOff, "audio,audio,video");
+  AddTracks(mSessionAns, "audio,audio,video");
+
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer, CHECK_SUCCESS);
+  SetRemoteOffer(offer, CHECK_SUCCESS);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer, CHECK_SUCCESS);
+  SetRemoteAnswer(answer, CHECK_SUCCESS);
+
+  auto offerPairs = mSessionOff.GetNegotiatedTrackPairs();
+  auto answerPairs = mSessionAns.GetNegotiatedTrackPairs();
+  ASSERT_EQ(3U, offerPairs.size());
+  ASSERT_EQ(3U, answerPairs.size());
+
+  ASSERT_TRUE(offerPairs[0].mReceiving);
+  ASSERT_TRUE(offerPairs[0].mReceiving->GetNegotiatedDetails());
+  ASSERT_EQ(0U,
+      offerPairs[0].mReceiving->GetNegotiatedDetails()->
+      GetUniquePayloadTypes().size());
+
+  ASSERT_TRUE(offerPairs[1].mReceiving);
+  ASSERT_TRUE(offerPairs[1].mReceiving->GetNegotiatedDetails());
+  ASSERT_EQ(0U,
+      offerPairs[1].mReceiving->GetNegotiatedDetails()->
+      GetUniquePayloadTypes().size());
+
+  ASSERT_TRUE(offerPairs[2].mReceiving);
+  ASSERT_TRUE(offerPairs[2].mReceiving->GetNegotiatedDetails());
+  ASSERT_NE(0U,
+      offerPairs[2].mReceiving->GetNegotiatedDetails()->
+      GetUniquePayloadTypes().size());
+
+  ASSERT_TRUE(answerPairs[0].mReceiving);
+  ASSERT_TRUE(answerPairs[0].mReceiving->GetNegotiatedDetails());
+  ASSERT_EQ(0U,
+      answerPairs[0].mReceiving->GetNegotiatedDetails()->
+      GetUniquePayloadTypes().size());
+
+  ASSERT_TRUE(answerPairs[1].mReceiving);
+  ASSERT_TRUE(answerPairs[1].mReceiving->GetNegotiatedDetails());
+  ASSERT_EQ(0U,
+      answerPairs[1].mReceiving->GetNegotiatedDetails()->
+      GetUniquePayloadTypes().size());
+
+  ASSERT_TRUE(answerPairs[2].mReceiving);
+  ASSERT_TRUE(answerPairs[2].mReceiving->GetNegotiatedDetails());
+  ASSERT_NE(0U,
+      answerPairs[2].mReceiving->GetNegotiatedDetails()->
+      GetUniquePayloadTypes().size());
+}
+
+TEST_F(JsepSessionTest, UnknownFingerprintAlgorithm)
+{
+  types.push_back(SdpMediaSection::kAudio);
+  AddTracks(mSessionOff, "audio");
+  AddTracks(mSessionAns, "audio");
+
+  std::string offer(CreateOffer());
+  SetLocalOffer(offer);
+  ReplaceAll("fingerprint:sha", "fingerprint:foo", &offer);
+  nsresult rv = mSessionAns.SetRemoteDescription(kJsepSdpOffer, offer);
+  ASSERT_NE(NS_OK, rv);
+  ASSERT_NE("", mSessionAns.GetLastError());
+}
+
+TEST(H264ProfileLevelIdTest, TestLevelComparisons)
+{
+  ASSERT_LT(JsepVideoCodecDescription::GetSaneH264Level(0x421D0B), // 1b
+            JsepVideoCodecDescription::GetSaneH264Level(0x420D0B)); // 1.1
+  ASSERT_LT(JsepVideoCodecDescription::GetSaneH264Level(0x420D0A), // 1.0
+            JsepVideoCodecDescription::GetSaneH264Level(0x421D0B)); // 1b
+  ASSERT_LT(JsepVideoCodecDescription::GetSaneH264Level(0x420D0A), // 1.0
+            JsepVideoCodecDescription::GetSaneH264Level(0x420D0B)); // 1.1
+
+  ASSERT_LT(JsepVideoCodecDescription::GetSaneH264Level(0x640009), // 1b
+            JsepVideoCodecDescription::GetSaneH264Level(0x64000B)); // 1.1
+  ASSERT_LT(JsepVideoCodecDescription::GetSaneH264Level(0x64000A), // 1.0
+            JsepVideoCodecDescription::GetSaneH264Level(0x640009)); // 1b
+  ASSERT_LT(JsepVideoCodecDescription::GetSaneH264Level(0x64000A), // 1.0
+            JsepVideoCodecDescription::GetSaneH264Level(0x64000B)); // 1.1
+}
+
+TEST(H264ProfileLevelIdTest, TestLevelSetting)
+{
+  uint32_t profileLevelId = 0x420D0A;
+  JsepVideoCodecDescription::SetSaneH264Level(
+      JsepVideoCodecDescription::GetSaneH264Level(0x42100B),
+      &profileLevelId);
+  ASSERT_EQ((uint32_t)0x421D0B, profileLevelId);
+
+  JsepVideoCodecDescription::SetSaneH264Level(
+      JsepVideoCodecDescription::GetSaneH264Level(0x42000A),
+      &profileLevelId);
+  ASSERT_EQ((uint32_t)0x420D0A, profileLevelId);
+
+  profileLevelId = 0x6E100A;
+  JsepVideoCodecDescription::SetSaneH264Level(
+      JsepVideoCodecDescription::GetSaneH264Level(0x640009),
+      &profileLevelId);
+  ASSERT_EQ((uint32_t)0x6E1009, profileLevelId);
+
+  JsepVideoCodecDescription::SetSaneH264Level(
+      JsepVideoCodecDescription::GetSaneH264Level(0x64000B),
+      &profileLevelId);
+  ASSERT_EQ((uint32_t)0x6E100B, profileLevelId);
+}
+
+TEST_F(JsepSessionTest, StronglyPreferredCodec)
+{
+  for (JsepCodecDescription* codec : mSessionAns.Codecs()) {
+    if (codec->mName == "H264") {
+      codec->mStronglyPreferred = true;
+    }
+  }
+
+  types.push_back(SdpMediaSection::kVideo);
+  AddTracks(mSessionOff, "video");
+  AddTracks(mSessionAns, "video");
+
+  OfferAnswer();
+
+  const JsepCodecDescription* codec;
+  GetCodec(mSessionAns, 0, sdp::kSend, 0, 0, &codec);
+  ASSERT_TRUE(codec);
+  ASSERT_EQ("H264", codec->mName);
+  GetCodec(mSessionAns, 0, sdp::kRecv, 0, 0, &codec);
+  ASSERT_TRUE(codec);
+  ASSERT_EQ("H264", codec->mName);
+}
+
+TEST_F(JsepSessionTest, LowDynamicPayloadType)
+{
+  SetPayloadTypeNumber(mSessionOff, "opus", "12");
+  types.push_back(SdpMediaSection::kAudio);
+  AddTracks(mSessionOff, "audio");
+  AddTracks(mSessionAns, "audio");
+
+  OfferAnswer();
+  const JsepCodecDescription* codec;
+  GetCodec(mSessionAns, 0, sdp::kSend, 0, 0, &codec);
+  ASSERT_TRUE(codec);
+  ASSERT_EQ("opus", codec->mName);
+  ASSERT_EQ("12", codec->mDefaultPt);
+  GetCodec(mSessionAns, 0, sdp::kRecv, 0, 0, &codec);
+  ASSERT_TRUE(codec);
+  ASSERT_EQ("opus", codec->mName);
+  ASSERT_EQ("12", codec->mDefaultPt);
+}
+
+TEST_F(JsepSessionTest, PayloadTypeClash)
+{
+  // Disable this so mSessionOff doesn't have a duplicate
+  SetCodecEnabled(mSessionOff, "PCMU", false);
+  SetPayloadTypeNumber(mSessionOff, "opus", "0");
+  SetPayloadTypeNumber(mSessionAns, "PCMU", "0");
+  types.push_back(SdpMediaSection::kAudio);
+  AddTracks(mSessionOff, "audio");
+  AddTracks(mSessionAns, "audio");
+
+  OfferAnswer();
+  const JsepCodecDescription* codec;
+  GetCodec(mSessionAns, 0, sdp::kSend, 0, 0, &codec);
+  ASSERT_TRUE(codec);
+  ASSERT_EQ("opus", codec->mName);
+  ASSERT_EQ("0", codec->mDefaultPt);
+  GetCodec(mSessionAns, 0, sdp::kRecv, 0, 0, &codec);
+  ASSERT_TRUE(codec);
+  ASSERT_EQ("opus", codec->mName);
+  ASSERT_EQ("0", codec->mDefaultPt);
+
+  // Now, make sure that mSessionAns does not put a=rtpmap:0 PCMU in a reoffer,
+  // since pt 0 is taken for opus (the answerer still supports PCMU, and will
+  // reoffer it, but it should choose a new payload type for it)
+  JsepOfferOptions options;
+  std::string reoffer;
+  nsresult rv = mSessionAns.CreateOffer(options, &reoffer);
+  ASSERT_EQ(NS_OK, rv);
+  ASSERT_EQ(std::string::npos, reoffer.find("a=rtpmap:0 PCMU")) << reoffer;
+}
+
+TEST_P(JsepSessionTest, TestGlareRollback)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+  JsepOfferOptions options;
+
+  std::string offer;
+  ASSERT_EQ(NS_OK, mSessionAns.CreateOffer(options, &offer));
+  ASSERT_EQ(NS_OK,
+            mSessionAns.SetLocalDescription(kJsepSdpOffer, offer));
+  ASSERT_EQ(kJsepStateHaveLocalOffer, mSessionAns.GetState());
+
+  ASSERT_EQ(NS_OK, mSessionOff.CreateOffer(options, &offer));
+  ASSERT_EQ(NS_OK,
+            mSessionOff.SetLocalDescription(kJsepSdpOffer, offer));
+  ASSERT_EQ(kJsepStateHaveLocalOffer, mSessionOff.GetState());
+
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionAns.SetRemoteDescription(kJsepSdpOffer, offer));
+  ASSERT_EQ(NS_OK,
+            mSessionAns.SetLocalDescription(kJsepSdpRollback, ""));
+  ASSERT_EQ(kJsepStateStable, mSessionAns.GetState());
+
+  SetRemoteOffer(offer);
+
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer);
+}
+
+TEST_P(JsepSessionTest, TestRejectOfferRollback)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  std::string offer = CreateOffer();
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+
+  ASSERT_EQ(NS_OK,
+            mSessionAns.SetRemoteDescription(kJsepSdpRollback, ""));
+  ASSERT_EQ(kJsepStateStable, mSessionAns.GetState());
+  ASSERT_EQ(types.size(), mSessionAns.GetRemoteTracksRemoved().size());
+
+  ASSERT_EQ(NS_OK,
+            mSessionOff.SetLocalDescription(kJsepSdpRollback, ""));
+  ASSERT_EQ(kJsepStateStable, mSessionOff.GetState());
+
+  OfferAnswer();
+}
+
+TEST_P(JsepSessionTest, TestInvalidRollback)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionOff.SetLocalDescription(kJsepSdpRollback, ""));
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionOff.SetRemoteDescription(kJsepSdpRollback, ""));
+
+  std::string offer = CreateOffer();
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionOff.SetLocalDescription(kJsepSdpRollback, ""));
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionOff.SetRemoteDescription(kJsepSdpRollback, ""));
+
+  SetLocalOffer(offer);
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionOff.SetRemoteDescription(kJsepSdpRollback, ""));
+
+  SetRemoteOffer(offer);
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionAns.SetLocalDescription(kJsepSdpRollback, ""));
+
+  std::string answer = CreateAnswer();
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionAns.SetLocalDescription(kJsepSdpRollback, ""));
+
+  SetLocalAnswer(answer);
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionAns.SetLocalDescription(kJsepSdpRollback, ""));
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionAns.SetRemoteDescription(kJsepSdpRollback, ""));
+
+  SetRemoteAnswer(answer);
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionOff.SetLocalDescription(kJsepSdpRollback, ""));
+  ASSERT_EQ(NS_ERROR_UNEXPECTED,
+            mSessionOff.SetRemoteDescription(kJsepSdpRollback, ""));
+}
+
+size_t GetActiveTransportCount(const JsepSession& session)
+{
+  auto transports = session.GetTransports();
+  size_t activeTransportCount = 0;
+  for (RefPtr<JsepTransport>& transport : transports) {
+    activeTransportCount += transport->mComponents;
+  }
+  return activeTransportCount;
+}
+
+TEST_P(JsepSessionTest, TestBalancedBundle)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  mSessionOff.SetBundlePolicy(kBundleBalanced);
+
+  std::string offer = CreateOffer();
+  SipccSdpParser parser;
+  UniquePtr<Sdp> parsedOffer = parser.Parse(offer);
+  ASSERT_TRUE(parsedOffer.get());
+
+  std::map<SdpMediaSection::MediaType, SdpMediaSection*> firstByType;
+
+  for (size_t i = 0; i < parsedOffer->GetMediaSectionCount(); ++i) {
+    SdpMediaSection& msection(parsedOffer->GetMediaSection(i));
+    bool firstOfType = !firstByType.count(msection.GetMediaType());
+    if (firstOfType) {
+      firstByType[msection.GetMediaType()] = &msection;
+    }
+    ASSERT_EQ(!firstOfType,
+              msection.GetAttributeList().HasAttribute(
+                SdpAttribute::kBundleOnlyAttribute));
+  }
+
+  SetLocalOffer(offer);
+  SetRemoteOffer(offer);
+  std::string answer = CreateAnswer();
+  SetLocalAnswer(answer);
+  SetRemoteAnswer(answer);
+
+  CheckPairs(mSessionOff, "Offerer pairs");
+  CheckPairs(mSessionAns, "Answerer pairs");
+  EXPECT_EQ(1U, GetActiveTransportCount(mSessionOff));
+  EXPECT_EQ(1U, GetActiveTransportCount(mSessionAns));
+}
+
+TEST_P(JsepSessionTest, TestMaxBundle)
+{
+  AddTracks(mSessionOff);
+  AddTracks(mSessionAns);
+
+  mSessionOff.SetBundlePolicy(kBundleMaxBundle);
+  OfferAnswer();
+
+  std::string offer = mSessionOff.GetLocalDescription();
+  SipccSdpParser parser;
+  UniquePtr<Sdp> parsedOffer = parser.Parse(offer);
+  ASSERT_TRUE(parsedOffer.get());
+
+  ASSERT_FALSE(
+      parsedOffer->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kBundleOnlyAttribute));
+  for (size_t i = 1; i < parsedOffer->GetMediaSectionCount(); ++i) {
+    ASSERT_TRUE(
+        parsedOffer->GetMediaSection(i).GetAttributeList().HasAttribute(
+          SdpAttribute::kBundleOnlyAttribute));
+  }
+
+
+  CheckPairs(mSessionOff, "Offerer pairs");
+  CheckPairs(mSessionAns, "Answerer pairs");
+  EXPECT_EQ(1U, GetActiveTransportCount(mSessionOff));
+  EXPECT_EQ(1U, GetActiveTransportCount(mSessionAns));
+}
+
+TEST_F(JsepSessionTest, TestNonDefaultProtocol)
+{
+  AddTracks(mSessionOff, "audio,video,datachannel");
+  AddTracks(mSessionAns, "audio,video,datachannel");
+
+  std::string offer;
+  ASSERT_EQ(NS_OK, mSessionOff.CreateOffer(JsepOfferOptions(), &offer));
+  offer.replace(offer.find("UDP/TLS/RTP/SAVPF"),
+                strlen("UDP/TLS/RTP/SAVPF"),
+                "RTP/SAVPF");
+  offer.replace(offer.find("UDP/TLS/RTP/SAVPF"),
+                strlen("UDP/TLS/RTP/SAVPF"),
+                "RTP/SAVPF");
+  mSessionOff.SetLocalDescription(kJsepSdpOffer, offer);
+  mSessionAns.SetRemoteDescription(kJsepSdpOffer, offer);
+
+  std::string answer;
+  mSessionAns.CreateAnswer(JsepAnswerOptions(), &answer);
+  UniquePtr<Sdp> parsedAnswer = Parse(answer);
+  ASSERT_EQ(3U, parsedAnswer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf,
+            parsedAnswer->GetMediaSection(0).GetProtocol());
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf,
+            parsedAnswer->GetMediaSection(1).GetProtocol());
+
+  mSessionAns.SetLocalDescription(kJsepSdpAnswer, answer);
+  mSessionOff.SetRemoteDescription(kJsepSdpAnswer, answer);
+
+  // Make sure reoffer uses the same protocol as before
+  mSessionOff.CreateOffer(JsepOfferOptions(), &offer);
+  UniquePtr<Sdp> parsedOffer = Parse(offer);
+  ASSERT_EQ(3U, parsedOffer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf,
+            parsedOffer->GetMediaSection(0).GetProtocol());
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf,
+            parsedOffer->GetMediaSection(1).GetProtocol());
+
+  // Make sure reoffer from other side uses the same protocol as before
+  mSessionAns.CreateOffer(JsepOfferOptions(), &offer);
+  parsedOffer = Parse(offer);
+  ASSERT_EQ(3U, parsedOffer->GetMediaSectionCount());
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf,
+            parsedOffer->GetMediaSection(0).GetProtocol());
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf,
+            parsedOffer->GetMediaSection(1).GetProtocol());
+}
+
+} // namespace mozilla
+
+int
+main(int argc, char** argv)
+{
+  // Prevents some log spew
+  ScopedXPCOM xpcom("jsep_session_unittest");
+
+  NSS_NoDB_Init(nullptr);
+  NSS_SetDomesticPolicy();
+
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
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();
+}
+
diff --git a/media/webrtc/signaling/test/mediaconduit_unittests.cpp b/media/webrtc/signaling/test/mediaconduit_unittests.cpp
new file mode 100644
index 000000000..f0cf95a47
--- /dev/null
+++ b/media/webrtc/signaling/test/mediaconduit_unittests.cpp
@@ -0,0 +1,1091 @@
+/* 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/. */
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <unistd.h>
+#include <vector>
+#include <math.h>
+
+using namespace std;
+
+#include "mozilla/SyncRunnable.h"
+#include "mozilla/UniquePtr.h"
+#include <MediaConduitInterface.h>
+#include "GmpVideoCodec.h"
+#include "nsIEventTarget.h"
+#include "FakeMediaStreamsImpl.h"
+#include "FakeLogging.h"
+#include "nsThreadUtils.h"
+#include "runnable_utils.h"
+#include "signaling/src/common/EncodingConstraints.h"
+
+#include "FakeIPC.h"
+#include "FakeIPC.cpp"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+nsCOMPtr<nsIThread> gMainThread;
+nsCOMPtr<nsIThread> gGtestThread;
+bool gTestsComplete = false;
+
+#include "mtransport_test_utils.h"
+MtransportTestUtils *test_utils;
+
+//Video Frame Color
+const int COLOR = 0x80; //Gray
+
+//MWC RNG of George Marsaglia
+//taken from xiph.org
+static int32_t Rz, Rw;
+static inline int32_t fast_rand(void)
+{
+  Rz=36969*(Rz&65535)+(Rz>>16);
+  Rw=18000*(Rw&65535)+(Rw>>16);
+  return (Rz<<16)+Rw;
+}
+
+/**
+  * Global structure to store video test results.
+  */
+struct VideoTestStats
+{
+ int numRawFramesInserted;
+ int numFramesRenderedSuccessfully;
+ int numFramesRenderedWrongly;
+};
+
+VideoTestStats vidStatsGlobal={0,0,0};
+
+/**
+ * A Dummy Video Conduit Tester.
+ * The test-case inserts a 640*480 grey imagerevery 33 milliseconds
+ * to the video-conduit for encoding and transporting.
+ */
+
+class VideoSendAndReceive
+{
+public:
+  VideoSendAndReceive():width(640),
+                        height(480),
+			rate(30)
+  {
+  }
+
+  ~VideoSendAndReceive()
+  {
+  }
+
+  void SetDimensions(int w, int h)
+  {
+    width = w;
+    height = h;
+  }
+  void SetRate(int r) {
+    rate = r;
+  }
+  void Init(RefPtr<mozilla::VideoSessionConduit> aSession)
+  {
+        mSession = aSession;
+        mLen = ((width * height) * 3 / 2);
+        mFrame = mozilla::MakeUnique<uint8_t[]>(mLen);
+        memset(mFrame.get(), COLOR, mLen);
+        numFrames = 121;
+  }
+
+  void GenerateAndReadSamples()
+  {
+    do
+    {
+      mSession->SendVideoFrame(reinterpret_cast<unsigned char*>(mFrame.get()),
+                                mLen,
+                                width,
+                                height,
+                                mozilla::kVideoI420,
+                                0);
+      PR_Sleep(PR_MillisecondsToInterval(1000/rate));
+      vidStatsGlobal.numRawFramesInserted++;
+      numFrames--;
+    } while(numFrames >= 0);
+  }
+
+private:
+RefPtr<mozilla::VideoSessionConduit> mSession;
+mozilla::UniquePtr<uint8_t[]> mFrame;
+int mLen;
+int width, height;
+int rate;
+int numFrames;
+};
+
+
+
+/**
+ * A Dummy AudioConduit Tester
+ * The test reads PCM samples of a standard test file and
+ * passws to audio-conduit for encoding, RTPfication and
+ * decoding ebery 10 milliseconds.
+ * This decoded samples are read-off the conduit for writing
+ * into output audio file in PCM format.
+ */
+class AudioSendAndReceive
+{
+public:
+  static const unsigned int PLAYOUT_SAMPLE_FREQUENCY; //default is 16000
+  static const unsigned int PLAYOUT_SAMPLE_LENGTH; //default is 160000
+
+  AudioSendAndReceive()
+  {
+  }
+
+  ~AudioSendAndReceive()
+  {
+  }
+
+ void Init(RefPtr<mozilla::AudioSessionConduit> aSession,
+           RefPtr<mozilla::AudioSessionConduit> aOtherSession,
+           std::string fileIn, std::string fileOut)
+  {
+
+    mSession = aSession;
+    mOtherSession = aOtherSession;
+    iFile = fileIn;
+    oFile = fileOut;
+ }
+
+  //Kick start the test
+  void GenerateAndReadSamples();
+
+private:
+
+  RefPtr<mozilla::AudioSessionConduit> mSession;
+  RefPtr<mozilla::AudioSessionConduit> mOtherSession;
+  std::string iFile;
+  std::string oFile;
+
+  int WriteWaveHeader(int rate, int channels, FILE* outFile);
+  int FinishWaveHeader(FILE* outFile);
+  void GenerateMusic(int16_t* buf, int len);
+};
+
+const unsigned int AudioSendAndReceive::PLAYOUT_SAMPLE_FREQUENCY = 16000;
+const unsigned int AudioSendAndReceive::PLAYOUT_SAMPLE_LENGTH  = 160000;
+
+int AudioSendAndReceive::WriteWaveHeader(int rate, int channels, FILE* outFile)
+{
+  //Hardcoded for 16 bit samples
+  unsigned char header[] = {
+    // File header
+    0x52, 0x49, 0x46, 0x46, // 'RIFF'
+    0x00, 0x00, 0x00, 0x00, // chunk size
+    0x57, 0x41, 0x56, 0x45, // 'WAVE'
+    // fmt chunk. We always write 16-bit samples.
+    0x66, 0x6d, 0x74, 0x20, // 'fmt '
+    0x10, 0x00, 0x00, 0x00, // chunk size
+    0x01, 0x00,             // WAVE_FORMAT_PCM
+    0xFF, 0xFF,             // channels
+    0xFF, 0xFF, 0xFF, 0xFF, // sample rate
+    0x00, 0x00, 0x00, 0x00, // data rate
+    0xFF, 0xFF,             // frame size in bytes
+    0x10, 0x00,             // bits per sample
+    // data chunk
+    0x64, 0x61, 0x74, 0x61, // 'data'
+    0xFE, 0xFF, 0xFF, 0x7F  // chunk size
+  };
+
+#define set_uint16le(buffer, value) \
+  (buffer)[0] = (value) & 0xff; \
+  (buffer)[1] = (value) >> 8;
+#define set_uint32le(buffer, value) \
+  set_uint16le( (buffer), (value) & 0xffff ); \
+  set_uint16le( (buffer) + 2, (value) >> 16 );
+
+  // set dynamic header fields
+  set_uint16le(header + 22, channels);
+  set_uint32le(header + 24, rate);
+  set_uint16le(header + 32, channels*2);
+
+  size_t written = fwrite(header, 1, sizeof(header), outFile);
+  if (written != sizeof(header)) {
+    cerr << "Writing WAV header failed" << endl;
+    return -1;
+  }
+
+  return 0;
+}
+
+// Update the WAVE file header with the written length
+int AudioSendAndReceive::FinishWaveHeader(FILE* outFile)
+{
+  // Measure how much data we've written
+  long end = ftell(outFile);
+  if (end < 16) {
+    cerr << "Couldn't get output file length" << endl;
+    return (end < 0) ? end : -1;
+  }
+
+  // Update the header
+  unsigned char size[4];
+  int err = fseek(outFile, 40, SEEK_SET);
+  if (err < 0) {
+    cerr << "Couldn't seek to WAV file header." << endl;
+    return err;
+  }
+  set_uint32le(size, (end - 44) & 0xffffffff);
+  size_t written = fwrite(size, 1, sizeof(size), outFile);
+  if (written != sizeof(size)) {
+    cerr << "Couldn't write data size to WAV header" << endl;
+    return -1;
+  }
+
+  // Return to the end
+  err = fseek(outFile, 0, SEEK_END);
+  if (err < 0) {
+    cerr << "Couldn't seek to WAV file end." << endl;
+    return err;
+  }
+
+  return 0;
+}
+
+//Code from xiph.org to generate music of predefined length
+void AudioSendAndReceive::GenerateMusic(short* buf, int len)
+{
+  cerr <<" Generating Input Music " << endl;
+  int32_t a1,a2,b1,b2;
+  int32_t c1,c2,d1,d2;
+  int32_t i,j;
+  a1=b1=a2=b2=0;
+  c1=c2=d1=d2=0;
+  j=0;
+  /*60ms silence */
+  for(i=0;i<2880;i++)
+  {
+    buf[i*2]=buf[(i*2)+1]=0;
+  }
+  for(i=2880;i<len-1;i+=2)
+  {
+    int32_t r;
+    int32_t v1,v2;
+    v1=v2=(((j*((j>>12)^((j>>10|j>>12)&26&j>>7)))&128)+128)<<15;
+    r=fast_rand();v1+=r&65535;v1-=r>>16;
+    r=fast_rand();v2+=r&65535;v2-=r>>16;
+    b1=v1-a1+((b1*61+32)>>6);a1=v1;
+    b2=v2-a2+((b2*61+32)>>6);a2=v2;
+    c1=(30*(c1+b1+d1)+32)>>6;d1=b1;
+    c2=(30*(c2+b2+d2)+32)>>6;d2=b2;
+    v1=(c1+128)>>8;
+    v2=(c2+128)>>8;
+    buf[i]=v1>32767?32767:(v1<-32768?-32768:v1);
+    buf[i+1]=v2>32767?32767:(v2<-32768?-32768:v2);
+    if(i%6==0)j++;
+  }
+  cerr << "Generating Input Music Done " << endl;
+}
+
+//Hardcoded for 16 bit samples for now
+void AudioSendAndReceive::GenerateAndReadSamples()
+{
+   auto audioInput = mozilla::MakeUnique<int16_t []>(PLAYOUT_SAMPLE_LENGTH);
+   auto audioOutput = mozilla::MakeUnique<int16_t []>(PLAYOUT_SAMPLE_LENGTH);
+   short* inbuf;
+   int sampleLengthDecoded = 0;
+   unsigned int SAMPLES = (PLAYOUT_SAMPLE_FREQUENCY * 10); //10 seconds
+   int CHANNELS = 1; //mono audio
+   int sampleLengthInBytes = sizeof(int16_t) * PLAYOUT_SAMPLE_LENGTH;
+   //generated audio buffer
+   inbuf = (short *)moz_xmalloc(sizeof(short)*SAMPLES*CHANNELS);
+   memset(audioInput.get(),0,sampleLengthInBytes);
+   memset(audioOutput.get(),0,sampleLengthInBytes);
+   MOZ_ASSERT(SAMPLES <= PLAYOUT_SAMPLE_LENGTH);
+
+   FILE* inFile = fopen( iFile.c_str(), "wb+");
+   if(!inFile) {
+     cerr << "Input File Creation Failed " << endl;
+     free(inbuf);
+     return;
+   }
+
+   FILE* outFile = fopen( oFile.c_str(), "wb+");
+   if(!outFile) {
+     cerr << "Output File Creation Failed " << endl;
+     free(inbuf);
+     fclose(inFile);
+     return;
+   }
+
+   //Create input file with the music
+   WriteWaveHeader(PLAYOUT_SAMPLE_FREQUENCY, 1, inFile);
+   GenerateMusic(inbuf, SAMPLES);
+   fwrite(inbuf,1,SAMPLES*sizeof(inbuf[0])*CHANNELS,inFile);
+   FinishWaveHeader(inFile);
+   fclose(inFile);
+
+   WriteWaveHeader(PLAYOUT_SAMPLE_FREQUENCY, 1, outFile);
+   unsigned int numSamplesReadFromInput = 0;
+   do
+   {
+    if(!memcpy(audioInput.get(), inbuf, sampleLengthInBytes))
+    {
+      free(inbuf);
+      fclose(outFile);
+      return;
+    }
+
+    numSamplesReadFromInput += PLAYOUT_SAMPLE_LENGTH;
+    inbuf += PLAYOUT_SAMPLE_LENGTH;
+
+    mSession->SendAudioFrame(audioInput.get(),
+                             PLAYOUT_SAMPLE_LENGTH,
+                             PLAYOUT_SAMPLE_FREQUENCY,10);
+
+    PR_Sleep(PR_MillisecondsToInterval(10));
+    mOtherSession->GetAudioFrame(audioOutput.get(), PLAYOUT_SAMPLE_FREQUENCY,
+                                 10, sampleLengthDecoded);
+    if(sampleLengthDecoded == 0)
+    {
+      cerr << " Zero length Sample " << endl;
+    }
+
+    int wrote_  = fwrite (audioOutput.get(), 1 , sampleLengthInBytes, outFile);
+    if(wrote_ != sampleLengthInBytes)
+    {
+      cerr << "Couldn't Write " << sampleLengthInBytes << "bytes" << endl;
+      break;
+    }
+   }while(numSamplesReadFromInput < SAMPLES);
+
+   FinishWaveHeader(outFile);
+   free(inbuf);
+   fclose(outFile);
+}
+
+/**
+ * Dummy Video Target for the conduit
+ * This class acts as renderer attached to the video conuit
+ * As of today we just verify if the frames rendered are exactly
+ * the same as frame inserted at the first place
+ */
+class DummyVideoTarget: public mozilla::VideoRenderer
+{
+public:
+  DummyVideoTarget()
+  {
+  }
+
+  virtual ~DummyVideoTarget()
+  {
+  }
+
+
+  void RenderVideoFrame(const unsigned char* buffer,
+                        size_t buffer_size,
+                        uint32_t y_stride,
+                        uint32_t cbcr_stride,
+                        uint32_t time_stamp,
+                        int64_t render_time,
+                        const mozilla::ImageHandle& handle) override
+  {
+    RenderVideoFrame(buffer, buffer_size, time_stamp, render_time, handle);
+  }
+
+  void RenderVideoFrame(const unsigned char* buffer,
+                        size_t buffer_size,
+                        uint32_t time_stamp,
+                        int64_t render_time,
+                        const mozilla::ImageHandle& handle) override
+ {
+  //write the frame to the file
+  if(VerifyFrame(buffer, buffer_size) == 0)
+  {
+      vidStatsGlobal.numFramesRenderedSuccessfully++;
+  } else
+  {
+      vidStatsGlobal.numFramesRenderedWrongly++;
+  }
+ }
+
+ void FrameSizeChange(unsigned int, unsigned int, unsigned int) override
+ {
+    //do nothing
+ }
+
+ //This is hardcoded to check if the contents of frame is COLOR
+ // as we set while sending.
+ int VerifyFrame(const unsigned char* buffer, unsigned int buffer_size)
+ {
+    int good = 0;
+    for(int i=0; i < (int) buffer_size; i++)
+    {
+      if(buffer[i] == COLOR)
+      {
+        ++good;
+      }
+      else
+      {
+        --good;
+      }
+    }
+   return 0;
+ }
+
+};
+
+/**
+ *  Webrtc Audio and Video External Transport Class
+ *  The functions in this class will be invoked by the conduit
+ *  when it has RTP/RTCP frame to transmit.
+ *  For everty RTP/RTCP frame we receive, we pass it back
+ *  to the conduit for eventual decoding and rendering.
+ */
+class WebrtcMediaTransport : public mozilla::TransportInterface
+{
+public:
+  WebrtcMediaTransport():numPkts(0),
+                       mAudio(false),
+                       mVideo(false)
+  {
+  }
+
+  ~WebrtcMediaTransport()
+  {
+  }
+
+  virtual nsresult SendRtpPacket(const void* data, int len)
+  {
+    ++numPkts;
+    if(mAudio)
+    {
+      mOtherAudioSession->ReceivedRTPPacket(data,len);
+    } else
+    {
+      mOtherVideoSession->ReceivedRTPPacket(data,len);
+    }
+    return NS_OK;
+  }
+
+  virtual nsresult SendRtcpPacket(const void* data, int len)
+  {
+    if(mAudio)
+    {
+      mOtherAudioSession->ReceivedRTCPPacket(data,len);
+    } else
+    {
+      mOtherVideoSession->ReceivedRTCPPacket(data,len);
+    }
+    return NS_OK;
+  }
+
+  //Treat this object as Audio Transport
+  void SetAudioSession(RefPtr<mozilla::AudioSessionConduit> aSession,
+                        RefPtr<mozilla::AudioSessionConduit>
+                        aOtherSession)
+  {
+    mAudioSession = aSession;
+    mOtherAudioSession = aOtherSession;
+    mAudio = true;
+  }
+
+  // Treat this object as Video Transport
+  void SetVideoSession(RefPtr<mozilla::VideoSessionConduit> aSession,
+                       RefPtr<mozilla::VideoSessionConduit>
+                       aOtherSession)
+  {
+    mVideoSession = aSession;
+    mOtherVideoSession = aOtherSession;
+    mVideo = true;
+  }
+
+private:
+  RefPtr<mozilla::AudioSessionConduit> mAudioSession;
+  RefPtr<mozilla::VideoSessionConduit> mVideoSession;
+  RefPtr<mozilla::VideoSessionConduit> mOtherVideoSession;
+  RefPtr<mozilla::AudioSessionConduit> mOtherAudioSession;
+  int numPkts;
+  bool mAudio, mVideo;
+};
+
+
+namespace {
+
+class TransportConduitTest : public ::testing::Test
+{
+ public:
+
+  TransportConduitTest()
+  {
+    //input and output file names
+    iAudiofilename = "input.wav";
+    oAudiofilename = "recorded.wav";
+  }
+
+  ~TransportConduitTest()
+  {
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+                                            mozilla::WrapRunnable(
+                                                this,
+                                                &TransportConduitTest::SelfDestruct));
+  }
+
+  void SelfDestruct() {
+    mAudioSession = nullptr;
+    mAudioSession2 = nullptr;
+    mAudioTransport = nullptr;
+
+    mVideoSession = nullptr;
+    mVideoSession2 = nullptr;
+    mVideoRenderer = nullptr;
+    mVideoTransport = nullptr;
+  }
+
+  //1. Dump audio samples to dummy external transport
+  void TestDummyAudioAndTransport()
+  {
+    //get pointer to AudioSessionConduit
+    int err=0;
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+                                            WrapRunnableNMRet(&mAudioSession,
+                                                &mozilla::AudioSessionConduit::Create));
+    if( !mAudioSession )
+      ASSERT_NE(mAudioSession, (void*)nullptr);
+
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+                                            WrapRunnableNMRet(&mAudioSession2,
+                                                &mozilla::AudioSessionConduit::Create));
+    if( !mAudioSession2 )
+      ASSERT_NE(mAudioSession2, (void*)nullptr);
+
+    WebrtcMediaTransport* xport = new WebrtcMediaTransport();
+    ASSERT_NE(xport, (void*)nullptr);
+    xport->SetAudioSession(mAudioSession, mAudioSession2);
+    mAudioTransport = xport;
+
+    // attach the transport to audio-conduit
+    err = mAudioSession->SetTransmitterTransport(mAudioTransport);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mAudioSession2->SetReceiverTransport(mAudioTransport);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+    //configure send and recv codecs on the audio-conduit
+    //mozilla::AudioCodecConfig cinst1(124, "PCMU", 8000, 80, 1, 64000, false);
+    mozilla::AudioCodecConfig cinst1(124, "opus", 48000, 960, 1, 64000, false);
+    mozilla::AudioCodecConfig cinst2(125, "L16", 16000, 320, 1, 256000, false);
+
+    std::vector<mozilla::AudioCodecConfig*> rcvCodecList;
+    rcvCodecList.push_back(&cinst1);
+    rcvCodecList.push_back(&cinst2);
+
+    err = mAudioSession->ConfigureSendMediaCodec(&cinst1);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mAudioSession->StartTransmitting();
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mAudioSession->ConfigureRecvMediaCodecs(rcvCodecList);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+    err = mAudioSession2->ConfigureSendMediaCodec(&cinst1);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mAudioSession2->StartTransmitting();
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mAudioSession2->ConfigureRecvMediaCodecs(rcvCodecList);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+    //start generating samples
+    audioTester.Init(mAudioSession,mAudioSession2, iAudiofilename,oAudiofilename);
+    cerr << "   ******************************************************** " << endl;
+    cerr << "    Generating Audio Samples " << endl;
+    cerr << "   ******************************************************** " << endl;
+    PR_Sleep(PR_SecondsToInterval(2));
+    audioTester.GenerateAndReadSamples();
+    PR_Sleep(PR_SecondsToInterval(2));
+    cerr << "   ******************************************************** " << endl;
+    cerr << "    Input Audio  File                " << iAudiofilename << endl;
+    cerr << "    Output Audio File                " << oAudiofilename << endl;
+    cerr << "   ******************************************************** " << endl;
+  }
+
+  //2. Dump audio samples to dummy external transport
+  void TestDummyVideoAndTransport(bool send_vp8 = true, const char *source_file = nullptr)
+  {
+    int err = 0;
+    //get pointer to VideoSessionConduit
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+                                            WrapRunnableNMRet(&mVideoSession,
+                                                &mozilla::VideoSessionConduit::Create));
+    if( !mVideoSession )
+      ASSERT_NE(mVideoSession, (void*)nullptr);
+
+   // This session is for other one
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+                                            WrapRunnableNMRet(&mVideoSession2,
+                                                &mozilla::VideoSessionConduit::Create));
+    if( !mVideoSession2 )
+      ASSERT_NE(mVideoSession2,(void*)nullptr);
+
+    if (!send_vp8) {
+      SetGmpCodecs();
+    }
+
+    mVideoRenderer = new DummyVideoTarget();
+    ASSERT_NE(mVideoRenderer, (void*)nullptr);
+
+    WebrtcMediaTransport* xport = new WebrtcMediaTransport();
+    ASSERT_NE(xport, (void*)nullptr);
+    xport->SetVideoSession(mVideoSession,mVideoSession2);
+    mVideoTransport = xport;
+
+    // attach the transport and renderer to video-conduit
+    err = mVideoSession2->AttachRenderer(mVideoRenderer);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mVideoSession->SetTransmitterTransport(mVideoTransport);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mVideoSession2->SetReceiverTransport(mVideoTransport);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+    mozilla::EncodingConstraints constraints;
+    //configure send and recv codecs on theconduit
+    mozilla::VideoCodecConfig cinst1(120, "VP8", constraints);
+    mozilla::VideoCodecConfig cinst2(124, "I420", constraints);
+
+
+    std::vector<mozilla::VideoCodecConfig* > rcvCodecList;
+    rcvCodecList.push_back(&cinst1);
+    rcvCodecList.push_back(&cinst2);
+
+    err = mVideoSession->ConfigureSendMediaCodec(
+        send_vp8 ? &cinst1 : &cinst2);
+
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mVideoSession->StartTransmitting();
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+    err = mVideoSession2->ConfigureSendMediaCodec(
+        send_vp8 ? &cinst1 : &cinst2);
+    err = mVideoSession2->StartTransmitting();
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mVideoSession2->ConfigureRecvMediaCodecs(rcvCodecList);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+    //start generating samples
+    cerr << "   *************************************************" << endl;
+    cerr << "    Starting the Video Sample Generation " << endl;
+    cerr << "   *************************************************" << endl;
+    PR_Sleep(PR_SecondsToInterval(2));
+    videoTester.Init(mVideoSession);
+    videoTester.GenerateAndReadSamples();
+    PR_Sleep(PR_SecondsToInterval(2));
+
+    cerr << "   **************************************************" << endl;
+    cerr << "    Done With The Testing  " << endl;
+    cerr << "    VIDEO TEST STATS  "  << endl;
+    cerr << "    Num Raw Frames Inserted: "<<
+                                        vidStatsGlobal.numRawFramesInserted << endl;
+    cerr << "    Num Frames Successfully Rendered: "<<
+                                        vidStatsGlobal.numFramesRenderedSuccessfully << endl;
+    cerr << "    Num Frames Wrongly Rendered: "<<
+                                        vidStatsGlobal.numFramesRenderedWrongly << endl;
+
+    cerr << "    Done With The Testing  " << endl;
+
+    cerr << "   **************************************************" << endl;
+    ASSERT_EQ(0, vidStatsGlobal.numFramesRenderedWrongly);
+    if (send_vp8) {
+	ASSERT_EQ(vidStatsGlobal.numRawFramesInserted,
+		  vidStatsGlobal.numFramesRenderedSuccessfully);
+    }
+    else {
+	// Allow some fudge because there seems to be some buffering.
+	// TODO(ekr@rtfm.com): Fix this.
+	ASSERT_GE(vidStatsGlobal.numRawFramesInserted,
+		  vidStatsGlobal.numFramesRenderedSuccessfully);
+	ASSERT_LE(vidStatsGlobal.numRawFramesInserted,
+		  vidStatsGlobal.numFramesRenderedSuccessfully + 2);
+    }
+  }
+
+ void TestVideoConduitCodecAPI()
+  {
+    int err = 0;
+    RefPtr<mozilla::VideoSessionConduit> videoSession;
+    //get pointer to VideoSessionConduit
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+                                            WrapRunnableNMRet(&videoSession,
+                                                &mozilla::VideoSessionConduit::Create));
+    if( !videoSession )
+      ASSERT_NE(videoSession, (void*)nullptr);
+
+    //Test Configure Recv Codec APIS
+    cerr << "   *************************************************" << endl;
+    cerr << "    Test Receive Codec Configuration API Now " << endl;
+    cerr << "   *************************************************" << endl;
+
+    std::vector<mozilla::VideoCodecConfig* > rcvCodecList;
+
+    //Same APIs
+    cerr << "   *************************************************" << endl;
+    cerr << "    1. Same Codec (VP8) Repeated Twice " << endl;
+    cerr << "   *************************************************" << endl;
+
+    mozilla::EncodingConstraints constraints;
+    mozilla::VideoCodecConfig cinst1(120, "VP8", constraints);
+    mozilla::VideoCodecConfig cinst2(120, "VP8", constraints);
+    rcvCodecList.push_back(&cinst1);
+    rcvCodecList.push_back(&cinst2);
+    err = videoSession->ConfigureRecvMediaCodecs(rcvCodecList);
+    EXPECT_NE(err,mozilla::kMediaConduitNoError);
+    rcvCodecList.pop_back();
+    rcvCodecList.pop_back();
+
+
+    PR_Sleep(PR_SecondsToInterval(2));
+    cerr << "   *************************************************" << endl;
+    cerr << "    2. Codec With Invalid Payload Names " << endl;
+    cerr << "   *************************************************" << endl;
+    cerr << "   Setting payload 1 with name: I4201234tttttthhhyyyy89087987y76t567r7756765rr6u6676" << endl;
+    cerr << "   Setting payload 2 with name of zero length" << endl;
+
+    mozilla::VideoCodecConfig cinst3(124, "I4201234tttttthhhyyyy89087987y76t567r7756765rr6u6676", constraints);
+    mozilla::VideoCodecConfig cinst4(124, "", constraints);
+
+    rcvCodecList.push_back(&cinst3);
+    rcvCodecList.push_back(&cinst4);
+
+    err = videoSession->ConfigureRecvMediaCodecs(rcvCodecList);
+    EXPECT_TRUE(err != mozilla::kMediaConduitNoError);
+    rcvCodecList.pop_back();
+    rcvCodecList.pop_back();
+
+
+    PR_Sleep(PR_SecondsToInterval(2));
+    cerr << "   *************************************************" << endl;
+    cerr << "    3. Null Codec Parameter  " << endl;
+    cerr << "   *************************************************" << endl;
+
+    rcvCodecList.push_back(0);
+
+    err = videoSession->ConfigureRecvMediaCodecs(rcvCodecList);
+    EXPECT_TRUE(err != mozilla::kMediaConduitNoError);
+    rcvCodecList.pop_back();
+
+    cerr << "   *************************************************" << endl;
+    cerr << "    Test Send Codec Configuration API Now " << endl;
+    cerr << "   *************************************************" << endl;
+
+    cerr << "   *************************************************" << endl;
+    cerr << "    1. Same Codec (VP8) Repeated Twice " << endl;
+    cerr << "   *************************************************" << endl;
+
+
+    err = videoSession->ConfigureSendMediaCodec(&cinst1);
+    EXPECT_EQ(mozilla::kMediaConduitNoError, err);
+    err = videoSession->StartTransmitting();
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = videoSession->ConfigureSendMediaCodec(&cinst1);
+    EXPECT_EQ(mozilla::kMediaConduitCodecInUse, err);
+    err = videoSession->StartTransmitting();
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+
+    cerr << "   *************************************************" << endl;
+    cerr << "    2. Codec With Invalid Payload Names " << endl;
+    cerr << "   *************************************************" << endl;
+    cerr << "   Setting payload with name: I4201234tttttthhhyyyy89087987y76t567r7756765rr6u6676" << endl;
+
+    err = videoSession->ConfigureSendMediaCodec(&cinst3);
+    EXPECT_TRUE(err != mozilla::kMediaConduitNoError);
+
+    cerr << "   *************************************************" << endl;
+    cerr << "    3. Null Codec Parameter  " << endl;
+    cerr << "   *************************************************" << endl;
+
+    err = videoSession->ConfigureSendMediaCodec(nullptr);
+    EXPECT_TRUE(err != mozilla::kMediaConduitNoError);
+
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+                                            WrapRunnable(
+                                                videoSession.forget().take(),
+                                                &mozilla::VideoSessionConduit::Release));
+  }
+
+  void DumpMaxFs(int orig_width, int orig_height, int max_fs,
+                 int new_width, int new_height)
+  {
+    cerr << "Applying max_fs=" << max_fs << " to input resolution " <<
+                 orig_width << "x" << orig_height << endl;
+    cerr << "New resolution: " << new_width << "x" << new_height << endl;
+    cerr << endl;
+  }
+
+  // Calculate new resolution for sending video by applying max-fs constraint.
+  void GetVideoResolutionWithMaxFs(int orig_width, int orig_height, int max_fs,
+                                   int *new_width, int *new_height)
+  {
+    int err = 0;
+
+    // Get pointer to VideoSessionConduit.
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+                                            WrapRunnableNMRet(&mVideoSession,
+                                                &mozilla::VideoSessionConduit::Create));
+    if( !mVideoSession )
+      ASSERT_NE(mVideoSession, (void*)nullptr);
+
+    mozilla::EncodingConstraints constraints;
+    constraints.maxFs = max_fs;
+    // Configure send codecs on the conduit.
+    mozilla::VideoCodecConfig cinst1(120, "VP8", constraints);
+
+    err = mVideoSession->ConfigureSendMediaCodec(&cinst1);
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+    err = mVideoSession->StartTransmitting();
+    ASSERT_EQ(mozilla::kMediaConduitNoError, err);
+
+    // Send one frame.
+    MOZ_ASSERT(!(orig_width & 1));
+    MOZ_ASSERT(!(orig_height & 1));
+    int len = ((orig_width * orig_height) * 3 / 2);
+    uint8_t* frame = (uint8_t*) PR_MALLOC(len);
+
+    memset(frame, COLOR, len);
+    mVideoSession->SendVideoFrame((unsigned char*)frame,
+                                  len,
+                                  orig_width,
+                                  orig_height,
+                                  mozilla::kVideoI420,
+                                  0);
+    PR_Free(frame);
+
+    // Get the new resolution as adjusted by the max-fs constraint.
+    *new_width = mVideoSession->SendingWidth();
+    *new_height = mVideoSession->SendingHeight();
+  }
+
+  void TestVideoConduitMaxFs()
+  {
+    int orig_width, orig_height, width, height, max_fs;
+
+    // No limitation.
+    cerr << "Test no max-fs limition" << endl;
+    orig_width = 640;
+    orig_height = 480;
+    max_fs = 0;
+    GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs, &width, &height);
+    DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+    ASSERT_EQ(width, 640);
+    ASSERT_EQ(height, 480);
+
+    // VGA to QVGA.
+    cerr << "Test resizing from VGA to QVGA" << endl;
+    orig_width = 640;
+    orig_height = 480;
+    max_fs = 300;
+    GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs, &width, &height);
+    DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+    ASSERT_EQ(width, 320);
+    ASSERT_EQ(height, 240);
+
+    // Extreme input resolution.
+    cerr << "Test extreme input resolution" << endl;
+    orig_width = 3072;
+    orig_height = 100;
+    max_fs = 300;
+    GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs, &width, &height);
+    DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+    ASSERT_EQ(width, 768);
+    ASSERT_EQ(height, 26);
+
+    // Small max-fs.
+    cerr << "Test small max-fs (case 1)" << endl;
+    orig_width = 8;
+    orig_height = 32;
+    max_fs = 1;
+    GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs, &width, &height);
+    DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+    ASSERT_EQ(width, 4);
+    ASSERT_EQ(height, 16);
+
+    // Small max-fs.
+    cerr << "Test small max-fs (case 2)" << endl;
+    orig_width = 4;
+    orig_height = 50;
+    max_fs = 1;
+    GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs, &width, &height);
+    DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+    ASSERT_EQ(width, 2);
+    ASSERT_EQ(height, 16);
+
+    // Small max-fs.
+    cerr << "Test small max-fs (case 3)" << endl;
+    orig_width = 872;
+    orig_height = 136;
+    max_fs = 3;
+    GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs, &width, &height);
+    DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+    ASSERT_EQ(width, 48);
+    ASSERT_EQ(height, 8);
+
+    // Small max-fs.
+    cerr << "Test small max-fs (case 4)" << endl;
+    orig_width = 160;
+    orig_height = 8;
+    max_fs = 5;
+    GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs, &width, &height);
+    DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+    ASSERT_EQ(width, 80);
+    ASSERT_EQ(height, 4);
+
+     // Extremely small width and height(see bug 919979).
+    cerr << "Test with extremely small width and height" << endl;
+    orig_width = 2;
+    orig_height = 2;
+    max_fs = 5;
+    GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs, &width, &height);
+    DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+    ASSERT_EQ(width, 2);
+    ASSERT_EQ(height, 2);
+
+    // Random values.
+    cerr << "Test with random values" << endl;
+    for (int i = 0; i < 30; i++) {
+      cerr << ".";
+      max_fs = rand() % 1000;
+      orig_width = ((rand() % 2000) & ~1) + 2;
+      orig_height = ((rand() % 2000) & ~1) + 2;
+
+      GetVideoResolutionWithMaxFs(orig_width, orig_height, max_fs,
+                                  &width, &height);
+      if (max_fs > 0 &&
+          ceil(width / 16.) * ceil(height / 16.) > max_fs) {
+        DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+        ADD_FAILURE();
+      }
+      if ((width & 1) || (height & 1)) {
+        DumpMaxFs(orig_width, orig_height, max_fs, width, height);
+        ADD_FAILURE();
+      }
+    }
+    cerr << endl;
+ }
+
+  void SetGmpCodecs() {
+    mExternalEncoder = mozilla::GmpVideoCodec::CreateEncoder();
+    mExternalDecoder = mozilla::GmpVideoCodec::CreateDecoder();
+    mozilla::EncodingConstraints constraints;
+    mozilla::VideoCodecConfig config(124, "H264", constraints);
+    mVideoSession->SetExternalSendCodec(&config, mExternalEncoder);
+    mVideoSession2->SetExternalRecvCodec(&config, mExternalDecoder);
+  }
+
+ private:
+  //Audio Conduit Test Objects
+  RefPtr<mozilla::AudioSessionConduit> mAudioSession;
+  RefPtr<mozilla::AudioSessionConduit> mAudioSession2;
+  RefPtr<mozilla::TransportInterface> mAudioTransport;
+  AudioSendAndReceive audioTester;
+
+  //Video Conduit Test Objects
+  RefPtr<mozilla::VideoSessionConduit> mVideoSession;
+  RefPtr<mozilla::VideoSessionConduit> mVideoSession2;
+  RefPtr<mozilla::VideoRenderer> mVideoRenderer;
+  RefPtr<mozilla::TransportInterface> mVideoTransport;
+  VideoSendAndReceive videoTester;
+
+  mozilla::VideoEncoder* mExternalEncoder;
+  mozilla::VideoDecoder* mExternalDecoder;
+
+  std::string fileToPlay;
+  std::string fileToRecord;
+  std::string iAudiofilename;
+  std::string oAudiofilename;
+};
+
+
+// Test 1: Test Dummy External Xport
+TEST_F(TransportConduitTest, TestDummyAudioWithTransport) {
+  TestDummyAudioAndTransport();
+}
+
+// Test 2: Test Dummy External Xport
+TEST_F(TransportConduitTest, TestDummyVideoWithTransport) {
+  TestDummyVideoAndTransport();
+ }
+
+TEST_F(TransportConduitTest, TestVideoConduitExternalCodec) {
+  TestDummyVideoAndTransport(false);
+}
+
+TEST_F(TransportConduitTest, TestVideoConduitCodecAPI) {
+  TestVideoConduitCodecAPI();
+ }
+
+TEST_F(TransportConduitTest, TestVideoConduitMaxFs) {
+  TestVideoConduitMaxFs();
+ }
+
+}  // end namespace
+
+static int test_result;
+bool test_finished = false;
+
+
+
+// This exists to send as an event to trigger shutdown.
+static void tests_complete() {
+  gTestsComplete = true;
+}
+
+// The GTest thread runs this instead of the main thread so it can
+// do things like ASSERT_TRUE_WAIT which you could not do on the main thread.
+static int gtest_main(int argc, char **argv) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  ::testing::InitGoogleTest(&argc, argv);
+
+  int result = RUN_ALL_TESTS();
+
+  // Set the global shutdown flag and tickle the main thread
+  // The main thread did not go through Init() so calling Shutdown()
+  // on it will not work.
+  gMainThread->Dispatch(mozilla::WrapRunnableNM(tests_complete), NS_DISPATCH_SYNC);
+
+  return result;
+}
+
+int main(int argc, char **argv)
+{
+  // This test can cause intermittent oranges on the builders
+  CHECK_ENVIRONMENT_FLAG("MOZ_WEBRTC_MEDIACONDUIT_TESTS")
+
+  test_utils = new MtransportTestUtils();
+
+  // Set the main thread global which is this thread.
+  nsIThread *thread;
+  NS_GetMainThread(&thread);
+  gMainThread = thread;
+
+  // Now create the GTest thread and run all of the tests on it
+  // When it is complete it will set gTestsComplete
+  NS_NewNamedThread("gtest_thread", &thread);
+  gGtestThread = thread;
+
+  int result;
+  gGtestThread->Dispatch(
+    mozilla::WrapRunnableNMRet(&result, gtest_main, argc, argv), NS_DISPATCH_NORMAL);
+
+  // Here we handle the event queue for dispatches to the main thread
+  // When the GTest thread is complete it will send one more dispatch
+  // with gTestsComplete == true.
+  while (!gTestsComplete && NS_ProcessNextEvent());
+
+  gGtestThread->Shutdown();
+
+  delete test_utils;
+  return test_result;
+}
+
+
+
diff --git a/media/webrtc/signaling/test/mediapipeline_unittest.cpp b/media/webrtc/signaling/test/mediapipeline_unittest.cpp
new file mode 100644
index 000000000..33518218b
--- /dev/null
+++ b/media/webrtc/signaling/test/mediapipeline_unittest.cpp
@@ -0,0 +1,720 @@
+/* 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/. */
+
+// Original author: ekr@rtfm.com
+
+#include <iostream>
+
+#include "sigslot.h"
+
+#include "logging.h"
+#include "nsThreadUtils.h"
+#include "nsXPCOM.h"
+#include "nss.h"
+#include "ssl.h"
+#include "sslproto.h"
+
+#include "dtlsidentity.h"
+#include "mozilla/RefPtr.h"
+#include "FakeMediaStreams.h"
+#include "FakeMediaStreamsImpl.h"
+#include "FakeLogging.h"
+#include "MediaConduitErrors.h"
+#include "MediaConduitInterface.h"
+#include "MediaPipeline.h"
+#include "MediaPipelineFilter.h"
+#include "runnable_utils.h"
+#include "transportflow.h"
+#include "transportlayerloopback.h"
+#include "transportlayerdtls.h"
+#include "mozilla/SyncRunnable.h"
+
+
+#include "mtransport_test_utils.h"
+#include "runnable_utils.h"
+
+#include "webrtc/modules/interface/module_common_types.h"
+
+#include "FakeIPC.h"
+#include "FakeIPC.cpp"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+#include "TestHarness.h"
+
+using namespace mozilla;
+MOZ_MTLOG_MODULE("mediapipeline")
+
+MtransportTestUtils *test_utils;
+
+namespace {
+
+class TransportInfo {
+ public:
+  TransportInfo() :
+    flow_(nullptr),
+    loopback_(nullptr),
+    dtls_(nullptr) {}
+
+  static void InitAndConnect(TransportInfo &client, TransportInfo &server) {
+    client.Init(true);
+    server.Init(false);
+    client.PushLayers();
+    server.PushLayers();
+    client.Connect(&server);
+    server.Connect(&client);
+  }
+
+  void Init(bool client) {
+    nsresult res;
+
+    flow_ = new TransportFlow();
+    loopback_ = new TransportLayerLoopback();
+    dtls_ = new TransportLayerDtls();
+
+    res = loopback_->Init();
+    if (res != NS_OK) {
+      FreeLayers();
+    }
+    ASSERT_EQ((nsresult)NS_OK, res);
+
+    std::vector<uint16_t> ciphers;
+    ciphers.push_back(SRTP_AES128_CM_HMAC_SHA1_80);
+    dtls_->SetSrtpCiphers(ciphers);
+    dtls_->SetIdentity(DtlsIdentity::Generate());
+    dtls_->SetRole(client ? TransportLayerDtls::CLIENT :
+      TransportLayerDtls::SERVER);
+    dtls_->SetVerificationAllowAll();
+  }
+
+  void PushLayers() {
+    nsresult res;
+
+    nsAutoPtr<std::queue<TransportLayer *> > layers(
+      new std::queue<TransportLayer *>);
+    layers->push(loopback_);
+    layers->push(dtls_);
+    res = flow_->PushLayers(layers);
+    if (res != NS_OK) {
+      FreeLayers();
+    }
+    ASSERT_EQ((nsresult)NS_OK, res);
+  }
+
+  void Connect(TransportInfo* peer) {
+    MOZ_ASSERT(loopback_);
+    MOZ_ASSERT(peer->loopback_);
+
+    loopback_->Connect(peer->loopback_);
+  }
+
+  // Free the memory allocated at the beginning of Init
+  // if failure occurs before layers setup.
+  void FreeLayers() {
+    delete loopback_;
+    loopback_ = nullptr;
+    delete dtls_;
+    dtls_ = nullptr;
+  }
+
+  void Shutdown() {
+    if (loopback_) {
+      loopback_->Disconnect();
+    }
+    loopback_ = nullptr;
+    dtls_ = nullptr;
+    flow_ = nullptr;
+  }
+
+  RefPtr<TransportFlow> flow_;
+  TransportLayerLoopback *loopback_;
+  TransportLayerDtls *dtls_;
+};
+
+class TestAgent {
+ public:
+  TestAgent() :
+      audio_config_(109, "opus", 48000, 960, 2, 64000, false),
+      audio_conduit_(mozilla::AudioSessionConduit::Create()),
+      audio_(),
+      audio_pipeline_() {
+  }
+
+  static void ConnectRtp(TestAgent *client, TestAgent *server) {
+    TransportInfo::InitAndConnect(client->audio_rtp_transport_,
+                                  server->audio_rtp_transport_);
+  }
+
+  static void ConnectRtcp(TestAgent *client, TestAgent *server) {
+    TransportInfo::InitAndConnect(client->audio_rtcp_transport_,
+                                  server->audio_rtcp_transport_);
+  }
+
+  static void ConnectBundle(TestAgent *client, TestAgent *server) {
+    TransportInfo::InitAndConnect(client->bundle_transport_,
+                                  server->bundle_transport_);
+  }
+
+  virtual void CreatePipelines_s(bool aIsRtcpMux) = 0;
+
+  void Start() {
+    nsresult ret;
+
+    MOZ_MTLOG(ML_DEBUG, "Starting");
+
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnableRet(&ret, audio_->GetStream(), &Fake_MediaStream::Start));
+
+    ASSERT_TRUE(NS_SUCCEEDED(ret));
+  }
+
+  void StopInt() {
+    audio_->GetStream()->Stop();
+  }
+
+  void Stop() {
+    MOZ_MTLOG(ML_DEBUG, "Stopping");
+
+    if (audio_pipeline_)
+      audio_pipeline_->ShutdownMedia_m();
+
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnable(this, &TestAgent::StopInt));
+  }
+
+  void Shutdown_s() {
+    audio_rtp_transport_.Shutdown();
+    audio_rtcp_transport_.Shutdown();
+    bundle_transport_.Shutdown();
+    if (audio_pipeline_)
+      audio_pipeline_->DetachTransport_s();
+  }
+
+  void Shutdown() {
+    if (audio_pipeline_)
+      audio_pipeline_->ShutdownMedia_m();
+
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnable(this, &TestAgent::Shutdown_s));
+  }
+
+  uint32_t GetRemoteSSRC() {
+    uint32_t res = 0;
+    audio_conduit_->GetRemoteSSRC(&res);
+    return res;
+  }
+
+  uint32_t GetLocalSSRC() {
+    uint32_t res = 0;
+    audio_conduit_->GetLocalSSRC(&res);
+    return res;
+  }
+
+  int GetAudioRtpCountSent() {
+    return audio_pipeline_->rtp_packets_sent();
+  }
+
+  int GetAudioRtpCountReceived() {
+    return audio_pipeline_->rtp_packets_received();
+  }
+
+  int GetAudioRtcpCountSent() {
+    return audio_pipeline_->rtcp_packets_sent();
+  }
+
+  int GetAudioRtcpCountReceived() {
+    return audio_pipeline_->rtcp_packets_received();
+  }
+
+ protected:
+  mozilla::AudioCodecConfig audio_config_;
+  RefPtr<mozilla::MediaSessionConduit> audio_conduit_;
+  RefPtr<DOMMediaStream> audio_;
+  // TODO(bcampen@mozilla.com): Right now this does not let us test RTCP in
+  // both directions; only the sender's RTCP is sent, but the receiver should
+  // be sending it too.
+  RefPtr<mozilla::MediaPipeline> audio_pipeline_;
+  TransportInfo audio_rtp_transport_;
+  TransportInfo audio_rtcp_transport_;
+  TransportInfo bundle_transport_;
+};
+
+class TestAgentSend : public TestAgent {
+ public:
+  TestAgentSend() : use_bundle_(false) {}
+
+  virtual void CreatePipelines_s(bool aIsRtcpMux) {
+    audio_ = new Fake_DOMMediaStream(new Fake_AudioStreamSource());
+    audio_->SetHintContents(Fake_DOMMediaStream::HINT_CONTENTS_AUDIO);
+
+    nsTArray<RefPtr<Fake_MediaStreamTrack>> tracks;
+    audio_->GetAudioTracks(tracks);
+    ASSERT_EQ(1U, tracks.Length());
+
+    mozilla::MediaConduitErrorCode err =
+        static_cast<mozilla::AudioSessionConduit *>(audio_conduit_.get())->
+        ConfigureSendMediaCodec(&audio_config_);
+    EXPECT_EQ(mozilla::kMediaConduitNoError, err);
+
+    std::string test_pc("PC");
+
+    if (aIsRtcpMux) {
+      ASSERT_FALSE(audio_rtcp_transport_.flow_);
+    }
+
+    RefPtr<TransportFlow> rtp(audio_rtp_transport_.flow_);
+    RefPtr<TransportFlow> rtcp(audio_rtcp_transport_.flow_);
+
+    if (use_bundle_) {
+      rtp = bundle_transport_.flow_;
+      rtcp = nullptr;
+    }
+
+    audio_pipeline_ = new mozilla::MediaPipelineTransmit(
+        test_pc,
+        nullptr,
+        test_utils->sts_target(),
+        tracks[0],
+        "audio_track_fake_uuid",
+        1,
+        audio_conduit_,
+        rtp,
+        rtcp,
+        nsAutoPtr<MediaPipelineFilter>());
+
+    audio_pipeline_->Init();
+  }
+
+  void SetUsingBundle(bool use_bundle) {
+    use_bundle_ = use_bundle;
+  }
+
+ private:
+  bool use_bundle_;
+};
+
+
+class TestAgentReceive : public TestAgent {
+ public:
+  virtual void CreatePipelines_s(bool aIsRtcpMux) {
+    mozilla::SourceMediaStream *audio = new Fake_SourceMediaStream();
+    audio->SetPullEnabled(true);
+
+    mozilla::AudioSegment* segment= new mozilla::AudioSegment();
+    audio->AddAudioTrack(0, 100, 0, segment);
+    audio->AdvanceKnownTracksTime(mozilla::STREAM_TIME_MAX);
+
+    audio_ = new Fake_DOMMediaStream(audio);
+
+    std::vector<mozilla::AudioCodecConfig *> codecs;
+    codecs.push_back(&audio_config_);
+
+    mozilla::MediaConduitErrorCode err =
+        static_cast<mozilla::AudioSessionConduit *>(audio_conduit_.get())->
+        ConfigureRecvMediaCodecs(codecs);
+    EXPECT_EQ(mozilla::kMediaConduitNoError, err);
+
+    std::string test_pc("PC");
+
+    if (aIsRtcpMux) {
+      ASSERT_FALSE(audio_rtcp_transport_.flow_);
+    }
+
+    audio_pipeline_ = new mozilla::MediaPipelineReceiveAudio(
+        test_pc,
+        nullptr,
+        test_utils->sts_target(),
+        audio_->GetStream()->AsSourceStream(), "audio_track_fake_uuid", 1, 1,
+        static_cast<mozilla::AudioSessionConduit *>(audio_conduit_.get()),
+        audio_rtp_transport_.flow_,
+        audio_rtcp_transport_.flow_,
+        bundle_filter_);
+
+    audio_pipeline_->Init();
+  }
+
+  void SetBundleFilter(nsAutoPtr<MediaPipelineFilter> filter) {
+    bundle_filter_ = filter;
+  }
+
+  void UpdateFilter_s(
+      nsAutoPtr<MediaPipelineFilter> filter) {
+    audio_pipeline_->UpdateTransport_s(1,
+                                       audio_rtp_transport_.flow_,
+                                       audio_rtcp_transport_.flow_,
+                                       filter);
+  }
+
+ private:
+  nsAutoPtr<MediaPipelineFilter> bundle_filter_;
+};
+
+
+class MediaPipelineTest : public ::testing::Test {
+ public:
+  ~MediaPipelineTest() {
+    p1_.Stop();
+    p2_.Stop();
+    p1_.Shutdown();
+    p2_.Shutdown();
+  }
+
+  // Setup transport.
+  void InitTransports(bool aIsRtcpMux) {
+    // RTP, p1_ is server, p2_ is client
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnableNM(&TestAgent::ConnectRtp, &p2_, &p1_));
+
+    // Create RTCP flows separately if we are not muxing them.
+    if(!aIsRtcpMux) {
+      // RTCP, p1_ is server, p2_ is client
+      mozilla::SyncRunnable::DispatchToThread(
+        test_utils->sts_target(),
+        WrapRunnableNM(&TestAgent::ConnectRtcp, &p2_, &p1_));
+    }
+
+    // BUNDLE, p1_ is server, p2_ is client
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnableNM(&TestAgent::ConnectBundle, &p2_, &p1_));
+  }
+
+  // Verify RTP and RTCP
+  void TestAudioSend(bool aIsRtcpMux,
+                     nsAutoPtr<MediaPipelineFilter> initialFilter =
+                        nsAutoPtr<MediaPipelineFilter>(nullptr),
+                     nsAutoPtr<MediaPipelineFilter> refinedFilter =
+                        nsAutoPtr<MediaPipelineFilter>(nullptr),
+                     unsigned int ms_until_filter_update = 500,
+                     unsigned int ms_of_traffic_after_answer = 10000) {
+
+    bool bundle = !!(initialFilter);
+    // We do not support testing bundle without rtcp mux, since that doesn't
+    // make any sense.
+    ASSERT_FALSE(!aIsRtcpMux && bundle);
+
+    p2_.SetBundleFilter(initialFilter);
+
+    // Setup transport flows
+    InitTransports(aIsRtcpMux);
+
+    NS_DispatchToMainThread(
+      WrapRunnable(&p1_, &TestAgent::CreatePipelines_s, aIsRtcpMux),
+      NS_DISPATCH_SYNC);
+
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnable(&p2_, &TestAgent::CreatePipelines_s, aIsRtcpMux));
+
+    p2_.Start();
+    p1_.Start();
+
+    if (bundle) {
+      PR_Sleep(ms_until_filter_update);
+
+      // Leaving refinedFilter not set implies we want to just update with
+      // the other side's SSRC
+      if (!refinedFilter) {
+        refinedFilter = new MediaPipelineFilter;
+        // Might not be safe, strictly speaking.
+        refinedFilter->AddRemoteSSRC(p1_.GetLocalSSRC());
+      }
+
+      mozilla::SyncRunnable::DispatchToThread(
+          test_utils->sts_target(),
+          WrapRunnable(&p2_,
+                       &TestAgentReceive::UpdateFilter_s,
+                       refinedFilter));
+    }
+
+    // wait for some RTP/RTCP tx and rx to happen
+    PR_Sleep(ms_of_traffic_after_answer);
+
+    p1_.Stop();
+    p2_.Stop();
+
+    // wait for any packets in flight to arrive
+    PR_Sleep(100);
+
+    p1_.Shutdown();
+    p2_.Shutdown();
+
+    if (!bundle) {
+      // If we are filtering, allow the test-case to do this checking.
+      ASSERT_GE(p1_.GetAudioRtpCountSent(), 40);
+      ASSERT_EQ(p1_.GetAudioRtpCountReceived(), p2_.GetAudioRtpCountSent());
+      ASSERT_EQ(p1_.GetAudioRtpCountSent(), p2_.GetAudioRtpCountReceived());
+
+      // Calling ShutdownMedia_m on both pipelines does not stop the flow of
+      // RTCP. So, we might be off by one here.
+      ASSERT_LE(p2_.GetAudioRtcpCountReceived(), p1_.GetAudioRtcpCountSent());
+      ASSERT_GE(p2_.GetAudioRtcpCountReceived() + 1, p1_.GetAudioRtcpCountSent());
+    }
+
+  }
+
+  void TestAudioReceiverBundle(bool bundle_accepted,
+      nsAutoPtr<MediaPipelineFilter> initialFilter,
+      nsAutoPtr<MediaPipelineFilter> refinedFilter =
+          nsAutoPtr<MediaPipelineFilter>(nullptr),
+      unsigned int ms_until_answer = 500,
+      unsigned int ms_of_traffic_after_answer = 10000) {
+    TestAudioSend(true,
+                  initialFilter,
+                  refinedFilter,
+                  ms_until_answer,
+                  ms_of_traffic_after_answer);
+  }
+protected:
+  TestAgentSend p1_;
+  TestAgentReceive p2_;
+};
+
+class MediaPipelineFilterTest : public ::testing::Test {
+  public:
+    bool Filter(MediaPipelineFilter& filter,
+                int32_t correlator,
+                uint32_t ssrc,
+                uint8_t payload_type) {
+
+      webrtc::RTPHeader header;
+      header.ssrc = ssrc;
+      header.payloadType = payload_type;
+      return filter.Filter(header, correlator);
+    }
+};
+
+TEST_F(MediaPipelineFilterTest, TestConstruct) {
+  MediaPipelineFilter filter;
+}
+
+TEST_F(MediaPipelineFilterTest, TestDefault) {
+  MediaPipelineFilter filter;
+  ASSERT_FALSE(Filter(filter, 0, 233, 110));
+}
+
+TEST_F(MediaPipelineFilterTest, TestSSRCFilter) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(555);
+  ASSERT_TRUE(Filter(filter, 0, 555, 110));
+  ASSERT_FALSE(Filter(filter, 0, 556, 110));
+}
+
+#define SSRC(ssrc) \
+  ((ssrc >> 24) & 0xFF), \
+  ((ssrc >> 16) & 0xFF), \
+  ((ssrc >> 8 ) & 0xFF), \
+  (ssrc         & 0xFF)
+
+#define REPORT_FRAGMENT(ssrc) \
+  SSRC(ssrc), \
+  0,0,0,0, \
+  0,0,0,0, \
+  0,0,0,0, \
+  0,0,0,0, \
+  0,0,0,0
+
+#define RTCP_TYPEINFO(num_rrs, type, size) \
+  0x80 + num_rrs, type, 0, size
+
+const unsigned char rtcp_sr_s16[] = {
+  // zero rrs, size 6 words
+  RTCP_TYPEINFO(0, MediaPipelineFilter::SENDER_REPORT_T, 6),
+  REPORT_FRAGMENT(16)
+};
+
+const unsigned char rtcp_sr_s16_r17[] = {
+  // one rr, size 12 words
+  RTCP_TYPEINFO(1, MediaPipelineFilter::SENDER_REPORT_T, 12),
+  REPORT_FRAGMENT(16),
+  REPORT_FRAGMENT(17)
+};
+
+const unsigned char unknown_type[] = {
+  RTCP_TYPEINFO(1, 222, 0)
+};
+
+TEST_F(MediaPipelineFilterTest, TestEmptyFilterReport0) {
+  MediaPipelineFilter filter;
+  ASSERT_FALSE(filter.FilterSenderReport(rtcp_sr_s16, sizeof(rtcp_sr_s16)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport0) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  ASSERT_TRUE(filter.FilterSenderReport(rtcp_sr_s16, sizeof(rtcp_sr_s16)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport0PTTruncated) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  const unsigned char data[] = {0x80};
+  ASSERT_FALSE(filter.FilterSenderReport(data, sizeof(data)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport0CountTruncated) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  const unsigned char data[] = {};
+  ASSERT_FALSE(filter.FilterSenderReport(data, sizeof(data)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport1SSRCTruncated) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  const unsigned char sr[] = {
+    RTCP_TYPEINFO(1, MediaPipelineFilter::SENDER_REPORT_T, 12),
+    REPORT_FRAGMENT(16),
+    0,0,0
+  };
+  ASSERT_TRUE(filter.FilterSenderReport(sr, sizeof(sr)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReport1BigSSRC) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(0x01020304);
+  const unsigned char sr[] = {
+    RTCP_TYPEINFO(1, MediaPipelineFilter::SENDER_REPORT_T, 12),
+    SSRC(0x01020304),
+    REPORT_FRAGMENT(0x11121314)
+  };
+  ASSERT_TRUE(filter.FilterSenderReport(sr, sizeof(sr)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReportMatch) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(16);
+  ASSERT_TRUE(filter.FilterSenderReport(rtcp_sr_s16_r17,
+                                        sizeof(rtcp_sr_s16_r17)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterReportNoMatch) {
+  MediaPipelineFilter filter;
+  filter.AddRemoteSSRC(17);
+  ASSERT_FALSE(filter.FilterSenderReport(rtcp_sr_s16_r17,
+                                         sizeof(rtcp_sr_s16_r17)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestFilterUnknownRTCPType) {
+  MediaPipelineFilter filter;
+  ASSERT_FALSE(filter.FilterSenderReport(unknown_type, sizeof(unknown_type)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestCorrelatorFilter) {
+  MediaPipelineFilter filter;
+  filter.SetCorrelator(7777);
+  ASSERT_TRUE(Filter(filter, 7777, 16, 110));
+  ASSERT_FALSE(Filter(filter, 7778, 17, 110));
+  // This should also have resulted in the SSRC 16 being added to the filter
+  ASSERT_TRUE(Filter(filter, 0, 16, 110));
+  ASSERT_FALSE(Filter(filter, 0, 17, 110));
+
+  // rtcp_sr_s16 has 16 as an SSRC
+  ASSERT_TRUE(filter.FilterSenderReport(rtcp_sr_s16, sizeof(rtcp_sr_s16)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestPayloadTypeFilter) {
+  MediaPipelineFilter filter;
+  filter.AddUniquePT(110);
+  ASSERT_TRUE(Filter(filter, 0, 555, 110));
+  ASSERT_FALSE(Filter(filter, 0, 556, 111));
+}
+
+TEST_F(MediaPipelineFilterTest, TestPayloadTypeFilterSSRCUpdate) {
+  MediaPipelineFilter filter;
+  filter.AddUniquePT(110);
+  ASSERT_TRUE(Filter(filter, 0, 16, 110));
+
+  // rtcp_sr_s16 has 16 as an SSRC
+  ASSERT_TRUE(filter.FilterSenderReport(rtcp_sr_s16, sizeof(rtcp_sr_s16)));
+}
+
+TEST_F(MediaPipelineFilterTest, TestSSRCMovedWithCorrelator) {
+  MediaPipelineFilter filter;
+  filter.SetCorrelator(7777);
+  ASSERT_TRUE(Filter(filter, 7777, 555, 110));
+  ASSERT_TRUE(Filter(filter, 0, 555, 110));
+  ASSERT_FALSE(Filter(filter, 7778, 555, 110));
+  ASSERT_FALSE(Filter(filter, 0, 555, 110));
+}
+
+TEST_F(MediaPipelineFilterTest, TestRemoteSDPNoSSRCs) {
+  // If the remote SDP doesn't have SSRCs, right now this is a no-op and
+  // there is no point of even incorporating a filter, but we make the
+  // behavior consistent to avoid confusion.
+  MediaPipelineFilter filter;
+  filter.SetCorrelator(7777);
+  filter.AddUniquePT(111);
+  ASSERT_TRUE(Filter(filter, 7777, 555, 110));
+
+  MediaPipelineFilter filter2;
+
+  filter.Update(filter2);
+
+  // Ensure that the old SSRC still works.
+  ASSERT_TRUE(Filter(filter, 0, 555, 110));
+}
+
+TEST_F(MediaPipelineTest, DISABLED_TestAudioSendNoMux) {
+  TestAudioSend(false);
+}
+
+TEST_F(MediaPipelineTest, DISABLED_TestAudioSendMux) {
+  TestAudioSend(true);
+}
+
+TEST_F(MediaPipelineTest, TestAudioSendBundle) {
+  nsAutoPtr<MediaPipelineFilter> filter(new MediaPipelineFilter);
+  // These durations have to be _extremely_ long to have any assurance that
+  // some RTCP will be sent at all. This is because the first RTCP packet
+  // is sometimes sent before the transports are ready, which causes it to
+  // be dropped.
+  TestAudioReceiverBundle(true,
+                          filter,
+  // We do not specify the filter for the remote description, so it will be
+  // set to something sane after a short time.
+                          nsAutoPtr<MediaPipelineFilter>(),
+                          10000,
+                          10000);
+
+  // Some packets should have been dropped, but not all
+  ASSERT_GT(p1_.GetAudioRtpCountSent(), p2_.GetAudioRtpCountReceived());
+  ASSERT_GT(p2_.GetAudioRtpCountReceived(), 40);
+  ASSERT_GT(p1_.GetAudioRtcpCountSent(), 1);
+  ASSERT_GT(p1_.GetAudioRtcpCountSent(), p2_.GetAudioRtcpCountReceived());
+  ASSERT_GT(p2_.GetAudioRtcpCountReceived(), 0);
+}
+
+TEST_F(MediaPipelineTest, TestAudioSendEmptyBundleFilter) {
+  nsAutoPtr<MediaPipelineFilter> filter(new MediaPipelineFilter);
+  nsAutoPtr<MediaPipelineFilter> bad_answer_filter(new MediaPipelineFilter);
+  TestAudioReceiverBundle(true, filter, bad_answer_filter);
+  // Filter is empty, so should drop everything.
+  ASSERT_EQ(0, p2_.GetAudioRtpCountReceived());
+}
+
+}  // end namespace
+
+
+int main(int argc, char **argv) {
+  ScopedXPCOM xpcom("mediapipeline_unittest");
+  test_utils = new MtransportTestUtils();
+  // Start the tests
+  NSS_NoDB_Init(nullptr);
+  NSS_SetDomesticPolicy();
+  ::testing::InitGoogleTest(&argc, argv);
+
+  int rv = RUN_ALL_TESTS();
+  delete test_utils;
+  return rv;
+}
+
+
+
diff --git a/media/webrtc/signaling/test/moz.build b/media/webrtc/signaling/test/moz.build
new file mode 100644
index 000000000..4d8704de4
--- /dev/null
+++ b/media/webrtc/signaling/test/moz.build
@@ -0,0 +1,33 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+# TODO: bug 1172551 - get these tests working on iOS
+if CONFIG['OS_TARGET'] != 'WINNT' and CONFIG['MOZ_WIDGET_TOOLKIT'] != 'gonk' and CONFIG['MOZ_WIDGET_TOOLKIT'] != 'uikit':
+    GeckoCppUnitTests([
+        'jsep_session_unittest',
+        'jsep_track_unittest',
+        'mediaconduit_unittests',
+        'sdp_file_parser',
+        'sdp_unittests',
+        'signaling_unittests',
+    ])
+
+include('/ipc/chromium/chromium-config.mozbuild')
+include('common.build')
+
+USE_LIBS += [
+    '/media/webrtc/signalingtest/signaling_ecc/ecc',
+    'mtransport_s',
+]
+
+if CONFIG['GNU_CXX']:
+    CXXFLAGS += ['-Wno-error=shadow']
+
+if CONFIG['_MSC_VER']:
+    # This is intended as a temporary workaround to enable warning free building
+    # with VS2015.
+    # reinterpret_cast': conversion from 'DWORD' to 'HANDLE' of greater size
+    CXXFLAGS += ['-wd4312']
diff --git a/media/webrtc/signaling/test/sdp_file_parser.cpp b/media/webrtc/signaling/test/sdp_file_parser.cpp
new file mode 100644
index 000000000..3fb0c2f1c
--- /dev/null
+++ b/media/webrtc/signaling/test/sdp_file_parser.cpp
@@ -0,0 +1,85 @@
+/* -*- 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/. */
+
+#include <string>
+#include <iostream>
+#include <fstream>
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+// without this include linking fails
+#include "FakeMediaStreamsImpl.h"
+#include "FakeLogging.h"
+
+#include "signaling/src/sdp/SipccSdpParser.h"
+
+#include "FakeIPC.h"
+#include "FakeIPC.cpp"
+
+namespace mozilla {
+
+const std::string kDefaultFilename((char *)"/tmp/sdp.bin");
+std::string filename(kDefaultFilename);
+
+class SdpParseTest : public ::testing::Test
+{
+  public:
+    SdpParseTest() {}
+
+    void ParseSdp(const std::string &sdp) {
+      mSdp = mParser.Parse(sdp);
+    }
+
+    void SerializeSdp() {
+      if (mSdp) {
+          mSdp->Serialize(os);
+          std::cout << "Serialized SDP:" << std::endl <<
+            os.str() << std::endl;;
+      }
+    }
+
+    SipccSdpParser mParser;
+    mozilla::UniquePtr<Sdp> mSdp;
+    std::stringstream os;
+}; // class SdpParseTest
+
+TEST_F(SdpParseTest, parseSdpFromFile)
+{
+  std::ifstream file(filename.c_str(),
+                     std::ios::in|std::ios::binary|std::ios::ate);
+  ASSERT_TRUE(file.is_open());
+  std::streampos size = file.tellg();
+  size_t nsize = size;
+  nsize+=1;
+  char *memblock = new char [nsize];
+  memset(memblock, '\0', nsize);
+  file.seekg(0, std::ios::beg);
+  file.read(memblock, size);
+  file.close();
+  std::cout << "Read file " << filename << std::endl;
+  ParseSdp(memblock);
+  std::cout << "Parsed SDP" << std::endl;
+  SerializeSdp();
+  delete[] memblock;
+}
+
+} // End namespace mozilla.
+
+int main(int argc, char **argv)
+{
+  ::testing::InitGoogleTest(&argc, argv);
+
+  if (argc == 2) {
+    mozilla::filename = argv[1];
+  } else if (argc > 2) {
+    std::cerr << "Usage: ./sdp_file_parser [filename]" << std::endl;
+    return(1);
+  }
+
+  return RUN_ALL_TESTS();
+}
diff --git a/media/webrtc/signaling/test/sdp_unittests.cpp b/media/webrtc/signaling/test/sdp_unittests.cpp
new file mode 100644
index 000000000..6d00764ae
--- /dev/null
+++ b/media/webrtc/signaling/test/sdp_unittests.cpp
@@ -0,0 +1,5377 @@
+/* -*- 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/. */
+
+#include "timecard.h"
+
+#include "CSFLog.h"
+
+#include <string>
+#include <sstream>
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+#include "nspr.h"
+#include "nss.h"
+#include "ssl.h"
+
+#include "nsThreadUtils.h"
+#include "FakeMediaStreams.h"
+#include "FakeMediaStreamsImpl.h"
+#include "FakeLogging.h"
+#include "PeerConnectionImpl.h"
+#include "PeerConnectionCtx.h"
+
+#include "mtransport_test_utils.h"
+MtransportTestUtils *test_utils;
+nsCOMPtr<nsIThread> gThread;
+
+#include "signaling/src/sdp/SipccSdpParser.h"
+#include "signaling/src/sdp/SdpMediaSection.h"
+#include "signaling/src/sdp/SdpAttribute.h"
+
+extern "C" {
+#include "signaling/src/sdp/sipcc/sdp.h"
+#include "signaling/src/sdp/sipcc/sdp_private.h"
+}
+
+#ifdef CRLF
+#undef CRLF
+#endif
+#define CRLF "\r\n"
+
+#include "FakeIPC.h"
+#include "FakeIPC.cpp"
+
+#include "TestHarness.h"
+
+using namespace mozilla;
+
+namespace test {
+
+static bool SetupGlobalThread() {
+  if (!gThread) {
+    nsIThread *thread;
+
+    nsresult rv = NS_NewNamedThread("pseudo-main",&thread);
+    if (NS_FAILED(rv))
+      return false;
+
+    gThread = thread;
+    PeerConnectionCtx::InitializeGlobal(gThread,
+                                               test_utils->sts_target());
+  }
+  return true;
+}
+
+class SdpTest : public ::testing::Test {
+  public:
+    SdpTest() : sdp_ptr_(nullptr) {
+    }
+
+    ~SdpTest() {
+      sdp_free_description(sdp_ptr_);
+    }
+
+    static void SetUpTestCase() {
+      ASSERT_TRUE(SetupGlobalThread());
+    }
+
+    void SetUp() {
+      final_level_ = 0;
+      sdp_ptr_ = nullptr;
+    }
+
+    static void TearDownTestCase() {
+      if (gThread) {
+        gThread->Shutdown();
+      }
+      gThread = nullptr;
+    }
+
+    void ResetSdp() {
+      if (!sdp_ptr_) {
+        sdp_free_description(sdp_ptr_);
+      }
+
+      sdp_media_e supported_media[] = {
+        SDP_MEDIA_AUDIO,
+        SDP_MEDIA_VIDEO,
+        SDP_MEDIA_APPLICATION,
+        SDP_MEDIA_DATA,
+        SDP_MEDIA_CONTROL,
+        SDP_MEDIA_NAS_RADIUS,
+        SDP_MEDIA_NAS_TACACS,
+        SDP_MEDIA_NAS_DIAMETER,
+        SDP_MEDIA_NAS_L2TP,
+        SDP_MEDIA_NAS_LOGIN,
+        SDP_MEDIA_NAS_NONE,
+        SDP_MEDIA_IMAGE,
+      };
+
+      sdp_conf_options_t *config_p = sdp_init_config();
+      unsigned int i;
+      for (i = 0; i < sizeof(supported_media) / sizeof(sdp_media_e); i++) {
+        sdp_media_supported(config_p, supported_media[i], true);
+      }
+      sdp_nettype_supported(config_p, SDP_NT_INTERNET, true);
+      sdp_addrtype_supported(config_p, SDP_AT_IP4, true);
+      sdp_addrtype_supported(config_p, SDP_AT_IP6, true);
+      sdp_transport_supported(config_p, SDP_TRANSPORT_RTPSAVPF, true);
+      sdp_transport_supported(config_p, SDP_TRANSPORT_UDPTL, true);
+      sdp_require_session_name(config_p, false);
+
+      sdp_ptr_ = sdp_init_description(config_p);
+      if (!sdp_ptr_) {
+        sdp_free_config(config_p);
+      }
+    }
+
+    void ParseSdp(const std::string &sdp_str) {
+      const char *buf = sdp_str.data();
+      ResetSdp();
+      ASSERT_EQ(sdp_parse(sdp_ptr_, buf, sdp_str.size()), SDP_SUCCESS);
+    }
+
+    void InitLocalSdp() {
+      ResetSdp();
+      ASSERT_EQ(sdp_set_version(sdp_ptr_, 0), SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_owner_username(sdp_ptr_, "-"), SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_owner_sessionid(sdp_ptr_, "132954853"), SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_owner_version(sdp_ptr_, "0"), SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_owner_network_type(sdp_ptr_, SDP_NT_INTERNET),
+                SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_owner_address_type(sdp_ptr_, SDP_AT_IP4), SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_owner_address(sdp_ptr_, "198.51.100.7"), SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_session_name(sdp_ptr_, "SDP Unit Test"), SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_time_start(sdp_ptr_, "0"), SDP_SUCCESS);
+      ASSERT_EQ(sdp_set_time_stop(sdp_ptr_, "0"), SDP_SUCCESS);
+    }
+
+    std::string SerializeSdp() {
+      flex_string fs;
+      flex_string_init(&fs);
+      EXPECT_EQ(sdp_build(sdp_ptr_, &fs), SDP_SUCCESS);
+      std::string body(fs.buffer);
+      flex_string_free(&fs);
+      return body;
+    }
+
+    // Returns "level" for new media section
+    int AddNewMedia(sdp_media_e type) {
+      final_level_++;
+      EXPECT_EQ(sdp_insert_media_line(sdp_ptr_, final_level_), SDP_SUCCESS);
+      EXPECT_EQ(sdp_set_conn_nettype(sdp_ptr_, final_level_, SDP_NT_INTERNET),
+                SDP_SUCCESS);
+      EXPECT_EQ(sdp_set_conn_addrtype(sdp_ptr_, final_level_, SDP_AT_IP4),
+                SDP_SUCCESS);
+      EXPECT_EQ(sdp_set_conn_address(sdp_ptr_, final_level_, "198.51.100.7"),
+                SDP_SUCCESS);
+      EXPECT_EQ(sdp_set_media_type(sdp_ptr_, final_level_, SDP_MEDIA_VIDEO),
+                SDP_SUCCESS);
+      EXPECT_EQ(sdp_set_media_transport(sdp_ptr_, final_level_,
+                                        SDP_TRANSPORT_RTPAVP),
+                SDP_SUCCESS);
+      EXPECT_EQ(sdp_set_media_portnum(sdp_ptr_, final_level_, 12345, 0),
+                SDP_SUCCESS);
+      EXPECT_EQ(sdp_add_media_payload_type(sdp_ptr_, final_level_, 120,
+                                           SDP_PAYLOAD_NUMERIC),
+                SDP_SUCCESS);
+      return final_level_;
+    }
+
+    uint16_t AddNewRtcpFbAck(int level, sdp_rtcp_fb_ack_type_e type,
+                         uint16_t payload = SDP_ALL_PAYLOADS) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_RTCP_FB,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_rtcp_fb_ack(sdp_ptr_, level, payload, inst_num,
+                                         type), SDP_SUCCESS);
+      return inst_num;
+    }
+
+    uint16_t AddNewRtcpFbNack(int level, sdp_rtcp_fb_nack_type_e type,
+                         uint16_t payload = SDP_ALL_PAYLOADS) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_RTCP_FB,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_rtcp_fb_nack(sdp_ptr_, level, payload, inst_num,
+                                          type), SDP_SUCCESS);
+      return inst_num;
+    }
+
+    uint16_t AddNewRtcpFbTrrInt(int level, uint32_t interval,
+                         uint16_t payload = SDP_ALL_PAYLOADS) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_RTCP_FB,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_rtcp_fb_trr_int(sdp_ptr_, level, payload, inst_num,
+                                             interval), SDP_SUCCESS);
+      return inst_num;
+    }
+
+    uint16_t AddNewRtcpFbRemb(int level,
+                              uint16_t payload = SDP_ALL_PAYLOADS) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_RTCP_FB,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_rtcp_fb_remb(sdp_ptr_, level, payload, inst_num
+                                          ), SDP_SUCCESS);
+      return inst_num;
+    }
+
+    uint16_t AddNewRtcpFbCcm(int level, sdp_rtcp_fb_ccm_type_e type,
+                         uint16_t payload = SDP_ALL_PAYLOADS) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_RTCP_FB,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_rtcp_fb_ccm(sdp_ptr_, level, payload, inst_num,
+                                         type), SDP_SUCCESS);
+      return inst_num;
+    }
+    uint16_t AddNewExtMap(int level, const char* uri) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_EXTMAP,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_extmap(sdp_ptr_, level, inst_num,
+                                    uri, inst_num), SDP_SUCCESS);
+      return inst_num;
+    }
+
+    uint16_t AddNewFmtpMaxFs(int level, uint32_t max_fs) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_FMTP,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_fmtp_payload_type(sdp_ptr_, level, 0, inst_num,
+                                               120), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_fmtp_max_fs(sdp_ptr_, level, 0, inst_num, max_fs),
+                                         SDP_SUCCESS);
+      return inst_num;
+    }
+
+    uint16_t AddNewFmtpMaxFr(int level, uint32_t max_fr) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_FMTP,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_fmtp_payload_type(sdp_ptr_, level, 0, inst_num,
+                                               120), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_fmtp_max_fr(sdp_ptr_, level, 0, inst_num, max_fr),
+                                         SDP_SUCCESS);
+      return inst_num;
+    }
+
+     uint16_t AddNewFmtpMaxFsFr(int level, uint32_t max_fs, uint32_t max_fr) {
+      uint16_t inst_num = 0;
+      EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level, 0, SDP_ATTR_FMTP,
+                                 &inst_num), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_fmtp_payload_type(sdp_ptr_, level, 0, inst_num,
+                                               120), SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_fmtp_max_fs(sdp_ptr_, level, 0, inst_num, max_fs),
+                                         SDP_SUCCESS);
+      EXPECT_EQ(sdp_attr_set_fmtp_max_fr(sdp_ptr_, level, 0, inst_num, max_fr),
+                                         SDP_SUCCESS);
+      return inst_num;
+    }
+
+  protected:
+    int final_level_;
+    sdp_t *sdp_ptr_;
+};
+
+static const std::string kVideoSdp =
+  "v=0\r\n"
+  "o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
+  "s=SIP Call\r\n"
+  "c=IN IP4 198.51.100.7\r\n"
+  "t=0 0\r\n"
+  "m=video 56436 RTP/SAVPF 120\r\n"
+  "a=rtpmap:120 VP8/90000\r\n";
+
+TEST_F(SdpTest, parseRtcpFbAckRpsi) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ack rpsi\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_ACK_RPSI);
+}
+
+TEST_F(SdpTest, parseRtcpFbAckApp) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ack app\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 1), SDP_RTCP_FB_ACK_APP);
+}
+
+TEST_F(SdpTest, parseRtcpFbAckAppFoo) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ack app foo\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 1), SDP_RTCP_FB_ACK_APP);
+}
+
+TEST_F(SdpTest, parseRtcpFbAckFooBar) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ack foo bar\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_ACK_UNKNOWN);
+}
+
+TEST_F(SdpTest, parseRtcpFbAckFooBarBaz) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ack foo bar baz\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_ACK_UNKNOWN);
+}
+
+TEST_F(SdpTest, parseRtcpFbNack) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 nack\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_NACK_BASIC);
+}
+
+TEST_F(SdpTest, parseRtcpFbNackPli) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 nack pli\r\n");
+}
+
+TEST_F(SdpTest, parseRtcpFbNackSli) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 nack sli\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_NACK_SLI);
+}
+
+TEST_F(SdpTest, parseRtcpFbNackRpsi) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 nack rpsi\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_NACK_RPSI);
+}
+
+TEST_F(SdpTest, parseRtcpFbNackApp) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 nack app\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_NACK_APP);
+}
+
+TEST_F(SdpTest, parseRtcpFbNackAppFoo) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 nack app foo\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_NACK_APP);
+}
+
+TEST_F(SdpTest, parseRtcpFbNackAppFooBar) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 nack app foo bar\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_NACK_APP);
+}
+
+TEST_F(SdpTest, parseRtcpFbNackFooBarBaz) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 nack foo bar baz\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_NACK_UNKNOWN);
+}
+
+TEST_F(SdpTest, parseRtcpFbRemb) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 goog-remb\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_remb_enabled(sdp_ptr_, 1, 120), true);
+}
+
+TEST_F(SdpTest, parseRtcpRbRembAllPt) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:* goog-remb\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_remb_enabled(sdp_ptr_, 1, SDP_ALL_PAYLOADS),
+                                              true);
+}
+
+TEST_F(SdpTest, parseRtcpFbTrrInt0) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 trr-int 0\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_, 1, 120, 1), 0U);
+}
+
+TEST_F(SdpTest, parseRtcpFbTrrInt123) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 trr-int 123\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_, 1, 120, 1), 123U);
+}
+
+TEST_F(SdpTest, parseRtcpFbCcmFir) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ccm fir\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 1), SDP_RTCP_FB_CCM_FIR);
+}
+
+TEST_F(SdpTest, parseRtcpFbCcmTmmbr) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ccm tmmbr\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_CCM_TMMBR);
+}
+
+TEST_F(SdpTest, parseRtcpFbCcmTmmbrSmaxpr) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ccm tmmbr smaxpr=456\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_CCM_TMMBR);
+}
+
+TEST_F(SdpTest, parseRtcpFbCcmTstr) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ccm tstr\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_CCM_TSTR);
+}
+
+TEST_F(SdpTest, parseRtcpFbCcmVbcm) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ccm vbcm 123 456 789\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 1),
+                                     SDP_RTCP_FB_CCM_VBCM);
+  // We don't currently parse out VBCM submessage types, since we don't have
+  // any use for them.
+}
+
+TEST_F(SdpTest, parseRtcpFbCcmFoo) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ccm foo\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_CCM_UNKNOWN);
+}
+
+TEST_F(SdpTest, parseRtcpFbCcmFooBarBaz) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 ccm foo bar baz\r\n");
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_CCM_UNKNOWN);
+}
+
+TEST_F(SdpTest, parseRtcpFbFoo) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 foo\r\n");
+}
+
+TEST_F(SdpTest, parseRtcpFbFooBar) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 foo bar\r\n");
+}
+
+TEST_F(SdpTest, parseRtcpFbFooBarBaz) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:120 foo bar baz\r\n");
+}
+
+static const std::string kVideoSdpWithUnknonwBrokenFtmp =
+  "v=0\r\n"
+  "o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
+  "s=SIP Call\r\n"
+  "c=IN IP4 198.51.100.7\r\n"
+  "t=0 0\r\n"
+  "m=video 56436 RTP/SAVPF 120\r\n"
+  "a=rtpmap:120 VP8/90000\r\n"
+  "a=fmtp:122 unknown=10\n"
+  "a=rtpmap:122 red/90000\r\n";
+
+TEST_F(SdpTest, parseUnknownBrokenFtmp) {
+  ParseSdp(kVideoSdpWithUnknonwBrokenFtmp);
+}
+
+TEST_F(SdpTest, parseRtcpFbKitchenSink) {
+  ParseSdp(kVideoSdp +
+    "a=rtcp-fb:120 ack rpsi\r\n"
+    "a=rtcp-fb:120 ack app\r\n"
+    "a=rtcp-fb:120 ack app foo\r\n"
+    "a=rtcp-fb:120 ack foo bar\r\n"
+    "a=rtcp-fb:120 ack foo bar baz\r\n"
+    "a=rtcp-fb:120 nack\r\n"
+    "a=rtcp-fb:120 nack pli\r\n"
+    "a=rtcp-fb:120 nack sli\r\n"
+    "a=rtcp-fb:120 nack rpsi\r\n"
+    "a=rtcp-fb:120 nack app\r\n"
+    "a=rtcp-fb:120 nack app foo\r\n"
+    "a=rtcp-fb:120 nack app foo bar\r\n"
+    "a=rtcp-fb:120 nack foo bar baz\r\n"
+    "a=rtcp-fb:120 trr-int 0\r\n"
+    "a=rtcp-fb:120 trr-int 123\r\n"
+    "a=rtcp-fb:120 goog-remb\r\n"
+    "a=rtcp-fb:120 ccm fir\r\n"
+    "a=rtcp-fb:120 ccm tmmbr\r\n"
+    "a=rtcp-fb:120 ccm tmmbr smaxpr=456\r\n"
+    "a=rtcp-fb:120 ccm tstr\r\n"
+    "a=rtcp-fb:120 ccm vbcm 123 456 789\r\n"
+    "a=rtcp-fb:120 ccm foo\r\n"
+    "a=rtcp-fb:120 ccm foo bar baz\r\n"
+    "a=rtcp-fb:120 foo\r\n"
+    "a=rtcp-fb:120 foo bar\r\n"
+    "a=rtcp-fb:120 foo bar baz\r\n");
+
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 1), SDP_RTCP_FB_ACK_RPSI);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 2), SDP_RTCP_FB_ACK_APP);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 3), SDP_RTCP_FB_ACK_APP);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 4),
+            SDP_RTCP_FB_ACK_UNKNOWN);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 5),
+            SDP_RTCP_FB_ACK_UNKNOWN);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, 120, 6),
+            SDP_RTCP_FB_ACK_NOT_FOUND);
+
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 1),
+            SDP_RTCP_FB_NACK_BASIC);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 2),
+            SDP_RTCP_FB_NACK_PLI);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 3),
+            SDP_RTCP_FB_NACK_SLI);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 4),
+            SDP_RTCP_FB_NACK_RPSI);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 5),
+            SDP_RTCP_FB_NACK_APP);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 6),
+            SDP_RTCP_FB_NACK_APP);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 7),
+            SDP_RTCP_FB_NACK_APP);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 8),
+            SDP_RTCP_FB_NACK_UNKNOWN);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_, 1, 120, 9),
+            SDP_RTCP_FB_NACK_NOT_FOUND);
+
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_, 1, 120, 1), 0U);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_, 1, 120, 2), 123U);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_, 1, 120, 3), 0xFFFFFFFF);
+
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_remb_enabled(sdp_ptr_, 1, 120), true);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_remb_enabled(sdp_ptr_, 2, 120), false);
+
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 1), SDP_RTCP_FB_CCM_FIR);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 2),
+            SDP_RTCP_FB_CCM_TMMBR);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 3),
+            SDP_RTCP_FB_CCM_TMMBR);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 4),
+            SDP_RTCP_FB_CCM_TSTR);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 5),
+            SDP_RTCP_FB_CCM_VBCM);
+  // We don't currently parse out VBCM submessage types, since we don't have
+  // any use for them.
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 6),
+            SDP_RTCP_FB_CCM_UNKNOWN);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 7),
+            SDP_RTCP_FB_CCM_UNKNOWN);
+  ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_, 1, 120, 8),
+            SDP_RTCP_FB_CCM_NOT_FOUND);
+}
+
+TEST_F(SdpTest, addRtcpFbAckRpsi) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbAck(level, SDP_RTCP_FB_ACK_RPSI, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 ack rpsi\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbAckRpsiAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbAck(level, SDP_RTCP_FB_ACK_RPSI);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* ack rpsi\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbAckApp) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbAck(level, SDP_RTCP_FB_ACK_APP, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 ack app\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbAckAppAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbAck(level, SDP_RTCP_FB_ACK_APP);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* ack app\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNack) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_BASIC, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_BASIC);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackSli) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_SLI, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack sli\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackSliAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_SLI);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack sli\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackPli) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_PLI, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack pli\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackPliAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_PLI);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack pli\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackRpsi) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_RPSI, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack rpsi\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackRpsiAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_RPSI);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack rpsi\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackApp) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_APP, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack app\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackAppAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_APP);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack app\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackRai) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_RAI, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack rai\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackRaiAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_RAI);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack rai\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackTllei) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_TLLEI, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack tllei\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackTlleiAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_TLLEI);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack tllei\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackPslei) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_PSLEI, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack pslei\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackPsleiAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_PSLEI);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack pslei\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackEcn) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_ECN, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 nack ecn\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackEcnAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_ECN);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* nack ecn\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbRemb) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbRemb(level, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 goog-remb\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbRembAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbRemb(level);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* goog-remb\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbTrrInt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbTrrInt(level, 12345, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 trr-int 12345\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbNackTrrIntAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbTrrInt(level, 0);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* trr-int 0\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbCcmFir) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_FIR, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 ccm fir\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbCcmFirAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_FIR);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* ccm fir\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbCcmTmmbr) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_TMMBR, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 ccm tmmbr\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbCcmTmmbrAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_TMMBR);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* ccm tmmbr\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbCcmTstr) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_TSTR, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 ccm tstr\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbCcmTstrAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_TSTR);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* ccm tstr\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbCcmVbcm) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_VBCM, 120);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:120 ccm vbcm\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addRtcpFbCcmVbcmAllPt) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_VBCM);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=rtcp-fb:* ccm vbcm\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, parseRtcpFbAllPayloads) {
+  ParseSdp(kVideoSdp + "a=rtcp-fb:* ack rpsi\r\n");
+  for (int i = 0; i < 128; i++) {
+    ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_, 1, i, 1),
+              SDP_RTCP_FB_ACK_RPSI);
+  }
+}
+TEST_F(SdpTest, addExtMap) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewExtMap(level, SDP_EXTMAP_AUDIO_LEVEL);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, parseExtMap) {
+  ParseSdp(kVideoSdp +
+    "a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n");
+  ASSERT_STREQ(sdp_attr_get_extmap_uri(sdp_ptr_, 1, 1),
+            SDP_EXTMAP_AUDIO_LEVEL);
+  ASSERT_EQ(sdp_attr_get_extmap_id(sdp_ptr_, 1, 1),
+            1);
+
+}
+
+TEST_F(SdpTest, parseFmtpBitrate) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 bitrate=400\r\n");
+  ASSERT_EQ(400, sdp_attr_get_fmtp_bitrate_type(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpBitrateWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 bitrate=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_bitrate_type(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpBitrateWith32001) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 bitrate=32001\r\n");
+  ASSERT_EQ(32001, sdp_attr_get_fmtp_bitrate_type(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpBitrateWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 bitrate=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_bitrate_type(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpMode) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 mode=200\r\n");
+  ASSERT_EQ(200U, sdp_attr_get_fmtp_mode_for_payload_type(sdp_ptr_, 1, 0, 120));
+}
+
+TEST_F(SdpTest, parseFmtpModeWith4294967295) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 mode=4294967295\r\n");
+  ASSERT_EQ(4294967295, sdp_attr_get_fmtp_mode_for_payload_type(sdp_ptr_, 1, 0, 120));
+}
+
+TEST_F(SdpTest, parseFmtpModeWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 mode=4294967296\r\n");
+  // returns 0 if not found
+  ASSERT_EQ(0U, sdp_attr_get_fmtp_mode_for_payload_type(sdp_ptr_, 1, 0, 120));
+}
+
+TEST_F(SdpTest, parseFmtpQcif) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 qcif=20\r\n");
+  ASSERT_EQ(20, sdp_attr_get_fmtp_qcif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpQcifWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 qcif=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_qcif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpQcifWith33) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 qcif=33\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_qcif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCif) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif=11\r\n");
+  ASSERT_EQ(11, sdp_attr_get_fmtp_cif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCifWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCifWith33) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif=33\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpMaxbr) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxbr=21\r\n");
+  ASSERT_EQ(21, sdp_attr_get_fmtp_maxbr(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpMaxbrWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxbr=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_maxbr(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpMaxbrWith65536) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxbr=65536\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_maxbr(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpSqcif) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sqcif=6\r\n");
+  ASSERT_EQ(6, sdp_attr_get_fmtp_sqcif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpSqcifWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sqcif=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_sqcif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpSqcifWith33) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sqcif=33\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_sqcif(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCif4) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif4=11\r\n");
+  ASSERT_EQ(11, sdp_attr_get_fmtp_cif4(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCif4With0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif4=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif4(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCif4With33) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif4=33\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif4(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCif16) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif16=11\r\n");
+  ASSERT_EQ(11, sdp_attr_get_fmtp_cif16(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCif16With0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif16=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif16(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpCif16With33) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cif16=33\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif16(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpBpp) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 bpp=7\r\n");
+  ASSERT_EQ(7, sdp_attr_get_fmtp_bpp(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpBppWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 bpp=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_bpp(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpBppWith65536) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 bpp=65536\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_bpp(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpHrd) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 hrd=800\r\n");
+  ASSERT_EQ(800, sdp_attr_get_fmtp_hrd(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpHrdWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 hrd=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_hrd(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpHrdWith65536) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 hrd=65536\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_hrd(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpProfile) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 profile=4\r\n");
+  ASSERT_EQ(4, sdp_attr_get_fmtp_profile(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpProfileWith11) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 profile=11\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_profile(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpLevel) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 level=56\r\n");
+  ASSERT_EQ(56, sdp_attr_get_fmtp_level(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpLevelWith101) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 level=101\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_level(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpPacketizationMode) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 packetization-mode=1\r\n");
+  uint16_t packetizationMode;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_pack_mode(sdp_ptr_, 1, 0, 1, &packetizationMode));
+  ASSERT_EQ(1, packetizationMode);
+}
+
+TEST_F(SdpTest, parseFmtpPacketizationModeWith3) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 packetization-mode=3\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_pack_mode(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpInterleavingDepth) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-interleaving-depth=566\r\n");
+  uint16_t interleavingDepth;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_interleaving_depth(sdp_ptr_, 1, 0, 1, &interleavingDepth));
+  ASSERT_EQ(566, interleavingDepth);
+}
+
+TEST_F(SdpTest, parseFmtpInterleavingDepthWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-interleaving-depth=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_interleaving_depth(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpInterleavingDepthWith65536) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-interleaving-depth=65536\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_interleaving_depth(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpDeintBuf) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-deint-buf-req=4294967295\r\n");
+  uint32_t deintBuf;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_deint_buf_req(sdp_ptr_, 1, 0, 1, &deintBuf));
+  ASSERT_EQ(4294967295, deintBuf);
+}
+
+TEST_F(SdpTest, parseFmtpDeintBufWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-deint-buf-req=0\r\n");
+  uint32_t deintBuf;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_deint_buf_req(sdp_ptr_, 1, 0, 1, &deintBuf));
+  ASSERT_EQ(0U, deintBuf);
+}
+
+TEST_F(SdpTest, parseFmtpDeintBufWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-deint-buf-req=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_deint_buf_req(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxDonDiff) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-max-don-diff=5678\r\n");
+  uint32_t maxDonDiff;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_don_diff(sdp_ptr_, 1, 0, 1, &maxDonDiff));
+  ASSERT_EQ(5678U, maxDonDiff);
+}
+
+TEST_F(SdpTest, parseFmtpMaxDonDiffWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-max-don-diff=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_don_diff(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxDonDiffWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-max-don-diff=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_don_diff(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpInitBufTime) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-init-buf-time=4294967295\r\n");
+  uint32_t initBufTime;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_init_buf_time(sdp_ptr_, 1, 0, 1, &initBufTime));
+  ASSERT_EQ(4294967295, initBufTime);
+}
+
+TEST_F(SdpTest, parseFmtpInitBufTimeWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-init-buf-time=0\r\n");
+  uint32_t initBufTime;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_init_buf_time(sdp_ptr_, 1, 0, 1, &initBufTime));
+  ASSERT_EQ(0U, initBufTime);
+}
+
+TEST_F(SdpTest, parseFmtpInitBufTimeWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 sprop-init-buf-time=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_init_buf_time(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxMbps) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-mbps=46789\r\n");
+  uint32_t maxMpbs;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_mbps(sdp_ptr_, 1, 0, 1, &maxMpbs));
+  ASSERT_EQ(46789U, maxMpbs);
+}
+
+TEST_F(SdpTest, parseFmtpMaxMbpsWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-mbps=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_mbps(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxMbpsWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-mbps=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_mbps(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxCpb) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-cpb=47891\r\n");
+  uint32_t maxCpb;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_cpb(sdp_ptr_, 1, 0, 1, &maxCpb));
+  ASSERT_EQ(47891U, maxCpb);
+}
+
+TEST_F(SdpTest, parseFmtpMaxCpbWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-cpb=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_cpb(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxCpbWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-cpb=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_cpb(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxDpb) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-dpb=47892\r\n");
+  uint32_t maxDpb;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_dpb(sdp_ptr_, 1, 0, 1, &maxDpb));
+  ASSERT_EQ(47892U, maxDpb);
+}
+
+TEST_F(SdpTest, parseFmtpMaxDpbWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-dpb=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_dpb(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxDpbWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-dpb=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_dpb(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxBr) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-br=47893\r\n");
+  uint32_t maxBr;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_br(sdp_ptr_, 1, 0, 1, &maxBr));
+  ASSERT_EQ(47893U, maxBr);
+}
+
+TEST_F(SdpTest, parseFmtpMaxBrWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-br=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_br(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxBrWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-br=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_br(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpRedundantPicCap) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 redundant-pic-cap=1\r\n");
+  ASSERT_EQ(1, sdp_attr_fmtp_is_redundant_pic_cap(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpRedundantPicCapWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 redundant-pic-cap=0\r\n");
+  ASSERT_EQ(0, sdp_attr_fmtp_is_redundant_pic_cap(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpRedundantPicCapWith2) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 redundant-pic-cap=2\r\n");
+  ASSERT_EQ(0, sdp_attr_fmtp_is_redundant_pic_cap(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpDeintBufCap) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 deint-buf-cap=4294967295\r\n");
+  uint32_t deintBufCap;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_deint_buf_cap(sdp_ptr_, 1, 0, 1, &deintBufCap));
+  ASSERT_EQ(4294967295, deintBufCap);
+}
+
+TEST_F(SdpTest, parseFmtpDeintBufCapWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 deint-buf-cap=0\r\n");
+  uint32_t deintBufCap;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_deint_buf_cap(sdp_ptr_, 1, 0, 1, &deintBufCap));
+  ASSERT_EQ(0U, deintBufCap);
+}
+
+TEST_F(SdpTest, parseFmtpDeintBufCapWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 deint-buf-cap=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_deint_buf_cap(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxRcmdNaluSize) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-rcmd-nalu-size=4294967295\r\n");
+  uint32_t maxRcmdNaluSize;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_rcmd_nalu_size(sdp_ptr_, 1, 0, 1, &maxRcmdNaluSize));
+  ASSERT_EQ(4294967295, maxRcmdNaluSize);
+}
+
+TEST_F(SdpTest, parseFmtpMaxRcmdNaluSizeWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-rcmd-nalu-size=0\r\n");
+  uint32_t maxRcmdNaluSize;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_rcmd_nalu_size(sdp_ptr_, 1, 0, 1, &maxRcmdNaluSize));
+  ASSERT_EQ(0U, maxRcmdNaluSize);
+}
+
+TEST_F(SdpTest, parseFmtpMaxRcmdNaluSizeWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-rcmd-nalu-size=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_rcmd_nalu_size(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpParameterAdd) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 parameter-add=1\r\n");
+  ASSERT_EQ(1, sdp_attr_fmtp_is_parameter_add(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpParameterAddWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 parameter-add=0\r\n");
+  ASSERT_EQ(0, sdp_attr_fmtp_is_parameter_add(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpParameterAddWith2) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 parameter-add=2\r\n");
+  ASSERT_EQ(0, sdp_attr_fmtp_is_parameter_add(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexK) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 K=566\r\n");
+  ASSERT_EQ(566, sdp_attr_get_fmtp_annex_k_val(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexKWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 K=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_annex_k_val(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexKWith65536) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 K=65536\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_annex_k_val(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexN) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 N=4567\r\n");
+  ASSERT_EQ(4567, sdp_attr_get_fmtp_annex_n_val(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexNWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 N=0\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_annex_n_val(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexNWith65536) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 N=65536\r\n");
+  ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_annex_n_val(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexP) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 P=5678,2\r\n");
+  ASSERT_EQ(5678, sdp_attr_get_fmtp_annex_p_picture_resize(sdp_ptr_, 1, 0, 1));
+  ASSERT_EQ(2, sdp_attr_get_fmtp_annex_p_warp(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexPWithResize0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 P=0,3\r\n");
+  ASSERT_EQ(0, sdp_attr_get_fmtp_annex_p_picture_resize(sdp_ptr_, 1, 0, 1));
+  ASSERT_EQ(3, sdp_attr_get_fmtp_annex_p_warp(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexPWithResize65536) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 P=65536,4\r\n");
+  ASSERT_EQ(0, sdp_attr_get_fmtp_annex_p_picture_resize(sdp_ptr_, 1, 0, 1));
+  // if the first fails, the second will too.  Both default to 0 on failure.
+  ASSERT_EQ(0, sdp_attr_get_fmtp_annex_p_warp(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpAnnexPWithWarp65536) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 P=346,65536\r\n");
+  ASSERT_EQ(346, sdp_attr_get_fmtp_annex_p_picture_resize(sdp_ptr_, 1, 0, 1));
+  ASSERT_EQ(0, sdp_attr_get_fmtp_annex_p_warp(sdp_ptr_, 1, 0, 1));
+}
+
+TEST_F(SdpTest, parseFmtpLevelAsymmetryAllowed) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 level-asymmetry-allowed=1\r\n");
+
+  uint16_t levelAsymmetryAllowed;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_level_asymmetry_allowed(sdp_ptr_, 1, 0, 1, &levelAsymmetryAllowed));
+  ASSERT_EQ(1U, levelAsymmetryAllowed);
+}
+
+TEST_F(SdpTest, parseFmtpLevelAsymmetryAllowedWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 level-asymmetry-allowed=0\r\n");
+  uint16_t levelAsymmetryAllowed;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_level_asymmetry_allowed(sdp_ptr_, 1, 0, 1, &levelAsymmetryAllowed));
+  ASSERT_EQ(0U, levelAsymmetryAllowed);
+}
+
+TEST_F(SdpTest, parseFmtpLevelAsymmetryAllowedWith2) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 level-asymmetry-allowed=2\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_level_asymmetry_allowed(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxAverageBitrate) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxaveragebitrate=47893\r\n");
+  uint32_t maxAverageBitrate;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_average_bitrate(sdp_ptr_, 1, 0, 1, &maxAverageBitrate));
+  ASSERT_EQ(47893U, maxAverageBitrate);
+}
+
+TEST_F(SdpTest, parseFmtpMaxAverageBitrateWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxaveragebitrate=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_average_bitrate(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxAverageBitrateWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxaveragebitrate=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_average_bitrate(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpUsedTx) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 usedtx=1\r\n");
+  tinybool usedTx;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_usedtx(sdp_ptr_, 1, 0, 1, &usedTx));
+  ASSERT_EQ(1, usedTx);
+}
+
+TEST_F(SdpTest, parseFmtpUsedTxWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 usedtx=0\r\n");
+  tinybool usedTx;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_usedtx(sdp_ptr_, 1, 0, 1, &usedTx));
+  ASSERT_EQ(0, usedTx);
+}
+
+TEST_F(SdpTest, parseFmtpUsedTxWith2) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 usedtx=2\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_usedtx(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpStereo) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 stereo=1\r\n");
+  tinybool stereo;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_stereo(sdp_ptr_, 1, 0, 1, &stereo));
+  ASSERT_EQ(1, stereo);
+}
+
+TEST_F(SdpTest, parseFmtpStereoWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 stereo=0\r\n");
+  tinybool stereo;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_stereo(sdp_ptr_, 1, 0, 1, &stereo));
+  ASSERT_EQ(0, stereo);
+}
+
+TEST_F(SdpTest, parseFmtpStereoWith2) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 stereo=2\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_stereo(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpUseInBandFec) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 useinbandfec=1\r\n");
+  tinybool useInbandFec;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_useinbandfec(sdp_ptr_, 1, 0, 1, &useInbandFec));
+  ASSERT_EQ(1, useInbandFec);
+}
+
+TEST_F(SdpTest, parseFmtpUseInBandWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 useinbandfec=0\r\n");
+  tinybool useInbandFec;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_useinbandfec(sdp_ptr_, 1, 0, 1, &useInbandFec));
+  ASSERT_EQ(0, useInbandFec);
+}
+
+TEST_F(SdpTest, parseFmtpUseInBandWith2) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 useinbandfec=2\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_useinbandfec(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxCodedAudioBandwidth) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxcodedaudiobandwidth=abcdefg\r\n");
+  char* maxCodedAudioBandwith = sdp_attr_get_fmtp_maxcodedaudiobandwidth(sdp_ptr_, 1, 0, 1);
+  ASSERT_EQ(0, strcmp("abcdefg", maxCodedAudioBandwith));
+}
+
+TEST_F(SdpTest, parseFmtpMaxCodedAudioBandwidthBad) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxcodedaudiobandwidth=\r\n");
+  char* maxCodedAudioBandwith = sdp_attr_get_fmtp_maxcodedaudiobandwidth(sdp_ptr_, 1, 0, 1);
+  ASSERT_EQ(0, *maxCodedAudioBandwith);
+}
+
+TEST_F(SdpTest, parseFmtpCbr) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cbr=1\r\n");
+  tinybool cbr;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_cbr(sdp_ptr_, 1, 0, 1, &cbr));
+  ASSERT_EQ(1, cbr);
+}
+
+TEST_F(SdpTest, parseFmtpCbrWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cbr=0\r\n");
+  tinybool cbr;
+  ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_cbr(sdp_ptr_, 1, 0, 1, &cbr));
+  ASSERT_EQ(0, cbr);
+}
+
+TEST_F(SdpTest, parseFmtpCbrWith2) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 cbr=2\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_cbr(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxPlaybackRate) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxplaybackrate=47900\r\n");
+  sdp_attr_t *attr_p = sdp_find_attr(sdp_ptr_, 1, 0, SDP_ATTR_FMTP, 1);
+  ASSERT_NE(NULL, attr_p);
+  ASSERT_EQ(47900U, attr_p->attr.fmtp.maxplaybackrate);
+}
+
+TEST_F(SdpTest, parseFmtpMaxPlaybackRateWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxplaybackrate=0\r\n");
+  sdp_attr_t *attr_p = sdp_find_attr(sdp_ptr_, 1, 0, SDP_ATTR_FMTP, 1);
+  ASSERT_EQ(NULL, attr_p);
+}
+
+TEST_F(SdpTest, parseFmtpMaxPlaybackRateWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 maxplaybackrate=4294967296\r\n");
+  sdp_attr_t *attr_p = sdp_find_attr(sdp_ptr_, 1, 0, SDP_ATTR_FMTP, 1);
+  ASSERT_EQ(NULL, attr_p);
+}
+
+TEST_F(SdpTest, parseFmtpMaxFs) {
+  uint32_t val = 0;
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-fs=300;max-fr=30\r\n");
+  ASSERT_EQ(sdp_attr_get_fmtp_max_fs(sdp_ptr_, 1, 0, 1, &val), SDP_SUCCESS);
+  ASSERT_EQ(val, 300U);
+}
+TEST_F(SdpTest, parseFmtpMaxFsWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-fs=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_fs(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxFsWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-fs=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_fs(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxFr) {
+  uint32_t val = 0;
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-fs=300;max-fr=30\r\n");
+  ASSERT_EQ(sdp_attr_get_fmtp_max_fr(sdp_ptr_, 1, 0, 1, &val), SDP_SUCCESS);
+  ASSERT_EQ(val, 30U);
+}
+
+TEST_F(SdpTest, parseFmtpMaxFrWith0) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-fr=0\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_fr(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, parseFmtpMaxFrWith4294967296) {
+  ParseSdp(kVideoSdp + "a=fmtp:120 max-fr=4294967296\r\n");
+  ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_max_fr(sdp_ptr_, 1, 0, 1, nullptr));
+}
+
+TEST_F(SdpTest, addFmtpMaxFs) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewFmtpMaxFs(level, 300);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=fmtp:120 max-fs=300\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addFmtpMaxFr) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewFmtpMaxFr(level, 30);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=fmtp:120 max-fr=30\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, addFmtpMaxFsFr) {
+  InitLocalSdp();
+  int level = AddNewMedia(SDP_MEDIA_VIDEO);
+  AddNewFmtpMaxFsFr(level, 300, 30);
+  std::string body = SerializeSdp();
+  ASSERT_NE(body.find("a=fmtp:120 max-fs=300;max-fr=30\r\n"),
+            std::string::npos);
+}
+
+static const std::string kBrokenFmtp =
+  "v=0\r\n"
+  "o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
+  "s=SIP Call\r\n"
+  "t=0 0\r\n"
+  "m=video 56436 RTP/SAVPF 120\r\n"
+  "c=IN IP4 198.51.100.7\r\n"
+  "a=rtpmap:120 VP8/90000\r\n"
+  /* Note: the \0 in this string triggered bz://1089207
+   */
+  "a=fmtp:120 max-fs=300;max\0fr=30";
+
+TEST_F(SdpTest, parseBrokenFmtp) {
+  uint32_t val = 0;
+  const char *buf = kBrokenFmtp.data();
+  ResetSdp();
+  /* We need to manually invoke the parser here to be able to specify the length
+   * of the string beyond the \0 in last line of the string.
+   */
+  ASSERT_EQ(sdp_parse(sdp_ptr_, buf, 165), SDP_SUCCESS);
+  ASSERT_EQ(sdp_attr_get_fmtp_max_fs(sdp_ptr_, 1, 0, 1, &val), SDP_INVALID_PARAMETER);
+}
+
+TEST_F(SdpTest, addIceLite) {
+    InitLocalSdp();
+    uint16_t inst_num = 0;
+    EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, SDP_SESSION_LEVEL, 0,
+                               SDP_ATTR_ICE_LITE, &inst_num), SDP_SUCCESS);
+    std::string body = SerializeSdp();
+    ASSERT_NE(body.find("a=ice-lite\r\n"), std::string::npos);
+}
+
+TEST_F(SdpTest, parseIceLite) {
+    std::string sdp =
+        "v=0\r\n"
+        "o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
+        "s=SIP Call\r\n"
+        "t=0 0\r\n"
+        "a=ice-lite\r\n";
+  ParseSdp(sdp);
+  ASSERT_TRUE(sdp_attr_is_present(sdp_ptr_, SDP_ATTR_ICE_LITE,
+                                  SDP_SESSION_LEVEL, 0));
+}
+
+class NewSdpTest : public ::testing::Test,
+                   public ::testing::WithParamInterface<bool> {
+  public:
+    NewSdpTest() {}
+
+    void ParseSdp(const std::string &sdp, bool expectSuccess = true) {
+      mSdp = mozilla::Move(mParser.Parse(sdp));
+
+      // Are we configured to do a parse and serialize before actually
+      // running the test?
+      if (GetParam()) {
+        std::stringstream os;
+
+        if (expectSuccess) {
+          ASSERT_TRUE(!!mSdp) << "Parse failed on first pass: "
+                              << GetParseErrors();
+        }
+
+        if (mSdp) {
+          // Serialize and re-parse
+          mSdp->Serialize(os);
+          mSdp = mozilla::Move(mParser.Parse(os.str()));
+
+          // Whether we expected the parse to work or not, it should
+          // succeed the second time if it succeeded the first.
+          ASSERT_TRUE(!!mSdp) << "Parse failed on second pass, SDP was: "
+            << std::endl << os.str() <<  std::endl
+            << "Errors were: " << GetParseErrors();
+
+          // Serialize again and compare
+          std::stringstream os2;
+          mSdp->Serialize(os2);
+          ASSERT_EQ(os.str(), os2.str());
+        }
+      }
+
+      if (expectSuccess) {
+        ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+        ASSERT_EQ(0U, mParser.GetParseErrors().size())
+                  << "Got unexpected parse errors/warnings: "
+                  << GetParseErrors();
+      }
+    }
+
+    // For streaming parse errors
+    std::string GetParseErrors() const {
+      std::stringstream output;
+      for (auto e = mParser.GetParseErrors().begin();
+           e != mParser.GetParseErrors().end();
+           ++e) {
+        output << e->first << ": " << e->second << std::endl;
+      }
+      return output.str();
+    }
+
+    void CheckRtpmap(const std::string& expected_pt,
+                     SdpRtpmapAttributeList::CodecType codec,
+                     const std::string& name,
+                     uint32_t clock,
+                     uint16_t channels,
+                     const std::string& search_pt,
+                     const SdpRtpmapAttributeList& rtpmaps) const {
+      ASSERT_TRUE(rtpmaps.HasEntry(search_pt));
+      auto attr = rtpmaps.GetEntry(search_pt);
+      ASSERT_EQ(expected_pt, attr.pt);
+      ASSERT_EQ(codec, attr.codec);
+      ASSERT_EQ(name, attr.name);
+      ASSERT_EQ(clock, attr.clock);
+      ASSERT_EQ(channels, attr.channels);
+    }
+
+    void CheckSctpmap(const std::string& expected_pt,
+                      const std::string& name,
+                      uint16_t streams,
+                      const std::string& search_pt,
+                      const SdpSctpmapAttributeList& sctpmaps) const {
+      ASSERT_TRUE(sctpmaps.HasEntry(search_pt));
+      auto attr = sctpmaps.GetEntry(search_pt);
+      ASSERT_EQ(expected_pt, search_pt);
+      ASSERT_EQ(expected_pt, attr.pt);
+      ASSERT_EQ(name, attr.name);
+      ASSERT_EQ(streams, attr.streams);
+    }
+
+    void CheckRtcpFb(const SdpRtcpFbAttributeList::Feedback& feedback,
+                     const std::string& pt,
+                     SdpRtcpFbAttributeList::Type type,
+                     const std::string& first_parameter,
+                     const std::string& extra = "") const {
+      ASSERT_EQ(pt, feedback.pt);
+      ASSERT_EQ(type, feedback.type);
+      ASSERT_EQ(first_parameter, feedback.parameter);
+      ASSERT_EQ(extra, feedback.extra);
+    }
+
+    void CheckDtmfFmtp(const std::string& expectedDtmfTones) const {
+      ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+                  SdpAttribute::kFmtpAttribute));
+      auto audio_format_params =
+          mSdp->GetMediaSection(0).GetAttributeList().GetFmtp().mFmtps;
+      ASSERT_EQ(2U, audio_format_params.size());
+
+      ASSERT_EQ("101", audio_format_params[1].format);
+      ASSERT_TRUE(!!audio_format_params[1].parameters);
+      const SdpFmtpAttributeList::TelephoneEventParameters* te_parameters =
+        static_cast<SdpFmtpAttributeList::TelephoneEventParameters*>(
+            audio_format_params[1].parameters.get());
+      ASSERT_NE(0U, te_parameters->dtmfTones.size());
+      ASSERT_EQ(expectedDtmfTones, te_parameters->dtmfTones);
+    }
+
+    void CheckSerialize(const std::string& expected,
+                        const SdpAttribute& attr) const {
+      std::stringstream str;
+      attr.Serialize(str);
+      ASSERT_EQ(expected, str.str());
+    }
+
+    SipccSdpParser mParser;
+    mozilla::UniquePtr<Sdp> mSdp;
+}; // class NewSdpTest
+
+TEST_P(NewSdpTest, CreateDestroy) {
+}
+
+TEST_P(NewSdpTest, ParseEmpty) {
+  ParseSdp("", false);
+  ASSERT_FALSE(mSdp);
+  ASSERT_NE(0U, mParser.GetParseErrors().size())
+    << "Expected at least one parse error.";
+}
+
+const std::string kBadSdp = "This is SDPARTA!!!!";
+
+TEST_P(NewSdpTest, ParseGarbage) {
+  ParseSdp(kBadSdp, false);
+  ASSERT_FALSE(mSdp);
+  ASSERT_NE(0U, mParser.GetParseErrors().size())
+    << "Expected at least one parse error.";
+}
+
+TEST_P(NewSdpTest, ParseGarbageTwice) {
+  ParseSdp(kBadSdp, false);
+  ASSERT_FALSE(mSdp);
+  size_t errorCount = mParser.GetParseErrors().size();
+  ASSERT_NE(0U, errorCount)
+    << "Expected at least one parse error.";
+  ParseSdp(kBadSdp, false);
+  ASSERT_FALSE(mSdp);
+  ASSERT_EQ(errorCount, mParser.GetParseErrors().size())
+    << "Expected same error count for same SDP.";
+}
+
+TEST_P(NewSdpTest, ParseMinimal) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(0U, mParser.GetParseErrors().size()) <<
+    "Got parse errors: " << GetParseErrors();
+}
+
+TEST_P(NewSdpTest, CheckOriginGetUsername) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ("-", mSdp->GetOrigin().GetUsername())
+    << "Wrong username in origin";
+}
+
+TEST_P(NewSdpTest, CheckOriginGetSessionId) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(4294967296U, mSdp->GetOrigin().GetSessionId())
+    << "Wrong session id in origin";
+}
+
+TEST_P(NewSdpTest, CheckOriginGetSessionVersion) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(2U , mSdp->GetOrigin().GetSessionVersion())
+    << "Wrong version in origin";
+}
+
+TEST_P(NewSdpTest, CheckOriginGetAddrType) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(sdp::kIPv4, mSdp->GetOrigin().GetAddrType())
+    << "Wrong address type in origin";
+}
+
+TEST_P(NewSdpTest, CheckOriginGetAddress) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ("127.0.0.1" , mSdp->GetOrigin().GetAddress())
+    << "Wrong address in origin";
+}
+
+TEST_P(NewSdpTest, CheckGetMissingBandwidth) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(0U, mSdp->GetBandwidth("CT"))
+    << "Wrong bandwidth in session";
+}
+
+TEST_P(NewSdpTest, CheckGetBandwidth) {
+  ParseSdp("v=0" CRLF
+           "o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
+           "s=SIP Call" CRLF
+           "c=IN IP4 198.51.100.7" CRLF
+           "b=CT:5000" CRLF
+           "b=FOOBAR:10" CRLF
+           "b=AS:4" CRLF
+           "t=0 0" CRLF
+           "m=video 56436 RTP/SAVPF 120" CRLF
+           "a=rtpmap:120 VP8/90000" CRLF
+           );
+  ASSERT_EQ(5000U, mSdp->GetBandwidth("CT"))
+    << "Wrong CT bandwidth in session";
+  ASSERT_EQ(0U, mSdp->GetBandwidth("FOOBAR"))
+    << "Wrong FOOBAR bandwidth in session";
+  ASSERT_EQ(4U, mSdp->GetBandwidth("AS"))
+    << "Wrong AS bandwidth in session";
+}
+
+TEST_P(NewSdpTest, CheckGetMediaSectionsCount) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+}
+
+TEST_P(NewSdpTest, CheckMediaSectionGetMediaType) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(SdpMediaSection::kVideo, mSdp->GetMediaSection(0).GetMediaType())
+    << "Wrong type for first media section";
+}
+
+TEST_P(NewSdpTest, CheckMediaSectionGetProtocol) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf, mSdp->GetMediaSection(0).GetProtocol())
+    << "Wrong protocol for video";
+}
+
+TEST_P(NewSdpTest, CheckMediaSectionGetFormats) {
+  ParseSdp(kVideoSdp);
+  auto video_formats = mSdp->GetMediaSection(0).GetFormats();
+  ASSERT_EQ(1U, video_formats.size()) << "Wrong number of formats for video";
+  ASSERT_EQ("120", video_formats[0]);
+}
+
+TEST_P(NewSdpTest, CheckMediaSectionGetPort) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(56436U, mSdp->GetMediaSection(0).GetPort())
+    << "Wrong port number in media section";
+}
+
+TEST_P(NewSdpTest, CheckMediaSectionGetMissingPortCount) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(0U, mSdp->GetMediaSection(0).GetPortCount())
+    << "Wrong port count in media section";
+}
+
+TEST_P(NewSdpTest, CheckMediaSectionGetPortCount) {
+  ParseSdp(kVideoSdp +
+      "m=audio 12345/2 RTP/SAVPF 0" CRLF
+      "a=rtpmap:0 PCMU/8000" CRLF
+      );
+  ASSERT_EQ(2U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+  ASSERT_EQ(2U, mSdp->GetMediaSection(1).GetPortCount())
+    << "Wrong port count in media section";
+}
+
+TEST_P(NewSdpTest, CheckMediaSectionGetMissingBandwidth) {
+  ParseSdp(kVideoSdp);
+  ASSERT_EQ(0U, mSdp->GetMediaSection(0).GetBandwidth("CT"))
+    << "Wrong bandwidth in media section";
+}
+
+TEST_P(NewSdpTest, CheckMediaSectionGetBandwidth) {
+  ParseSdp("v=0\r\n"
+           "o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
+           "c=IN IP4 198.51.100.7\r\n"
+           "t=0 0\r\n"
+           "m=video 56436 RTP/SAVPF 120\r\n"
+           "b=CT:1000\r\n"
+           "a=rtpmap:120 VP8/90000\r\n");
+  ASSERT_EQ(1000U, mSdp->GetMediaSection(0).GetBandwidth("CT"))
+    << "Wrong bandwidth in media section";
+}
+
+// Define a string that is 258 characters long. We use a long string here so
+// that we can test that we are able to parse and handle a string longer than
+// the default maximum length of 256 in sipcc.
+#define ID_A "1234567890abcdef"
+#define ID_B ID_A ID_A ID_A ID_A
+#define LONG_IDENTITY ID_B ID_B ID_B ID_B "xx"
+
+#define BASE64_DTLS_HELLO "FgEAAAAAAAAAAAAAagEAAF4AAAAAAAAAXgEARI11KHx3QB6Ky" \
+  "CKgoBj/kwjKrApkL8kiZLwIqBaJGT8AAAA2ADkAOAA1ABYAEwAKADMAMgAvAAcAZgAFAAQAYw" \
+  "BiAGEAFQASAAkAZQBkAGAAFAARAAgABgADAQA="
+
+// SDP from a basic A/V apprtc call FFX/FFX
+const std::string kBasicAudioVideoOffer =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=dtls-message:client " BASE64_DTLS_HELLO CRLF
+"a=ice-ufrag:4a799b2e" CRLF
+"a=ice-pwd:e4cc12a910f106a0a744719425510e17" CRLF
+"a=ice-lite" CRLF
+"a=ice-options:trickle foo" CRLF
+"a=msid-semantic:WMS stream streama" CRLF
+"a=msid-semantic:foo stream" CRLF
+"a=fingerprint:sha-256 DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C" CRLF
+"a=identity:" LONG_IDENTITY CRLF
+"a=group:BUNDLE first second" CRLF
+"a=group:BUNDLE third" CRLF
+"a=group:LS first third" CRLF
+"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=mid:first" CRLF
+"a=rtpmap:109 opus/48000/2" CRLF
+"a=fmtp:109 maxplaybackrate=32000;stereo=1" CRLF
+"a=ptime:20" CRLF
+"a=maxptime:20" CRLF
+"a=rtpmap:9 G722/8000" CRLF
+"a=rtpmap:0 PCMU/8000" CRLF
+"a=rtpmap:8 PCMA/8000" CRLF
+"a=rtpmap:101 telephone-event/8000" CRLF
+"a=fmtp:101 0-15,66,32-34,67" CRLF
+"a=ice-ufrag:00000000" CRLF
+"a=ice-pwd:0000000000000000000000000000000" CRLF
+"a=sendonly" CRLF
+"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level" CRLF
+"a=setup:actpass" CRLF
+"a=rtcp-mux" CRLF
+"a=msid:stream track" CRLF
+"a=candidate:0 1 UDP 2130379007 10.0.0.36 62453 typ host" CRLF
+"a=candidate:2 1 UDP 1694236671 24.6.134.204 62453 typ srflx raddr 10.0.0.36 rport 62453" CRLF
+"a=candidate:3 1 UDP 100401151 162.222.183.171 49761 typ relay raddr 162.222.183.171 rport 49761" CRLF
+"a=candidate:6 1 UDP 16515071 162.222.183.171 51858 typ relay raddr 162.222.183.171 rport 51858" CRLF
+"a=candidate:3 2 UDP 100401150 162.222.183.171 62454 typ relay raddr 162.222.183.171 rport 62454" CRLF
+"a=candidate:2 2 UDP 1694236670 24.6.134.204 55428 typ srflx raddr 10.0.0.36 rport 55428" CRLF
+"a=candidate:6 2 UDP 16515070 162.222.183.171 50340 typ relay raddr 162.222.183.171 rport 50340" CRLF
+"a=candidate:0 2 UDP 2130379006 10.0.0.36 55428 typ host" CRLF
+"a=rtcp:62454 IN IP4 162.222.183.171" CRLF
+"a=end-of-candidates" CRLF
+"a=ssrc:5150" CRLF
+"m=video 9 RTP/SAVPF 120 121 122 123" CRLF
+"c=IN IP6 ::1" CRLF
+"a=fingerprint:sha-1 DF:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7" CRLF
+"a=mid:second" CRLF
+"a=rtpmap:120 VP8/90000" CRLF
+"a=fmtp:120 max-fs=3600;max-fr=30" CRLF
+"a=rtpmap:121 VP9/90000" CRLF
+"a=fmtp:121 max-fs=3600;max-fr=30" CRLF
+"a=rtpmap:122 red/90000" CRLF
+"a=rtpmap:123 ulpfec/90000" CRLF
+"a=recvonly" CRLF
+"a=rtcp-fb:120 nack" CRLF
+"a=rtcp-fb:120 nack pli" CRLF
+"a=rtcp-fb:120 ccm fir" CRLF
+"a=rtcp-fb:121 nack" CRLF
+"a=rtcp-fb:121 nack pli" CRLF
+"a=rtcp-fb:121 ccm fir" CRLF
+"a=setup:active" CRLF
+"a=rtcp-mux" CRLF
+"a=msid:streama tracka" CRLF
+"a=msid:streamb trackb" CRLF
+"a=candidate:0 1 UDP 2130379007 10.0.0.36 59530 typ host" CRLF
+"a=candidate:0 2 UDP 2130379006 10.0.0.36 64378 typ host" CRLF
+"a=candidate:2 2 UDP 1694236670 24.6.134.204 64378 typ srflx raddr 10.0.0.36 rport 64378" CRLF
+"a=candidate:6 2 UDP 16515070 162.222.183.171 64941 typ relay raddr 162.222.183.171 rport 64941" CRLF
+"a=candidate:6 1 UDP 16515071 162.222.183.171 64800 typ relay raddr 162.222.183.171 rport 64800" CRLF
+"a=candidate:2 1 UDP 1694236671 24.6.134.204 59530 typ srflx raddr 10.0.0.36 rport 59530" CRLF
+"a=candidate:3 1 UDP 100401151 162.222.183.171 62935 typ relay raddr 162.222.183.171 rport 62935" CRLF
+"a=candidate:3 2 UDP 100401150 162.222.183.171 61026 typ relay raddr 162.222.183.171 rport 61026" CRLF
+"a=rtcp:61026" CRLF
+"a=end-of-candidates" CRLF
+"a=ssrc:1111 foo" CRLF
+"a=ssrc:1111 foo:bar" CRLF
+"a=imageattr:120 send * recv *" CRLF
+"a=imageattr:121 send [x=640,y=480] recv [x=640,y=480]" CRLF
+"a=simulcast:recv pt=120;121" CRLF
+"a=rid:bar recv pt=96;max-width=800;max-height=600" CRLF
+"m=audio 9 RTP/SAVPF 0" CRLF
+"a=mid:third" CRLF
+"a=rtpmap:0 PCMU/8000" CRLF
+"a=ice-lite" CRLF
+"a=ice-options:foo bar" CRLF
+"a=msid:noappdata" CRLF
+"a=bundle-only" CRLF;
+
+TEST_P(NewSdpTest, BasicAudioVideoSdpParse) {
+  ParseSdp(kBasicAudioVideoOffer);
+}
+
+TEST_P(NewSdpTest, CheckRemoveFmtp) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  SdpAttributeList& audioAttrList = mSdp->GetMediaSection(0).GetAttributeList();
+
+  ASSERT_TRUE(audioAttrList.HasAttribute(SdpAttribute::kFmtpAttribute));
+  ASSERT_EQ(2U, audioAttrList.GetFmtp().mFmtps.size());
+  ASSERT_TRUE(mSdp->GetMediaSection(0).FindFmtp("109"));
+  ASSERT_TRUE(mSdp->GetMediaSection(0).FindFmtp("101"));
+
+  mSdp->GetMediaSection(0).RemoveFmtp("101");
+
+  ASSERT_TRUE(audioAttrList.HasAttribute(SdpAttribute::kFmtpAttribute));
+  ASSERT_EQ(1U, audioAttrList.GetFmtp().mFmtps.size());
+  ASSERT_TRUE(mSdp->GetMediaSection(0).FindFmtp("109"));
+  ASSERT_FALSE(mSdp->GetMediaSection(0).FindFmtp("101"));
+
+  mSdp->GetMediaSection(0).RemoveFmtp("109");
+
+  ASSERT_TRUE(audioAttrList.HasAttribute(SdpAttribute::kFmtpAttribute));
+  ASSERT_EQ(0U, audioAttrList.GetFmtp().mFmtps.size());
+  ASSERT_FALSE(mSdp->GetMediaSection(0).FindFmtp("109"));
+  ASSERT_FALSE(mSdp->GetMediaSection(0).FindFmtp("101"));
+
+  // make sure we haven't disturbed the video fmtps
+  SdpAttributeList& videoAttrList = mSdp->GetMediaSection(1).GetAttributeList();
+  ASSERT_TRUE(videoAttrList.HasAttribute(SdpAttribute::kFmtpAttribute));
+  ASSERT_EQ(2U, videoAttrList.GetFmtp().mFmtps.size());
+  ASSERT_TRUE(mSdp->GetMediaSection(1).FindFmtp("120"));
+  ASSERT_TRUE(mSdp->GetMediaSection(1).FindFmtp("121"));
+}
+
+TEST_P(NewSdpTest, CheckIceUfrag) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kIceUfragAttribute));
+  auto ice_ufrag = mSdp->GetAttributeList().GetIceUfrag();
+  ASSERT_EQ("4a799b2e", ice_ufrag) << "Wrong ice-ufrag value";
+
+  ice_ufrag = mSdp->GetMediaSection(0)
+      .GetAttributeList().GetIceUfrag();
+  ASSERT_EQ("00000000", ice_ufrag) << "ice-ufrag isn't overridden";
+
+  ice_ufrag = mSdp->GetMediaSection(1)
+      .GetAttributeList().GetIceUfrag();
+  ASSERT_EQ("4a799b2e", ice_ufrag) << "ice-ufrag isn't carried to m-section";
+}
+
+TEST_P(NewSdpTest, CheckIcePwd) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kIcePwdAttribute));
+  auto ice_pwd = mSdp->GetAttributeList().GetIcePwd();
+  ASSERT_EQ("e4cc12a910f106a0a744719425510e17", ice_pwd) << "Wrong ice-pwd value";
+
+  ice_pwd = mSdp->GetMediaSection(0)
+      .GetAttributeList().GetIcePwd();
+  ASSERT_EQ("0000000000000000000000000000000", ice_pwd)
+      << "ice-pwd isn't overridden";
+
+  ice_pwd = mSdp->GetMediaSection(1)
+      .GetAttributeList().GetIcePwd();
+  ASSERT_EQ("e4cc12a910f106a0a744719425510e17", ice_pwd)
+      << "ice-pwd isn't carried to m-section";
+}
+
+TEST_P(NewSdpTest, CheckIceOptions) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kIceOptionsAttribute));
+  auto ice_options = mSdp->GetAttributeList().GetIceOptions();
+  ASSERT_EQ(2U, ice_options.mValues.size()) << "Wrong ice-options size";
+  ASSERT_EQ("trickle", ice_options.mValues[0]) << "Wrong ice-options value";
+  ASSERT_EQ("foo", ice_options.mValues[1]) << "Wrong ice-options value";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+        SdpAttribute::kIceOptionsAttribute));
+  auto ice_options_media_level =
+    mSdp->GetMediaSection(2).GetAttributeList().GetIceOptions();
+  ASSERT_EQ(2U, ice_options_media_level.mValues.size()) << "Wrong ice-options size";
+  ASSERT_EQ("foo", ice_options_media_level.mValues[0]) << "Wrong ice-options value";
+  ASSERT_EQ("bar", ice_options_media_level.mValues[1]) << "Wrong ice-options value";
+}
+
+TEST_P(NewSdpTest, CheckFingerprint) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kFingerprintAttribute));
+  auto fingerprints = mSdp->GetAttributeList().GetFingerprint();
+  ASSERT_EQ(1U, fingerprints.mFingerprints.size());
+  ASSERT_EQ(SdpFingerprintAttributeList::kSha256,
+      fingerprints.mFingerprints[0].hashFunc)
+    << "Wrong hash function";
+  ASSERT_EQ("DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:"
+            "3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C",
+            SdpFingerprintAttributeList::FormatFingerprint(
+                fingerprints.mFingerprints[0].fingerprint))
+    << "Wrong fingerprint";
+  ASSERT_EQ(0xdfU, fingerprints.mFingerprints[0].fingerprint[0])
+      << "first fingerprint element is iffy";
+
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount());
+
+  // Fallback to session level
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kFingerprintAttribute));
+  fingerprints = mSdp->GetMediaSection(0).GetAttributeList().GetFingerprint();
+  ASSERT_EQ(1U, fingerprints.mFingerprints.size());
+  ASSERT_EQ(SdpFingerprintAttributeList::kSha256,
+      fingerprints.mFingerprints[0].hashFunc)
+    << "Wrong hash function";
+  ASSERT_EQ("DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:"
+            "3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C",
+            SdpFingerprintAttributeList::FormatFingerprint(
+                fingerprints.mFingerprints[0].fingerprint))
+    << "Wrong fingerprint";
+  ASSERT_EQ(0xdfU, fingerprints.mFingerprints[0].fingerprint[0])
+      << "first fingerprint element is iffy";
+
+  // Media level
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+        SdpAttribute::kFingerprintAttribute));
+  fingerprints = mSdp->GetMediaSection(1).GetAttributeList().GetFingerprint();
+  ASSERT_EQ(1U, fingerprints.mFingerprints.size());
+  ASSERT_EQ(SdpFingerprintAttributeList::kSha1,
+      fingerprints.mFingerprints[0].hashFunc)
+    << "Wrong hash function";
+  ASSERT_EQ("DF:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:"
+            "08:6D:0F:4C:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7",
+            SdpFingerprintAttributeList::FormatFingerprint(
+                fingerprints.mFingerprints[0].fingerprint))
+    << "Wrong fingerprint";
+  ASSERT_EQ(0xdfU, fingerprints.mFingerprints[0].fingerprint[0])
+      << "first fingerprint element is iffy";
+}
+
+TEST_P(NewSdpTest, CheckIdentity) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kIdentityAttribute));
+  auto identity = mSdp->GetAttributeList().GetIdentity();
+  ASSERT_EQ(LONG_IDENTITY, identity) << "Wrong identity assertion";
+}
+
+TEST_P(NewSdpTest, CheckDtlsMessage) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kDtlsMessageAttribute));
+  auto dtls_message = mSdp->GetAttributeList().GetDtlsMessage();
+  ASSERT_EQ(SdpDtlsMessageAttribute::kClient, dtls_message.mRole)
+    << "Wrong dtls-message role";
+  ASSERT_EQ(BASE64_DTLS_HELLO, dtls_message.mValue)
+    << "Wrong dtls-message value";
+}
+
+TEST_P(NewSdpTest, CheckNumberOfMediaSections) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+}
+
+TEST_P(NewSdpTest, CheckMlines) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+  ASSERT_EQ(SdpMediaSection::kAudio, mSdp->GetMediaSection(0).GetMediaType())
+    << "Wrong type for first media section";
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf,
+            mSdp->GetMediaSection(0).GetProtocol())
+    << "Wrong protocol for audio";
+  auto audio_formats = mSdp->GetMediaSection(0).GetFormats();
+  ASSERT_EQ(5U, audio_formats.size()) << "Wrong number of formats for audio";
+  ASSERT_EQ("109", audio_formats[0]);
+  ASSERT_EQ("9",   audio_formats[1]);
+  ASSERT_EQ("0",   audio_formats[2]);
+  ASSERT_EQ("8",   audio_formats[3]);
+  ASSERT_EQ("101", audio_formats[4]);
+
+  ASSERT_EQ(SdpMediaSection::kVideo, mSdp->GetMediaSection(1).GetMediaType())
+    << "Wrong type for second media section";
+  ASSERT_EQ(SdpMediaSection::kRtpSavpf,
+            mSdp->GetMediaSection(1).GetProtocol())
+    << "Wrong protocol for video";
+  auto video_formats = mSdp->GetMediaSection(1).GetFormats();
+  ASSERT_EQ(4U, video_formats.size()) << "Wrong number of formats for video";
+  ASSERT_EQ("120", video_formats[0]);
+  ASSERT_EQ("121", video_formats[1]);
+  ASSERT_EQ("122", video_formats[2]);
+  ASSERT_EQ("123", video_formats[3]);
+
+  ASSERT_EQ(SdpMediaSection::kAudio, mSdp->GetMediaSection(2).GetMediaType())
+    << "Wrong type for third media section";
+}
+
+TEST_P(NewSdpTest, CheckSetup) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kSetupAttribute));
+  ASSERT_EQ(SdpSetupAttribute::kActpass,
+      mSdp->GetMediaSection(0).GetAttributeList().GetSetup().mRole);
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kSetupAttribute));
+  ASSERT_EQ(SdpSetupAttribute::kActive,
+      mSdp->GetMediaSection(1).GetAttributeList().GetSetup().mRole);
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+        SdpAttribute::kSetupAttribute));
+}
+
+TEST_P(NewSdpTest, CheckSsrc)
+{
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kSsrcAttribute));
+  auto ssrcs = mSdp->GetMediaSection(0).GetAttributeList().GetSsrc().mSsrcs;
+  ASSERT_EQ(1U, ssrcs.size());
+  ASSERT_EQ(5150U, ssrcs[0].ssrc);
+  ASSERT_EQ("", ssrcs[0].attribute);
+
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kSsrcAttribute));
+  ssrcs = mSdp->GetMediaSection(1).GetAttributeList().GetSsrc().mSsrcs;
+  ASSERT_EQ(2U, ssrcs.size());
+  ASSERT_EQ(1111U, ssrcs[0].ssrc);
+  ASSERT_EQ("foo", ssrcs[0].attribute);
+  ASSERT_EQ(1111U, ssrcs[1].ssrc);
+  ASSERT_EQ("foo:bar", ssrcs[1].attribute);
+}
+
+TEST_P(NewSdpTest, CheckRtpmap) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  const SdpMediaSection& audiosec = mSdp->GetMediaSection(0);
+  const SdpRtpmapAttributeList& rtpmap = audiosec.GetAttributeList().GetRtpmap();
+  ASSERT_EQ(5U, rtpmap.mRtpmaps.size())
+    << "Wrong number of rtpmap attributes for audio";
+
+  // Need to know name of type
+  CheckRtpmap("109",
+              SdpRtpmapAttributeList::kOpus,
+              "opus",
+              48000,
+              2,
+              audiosec.GetFormats()[0],
+              rtpmap);
+
+  CheckRtpmap("9",
+              SdpRtpmapAttributeList::kG722,
+              "G722",
+              8000,
+              1,
+              audiosec.GetFormats()[1],
+              rtpmap);
+
+  CheckRtpmap("0",
+              SdpRtpmapAttributeList::kPCMU,
+              "PCMU",
+              8000,
+              1,
+              audiosec.GetFormats()[2],
+              rtpmap);
+
+  CheckRtpmap("8",
+              SdpRtpmapAttributeList::kPCMA,
+              "PCMA",
+              8000,
+              1,
+              audiosec.GetFormats()[3],
+              rtpmap);
+
+  CheckRtpmap("101",
+              SdpRtpmapAttributeList::kTelephoneEvent,
+              "telephone-event",
+              8000,
+              1,
+              audiosec.GetFormats()[4],
+              rtpmap);
+
+  const SdpMediaSection& videosec = mSdp->GetMediaSection(1);
+  const SdpRtpmapAttributeList videoRtpmap =
+    videosec.GetAttributeList().GetRtpmap();
+  ASSERT_EQ(4U, videoRtpmap.mRtpmaps.size())
+    << "Wrong number of rtpmap attributes for video";
+
+  CheckRtpmap("120",
+              SdpRtpmapAttributeList::kVP8,
+              "VP8",
+              90000,
+              0,
+              videosec.GetFormats()[0],
+              videoRtpmap);
+
+  CheckRtpmap("121",
+              SdpRtpmapAttributeList::kVP9,
+              "VP9",
+              90000,
+              0,
+              videosec.GetFormats()[1],
+              videoRtpmap);
+
+  CheckRtpmap("122",
+              SdpRtpmapAttributeList::kRed,
+              "red",
+              90000,
+              0,
+              videosec.GetFormats()[2],
+              videoRtpmap);
+
+  CheckRtpmap("123",
+              SdpRtpmapAttributeList::kUlpfec,
+              "ulpfec",
+              90000,
+              0,
+              videosec.GetFormats()[3],
+              videoRtpmap);
+}
+
+static const std::string kAudioWithTelephoneEvent =
+  "v=0" CRLF
+  "o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
+  "s=SIP Call" CRLF
+  "c=IN IP4 198.51.100.7" CRLF
+  "t=0 0" CRLF
+  "m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
+  "c=IN IP4 0.0.0.0" CRLF
+  "a=mid:first" CRLF
+  "a=rtpmap:109 opus/48000/2" CRLF
+  "a=fmtp:109 maxplaybackrate=32000;stereo=1" CRLF
+  "a=ptime:20" CRLF
+  "a=maxptime:20" CRLF
+  "a=rtpmap:9 G722/8000" CRLF
+  "a=rtpmap:0 PCMU/8000" CRLF
+  "a=rtpmap:8 PCMA/8000" CRLF
+  "a=rtpmap:101 telephone-event/8000" CRLF;
+
+TEST_P(NewSdpTest, CheckTelephoneEventNoFmtp) {
+  ParseSdp(kAudioWithTelephoneEvent);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+              SdpAttribute::kFmtpAttribute));
+  auto audio_format_params =
+      mSdp->GetMediaSection(0).GetAttributeList().GetFmtp().mFmtps;
+  ASSERT_EQ(1U, audio_format_params.size());
+
+  // make sure we don't get a fmtp for codec 101
+  for (size_t i = 0; i < audio_format_params.size(); ++i) {
+    ASSERT_NE("101", audio_format_params[i].format);
+  }
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventWithDefaultEvents) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 0-15" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventWithBadCharacter) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 0-5." CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventIncludingCommas) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 0-15,66,67" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  CheckDtmfFmtp("0-15,66,67");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventComplexEvents) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 0,1,2-4,5-15,66,67" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  CheckDtmfFmtp("0,1,2-4,5-15,66,67");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventNoHyphen) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 5,6,7" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  CheckDtmfFmtp("5,6,7");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventOnlyZero) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 0" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  CheckDtmfFmtp("0");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventOnlyOne) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 1" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  CheckDtmfFmtp("1");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadThreeDigit) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 123" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadThreeDigitWithHyphen) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 0-123" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadLeadingHyphen) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 -12" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadTrailingHyphen) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 12-" CRLF, false);
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadTrailingHyphenInMiddle) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 1,12-,4" CRLF, false);
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadLeadingComma) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 ,2,3" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadMultipleLeadingComma) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 ,,,2,3" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadConsecutiveCommas) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 1,,,,,,,,3" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadTrailingComma) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 1,2,3," CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadTwoHyphens) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 1-2-3" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadSixDigit) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 112233" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+TEST_P(NewSdpTest, CheckTelephoneEventBadRangeReversed) {
+  ParseSdp(kAudioWithTelephoneEvent
+           + "a=fmtp:101 33-2" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  // check for the default dtmf tones
+  CheckDtmfFmtp("0-15");
+}
+
+static const std::string kVideoWithRedAndUlpfecSdp =
+  "v=0" CRLF
+  "o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
+  "s=SIP Call" CRLF
+  "c=IN IP4 198.51.100.7" CRLF
+  "t=0 0" CRLF
+  "m=video 9 RTP/SAVPF 97 120 121 122 123" CRLF
+  "c=IN IP6 ::1" CRLF
+  "a=fingerprint:sha-1 DF:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7" CRLF
+  "a=rtpmap:97 H264/90000" CRLF
+  "a=fmtp:97 profile-level-id=42a01e" CRLF
+  "a=rtpmap:120 VP8/90000" CRLF
+  "a=fmtp:120 max-fs=3600;max-fr=30" CRLF
+  "a=rtpmap:121 VP9/90000" CRLF
+  "a=fmtp:121 max-fs=3600;max-fr=30" CRLF
+  "a=rtpmap:122 red/90000" CRLF
+  "a=rtpmap:123 ulpfec/90000" CRLF;
+
+TEST_P(NewSdpTest, CheckRedNoFmtp) {
+  ParseSdp(kVideoWithRedAndUlpfecSdp);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+              SdpAttribute::kFmtpAttribute));
+  auto video_format_params =
+      mSdp->GetMediaSection(0).GetAttributeList().GetFmtp().mFmtps;
+  ASSERT_EQ(3U, video_format_params.size());
+
+  // make sure we don't get a fmtp for codec 122
+  for (size_t i = 0; i < video_format_params.size(); ++i) {
+    ASSERT_NE("122", video_format_params[i].format);
+  }
+}
+
+TEST_P(NewSdpTest, CheckRedFmtpWith2Codecs) {
+  ParseSdp(kVideoWithRedAndUlpfecSdp + "a=fmtp:122 120/121" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+              SdpAttribute::kFmtpAttribute));
+  auto video_format_params =
+      mSdp->GetMediaSection(0).GetAttributeList().GetFmtp().mFmtps;
+  ASSERT_EQ(4U, video_format_params.size());
+
+  ASSERT_EQ("122", video_format_params[3].format);
+  ASSERT_TRUE(!!video_format_params[3].parameters);
+  ASSERT_EQ(SdpRtpmapAttributeList::kRed,
+            video_format_params[3].parameters->codec_type);
+  const SdpFmtpAttributeList::RedParameters* red_parameters(
+      static_cast<SdpFmtpAttributeList::RedParameters*>(
+        video_format_params[3].parameters.get()));
+  ASSERT_EQ(2U, red_parameters->encodings.size());
+  ASSERT_EQ(120U, red_parameters->encodings[0]);
+  ASSERT_EQ(121U, red_parameters->encodings[1]);
+}
+
+TEST_P(NewSdpTest, CheckRedFmtpWith3Codecs) {
+  ParseSdp(kVideoWithRedAndUlpfecSdp + "a=fmtp:122 120/121/123" CRLF);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(1U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+              SdpAttribute::kFmtpAttribute));
+  auto video_format_params =
+      mSdp->GetMediaSection(0).GetAttributeList().GetFmtp().mFmtps;
+  ASSERT_EQ(4U, video_format_params.size());
+
+  ASSERT_EQ("122", video_format_params[3].format);
+  ASSERT_TRUE(!!video_format_params[3].parameters);
+  ASSERT_EQ(SdpRtpmapAttributeList::kRed,
+            video_format_params[3].parameters->codec_type);
+  const SdpFmtpAttributeList::RedParameters* red_parameters(
+      static_cast<SdpFmtpAttributeList::RedParameters*>(
+        video_format_params[3].parameters.get()));
+  ASSERT_EQ(3U, red_parameters->encodings.size());
+  ASSERT_EQ(120U, red_parameters->encodings[0]);
+  ASSERT_EQ(121U, red_parameters->encodings[1]);
+  ASSERT_EQ(123U, red_parameters->encodings[2]);
+}
+
+const std::string kH264AudioVideoOffer =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=ice-ufrag:4a799b2e" CRLF
+"a=ice-pwd:e4cc12a910f106a0a744719425510e17" CRLF
+"a=ice-lite" CRLF
+"a=msid-semantic:WMS stream streama" CRLF
+"a=fingerprint:sha-256 DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C" CRLF
+"a=group:BUNDLE first second" CRLF
+"a=group:BUNDLE third" CRLF
+"a=group:LS first third" CRLF
+"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=mid:first" CRLF
+"a=rtpmap:109 opus/48000/2" CRLF
+"a=ptime:20" CRLF
+"a=maxptime:20" CRLF
+"a=rtpmap:9 G722/8000" CRLF
+"a=rtpmap:0 PCMU/8000" CRLF
+"a=rtpmap:8 PCMA/8000" CRLF
+"a=rtpmap:101 telephone-event/8000" CRLF
+"a=fmtp:109 maxplaybackrate=32000;stereo=1;useinbandfec=1" CRLF
+"a=fmtp:101 0-15,66,32-34,67" CRLF
+"a=ice-ufrag:00000000" CRLF
+"a=ice-pwd:0000000000000000000000000000000" CRLF
+"a=sendonly" CRLF
+"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level" CRLF
+"a=setup:actpass" CRLF
+"a=rtcp-mux" CRLF
+"a=msid:stream track" CRLF
+"a=candidate:0 1 UDP 2130379007 10.0.0.36 62453 typ host" CRLF
+"a=candidate:2 1 UDP 1694236671 24.6.134.204 62453 typ srflx raddr 10.0.0.36 rport 62453" CRLF
+"a=candidate:3 1 UDP 100401151 162.222.183.171 49761 typ relay raddr 162.222.183.171 rport 49761" CRLF
+"a=candidate:6 1 UDP 16515071 162.222.183.171 51858 typ relay raddr 162.222.183.171 rport 51858" CRLF
+"a=candidate:3 2 UDP 100401150 162.222.183.171 62454 typ relay raddr 162.222.183.171 rport 62454" CRLF
+"a=candidate:2 2 UDP 1694236670 24.6.134.204 55428 typ srflx raddr 10.0.0.36 rport 55428" CRLF
+"a=candidate:6 2 UDP 16515070 162.222.183.171 50340 typ relay raddr 162.222.183.171 rport 50340" CRLF
+"a=candidate:0 2 UDP 2130379006 10.0.0.36 55428 typ host" CRLF
+"m=video 9 RTP/SAVPF 97 98 120" CRLF
+"c=IN IP6 ::1" CRLF
+"a=mid:second" CRLF
+"a=rtpmap:97 H264/90000" CRLF
+"a=fmtp:97 profile-level-id=42a01e" CRLF
+"a=rtpmap:98 H264/90000" CRLF
+"a=fmtp:98 PROFILE=0;LEVEL=0;profile-level-id=42a00d;packetization-mode=1;level-asymmetry-allowed=1;max-mbps=42000;max-fs=1400;max-cpb=1000;max-dpb=1000;max-br=180000;parameter-add=1;usedtx=0;stereo=0;useinbandfec=0;cbr=0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF
+"a=fmtp:120 max-fs=3601;max-fr=31" CRLF
+"a=recvonly" CRLF
+"a=setup:active" CRLF
+"a=rtcp-mux" CRLF
+"a=msid:streama tracka" CRLF
+"a=msid:streamb trackb" CRLF
+"a=candidate:0 1 UDP 2130379007 10.0.0.36 59530 typ host" CRLF
+"a=candidate:0 2 UDP 2130379006 10.0.0.36 64378 typ host" CRLF
+"a=candidate:2 2 UDP 1694236670 24.6.134.204 64378 typ srflx raddr 10.0.0.36 rport 64378" CRLF
+"a=candidate:6 2 UDP 16515070 162.222.183.171 64941 typ relay raddr 162.222.183.171 rport 64941" CRLF
+"a=candidate:6 1 UDP 16515071 162.222.183.171 64800 typ relay raddr 162.222.183.171 rport 64800" CRLF
+"a=candidate:2 1 UDP 1694236671 24.6.134.204 59530 typ srflx raddr 10.0.0.36 rport 59530" CRLF
+"a=candidate:3 1 UDP 100401151 162.222.183.171 62935 typ relay raddr 162.222.183.171 rport 62935" CRLF
+"a=candidate:3 2 UDP 100401150 162.222.183.171 61026 typ relay raddr 162.222.183.171 rport 61026" CRLF
+"m=audio 9 RTP/SAVPF 0" CRLF
+"a=mid:third" CRLF
+"a=rtpmap:0 PCMU/8000" CRLF
+"a=ice-lite" CRLF
+"a=msid:noappdata" CRLF;
+
+TEST_P(NewSdpTest, CheckFormatParameters) {
+  ParseSdp(kH264AudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kFmtpAttribute));
+  auto audio_format_params =
+      mSdp->GetMediaSection(0).GetAttributeList().GetFmtp().mFmtps;
+  ASSERT_EQ(2U, audio_format_params.size());
+  ASSERT_EQ("109", audio_format_params[0].format);
+  ASSERT_TRUE(!!audio_format_params[0].parameters);
+  const SdpFmtpAttributeList::OpusParameters* opus_parameters =
+    static_cast<SdpFmtpAttributeList::OpusParameters*>(
+        audio_format_params[0].parameters.get());
+  ASSERT_EQ(32000U, opus_parameters->maxplaybackrate);
+  ASSERT_EQ(1U, opus_parameters->stereo);
+  ASSERT_EQ(1U, opus_parameters->useInBandFec);
+  ASSERT_EQ("101", audio_format_params[1].format);
+  ASSERT_TRUE(!!audio_format_params[1].parameters);
+  const SdpFmtpAttributeList::TelephoneEventParameters* te_parameters =
+    static_cast<SdpFmtpAttributeList::TelephoneEventParameters*>(
+        audio_format_params[1].parameters.get());
+  ASSERT_NE(0U, te_parameters->dtmfTones.size());
+  ASSERT_EQ("0-15,66,32-34,67", te_parameters->dtmfTones);
+
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kFmtpAttribute));
+  auto video_format_params =
+      mSdp->GetMediaSection(1).GetAttributeList().GetFmtp().mFmtps;
+  ASSERT_EQ(3U, video_format_params.size());
+  ASSERT_EQ("97", video_format_params[0].format);
+  ASSERT_TRUE(!!video_format_params[0].parameters);
+  ASSERT_EQ(SdpRtpmapAttributeList::kH264,
+            video_format_params[0].parameters->codec_type);
+  const SdpFmtpAttributeList::H264Parameters *h264_parameters(
+      static_cast<SdpFmtpAttributeList::H264Parameters*>(
+        video_format_params[0].parameters.get()));
+  ASSERT_EQ((uint32_t)0x42a01e, h264_parameters->profile_level_id);
+  ASSERT_EQ(0U, h264_parameters->packetization_mode);
+  ASSERT_FALSE(static_cast<bool>(h264_parameters->level_asymmetry_allowed));
+  ASSERT_EQ(0U, h264_parameters->max_mbps);
+  ASSERT_EQ(0U, h264_parameters->max_fs);
+  ASSERT_EQ(0U, h264_parameters->max_cpb);
+  ASSERT_EQ(0U, h264_parameters->max_dpb);
+  ASSERT_EQ(0U, h264_parameters->max_br);
+
+  ASSERT_EQ("98", video_format_params[1].format);
+  ASSERT_TRUE(!!video_format_params[1].parameters);
+  ASSERT_EQ(SdpRtpmapAttributeList::kH264,
+            video_format_params[1].parameters->codec_type);
+  h264_parameters =
+      static_cast<SdpFmtpAttributeList::H264Parameters*>(
+        video_format_params[1].parameters.get());
+  ASSERT_EQ((uint32_t)0x42a00d, h264_parameters->profile_level_id);
+  ASSERT_EQ(1U, h264_parameters->packetization_mode);
+  ASSERT_TRUE(static_cast<bool>(h264_parameters->level_asymmetry_allowed));
+  ASSERT_EQ(42000U, h264_parameters->max_mbps);
+  ASSERT_EQ(1400U, h264_parameters->max_fs);
+  ASSERT_EQ(1000U, h264_parameters->max_cpb);
+  ASSERT_EQ(1000U, h264_parameters->max_dpb);
+  ASSERT_EQ(180000U, h264_parameters->max_br);
+
+  ASSERT_EQ("120", video_format_params[2].format);
+  ASSERT_TRUE(!!video_format_params[2].parameters);
+  ASSERT_EQ(SdpRtpmapAttributeList::kVP8,
+            video_format_params[2].parameters->codec_type);
+  const SdpFmtpAttributeList::VP8Parameters *vp8_parameters =
+      static_cast<SdpFmtpAttributeList::VP8Parameters*>(
+        video_format_params[2].parameters.get());
+  ASSERT_EQ(3601U, vp8_parameters->max_fs);
+  ASSERT_EQ(31U, vp8_parameters->max_fr);
+
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kFmtpAttribute));
+}
+
+TEST_P(NewSdpTest, CheckPtime) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_EQ(20U, mSdp->GetMediaSection(0).GetAttributeList().GetPtime());
+  ASSERT_FALSE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kPtimeAttribute));
+}
+
+TEST_P(NewSdpTest, CheckFlags) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+      SdpAttribute::kIceLiteAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kIceLiteAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kIceLiteAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kIceLiteAttribute));
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kRtcpMuxAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kRtcpMuxAttribute));
+
+  ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kBundleOnlyAttribute));
+  ASSERT_TRUE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kBundleOnlyAttribute));
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kEndOfCandidatesAttribute));
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kEndOfCandidatesAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kEndOfCandidatesAttribute));
+}
+
+TEST_P(NewSdpTest, CheckConnectionLines) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  const SdpConnection& conn1 = mSdp->GetMediaSection(0).GetConnection();
+  ASSERT_EQ(sdp::kIPv4, conn1.GetAddrType());
+  ASSERT_EQ("0.0.0.0", conn1.GetAddress());
+  ASSERT_EQ(0U, conn1.GetTtl());
+  ASSERT_EQ(0U, conn1.GetCount());
+
+  const SdpConnection& conn2 = mSdp->GetMediaSection(1).GetConnection();
+  ASSERT_EQ(sdp::kIPv6, conn2.GetAddrType());
+  ASSERT_EQ("::1", conn2.GetAddress());
+  ASSERT_EQ(0U, conn2.GetTtl());
+  ASSERT_EQ(0U, conn2.GetCount());
+
+  // tests that we can fall through to session level as appropriate
+  const SdpConnection& conn3 = mSdp->GetMediaSection(2).GetConnection();
+  ASSERT_EQ(sdp::kIPv4, conn3.GetAddrType());
+  ASSERT_EQ("224.0.0.1", conn3.GetAddress());
+  ASSERT_EQ(100U, conn3.GetTtl());
+  ASSERT_EQ(12U, conn3.GetCount());
+}
+
+TEST_P(NewSdpTest, CheckDirections) {
+  ParseSdp(kBasicAudioVideoOffer);
+
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(SdpDirectionAttribute::kSendonly,
+            mSdp->GetMediaSection(0).GetAttributeList().GetDirection());
+  ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
+            mSdp->GetMediaSection(1).GetAttributeList().GetDirection());
+  ASSERT_EQ(SdpDirectionAttribute::kSendrecv,
+            mSdp->GetMediaSection(2).GetAttributeList().GetDirection());
+}
+
+TEST_P(NewSdpTest, CheckCandidates) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+      SdpAttribute::kCandidateAttribute));
+  auto audio_candidates =
+      mSdp->GetMediaSection(0).GetAttributeList().GetCandidate();
+  ASSERT_EQ(8U, audio_candidates.size());
+  ASSERT_EQ("0 1 UDP 2130379007 10.0.0.36 62453 typ host", audio_candidates[0]);
+  ASSERT_EQ("2 1 UDP 1694236671 24.6.134.204 62453 typ srflx raddr 10.0.0.36 rport 62453", audio_candidates[1]);
+  ASSERT_EQ("3 1 UDP 100401151 162.222.183.171 49761 typ relay raddr 162.222.183.171 rport 49761", audio_candidates[2]);
+  ASSERT_EQ("6 1 UDP 16515071 162.222.183.171 51858 typ relay raddr 162.222.183.171 rport 51858", audio_candidates[3]);
+  ASSERT_EQ("3 2 UDP 100401150 162.222.183.171 62454 typ relay raddr 162.222.183.171 rport 62454", audio_candidates[4]);
+  ASSERT_EQ("2 2 UDP 1694236670 24.6.134.204 55428 typ srflx raddr 10.0.0.36 rport 55428", audio_candidates[5]);
+  ASSERT_EQ("6 2 UDP 16515070 162.222.183.171 50340 typ relay raddr 162.222.183.171 rport 50340", audio_candidates[6]);
+  ASSERT_EQ("0 2 UDP 2130379006 10.0.0.36 55428 typ host", audio_candidates[7]);
+
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+      SdpAttribute::kCandidateAttribute));
+  auto video_candidates =
+      mSdp->GetMediaSection(1).GetAttributeList().GetCandidate();
+  ASSERT_EQ(8U, video_candidates.size());
+  ASSERT_EQ("0 1 UDP 2130379007 10.0.0.36 59530 typ host", video_candidates[0]);
+  ASSERT_EQ("0 2 UDP 2130379006 10.0.0.36 64378 typ host", video_candidates[1]);
+  ASSERT_EQ("2 2 UDP 1694236670 24.6.134.204 64378 typ srflx raddr 10.0.0.36 rport 64378", video_candidates[2]);
+  ASSERT_EQ("6 2 UDP 16515070 162.222.183.171 64941 typ relay raddr 162.222.183.171 rport 64941", video_candidates[3]);
+  ASSERT_EQ("6 1 UDP 16515071 162.222.183.171 64800 typ relay raddr 162.222.183.171 rport 64800", video_candidates[4]);
+  ASSERT_EQ("2 1 UDP 1694236671 24.6.134.204 59530 typ srflx raddr 10.0.0.36 rport 59530", video_candidates[5]);
+  ASSERT_EQ("3 1 UDP 100401151 162.222.183.171 62935 typ relay raddr 162.222.183.171 rport 62935", video_candidates[6]);
+  ASSERT_EQ("3 2 UDP 100401150 162.222.183.171 61026 typ relay raddr 162.222.183.171 rport 61026", video_candidates[7]);
+
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kCandidateAttribute));
+}
+
+TEST_P(NewSdpTest, CheckMid) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_EQ("first", mSdp->GetMediaSection(0).GetAttributeList().GetMid());
+  ASSERT_EQ("second", mSdp->GetMediaSection(1).GetAttributeList().GetMid());
+  ASSERT_EQ("third", mSdp->GetMediaSection(2).GetAttributeList().GetMid());
+}
+
+TEST_P(NewSdpTest, CheckMsid) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+      SdpAttribute::kMsidSemanticAttribute));
+  auto semantics = mSdp->GetAttributeList().GetMsidSemantic().mMsidSemantics;
+  ASSERT_EQ(2U, semantics.size());
+  ASSERT_EQ("WMS", semantics[0].semantic);
+  ASSERT_EQ(2U, semantics[0].msids.size());
+  ASSERT_EQ("stream", semantics[0].msids[0]);
+  ASSERT_EQ("streama", semantics[0].msids[1]);
+  ASSERT_EQ("foo", semantics[1].semantic);
+  ASSERT_EQ(1U, semantics[1].msids.size());
+  ASSERT_EQ("stream", semantics[1].msids[0]);
+
+
+  const SdpMsidAttributeList& msids1 =
+      mSdp->GetMediaSection(0).GetAttributeList().GetMsid();
+  ASSERT_EQ(1U, msids1.mMsids.size());
+  ASSERT_EQ("stream", msids1.mMsids[0].identifier);
+  ASSERT_EQ("track", msids1.mMsids[0].appdata);
+  const SdpMsidAttributeList& msids2 =
+      mSdp->GetMediaSection(1).GetAttributeList().GetMsid();
+  ASSERT_EQ(2U, msids2.mMsids.size());
+  ASSERT_EQ("streama", msids2.mMsids[0].identifier);
+  ASSERT_EQ("tracka", msids2.mMsids[0].appdata);
+  ASSERT_EQ("streamb", msids2.mMsids[1].identifier);
+  ASSERT_EQ("trackb", msids2.mMsids[1].appdata);
+  const SdpMsidAttributeList& msids3 =
+      mSdp->GetMediaSection(2).GetAttributeList().GetMsid();
+  ASSERT_EQ(1U, msids3.mMsids.size());
+  ASSERT_EQ("noappdata", msids3.mMsids[0].identifier);
+  ASSERT_EQ("", msids3.mMsids[0].appdata);
+}
+
+TEST_P(NewSdpTest, CheckRid)
+{
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp);
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kRidAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kRidAttribute));
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+        SdpAttribute::kRidAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+        SdpAttribute::kRidAttribute));
+
+  const SdpRidAttributeList& rids =
+    mSdp->GetMediaSection(1).GetAttributeList().GetRid();
+
+  ASSERT_EQ(1U, rids.mRids.size());
+  ASSERT_EQ("bar", rids.mRids[0].id);
+  ASSERT_EQ(sdp::kRecv, rids.mRids[0].direction);
+  ASSERT_EQ(1U, rids.mRids[0].formats.size());
+  ASSERT_EQ(96U, rids.mRids[0].formats[0]);
+  ASSERT_EQ(800U, rids.mRids[0].constraints.maxWidth);
+  ASSERT_EQ(600U, rids.mRids[0].constraints.maxHeight);
+}
+
+TEST_P(NewSdpTest, CheckMediaLevelIceUfrag) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kIceUfragAttribute, true));
+  ASSERT_EQ("00000000",
+            mSdp->GetMediaSection(0).GetAttributeList().GetIceUfrag());
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kIceUfragAttribute, false));
+
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+        SdpAttribute::kIceUfragAttribute, true));
+  ASSERT_EQ("4a799b2e",
+            mSdp->GetMediaSection(1).GetAttributeList().GetIceUfrag());
+}
+
+TEST_P(NewSdpTest, CheckMediaLevelIcePwd) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kIcePwdAttribute));
+  ASSERT_EQ("0000000000000000000000000000000",
+            mSdp->GetMediaSection(0).GetAttributeList().GetIcePwd());
+
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+        SdpAttribute::kIcePwdAttribute));
+  ASSERT_EQ("e4cc12a910f106a0a744719425510e17",
+            mSdp->GetMediaSection(1).GetAttributeList().GetIcePwd());
+}
+
+TEST_P(NewSdpTest, CheckGroups) {
+  ParseSdp(kBasicAudioVideoOffer);
+  const SdpGroupAttributeList& group = mSdp->GetAttributeList().GetGroup();
+  const SdpGroupAttributeList::Group& group1 = group.mGroups[0];
+  ASSERT_EQ(SdpGroupAttributeList::kBundle, group1.semantics);
+  ASSERT_EQ(2U, group1.tags.size());
+  ASSERT_EQ("first", group1.tags[0]);
+  ASSERT_EQ("second", group1.tags[1]);
+
+  const SdpGroupAttributeList::Group& group2 = group.mGroups[1];
+  ASSERT_EQ(SdpGroupAttributeList::kBundle, group2.semantics);
+  ASSERT_EQ(1U, group2.tags.size());
+  ASSERT_EQ("third", group2.tags[0]);
+
+  const SdpGroupAttributeList::Group& group3 = group.mGroups[2];
+  ASSERT_EQ(SdpGroupAttributeList::kLs, group3.semantics);
+  ASSERT_EQ(2U, group3.tags.size());
+  ASSERT_EQ("first", group3.tags[0]);
+  ASSERT_EQ("third", group3.tags[1]);
+}
+
+// SDP from a basic A/V call with data channel FFX/FFX
+const std::string kBasicAudioVideoDataOffer =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 27987 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"t=0 0" CRLF
+"a=ice-ufrag:8a39d2ae" CRLF
+"a=ice-pwd:601d53aba51a318351b3ecf5ee00048f" CRLF
+"a=fingerprint:sha-256 30:FF:8E:2B:AC:9D:ED:70:18:10:67:C8:AE:9E:68:F3:86:53:51:B0:AC:31:B7:BE:6D:CF:A4:2E:D3:6E:B4:28" CRLF
+"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:109 opus/48000/2" CRLF
+"a=ptime:20" CRLF
+"a=rtpmap:9 G722/8000" CRLF
+"a=rtpmap:0 PCMU/8000" CRLF
+"a=rtpmap:8 PCMA/8000" CRLF
+"a=rtpmap:101 telephone-event/8000" CRLF
+"a=fmtp:101 0-15" CRLF
+"a=sendrecv" CRLF
+"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level" CRLF
+"a=extmap:2/sendonly some_extension" CRLF
+"a=extmap:3 some_other_extension some_params some more params" CRLF
+"a=setup:actpass" CRLF
+"a=rtcp-mux" CRLF
+"m=video 9 RTP/SAVPF 120 126 97" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF
+"a=rtpmap:126 H264/90000" CRLF
+"a=fmtp:126 profile-level-id=42e01f;packetization-mode=1" CRLF
+"a=rtpmap:97 H264/90000" CRLF
+"a=fmtp:97 profile-level-id=42e01f" CRLF
+"a=sendrecv" CRLF
+// sipcc barfs on this, despite that it is valid syntax
+// Do we care about fixing?
+//"a=rtcp-fb:120 ack" CRLF // Should be ignored by sipcc
+"a=rtcp-fb:120 ack rpsi" CRLF
+"a=rtcp-fb:120 ack app foo" CRLF
+"a=rtcp-fb:120 ack foo" CRLF // Should be ignored
+"a=rtcp-fb:120 nack" CRLF
+"a=rtcp-fb:120 nack sli" CRLF
+"a=rtcp-fb:120 nack pli" CRLF
+"a=rtcp-fb:120 nack rpsi" CRLF
+"a=rtcp-fb:120 nack app foo" CRLF
+"a=rtcp-fb:120 nack foo" CRLF // Should be ignored
+"a=rtcp-fb:120 ccm fir" CRLF
+"a=rtcp-fb:120 ccm tmmbr" CRLF
+"a=rtcp-fb:120 ccm tstr" CRLF
+"a=rtcp-fb:120 ccm vbcm" CRLF
+"a=rtcp-fb:120 ccm foo" CRLF // Should be ignored
+"a=rtcp-fb:120 trr-int 10" CRLF
+"a=rtcp-fb:120 goog-remb" CRLF
+"a=rtcp-fb:120 foo" CRLF // Should be ignored
+"a=rtcp-fb:126 nack" CRLF
+"a=rtcp-fb:126 nack pli" CRLF
+"a=rtcp-fb:126 ccm fir" CRLF
+"a=rtcp-fb:97 nack" CRLF
+"a=rtcp-fb:97 nack pli" CRLF
+"a=rtcp-fb:97 ccm fir" CRLF
+"a=rtcp-fb:* ccm tmmbr" CRLF
+"a=setup:actpass" CRLF
+"a=rtcp-mux" CRLF
+"m=application 9 DTLS/SCTP 5000" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=sctpmap:5000 webrtc-datachannel 16" CRLF
+"a=setup:actpass" CRLF;
+
+TEST_P(NewSdpTest, BasicAudioVideoDataSdpParse) {
+  ParseSdp(kBasicAudioVideoDataOffer);
+  ASSERT_EQ(0U, mParser.GetParseErrors().size()) <<
+    "Got parse errors: " << GetParseErrors();
+}
+
+TEST_P(NewSdpTest, CheckApplicationParameters) {
+  ParseSdp(kBasicAudioVideoDataOffer);
+  ASSERT_TRUE(!!mSdp);
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+  ASSERT_EQ(SdpMediaSection::kAudio, mSdp->GetMediaSection(0).GetMediaType())
+    << "Wrong type for first media section";
+  ASSERT_EQ(SdpMediaSection::kVideo, mSdp->GetMediaSection(1).GetMediaType())
+    << "Wrong type for second media section";
+  ASSERT_EQ(SdpMediaSection::kApplication, mSdp->GetMediaSection(2).GetMediaType())
+    << "Wrong type for third media section";
+
+  ASSERT_EQ(SdpMediaSection::kDtlsSctp,
+            mSdp->GetMediaSection(2).GetProtocol())
+    << "Wrong protocol for application";
+  auto app_formats = mSdp->GetMediaSection(2).GetFormats();
+  ASSERT_EQ(1U, app_formats.size()) << "Wrong number of formats for audio";
+  ASSERT_EQ("5000", app_formats[0]);
+
+  const SdpConnection& conn3 = mSdp->GetMediaSection(2).GetConnection();
+  ASSERT_EQ(sdp::kIPv4, conn3.GetAddrType());
+  ASSERT_EQ("0.0.0.0", conn3.GetAddress());
+  ASSERT_EQ(0U, conn3.GetTtl());
+  ASSERT_EQ(0U, conn3.GetCount());
+
+  ASSERT_TRUE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+      SdpAttribute::kSetupAttribute));
+  ASSERT_EQ(SdpSetupAttribute::kActpass,
+      mSdp->GetMediaSection(2).GetAttributeList().GetSetup().mRole);
+}
+
+TEST_P(NewSdpTest, CheckExtmap) {
+  ParseSdp(kBasicAudioVideoDataOffer);
+  ASSERT_TRUE(!!mSdp);
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kExtmapAttribute));
+
+  auto extmaps =
+    mSdp->GetMediaSection(0).GetAttributeList().GetExtmap().mExtmaps;
+  ASSERT_EQ(3U, extmaps.size());
+
+  ASSERT_EQ(1U, extmaps[0].entry);
+  ASSERT_FALSE(extmaps[0].direction_specified);
+  ASSERT_EQ("urn:ietf:params:rtp-hdrext:ssrc-audio-level",
+      extmaps[0].extensionname);
+  ASSERT_EQ("",
+      extmaps[0].extensionattributes);
+
+  ASSERT_EQ(2U, extmaps[1].entry);
+  ASSERT_TRUE(extmaps[1].direction_specified);
+  ASSERT_EQ(SdpDirectionAttribute::kSendonly, extmaps[1].direction);
+  ASSERT_EQ("some_extension",
+      extmaps[1].extensionname);
+  ASSERT_EQ("",
+      extmaps[1].extensionattributes);
+
+  ASSERT_EQ(3U, extmaps[2].entry);
+  ASSERT_FALSE(extmaps[2].direction_specified);
+  ASSERT_EQ("some_other_extension",
+      extmaps[2].extensionname);
+  ASSERT_EQ("some_params some more params",
+      extmaps[2].extensionattributes);
+}
+
+TEST_P(NewSdpTest, CheckRtcpFb) {
+  ParseSdp(kBasicAudioVideoDataOffer);
+  ASSERT_TRUE(!!mSdp);
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  auto& video_attrs = mSdp->GetMediaSection(1).GetAttributeList();
+  ASSERT_TRUE(video_attrs.HasAttribute(SdpAttribute::kRtcpFbAttribute));
+  auto& rtcpfbs = video_attrs.GetRtcpFb().mFeedbacks;
+  ASSERT_EQ(20U, rtcpfbs.size());
+  CheckRtcpFb(rtcpfbs[0], "120", SdpRtcpFbAttributeList::kAck, "rpsi");
+  CheckRtcpFb(rtcpfbs[1], "120", SdpRtcpFbAttributeList::kAck, "app", "foo");
+  CheckRtcpFb(rtcpfbs[2], "120", SdpRtcpFbAttributeList::kNack, "");
+  CheckRtcpFb(rtcpfbs[3], "120", SdpRtcpFbAttributeList::kNack, "sli");
+  CheckRtcpFb(rtcpfbs[4], "120", SdpRtcpFbAttributeList::kNack, "pli");
+  CheckRtcpFb(rtcpfbs[5], "120", SdpRtcpFbAttributeList::kNack, "rpsi");
+  CheckRtcpFb(rtcpfbs[6], "120", SdpRtcpFbAttributeList::kNack, "app", "foo");
+  CheckRtcpFb(rtcpfbs[7], "120", SdpRtcpFbAttributeList::kCcm, "fir");
+  CheckRtcpFb(rtcpfbs[8], "120", SdpRtcpFbAttributeList::kCcm, "tmmbr");
+  CheckRtcpFb(rtcpfbs[9], "120", SdpRtcpFbAttributeList::kCcm, "tstr");
+  CheckRtcpFb(rtcpfbs[10], "120", SdpRtcpFbAttributeList::kCcm, "vbcm");
+  CheckRtcpFb(rtcpfbs[11], "120", SdpRtcpFbAttributeList::kTrrInt, "10");
+  CheckRtcpFb(rtcpfbs[12], "120", SdpRtcpFbAttributeList::kRemb, "");
+  CheckRtcpFb(rtcpfbs[13], "126", SdpRtcpFbAttributeList::kNack, "");
+  CheckRtcpFb(rtcpfbs[14], "126", SdpRtcpFbAttributeList::kNack, "pli");
+  CheckRtcpFb(rtcpfbs[15], "126", SdpRtcpFbAttributeList::kCcm, "fir");
+  CheckRtcpFb(rtcpfbs[16], "97",  SdpRtcpFbAttributeList::kNack, "");
+  CheckRtcpFb(rtcpfbs[17], "97",  SdpRtcpFbAttributeList::kNack, "pli");
+  CheckRtcpFb(rtcpfbs[18], "97", SdpRtcpFbAttributeList::kCcm, "fir");
+  CheckRtcpFb(rtcpfbs[19], "*", SdpRtcpFbAttributeList::kCcm, "tmmbr");
+}
+
+TEST_P(NewSdpTest, CheckRtcp) {
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp);
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kRtcpAttribute));
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kRtcpAttribute));
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+        SdpAttribute::kRtcpAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+        SdpAttribute::kRtcpAttribute));
+
+  auto& rtcpAttr_0 = mSdp->GetMediaSection(0).GetAttributeList().GetRtcp();
+  ASSERT_EQ(62454U, rtcpAttr_0.mPort);
+  ASSERT_EQ(sdp::kInternet, rtcpAttr_0.mNetType);
+  ASSERT_EQ(sdp::kIPv4, rtcpAttr_0.mAddrType);
+  ASSERT_EQ("162.222.183.171", rtcpAttr_0.mAddress);
+
+  auto& rtcpAttr_1 = mSdp->GetMediaSection(1).GetAttributeList().GetRtcp();
+  ASSERT_EQ(61026U, rtcpAttr_1.mPort);
+  ASSERT_EQ("", rtcpAttr_1.mAddress);
+}
+
+TEST_P(NewSdpTest, CheckImageattr)
+{
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp);
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kImageattrAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kImageattrAttribute));
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+        SdpAttribute::kImageattrAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+        SdpAttribute::kImageattrAttribute));
+
+  const SdpImageattrAttributeList& imageattrs =
+    mSdp->GetMediaSection(1).GetAttributeList().GetImageattr();
+
+  ASSERT_EQ(2U, imageattrs.mImageattrs.size());
+  const SdpImageattrAttributeList::Imageattr& imageattr_0(
+      imageattrs.mImageattrs[0]);
+  ASSERT_TRUE(imageattr_0.pt.isSome());
+  ASSERT_EQ(120U, *imageattr_0.pt);
+  ASSERT_TRUE(imageattr_0.sendAll);
+  ASSERT_TRUE(imageattr_0.recvAll);
+
+  const SdpImageattrAttributeList::Imageattr& imageattr_1(
+      imageattrs.mImageattrs[1]);
+  ASSERT_TRUE(imageattr_1.pt.isSome());
+  ASSERT_EQ(121U, *imageattr_1.pt);
+  ASSERT_FALSE(imageattr_1.sendAll);
+  ASSERT_FALSE(imageattr_1.recvAll);
+  ASSERT_EQ(1U, imageattr_1.sendSets.size());
+  ASSERT_EQ(1U, imageattr_1.sendSets[0].xRange.discreteValues.size());
+  ASSERT_EQ(640U, imageattr_1.sendSets[0].xRange.discreteValues.front());
+  ASSERT_EQ(1U, imageattr_1.sendSets[0].yRange.discreteValues.size());
+  ASSERT_EQ(480U, imageattr_1.sendSets[0].yRange.discreteValues.front());
+  ASSERT_EQ(1U, imageattr_1.recvSets.size());
+  ASSERT_EQ(1U, imageattr_1.recvSets[0].xRange.discreteValues.size());
+  ASSERT_EQ(640U, imageattr_1.recvSets[0].xRange.discreteValues.front());
+  ASSERT_EQ(1U, imageattr_1.recvSets[0].yRange.discreteValues.size());
+  ASSERT_EQ(480U, imageattr_1.recvSets[0].yRange.discreteValues.front());
+}
+
+TEST_P(NewSdpTest, CheckSimulcast)
+{
+  ParseSdp(kBasicAudioVideoOffer);
+  ASSERT_TRUE(!!mSdp);
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount()) << "Wrong number of media sections";
+
+  ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kSimulcastAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kSimulcastAttribute));
+  ASSERT_TRUE(mSdp->GetMediaSection(1).GetAttributeList().HasAttribute(
+        SdpAttribute::kSimulcastAttribute));
+  ASSERT_FALSE(mSdp->GetMediaSection(2).GetAttributeList().HasAttribute(
+        SdpAttribute::kSimulcastAttribute));
+
+  const SdpSimulcastAttribute& simulcast =
+    mSdp->GetMediaSection(1).GetAttributeList().GetSimulcast();
+
+  ASSERT_EQ(2U, simulcast.recvVersions.size());
+  ASSERT_EQ(0U, simulcast.sendVersions.size());
+  ASSERT_EQ(1U, simulcast.recvVersions[0].choices.size());
+  ASSERT_EQ("120", simulcast.recvVersions[0].choices[0]);
+  ASSERT_EQ(1U, simulcast.recvVersions[1].choices.size());
+  ASSERT_EQ("121", simulcast.recvVersions[1].choices[0]);
+  ASSERT_EQ(SdpSimulcastAttribute::Versions::kPt,
+            simulcast.recvVersions.type);
+}
+
+TEST_P(NewSdpTest, CheckSctpmap) {
+  ParseSdp(kBasicAudioVideoDataOffer);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+  ASSERT_EQ(3U, mSdp->GetMediaSectionCount())
+    << "Wrong number of media sections";
+
+  const SdpMediaSection& appsec = mSdp->GetMediaSection(2);
+  ASSERT_TRUE(
+      appsec.GetAttributeList().HasAttribute(SdpAttribute::kSctpmapAttribute));
+  const SdpSctpmapAttributeList& sctpmap =
+    appsec.GetAttributeList().GetSctpmap();
+
+  ASSERT_EQ(1U, sctpmap.mSctpmaps.size())
+    << "Wrong number of sctpmap attributes";
+  ASSERT_EQ(1U, appsec.GetFormats().size());
+
+  // Need to know name of type
+  CheckSctpmap("5000",
+              "webrtc-datachannel",
+              16,
+              appsec.GetFormats()[0],
+              sctpmap);
+}
+
+const std::string kNewSctpmapOfferDraft07 =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 27987 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"t=0 0" CRLF
+"a=ice-ufrag:8a39d2ae" CRLF
+"a=ice-pwd:601d53aba51a318351b3ecf5ee00048f" CRLF
+"a=fingerprint:sha-256 30:FF:8E:2B:AC:9D:ED:70:18:10:67:C8:AE:9E:68:F3:86:53:51:B0:AC:31:B7:BE:6D:CF:A4:2E:D3:6E:B4:28" CRLF
+"m=application 9 DTLS/SCTP webrtc-datachannel" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=fmtp:webrtc-datachannel max-message-size=100000" CRLF
+"a=sctp-port 5000" CRLF
+"a=setup:actpass" CRLF;
+
+TEST_P(NewSdpTest, NewSctpmapSdpParse) {
+  ParseSdp(kNewSctpmapOfferDraft07, false);
+}
+
+INSTANTIATE_TEST_CASE_P(RoundTripSerialize,
+                        NewSdpTest,
+                        ::testing::Values(false, true));
+
+const std::string kCandidateInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=candidate:0 1 UDP 2130379007 10.0.0.36 62453 typ host" CRLF
+"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:109 opus/48000/2" CRLF;
+
+// This may or may not parse, but if it does, the errant candidate attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckCandidateInSessionLevel) {
+  ParseSdp(kCandidateInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kCandidateAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kCandidateAttribute));
+  }
+}
+
+const std::string kBundleOnlyInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=bundle-only" CRLF
+"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:109 opus/48000/2" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckBundleOnlyInSessionLevel) {
+  ParseSdp(kBundleOnlyInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kBundleOnlyAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kBundleOnlyAttribute));
+  }
+}
+
+const std::string kFmtpInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=fmtp:109 0-15" CRLF
+"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:109 opus/48000/2" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckFmtpInSessionLevel) {
+  ParseSdp(kFmtpInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kFmtpAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kFmtpAttribute));
+  }
+}
+
+const std::string kIceMismatchInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=ice-mismatch" CRLF
+"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:109 opus/48000/2" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckIceMismatchInSessionLevel) {
+  ParseSdp(kIceMismatchInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kIceMismatchAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kIceMismatchAttribute));
+  }
+}
+
+const std::string kImageattrInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=imageattr:120 send * recv *" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckImageattrInSessionLevel) {
+  ParseSdp(kImageattrInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kImageattrAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kImageattrAttribute));
+  }
+}
+
+const std::string kLabelInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=label:foobar" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckLabelInSessionLevel) {
+  ParseSdp(kLabelInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kLabelAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kLabelAttribute));
+  }
+}
+
+const std::string kMaxptimeInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=maxptime:100" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckMaxptimeInSessionLevel) {
+  ParseSdp(kMaxptimeInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kMaxptimeAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kMaxptimeAttribute));
+  }
+}
+
+const std::string kMidInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=mid:foobar" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckMidInSessionLevel) {
+  ParseSdp(kMidInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kMidAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kMidAttribute));
+  }
+}
+
+const std::string kMsidInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=msid:foobar" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckMsidInSessionLevel) {
+  ParseSdp(kMsidInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kMsidAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kMsidAttribute));
+  }
+}
+
+const std::string kPtimeInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=ptime:50" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckPtimeInSessionLevel) {
+  ParseSdp(kPtimeInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kPtimeAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kPtimeAttribute));
+  }
+}
+
+const std::string kRemoteCandidatesInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=remote-candidates:0 10.0.0.1 5555" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckRemoteCandidatesInSessionLevel) {
+  ParseSdp(kRemoteCandidatesInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kRemoteCandidatesAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kRemoteCandidatesAttribute));
+  }
+}
+
+const std::string kRtcpInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=rtcp:5555" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckRtcpInSessionLevel) {
+  ParseSdp(kRtcpInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kRtcpAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kRtcpAttribute));
+  }
+}
+
+const std::string kRtcpFbInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=rtcp-fb:120 nack" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckRtcpFbInSessionLevel) {
+  ParseSdp(kRtcpFbInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kRtcpFbAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kRtcpFbAttribute));
+  }
+}
+
+const std::string kRtcpMuxInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=rtcp-mux" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckRtcpMuxInSessionLevel) {
+  ParseSdp(kRtcpMuxInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kRtcpMuxAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kRtcpMuxAttribute));
+  }
+}
+
+const std::string kRtcpRsizeInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=rtcp-rsize" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckRtcpRsizeInSessionLevel) {
+  ParseSdp(kRtcpRsizeInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kRtcpRsizeAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kRtcpRsizeAttribute));
+  }
+}
+
+const std::string kRtpmapInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckRtpmapInSessionLevel) {
+  ParseSdp(kRtpmapInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kRtpmapAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kRtpmapAttribute));
+  }
+}
+
+const std::string kSctpmapInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=sctpmap:5000" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckSctpmapInSessionLevel) {
+  ParseSdp(kSctpmapInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kSctpmapAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kSctpmapAttribute));
+  }
+}
+
+const std::string kSsrcInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=ssrc:5000" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckSsrcInSessionLevel) {
+  ParseSdp(kSsrcInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kSsrcAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kSsrcAttribute));
+  }
+}
+
+const std::string kSsrcGroupInSessionSDP =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"a=ssrc-group:FID 5000" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+// This may or may not parse, but if it does, the errant attribute
+// should be ignored.
+TEST_P(NewSdpTest, CheckSsrcGroupInSessionLevel) {
+  ParseSdp(kSsrcGroupInSessionSDP, false);
+  if (mSdp) {
+    ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+          SdpAttribute::kSsrcGroupAttribute));
+    ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+          SdpAttribute::kSsrcGroupAttribute));
+  }
+}
+
+const std::string kMalformedImageattr =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF
+"a=imageattr:flob" CRLF;
+
+TEST_P(NewSdpTest, CheckMalformedImageattr)
+{
+  if (GetParam()) {
+    // Don't do a parse/serialize before running this test
+    return;
+  }
+
+  ParseSdp(kMalformedImageattr, false);
+  ASSERT_NE("", GetParseErrors());
+}
+
+TEST_P(NewSdpTest, ParseInvalidSimulcastNoSuchSendRid) {
+  ParseSdp("v=0" CRLF
+           "o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
+           "s=SIP Call" CRLF
+           "c=IN IP4 198.51.100.7" CRLF
+           "b=CT:5000" CRLF
+           "t=0 0" CRLF
+           "m=video 56436 RTP/SAVPF 120" CRLF
+           "a=rtpmap:120 VP8/90000" CRLF
+           "a=sendrecv" CRLF
+           "a=simulcast: send rid=9" CRLF,
+           false);
+  ASSERT_NE("", GetParseErrors());
+}
+
+TEST_P(NewSdpTest, ParseInvalidSimulcastNoSuchRecvRid) {
+  ParseSdp("v=0" CRLF
+           "o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
+           "s=SIP Call" CRLF
+           "c=IN IP4 198.51.100.7" CRLF
+           "b=CT:5000" CRLF
+           "t=0 0" CRLF
+           "m=video 56436 RTP/SAVPF 120" CRLF
+           "a=rtpmap:120 VP8/90000" CRLF
+           "a=sendrecv" CRLF
+           "a=simulcast: recv rid=9" CRLF,
+           false);
+  ASSERT_NE("", GetParseErrors());
+}
+
+TEST_P(NewSdpTest, ParseInvalidSimulcastNoSuchPt) {
+  ParseSdp("v=0" CRLF
+           "o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
+           "s=SIP Call" CRLF
+           "c=IN IP4 198.51.100.7" CRLF
+           "b=CT:5000" CRLF
+           "t=0 0" CRLF
+           "m=video 56436 RTP/SAVPF 120" CRLF
+           "a=rtpmap:120 VP8/90000" CRLF
+           "a=sendrecv" CRLF
+           "a=simulcast: send pt=9" CRLF,
+           false);
+  ASSERT_NE("", GetParseErrors());
+}
+
+TEST_P(NewSdpTest, ParseInvalidSimulcastNotSending) {
+  ParseSdp("v=0" CRLF
+           "o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
+           "s=SIP Call" CRLF
+           "c=IN IP4 198.51.100.7" CRLF
+           "b=CT:5000" CRLF
+           "t=0 0" CRLF
+           "m=video 56436 RTP/SAVPF 120" CRLF
+           "a=rtpmap:120 VP8/90000" CRLF
+           "a=recvonly" CRLF
+           "a=simulcast: send pt=120" CRLF,
+           false);
+  ASSERT_NE("", GetParseErrors());
+}
+
+TEST_P(NewSdpTest, ParseInvalidSimulcastNotReceiving) {
+  ParseSdp("v=0" CRLF
+           "o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
+           "s=SIP Call" CRLF
+           "c=IN IP4 198.51.100.7" CRLF
+           "b=CT:5000" CRLF
+           "t=0 0" CRLF
+           "m=video 56436 RTP/SAVPF 120" CRLF
+           "a=rtpmap:120 VP8/90000" CRLF
+           "a=sendonly" CRLF
+           "a=simulcast: recv pt=120" CRLF,
+           false);
+  ASSERT_NE("", GetParseErrors());
+}
+
+const std::string kNoAttributes =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+TEST_P(NewSdpTest, CheckNoAttributes) {
+  ParseSdp(kNoAttributes);
+
+  for (auto a = static_cast<size_t>(SdpAttribute::kFirstAttribute);
+       a <= static_cast<size_t>(SdpAttribute::kLastAttribute);
+       ++a) {
+
+    SdpAttribute::AttributeType type =
+      static_cast<SdpAttribute::AttributeType>(a);
+
+    // rtpmap is a special case right now, we throw parse errors if it is
+    // missing, and then insert one.
+    // direction is another special case that gets a default if not present
+    if (type != SdpAttribute::kRtpmapAttribute &&
+        type != SdpAttribute::kDirectionAttribute) {
+      ASSERT_FALSE(
+          mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(type))
+        << "Attribute " << a << " should not have been present at media level";
+      ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(type))
+        << "Attribute " << a << " should not have been present at session level";
+    }
+  }
+
+  ASSERT_FALSE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kRtpmapAttribute));
+
+  ASSERT_TRUE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kDirectionAttribute));
+  ASSERT_EQ(SdpDirectionAttribute::kSendrecv,
+      mSdp->GetMediaSection(0).GetAttributeList().GetDirection());
+  ASSERT_TRUE(mSdp->GetAttributeList().HasAttribute(
+        SdpAttribute::kDirectionAttribute));
+  ASSERT_EQ(SdpDirectionAttribute::kSendrecv,
+      mSdp->GetAttributeList().GetDirection());
+}
+
+
+const std::string kMediaLevelDtlsMessage =
+"v=0" CRLF
+"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
+"s=SIP Call" CRLF
+"c=IN IP4 224.0.0.1/100/12" CRLF
+"t=0 0" CRLF
+"m=video 9 RTP/SAVPF 120" CRLF
+"c=IN IP4 0.0.0.0" CRLF
+"a=dtls-message:client " BASE64_DTLS_HELLO CRLF
+"a=rtpmap:120 VP8/90000" CRLF;
+
+TEST_P(NewSdpTest, CheckMediaLevelDtlsMessage) {
+  ParseSdp(kMediaLevelDtlsMessage);
+  ASSERT_TRUE(!!mSdp) << "Parse failed: " << GetParseErrors();
+
+  // dtls-message is not defined for use at the media level; we don't
+  // parse it
+  ASSERT_FALSE(mSdp->GetMediaSection(0).GetAttributeList().HasAttribute(
+        SdpAttribute::kDtlsMessageAttribute));
+}
+
+
+TEST(NewSdpTestNoFixture, CheckAttributeTypeSerialize) {
+  for (auto a = static_cast<size_t>(SdpAttribute::kFirstAttribute);
+       a <= static_cast<size_t>(SdpAttribute::kLastAttribute);
+       ++a) {
+
+    SdpAttribute::AttributeType type =
+      static_cast<SdpAttribute::AttributeType>(a);
+
+    // Direction attributes are handled a little differently
+    if (type != SdpAttribute::kDirectionAttribute) {
+      std::ostringstream os;
+      os << type;
+      ASSERT_NE("", os.str());
+    }
+  }
+}
+
+static SdpImageattrAttributeList::XYRange
+ParseXYRange(const std::string& input)
+{
+  std::istringstream is(input + ",");
+  std::string error;
+  SdpImageattrAttributeList::XYRange range;
+  EXPECT_TRUE(range.Parse(is, &error)) << error;
+  EXPECT_EQ(',', is.get());
+  EXPECT_EQ(EOF, is.get());
+  return range;
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrXYRangeParseValid)
+{
+  {
+    SdpImageattrAttributeList::XYRange range(ParseXYRange("640"));
+    ASSERT_EQ(1U, range.discreteValues.size());
+    ASSERT_EQ(640U, range.discreteValues[0]);
+  }
+
+  {
+    SdpImageattrAttributeList::XYRange range(ParseXYRange("[320,640]"));
+    ASSERT_EQ(2U, range.discreteValues.size());
+    ASSERT_EQ(320U, range.discreteValues[0]);
+    ASSERT_EQ(640U, range.discreteValues[1]);
+  }
+
+  {
+    SdpImageattrAttributeList::XYRange range(ParseXYRange("[320,640,1024]"));
+    ASSERT_EQ(3U, range.discreteValues.size());
+    ASSERT_EQ(320U, range.discreteValues[0]);
+    ASSERT_EQ(640U, range.discreteValues[1]);
+    ASSERT_EQ(1024U, range.discreteValues[2]);
+  }
+
+  {
+    SdpImageattrAttributeList::XYRange range(ParseXYRange("[320:640]"));
+    ASSERT_EQ(0U, range.discreteValues.size());
+    ASSERT_EQ(320U, range.min);
+    ASSERT_EQ(1U, range.step);
+    ASSERT_EQ(640U, range.max);
+  }
+
+  {
+    SdpImageattrAttributeList::XYRange range(ParseXYRange("[320:16:640]"));
+    ASSERT_EQ(0U, range.discreteValues.size());
+    ASSERT_EQ(320U, range.min);
+    ASSERT_EQ(16U, range.step);
+    ASSERT_EQ(640U, range.max);
+  }
+}
+
+template<typename T>
+void
+ParseInvalid(const std::string& input, size_t last)
+{
+  std::istringstream is(input);
+  T parsed;
+  std::string error;
+  ASSERT_FALSE(parsed.Parse(is, &error))
+    << "\'" << input << "\' should not have parsed successfully";
+  is.clear();
+  ASSERT_EQ(last, static_cast<size_t>(is.tellg()))
+    << "Parse failed at unexpected location:" << std::endl
+    << input << std::endl
+    << std::string(is.tellg(), ' ') << "^" << std::endl;
+  // For a human to eyeball to make sure the error strings look sane
+  std::cout << "\"" << input << "\" - " << error << std::endl; \
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrXYRangeParseInvalid)
+{
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[-1", 1);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[-", 1);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[-v", 1);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:-1", 5);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:16:-1", 8);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640,-1", 5);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640,-]", 5);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("-v", 0);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("-1", 0);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("", 0);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[", 1);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[v", 1);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[", 1);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[ 640", 1);
+  // It looks like the overflow detection only happens once the whole number
+  // is scanned...
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[99999999999999999:", 18);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640", 4);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:", 5);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:v", 5);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:16", 7);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:16:", 8);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:16:v", 8);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:16:320]", 11);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:16:320", 11);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:16:320v", 11);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:1024", 9);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:320]", 8);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640:1024v", 9);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640,", 5);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640,v", 5);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640]", 4);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640x", 4);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("[640,]", 5);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>(" ", 0);
+  ParseInvalid<SdpImageattrAttributeList::XYRange>("v", 0);
+}
+
+static SdpImageattrAttributeList::SRange
+ParseSRange(const std::string& input)
+{
+  std::istringstream is(input + ",");
+  std::string error;
+  SdpImageattrAttributeList::SRange range;
+  EXPECT_TRUE(range.Parse(is, &error)) << error;
+  EXPECT_EQ(',', is.get());
+  EXPECT_EQ(EOF, is.get());
+  return range;
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrSRangeParseValid)
+{
+  {
+    SdpImageattrAttributeList::SRange range(ParseSRange("0.1"));
+    ASSERT_EQ(1U, range.discreteValues.size());
+    ASSERT_FLOAT_EQ(0.1f, range.discreteValues[0]);
+  }
+
+  {
+    SdpImageattrAttributeList::SRange range(ParseSRange("[0.1,0.2]"));
+    ASSERT_EQ(2U, range.discreteValues.size());
+    ASSERT_FLOAT_EQ(0.1f, range.discreteValues[0]);
+    ASSERT_FLOAT_EQ(0.2f, range.discreteValues[1]);
+  }
+
+  {
+    SdpImageattrAttributeList::SRange range(ParseSRange("[0.1,0.2,0.3]"));
+    ASSERT_EQ(3U, range.discreteValues.size());
+    ASSERT_FLOAT_EQ(0.1f, range.discreteValues[0]);
+    ASSERT_FLOAT_EQ(0.2f, range.discreteValues[1]);
+    ASSERT_FLOAT_EQ(0.3f, range.discreteValues[2]);
+  }
+
+  {
+    SdpImageattrAttributeList::SRange range(ParseSRange("[0.1-0.2]"));
+    ASSERT_EQ(0U, range.discreteValues.size());
+    ASSERT_FLOAT_EQ(0.1f, range.min);
+    ASSERT_FLOAT_EQ(0.2f, range.max);
+  }
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrSRangeParseInvalid)
+{
+  ParseInvalid<SdpImageattrAttributeList::SRange>("", 0);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[", 1);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[v", 1);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[-1", 1);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[", 1);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[-", 1);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[v", 1);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[ 0.2", 1);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[10.1-", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.08-", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2", 4);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2-", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2-v", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2--1", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2-0.3", 8);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2-0.1]", 8);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2-0.3v", 8);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2,", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2,v", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2,-1", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2]", 4);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2v", 4);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2,]", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("[0.2,-]", 5);
+  ParseInvalid<SdpImageattrAttributeList::SRange>(" ", 0);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("v", 0);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("-v", 0);
+  ParseInvalid<SdpImageattrAttributeList::SRange>("-1", 0);
+}
+
+static SdpImageattrAttributeList::PRange
+ParsePRange(const std::string& input)
+{
+  std::istringstream is(input + ",");
+  std::string error;
+  SdpImageattrAttributeList::PRange range;
+  EXPECT_TRUE(range.Parse(is, &error)) << error;
+  EXPECT_EQ(',', is.get());
+  EXPECT_EQ(EOF, is.get());
+  return range;
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrPRangeParseValid)
+{
+  SdpImageattrAttributeList::PRange range(ParsePRange("[0.1000-9.9999]"));
+  ASSERT_FLOAT_EQ(0.1f, range.min);
+  ASSERT_FLOAT_EQ(9.9999f, range.max);
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrPRangeParseInvalid)
+{
+  ParseInvalid<SdpImageattrAttributeList::PRange>("", 0);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[", 1);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[v", 1);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[-1", 1);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[", 1);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[-", 1);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[v", 1);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[ 0.2", 1);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[10.1-", 5);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.08-", 5);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2", 4);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2-", 5);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2-v", 5);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2--1", 5);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2-0.3", 8);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2-0.1]", 8);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2-0.3v", 8);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2,", 4);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2:", 4);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2]", 4);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("[0.2v", 4);
+  ParseInvalid<SdpImageattrAttributeList::PRange>(" ", 0);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("v", 0);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("-x", 0);
+  ParseInvalid<SdpImageattrAttributeList::PRange>("-1", 0);
+}
+
+static SdpImageattrAttributeList::Set
+ParseSet(const std::string& input)
+{
+  std::istringstream is(input + " ");
+  std::string error;
+  SdpImageattrAttributeList::Set set;
+  EXPECT_TRUE(set.Parse(is, &error)) << error;
+  EXPECT_EQ(' ', is.get());
+  EXPECT_EQ(EOF, is.get());
+  return set;
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrSetParseValid)
+{
+  {
+    SdpImageattrAttributeList::Set set(ParseSet("[x=320,y=240]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_FALSE(set.sRange.IsSet());
+    ASSERT_FALSE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.5f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(ParseSet("[X=320,Y=240]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_FALSE(set.sRange.IsSet());
+    ASSERT_FALSE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.5f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(ParseSet("[x=320,y=240,par=[0.1-0.2]]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_FALSE(set.sRange.IsSet());
+    ASSERT_TRUE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.1f, set.pRange.min);
+    ASSERT_FLOAT_EQ(0.2f, set.pRange.max);
+    ASSERT_FLOAT_EQ(0.5f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(ParseSet("[x=320,y=240,sar=[0.1-0.2]]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_TRUE(set.sRange.IsSet());
+    ASSERT_FLOAT_EQ(0.1f, set.sRange.min);
+    ASSERT_FLOAT_EQ(0.2f, set.sRange.max);
+    ASSERT_FALSE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.5f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(ParseSet("[x=320,y=240,q=0.1]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_FALSE(set.sRange.IsSet());
+    ASSERT_FALSE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.1f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(
+        ParseSet("[x=320,y=240,par=[0.1-0.2],sar=[0.3-0.4],q=0.6]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_TRUE(set.sRange.IsSet());
+    ASSERT_FLOAT_EQ(0.3f, set.sRange.min);
+    ASSERT_FLOAT_EQ(0.4f, set.sRange.max);
+    ASSERT_TRUE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.1f, set.pRange.min);
+    ASSERT_FLOAT_EQ(0.2f, set.pRange.max);
+    ASSERT_FLOAT_EQ(0.6f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(ParseSet("[x=320,y=240,foo=bar,q=0.1]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_FALSE(set.sRange.IsSet());
+    ASSERT_FALSE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.1f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(
+        ParseSet("[x=320,y=240,foo=bar,q=0.1,bar=baz]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_FALSE(set.sRange.IsSet());
+    ASSERT_FALSE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.1f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(
+        ParseSet("[x=320,y=240,foo=[bar],q=0.1,bar=[baz]]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_FALSE(set.sRange.IsSet());
+    ASSERT_FALSE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.1f, set.qValue);
+  }
+
+  {
+    SdpImageattrAttributeList::Set set(
+        ParseSet("[x=320,y=240,foo=[par=foo,sar=bar],q=0.1,bar=[baz]]"));
+    ASSERT_EQ(1U, set.xRange.discreteValues.size());
+    ASSERT_EQ(320U, set.xRange.discreteValues[0]);
+    ASSERT_EQ(1U, set.yRange.discreteValues.size());
+    ASSERT_EQ(240U, set.yRange.discreteValues[0]);
+    ASSERT_FALSE(set.sRange.IsSet());
+    ASSERT_FALSE(set.pRange.IsSet());
+    ASSERT_FLOAT_EQ(0.1f, set.qValue);
+  }
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrSetParseInvalid)
+{
+  ParseInvalid<SdpImageattrAttributeList::Set>("", 0);
+  ParseInvalid<SdpImageattrAttributeList::Set>("x", 0);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[", 1);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[=", 2);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x", 2);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[y=", 3);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=[", 4);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320", 6);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320v", 6);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,", 7);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,=", 8);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,x", 8);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,x=", 9);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=[", 10);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240", 12);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240x", 12);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,", 13);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,q=", 15);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,q=v", 15);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,q=0.5", 18);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,q=0.5,", 19);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,q=0.5,]", 20);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,q=0.5,=]", 20);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,q=0.5,sar=v]", 23);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,q=0.5,q=0.4", 21);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,sar=", 17);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,sar=v", 17);
+  ParseInvalid<SdpImageattrAttributeList::Set>(
+      "[x=320,y=240,sar=[0.5-0.6],sar=[0.7-0.8]", 31);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,par=", 17);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,par=x", 17);
+  ParseInvalid<SdpImageattrAttributeList::Set>(
+      "[x=320,y=240,par=[0.5-0.6],par=[0.7-0.8]", 31);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,foo=", 17);
+  ParseInvalid<SdpImageattrAttributeList::Set>("[x=320,y=240,foo=x", 18);
+}
+
+static SdpImageattrAttributeList::Imageattr
+ParseImageattr(const std::string& input)
+{
+  std::istringstream is(input);
+  std::string error;
+  SdpImageattrAttributeList::Imageattr imageattr;
+  EXPECT_TRUE(imageattr.Parse(is, &error)) << error;
+  EXPECT_TRUE(is.eof());
+  return imageattr;
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrParseValid)
+{
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(ParseImageattr("* send *"));
+    ASSERT_FALSE(imageattr.pt.isSome());
+    ASSERT_TRUE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+    ASSERT_FALSE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(ParseImageattr("* SEND *"));
+    ASSERT_FALSE(imageattr.pt.isSome());
+    ASSERT_TRUE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+    ASSERT_FALSE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(ParseImageattr("* recv *"));
+    ASSERT_FALSE(imageattr.pt.isSome());
+    ASSERT_FALSE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+    ASSERT_TRUE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(ParseImageattr("* RECV *"));
+    ASSERT_FALSE(imageattr.pt.isSome());
+    ASSERT_FALSE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+    ASSERT_TRUE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(
+        ParseImageattr("* recv * send *"));
+    ASSERT_FALSE(imageattr.pt.isSome());
+    ASSERT_TRUE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+    ASSERT_TRUE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(
+        ParseImageattr("* send * recv *"));
+    ASSERT_FALSE(imageattr.pt.isSome());
+    ASSERT_TRUE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+    ASSERT_TRUE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(
+        ParseImageattr("8 send * recv *"));
+    ASSERT_EQ(8U, *imageattr.pt);
+    ASSERT_TRUE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+    ASSERT_TRUE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(
+        ParseImageattr("8 send [x=320,y=240] recv *"));
+    ASSERT_EQ(8U, *imageattr.pt);
+    ASSERT_FALSE(imageattr.sendAll);
+    ASSERT_EQ(1U, imageattr.sendSets.size());
+    ASSERT_EQ(1U, imageattr.sendSets[0].xRange.discreteValues.size());
+    ASSERT_EQ(320U, imageattr.sendSets[0].xRange.discreteValues[0]);
+    ASSERT_EQ(1U, imageattr.sendSets[0].yRange.discreteValues.size());
+    ASSERT_EQ(240U, imageattr.sendSets[0].yRange.discreteValues[0]);
+    ASSERT_TRUE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(
+        ParseImageattr("8 send [x=320,y=240] [x=640,y=480] recv *"));
+    ASSERT_EQ(8U, *imageattr.pt);
+    ASSERT_FALSE(imageattr.sendAll);
+    ASSERT_EQ(2U, imageattr.sendSets.size());
+    ASSERT_EQ(1U, imageattr.sendSets[0].xRange.discreteValues.size());
+    ASSERT_EQ(320U, imageattr.sendSets[0].xRange.discreteValues[0]);
+    ASSERT_EQ(1U, imageattr.sendSets[0].yRange.discreteValues.size());
+    ASSERT_EQ(240U, imageattr.sendSets[0].yRange.discreteValues[0]);
+    ASSERT_EQ(1U, imageattr.sendSets[1].xRange.discreteValues.size());
+    ASSERT_EQ(640U, imageattr.sendSets[1].xRange.discreteValues[0]);
+    ASSERT_EQ(1U, imageattr.sendSets[1].yRange.discreteValues.size());
+    ASSERT_EQ(480U, imageattr.sendSets[1].yRange.discreteValues[0]);
+    ASSERT_TRUE(imageattr.recvAll);
+    ASSERT_TRUE(imageattr.recvSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(
+        ParseImageattr("8 send * recv [x=320,y=240]"));
+    ASSERT_EQ(8U, *imageattr.pt);
+    ASSERT_FALSE(imageattr.recvAll);
+    ASSERT_EQ(1U, imageattr.recvSets.size());
+    ASSERT_EQ(1U, imageattr.recvSets[0].xRange.discreteValues.size());
+    ASSERT_EQ(320U, imageattr.recvSets[0].xRange.discreteValues[0]);
+    ASSERT_EQ(1U, imageattr.recvSets[0].yRange.discreteValues.size());
+    ASSERT_EQ(240U, imageattr.recvSets[0].yRange.discreteValues[0]);
+    ASSERT_TRUE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+  }
+
+  {
+    SdpImageattrAttributeList::Imageattr imageattr(
+        ParseImageattr("8 send * recv [x=320,y=240] [x=640,y=480]"));
+    ASSERT_EQ(8U, *imageattr.pt);
+    ASSERT_FALSE(imageattr.recvAll);
+    ASSERT_EQ(2U, imageattr.recvSets.size());
+    ASSERT_EQ(1U, imageattr.recvSets[0].xRange.discreteValues.size());
+    ASSERT_EQ(320U, imageattr.recvSets[0].xRange.discreteValues[0]);
+    ASSERT_EQ(1U, imageattr.recvSets[0].yRange.discreteValues.size());
+    ASSERT_EQ(240U, imageattr.recvSets[0].yRange.discreteValues[0]);
+    ASSERT_EQ(1U, imageattr.recvSets[1].xRange.discreteValues.size());
+    ASSERT_EQ(640U, imageattr.recvSets[1].xRange.discreteValues[0]);
+    ASSERT_EQ(1U, imageattr.recvSets[1].yRange.discreteValues.size());
+    ASSERT_EQ(480U, imageattr.recvSets[1].yRange.discreteValues[0]);
+    ASSERT_TRUE(imageattr.sendAll);
+    ASSERT_TRUE(imageattr.sendSets.empty());
+  }
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrParseInvalid)
+{
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("", 0);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>(" ", 0);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("-1", 0);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("99999 ", 5);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("*", 1);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("* sen", 5);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("* vcer *", 6);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("* send x", 7);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>(
+      "* send [x=640,y=480] [", 22);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("* send * sen", 12);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("* send * vcer *", 13);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("* send * send *", 13);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("* recv * recv *", 13);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>("* send * recv x", 14);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>(
+      "* send * recv [x=640,y=480] [", 29);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>(
+      "* send * recv [x=640,y=480] *", 28);
+  ParseInvalid<SdpImageattrAttributeList::Imageattr>(
+      "* send * recv [x=640,y=480] foobajooba", 28);
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrXYRangeSerialization)
+{
+  SdpImageattrAttributeList::XYRange range;
+  std::stringstream os;
+
+  range.min = 320;
+  range.max = 640;
+  range.Serialize(os);
+  ASSERT_EQ("[320:640]", os.str());
+  os.str(""); // clear
+
+  range.step = 16;
+  range.Serialize(os);
+  ASSERT_EQ("[320:16:640]", os.str());
+  os.str(""); // clear
+
+  range.min = 0;
+  range.max = 0;
+  range.discreteValues.push_back(320);
+  range.Serialize(os);
+  ASSERT_EQ("320", os.str());
+  os.str("");
+
+  range.discreteValues.push_back(640);
+  range.Serialize(os);
+  ASSERT_EQ("[320,640]", os.str());
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrSRangeSerialization)
+{
+  SdpImageattrAttributeList::SRange range;
+  std::ostringstream os;
+
+  range.min = 0.1f;
+  range.max = 0.9999f;
+  range.Serialize(os);
+  ASSERT_EQ("[0.1000-0.9999]", os.str());
+  os.str("");
+
+  range.min = 0.0f;
+  range.max = 0.0f;
+  range.discreteValues.push_back(0.1f);
+  range.Serialize(os);
+  ASSERT_EQ("0.1000", os.str());
+  os.str("");
+
+  range.discreteValues.push_back(0.5f);
+  range.Serialize(os);
+  ASSERT_EQ("[0.1000,0.5000]", os.str());
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrPRangeSerialization)
+{
+  SdpImageattrAttributeList::PRange range;
+  std::ostringstream os;
+
+  range.min = 0.1f;
+  range.max = 0.9999f;
+  range.Serialize(os);
+  ASSERT_EQ("[0.1000-0.9999]", os.str());
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrSetSerialization)
+{
+  SdpImageattrAttributeList::Set set;
+  std::ostringstream os;
+
+  set.xRange.discreteValues.push_back(640);
+  set.yRange.discreteValues.push_back(480);
+  set.Serialize(os);
+  ASSERT_EQ("[x=640,y=480]", os.str());
+  os.str("");
+
+  set.qValue = 0.00f;
+  set.Serialize(os);
+  ASSERT_EQ("[x=640,y=480,q=0.00]", os.str());
+  os.str("");
+
+  set.qValue = 0.10f;
+  set.Serialize(os);
+  ASSERT_EQ("[x=640,y=480,q=0.10]", os.str());
+  os.str("");
+
+  set.qValue = 1.00f;
+  set.Serialize(os);
+  ASSERT_EQ("[x=640,y=480,q=1.00]", os.str());
+  os.str("");
+
+  set.sRange.discreteValues.push_back(1.1f);
+  set.Serialize(os);
+  ASSERT_EQ("[x=640,y=480,sar=1.1000,q=1.00]", os.str());
+  os.str("");
+
+  set.pRange.min = 0.9f;
+  set.pRange.max = 1.1f;
+  set.Serialize(os);
+  ASSERT_EQ("[x=640,y=480,sar=1.1000,par=[0.9000-1.1000],q=1.00]", os.str());
+  os.str("");
+}
+
+TEST(NewSdpTestNoFixture, CheckImageattrSerialization)
+{
+  SdpImageattrAttributeList::Imageattr imageattr;
+  std::ostringstream os;
+
+  imageattr.sendAll = true;
+  imageattr.pt = Some<uint16_t>(8U);
+  imageattr.Serialize(os);
+  ASSERT_EQ("8 send *", os.str());
+  os.str("");
+
+  imageattr.pt.reset();;
+  imageattr.Serialize(os);
+  ASSERT_EQ("* send *", os.str());
+  os.str("");
+
+  imageattr.sendAll = false;
+  imageattr.recvAll = true;
+  imageattr.Serialize(os);
+  ASSERT_EQ("* recv *", os.str());
+  os.str("");
+
+  imageattr.sendAll = true;
+  imageattr.Serialize(os);
+  ASSERT_EQ("* send * recv *", os.str());
+  os.str("");
+
+  imageattr.sendAll = false;
+  imageattr.sendSets.push_back(SdpImageattrAttributeList::Set());
+  imageattr.sendSets.back().xRange.discreteValues.push_back(320);
+  imageattr.sendSets.back().yRange.discreteValues.push_back(240);
+  imageattr.Serialize(os);
+  ASSERT_EQ("* send [x=320,y=240] recv *", os.str());
+  os.str("");
+
+  imageattr.sendSets.push_back(SdpImageattrAttributeList::Set());
+  imageattr.sendSets.back().xRange.discreteValues.push_back(640);
+  imageattr.sendSets.back().yRange.discreteValues.push_back(480);
+  imageattr.Serialize(os);
+  ASSERT_EQ("* send [x=320,y=240] [x=640,y=480] recv *", os.str());
+  os.str("");
+
+  imageattr.recvAll = false;
+  imageattr.recvSets.push_back(SdpImageattrAttributeList::Set());
+  imageattr.recvSets.back().xRange.discreteValues.push_back(320);
+  imageattr.recvSets.back().yRange.discreteValues.push_back(240);
+  imageattr.Serialize(os);
+  ASSERT_EQ("* send [x=320,y=240] [x=640,y=480] recv [x=320,y=240]", os.str());
+  os.str("");
+
+  imageattr.recvSets.push_back(SdpImageattrAttributeList::Set());
+  imageattr.recvSets.back().xRange.discreteValues.push_back(640);
+  imageattr.recvSets.back().yRange.discreteValues.push_back(480);
+  imageattr.Serialize(os);
+  ASSERT_EQ(
+      "* send [x=320,y=240] [x=640,y=480] recv [x=320,y=240] [x=640,y=480]",
+      os.str());
+  os.str("");
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastVersionSerialize)
+{
+  std::ostringstream os;
+
+  SdpSimulcastAttribute::Version version;
+  version.choices.push_back("8");
+  version.Serialize(os);
+  ASSERT_EQ("8", os.str());
+  os.str("");
+
+  version.choices.push_back("9");
+  version.Serialize(os);
+  ASSERT_EQ("8,9", os.str());
+  os.str("");
+
+  version.choices.push_back("0");
+  version.Serialize(os);
+  ASSERT_EQ("8,9,0", os.str());
+  os.str("");
+}
+
+static SdpSimulcastAttribute::Version
+ParseSimulcastVersion(const std::string& input)
+{
+  std::istringstream is(input + ";");
+  std::string error;
+  SdpSimulcastAttribute::Version version;
+  EXPECT_TRUE(version.Parse(is, &error)) << error;
+  EXPECT_EQ(';', is.get());
+  EXPECT_EQ(EOF, is.get());
+  return version;
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastVersionValidParse)
+{
+  {
+    SdpSimulcastAttribute::Version version(
+        ParseSimulcastVersion("1"));
+    ASSERT_EQ(1U, version.choices.size());
+    ASSERT_EQ("1", version.choices[0]);
+  }
+
+  {
+    SdpSimulcastAttribute::Version version(
+        ParseSimulcastVersion("1,2"));
+    ASSERT_EQ(2U, version.choices.size());
+    ASSERT_EQ("1", version.choices[0]);
+    ASSERT_EQ("2", version.choices[1]);
+  }
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastVersionInvalidParse)
+{
+  ParseInvalid<SdpSimulcastAttribute::Version>("", 0);
+  ParseInvalid<SdpSimulcastAttribute::Version>(",", 0);
+  ParseInvalid<SdpSimulcastAttribute::Version>(";", 0);
+  ParseInvalid<SdpSimulcastAttribute::Version>(" ", 0);
+  ParseInvalid<SdpSimulcastAttribute::Version>("8,", 2);
+  ParseInvalid<SdpSimulcastAttribute::Version>("8, ", 2);
+  ParseInvalid<SdpSimulcastAttribute::Version>("8,,", 2);
+  ParseInvalid<SdpSimulcastAttribute::Version>("8,;", 2);
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastVersionsSerialize)
+{
+  std::ostringstream os;
+
+  SdpSimulcastAttribute::Versions versions;
+  versions.type = SdpSimulcastAttribute::Versions::kPt;
+  versions.push_back(SdpSimulcastAttribute::Version());
+  versions.back().choices.push_back("8");
+  versions.Serialize(os);
+  ASSERT_EQ("pt=8", os.str());
+  os.str("");
+
+  versions.type = SdpSimulcastAttribute::Versions::kRid;
+  versions.Serialize(os);
+  ASSERT_EQ("rid=8", os.str());
+  os.str("");
+
+  versions.push_back(SdpSimulcastAttribute::Version());
+  versions.Serialize(os);
+  ASSERT_EQ("rid=8", os.str());
+  os.str("");
+
+  versions.back().choices.push_back("9");
+  versions.Serialize(os);
+  ASSERT_EQ("rid=8;9", os.str());
+  os.str("");
+
+  versions.push_back(SdpSimulcastAttribute::Version());
+  versions.back().choices.push_back("0");
+  versions.Serialize(os);
+  ASSERT_EQ("rid=8;9;0", os.str());
+  os.str("");
+}
+
+static SdpSimulcastAttribute::Versions
+ParseSimulcastVersions(const std::string& input)
+{
+  std::istringstream is(input + " ");
+  std::string error;
+  SdpSimulcastAttribute::Versions list;
+  EXPECT_TRUE(list.Parse(is, &error)) << error;
+  EXPECT_EQ(' ', is.get());
+  EXPECT_EQ(EOF, is.get());
+  return list;
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastVersionsValidParse)
+{
+  {
+    SdpSimulcastAttribute::Versions versions(
+        ParseSimulcastVersions("pt=8"));
+    ASSERT_EQ(1U, versions.size());
+    ASSERT_EQ(SdpSimulcastAttribute::Versions::kPt, versions.type);
+    ASSERT_EQ(1U, versions[0].choices.size());
+    ASSERT_EQ("8", versions[0].choices[0]);
+  }
+
+  {
+    SdpSimulcastAttribute::Versions versions(
+        ParseSimulcastVersions("rid=8"));
+    ASSERT_EQ(1U, versions.size());
+    ASSERT_EQ(SdpSimulcastAttribute::Versions::kRid, versions.type);
+    ASSERT_EQ(1U, versions[0].choices.size());
+    ASSERT_EQ("8", versions[0].choices[0]);
+  }
+
+  {
+    SdpSimulcastAttribute::Versions versions(
+        ParseSimulcastVersions("pt=8,9"));
+    ASSERT_EQ(1U, versions.size());
+    ASSERT_EQ(2U, versions[0].choices.size());
+    ASSERT_EQ("8", versions[0].choices[0]);
+    ASSERT_EQ("9", versions[0].choices[1]);
+  }
+
+  {
+    SdpSimulcastAttribute::Versions versions(
+        ParseSimulcastVersions("pt=8,9;10"));
+    ASSERT_EQ(2U, versions.size());
+    ASSERT_EQ(2U, versions[0].choices.size());
+    ASSERT_EQ("8", versions[0].choices[0]);
+    ASSERT_EQ("9", versions[0].choices[1]);
+    ASSERT_EQ(1U, versions[1].choices.size());
+    ASSERT_EQ("10", versions[1].choices[0]);
+  }
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastVersionsInvalidParse)
+{
+  ParseInvalid<SdpSimulcastAttribute::Versions>("", 0);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("x", 1);
+  ParseInvalid<SdpSimulcastAttribute::Versions>(";", 1);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("8", 1);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("foo=", 4);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("foo=8", 4);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("pt=9999", 7);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("pt=-1", 5);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("pt=x", 4);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("pt=8;", 5);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("pt=8;x", 6);
+  ParseInvalid<SdpSimulcastAttribute::Versions>("pt=8;;", 5);
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastSerialize)
+{
+  std::ostringstream os;
+
+  SdpSimulcastAttribute simulcast;
+  simulcast.recvVersions.type = SdpSimulcastAttribute::Versions::kPt;
+  simulcast.recvVersions.push_back(SdpSimulcastAttribute::Version());
+  simulcast.recvVersions.back().choices.push_back("8");
+  simulcast.Serialize(os);
+  ASSERT_EQ("a=simulcast: recv pt=8" CRLF, os.str());
+  os.str("");
+
+  simulcast.sendVersions.push_back(SdpSimulcastAttribute::Version());
+  simulcast.sendVersions.back().choices.push_back("9");
+  simulcast.Serialize(os);
+  ASSERT_EQ("a=simulcast: send rid=9 recv pt=8" CRLF, os.str());
+  os.str("");
+}
+
+static SdpSimulcastAttribute
+ParseSimulcast(const std::string& input)
+{
+  std::istringstream is(input);
+  std::string error;
+  SdpSimulcastAttribute simulcast;
+  EXPECT_TRUE(simulcast.Parse(is, &error)) << error;
+  EXPECT_TRUE(is.eof());
+  return simulcast;
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastValidParse)
+{
+  {
+    SdpSimulcastAttribute simulcast(ParseSimulcast(" send pt=8"));
+    ASSERT_EQ(1U, simulcast.sendVersions.size());
+    ASSERT_EQ(SdpSimulcastAttribute::Versions::kPt,
+              simulcast.sendVersions.type);
+    ASSERT_EQ(1U, simulcast.sendVersions[0].choices.size());
+    ASSERT_EQ("8", simulcast.sendVersions[0].choices[0]);
+    ASSERT_EQ(0U, simulcast.recvVersions.size());
+  }
+
+  {
+    SdpSimulcastAttribute simulcast(ParseSimulcast(" SEND pt=8"));
+    ASSERT_EQ(1U, simulcast.sendVersions.size());
+    ASSERT_EQ(SdpSimulcastAttribute::Versions::kPt,
+              simulcast.sendVersions.type);
+    ASSERT_EQ(1U, simulcast.sendVersions[0].choices.size());
+    ASSERT_EQ("8", simulcast.sendVersions[0].choices[0]);
+    ASSERT_EQ(0U, simulcast.recvVersions.size());
+  }
+
+  {
+    SdpSimulcastAttribute simulcast(ParseSimulcast(" recv pt=8"));
+    ASSERT_EQ(1U, simulcast.recvVersions.size());
+    ASSERT_EQ(SdpSimulcastAttribute::Versions::kPt,
+              simulcast.recvVersions.type);
+    ASSERT_EQ(1U, simulcast.recvVersions[0].choices.size());
+    ASSERT_EQ("8", simulcast.recvVersions[0].choices[0]);
+    ASSERT_EQ(0U, simulcast.sendVersions.size());
+  }
+
+  {
+    SdpSimulcastAttribute simulcast(
+        ParseSimulcast(
+          " send pt=8,9;101;97,98 recv pt=101,120;97"));
+    ASSERT_EQ(3U, simulcast.sendVersions.size());
+    ASSERT_EQ(SdpSimulcastAttribute::Versions::kPt,
+              simulcast.sendVersions.type);
+    ASSERT_EQ(2U, simulcast.sendVersions[0].choices.size());
+    ASSERT_EQ("8", simulcast.sendVersions[0].choices[0]);
+    ASSERT_EQ("9", simulcast.sendVersions[0].choices[1]);
+    ASSERT_EQ(1U, simulcast.sendVersions[1].choices.size());
+    ASSERT_EQ("101", simulcast.sendVersions[1].choices[0]);
+    ASSERT_EQ(2U, simulcast.sendVersions[2].choices.size());
+    ASSERT_EQ("97", simulcast.sendVersions[2].choices[0]);
+    ASSERT_EQ("98", simulcast.sendVersions[2].choices[1]);
+
+    ASSERT_EQ(2U, simulcast.recvVersions.size());
+    ASSERT_EQ(SdpSimulcastAttribute::Versions::kPt,
+              simulcast.recvVersions.type);
+    ASSERT_EQ(2U, simulcast.recvVersions[0].choices.size());
+    ASSERT_EQ("101", simulcast.recvVersions[0].choices[0]);
+    ASSERT_EQ("120", simulcast.recvVersions[0].choices[1]);
+    ASSERT_EQ(1U, simulcast.recvVersions[1].choices.size());
+    ASSERT_EQ("97", simulcast.recvVersions[1].choices[0]);
+  }
+}
+
+TEST(NewSdpTestNoFixture, CheckSimulcastInvalidParse)
+{
+  ParseInvalid<SdpSimulcastAttribute>("", 0);
+  ParseInvalid<SdpSimulcastAttribute>(" ", 1);
+  ParseInvalid<SdpSimulcastAttribute>("vcer ", 4);
+  ParseInvalid<SdpSimulcastAttribute>(" send x", 7);
+  ParseInvalid<SdpSimulcastAttribute>(" recv x", 7);
+  ParseInvalid<SdpSimulcastAttribute>(" send pt=8 send ", 15);
+  ParseInvalid<SdpSimulcastAttribute>(" recv pt=8 recv ", 15);
+}
+
+static SdpRidAttributeList::Rid
+ParseRid(const std::string& input)
+{
+  std::istringstream is(input);
+  std::string error;
+  SdpRidAttributeList::Rid rid;
+  EXPECT_TRUE(rid.Parse(is, &error)) << error;
+  EXPECT_TRUE(is.eof());
+  return rid;
+}
+
+TEST(NewSdpTestNoFixture, CheckRidValidParse)
+{
+  {
+    SdpRidAttributeList::Rid rid(ParseRid("1 send"));
+    ASSERT_EQ("1", rid.id);
+    ASSERT_EQ(sdp::kSend, rid.direction);
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(ParseRid("1 send pt=96;max-width=800"));
+    ASSERT_EQ("1", rid.id);
+    ASSERT_EQ(sdp::kSend, rid.direction);
+    ASSERT_EQ(1U, rid.formats.size());
+    ASSERT_EQ(96U, rid.formats[0]);
+    ASSERT_EQ(800U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(ParseRid("1 send pt=96,97,98;max-width=800"));
+    ASSERT_EQ("1", rid.id);
+    ASSERT_EQ(sdp::kSend, rid.direction);
+    ASSERT_EQ(3U, rid.formats.size());
+    ASSERT_EQ(96U, rid.formats[0]);
+    ASSERT_EQ(97U, rid.formats[1]);
+    ASSERT_EQ(98U, rid.formats[2]);
+    ASSERT_EQ(800U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("0123456789az-_ recv max-width=800"));
+    ASSERT_EQ("0123456789az-_", rid.id);
+    ASSERT_EQ(sdp::kRecv, rid.direction);
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(800U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send pt=96"));
+    ASSERT_EQ(1U, rid.formats.size());
+    ASSERT_EQ(96U, rid.formats[0]);
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  // This is not technically permitted by the BNF, but the parse code is simpler
+  // if we allow it. If we decide to stop allowing this, this will need to be
+  // converted to an invalid parse test-case.
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-br=30000;pt=96"));
+    ASSERT_EQ(1U, rid.formats.size());
+    ASSERT_EQ(96U, rid.formats[0]);
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(30000U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send pt=96,97,98"));
+    ASSERT_EQ(3U, rid.formats.size());
+    ASSERT_EQ(96U, rid.formats[0]);
+    ASSERT_EQ(97U, rid.formats[1]);
+    ASSERT_EQ(98U, rid.formats[2]);
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-width=800"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(800U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-height=640"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(640U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-fps=30"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(30U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-fs=3600"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(3600U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-br=30000"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(30000U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-pps=9216000"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(9216000U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send depend=foo"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(1U, rid.dependIds.size());
+    ASSERT_EQ("foo", rid.dependIds[0]);
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-foo=20"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send depend=foo,bar"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(0U, rid.constraints.maxWidth);
+    ASSERT_EQ(0U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(2U, rid.dependIds.size());
+    ASSERT_EQ("foo", rid.dependIds[0]);
+    ASSERT_EQ("bar", rid.dependIds[1]);
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-width=800;max-height=600"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(800U, rid.constraints.maxWidth);
+    ASSERT_EQ(600U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send pt=96,97;max-width=800;max-height=600"));
+    ASSERT_EQ(2U, rid.formats.size());
+    ASSERT_EQ(96U, rid.formats[0]);
+    ASSERT_EQ(97U, rid.formats[1]);
+    ASSERT_EQ(800U, rid.constraints.maxWidth);
+    ASSERT_EQ(600U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send depend=foo,bar;max-width=800;max-height=600"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(800U, rid.constraints.maxWidth);
+    ASSERT_EQ(600U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(2U, rid.dependIds.size());
+    ASSERT_EQ("foo", rid.dependIds[0]);
+    ASSERT_EQ("bar", rid.dependIds[1]);
+  }
+
+  {
+    SdpRidAttributeList::Rid rid(
+        ParseRid("foo send max-foo=20;max-width=800;max-height=600"));
+    ASSERT_EQ(0U, rid.formats.size());
+    ASSERT_EQ(800U, rid.constraints.maxWidth);
+    ASSERT_EQ(600U, rid.constraints.maxHeight);
+    ASSERT_EQ(0U, rid.constraints.maxFps);
+    ASSERT_EQ(0U, rid.constraints.maxFs);
+    ASSERT_EQ(0U, rid.constraints.maxBr);
+    ASSERT_EQ(0U, rid.constraints.maxPps);
+    ASSERT_EQ(0U, rid.dependIds.size());
+  }
+}
+
+TEST(NewSdpTestNoFixture, CheckRidInvalidParse)
+{
+  ParseInvalid<SdpRidAttributeList::Rid>("", 0);
+  ParseInvalid<SdpRidAttributeList::Rid>(" ", 0);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo", 3);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo ", 4);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo  ", 5);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo bar", 7);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo recv ", 9);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo recv pt=", 12);
+  ParseInvalid<SdpRidAttributeList::Rid>(" ", 0);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send pt", 11);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send pt=", 12);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send pt=x", 12);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send pt=-1", 12);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send pt=96,", 15);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send pt=196", 15);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send max-width", 18);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send max-width=", 19);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send max-width=x", 19);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send max-width=-1", 19);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send max-width=800;", 23);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send max-width=800; ", 24);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send depend=",16);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send depend=,", 16);
+  ParseInvalid<SdpRidAttributeList::Rid>("foo send depend=1,", 18);
+}
+
+TEST(NewSdpTestNoFixture, CheckRidSerialize)
+{
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.formats.push_back(96);
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send pt=96", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.formats.push_back(96);
+    rid.formats.push_back(97);
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send pt=96,97", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.constraints.maxWidth = 800;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send max-width=800", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.constraints.maxHeight = 600;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send max-height=600", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.constraints.maxFps = 30;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send max-fps=30", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.constraints.maxFs = 3600;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send max-fs=3600", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.constraints.maxBr = 30000;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send max-br=30000", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.constraints.maxPps = 9216000;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send max-pps=9216000", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.dependIds.push_back("foo");
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send depend=foo", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.dependIds.push_back("foo");
+    rid.dependIds.push_back("bar");
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send depend=foo,bar", os.str());
+  }
+
+  {
+    SdpRidAttributeList::Rid rid;
+    rid.id = "foo";
+    rid.direction = sdp::kSend;
+    rid.formats.push_back(96);
+    rid.constraints.maxBr = 30000;
+    std::ostringstream os;
+    rid.Serialize(os);
+    ASSERT_EQ("foo send pt=96;max-br=30000", os.str());
+  }
+}
+
+} // End namespace test.
+
+int main(int argc, char **argv) {
+  ScopedXPCOM xpcom("sdp_unittests");
+
+  test_utils = new MtransportTestUtils();
+  NSS_NoDB_Init(nullptr);
+  NSS_SetDomesticPolicy();
+
+  ::testing::InitGoogleTest(&argc, argv);
+  int result = RUN_ALL_TESTS();
+
+  PeerConnectionCtx::Destroy();
+  delete test_utils;
+
+  return result;
+}
diff --git a/media/webrtc/signaling/test/signaling_unittests.cpp b/media/webrtc/signaling/test/signaling_unittests.cpp
new file mode 100644
index 000000000..27d4750c7
--- /dev/null
+++ b/media/webrtc/signaling/test/signaling_unittests.cpp
@@ -0,0 +1,4851 @@
+/* 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/. */
+
+#include <iostream>
+#include <map>
+#include <algorithm>
+#include <string>
+
+#include "base/basictypes.h"
+#include "logging.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+#include "nspr.h"
+#include "nss.h"
+#include "ssl.h"
+#include "prthread.h"
+
+#include "FakePCObserver.h"
+#include "FakeMediaStreams.h"
+#include "FakeMediaStreamsImpl.h"
+#include "FakeLogging.h"
+#include "PeerConnectionImpl.h"
+#include "PeerConnectionCtx.h"
+#include "PeerConnectionMedia.h"
+#include "MediaPipeline.h"
+#include "runnable_utils.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Services.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIDNSService.h"
+#include "nsQueryObject.h"
+#include "nsWeakReference.h"
+#include "nricectx.h"
+#include "rlogconnector.h"
+#include "mozilla/SyncRunnable.h"
+#include "logging.h"
+#include "stunserver.h"
+#include "stunserver.cpp"
+#ifdef SIGNALING_UNITTEST_STANDALONE
+#include "PeerConnectionImplEnumsBinding.cpp"
+#endif
+
+#include "FakeIPC.h"
+#include "FakeIPC.cpp"
+
+#include "ice_ctx.h"
+#include "ice_peer_ctx.h"
+
+#include "mtransport_test_utils.h"
+#include "gtest_ringbuffer_dumper.h"
+MtransportTestUtils *test_utils;
+nsCOMPtr<nsIThread> gMainThread;
+nsCOMPtr<nsIThread> gGtestThread;
+bool gTestsComplete = false;
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+#error USE_FAKE_MEDIA_STREAMS undefined
+#endif
+#ifndef USE_FAKE_PCOBSERVER
+#error USE_FAKE_PCOBSERVER undefined
+#endif
+
+static int kDefaultTimeout = 10000;
+
+static std::string callerName = "caller";
+static std::string calleeName = "callee";
+
+#define ARRAY_TO_STL(container, type, array) \
+        (container<type>((array), (array) + PR_ARRAY_SIZE(array)))
+
+#define ARRAY_TO_SET(type, array) ARRAY_TO_STL(std::set, type, array)
+
+std::string g_stun_server_address((char *)"23.21.150.121");
+uint16_t g_stun_server_port(3478);
+std::string kBogusSrflxAddress((char *)"192.0.2.1");
+uint16_t kBogusSrflxPort(1001);
+
+// We can't use webidl bindings here because it uses nsString,
+// so we pass options in using OfferOptions instead
+class OfferOptions : public mozilla::JsepOfferOptions {
+public:
+  void setInt32Option(const char *namePtr, size_t value) {
+    if (!strcmp(namePtr, "OfferToReceiveAudio")) {
+      mOfferToReceiveAudio = mozilla::Some(value);
+    } else if (!strcmp(namePtr, "OfferToReceiveVideo")) {
+      mOfferToReceiveVideo = mozilla::Some(value);
+    }
+  }
+  void setBoolOption(const char* namePtr, bool value) {
+    if (!strcmp(namePtr, "IceRestart")) {
+      mIceRestart = mozilla::Some(value);
+    }
+  }
+private:
+};
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+// XXX Workaround for bug 998092 to maintain the existing broken semantics
+template<>
+struct nsISupportsWeakReference::COMTypeInfo<nsSupportsWeakReference, void> {
+  static const nsIID kIID;
+};
+//const nsIID nsISupportsWeakReference::COMTypeInfo<nsSupportsWeakReference, void>::kIID = NS_ISUPPORTSWEAKREFERENCE_IID;
+
+namespace test {
+
+class SignalingAgent;
+
+std::string indent(const std::string &s, int width = 4) {
+  std::string prefix;
+  std::string out;
+  char previous = '\n';
+  prefix.assign(width, ' ');
+  for (std::string::const_iterator i = s.begin(); i != s.end(); i++) {
+    if (previous == '\n') {
+      out += prefix;
+    }
+    out += *i;
+    previous = *i;
+  }
+  return out;
+}
+
+static const std::string strSampleSdpAudioVideoNoIce =
+  "v=0\r\n"
+  "o=Mozilla-SIPUA 4949 0 IN IP4 10.86.255.143\r\n"
+  "s=SIP Call\r\n"
+  "t=0 0\r\n"
+  "a=ice-ufrag:qkEP\r\n"
+  "a=ice-pwd:ed6f9GuHjLcoCN6sC/Eh7fVl\r\n"
+  "m=audio 16384 RTP/AVP 0 8 9 101\r\n"
+  "c=IN IP4 10.86.255.143\r\n"
+  "a=rtpmap:0 PCMU/8000\r\n"
+  "a=rtpmap:8 PCMA/8000\r\n"
+  "a=rtpmap:9 G722/8000\r\n"
+  "a=rtpmap:101 telephone-event/8000\r\n"
+  "a=fmtp:101 0-15\r\n"
+  "a=sendrecv\r\n"
+  "a=candidate:1 1 UDP 2130706431 192.168.2.1 50005 typ host\r\n"
+  "a=candidate:2 2 UDP 2130706431 192.168.2.2 50006 typ host\r\n"
+  "m=video 1024 RTP/AVP 97\r\n"
+  "c=IN IP4 10.86.255.143\r\n"
+  "a=rtpmap:120 VP8/90000\r\n"
+  "a=fmtp:97 profile-level-id=42E00C\r\n"
+  "a=sendrecv\r\n"
+  "a=candidate:1 1 UDP 2130706431 192.168.2.3 50007 typ host\r\n"
+  "a=candidate:2 2 UDP 2130706431 192.168.2.4 50008 typ host\r\n";
+
+static const std::string strSampleCandidate =
+  "a=candidate:1 1 UDP 2130706431 192.168.2.1 50005 typ host\r\n";
+
+static const std::string strSampleMid = "sdparta";
+
+static const unsigned short nSamplelevel = 2;
+
+static const std::string strG711SdpOffer =
+    "v=0\r\n"
+    "o=- 1 1 IN IP4 148.147.200.251\r\n"
+    "s=-\r\n"
+    "b=AS:64\r\n"
+    "t=0 0\r\n"
+    "a=fingerprint:sha-256 F3:FA:20:C0:CD:48:C4:5F:02:5F:A5:D3:21:D0:2D:48:"
+      "7B:31:60:5C:5A:D8:0D:CD:78:78:6C:6D:CE:CC:0C:67\r\n"
+    "m=audio 9000 RTP/AVP 0 8 126\r\n"
+    "c=IN IP4 148.147.200.251\r\n"
+    "b=TIAS:64000\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:126 telephone-event/8000\r\n"
+    "a=candidate:0 1 udp 2130706432 148.147.200.251 9000 typ host\r\n"
+    "a=candidate:0 2 udp 2130706432 148.147.200.251 9005 typ host\r\n"
+    "a=ice-ufrag:cYuakxkEKH+RApYE\r\n"
+    "a=ice-pwd:bwtpzLZD+3jbu8vQHvEa6Xuq\r\n"
+    "a=setup:active\r\n"
+    "a=sendrecv\r\n";
+
+
+enum sdpTestFlags
+{
+  HAS_ALL_CANDIDATES     = (1 << 0),
+};
+
+enum offerAnswerFlags
+{
+  OFFER_NONE  = 0, // Sugar to make function calls clearer.
+  OFFER_AUDIO = (1<<0),
+  OFFER_VIDEO = (1<<1),
+  // Leaving some room here for other media types
+  ANSWER_NONE  = 0, // Sugar to make function calls clearer.
+  ANSWER_AUDIO = (1<<8),
+  ANSWER_VIDEO = (1<<9),
+
+  OFFER_AV = OFFER_AUDIO | OFFER_VIDEO,
+  ANSWER_AV = ANSWER_AUDIO | ANSWER_VIDEO
+};
+
+ typedef enum {
+   NO_TRICKLE = 0,
+   OFFERER_TRICKLES = 1,
+   ANSWERER_TRICKLES = 2,
+   BOTH_TRICKLE = OFFERER_TRICKLES | ANSWERER_TRICKLES
+ } TrickleType;
+
+class TestObserver : public AFakePCObserver
+{
+protected:
+  ~TestObserver() {}
+
+public:
+  TestObserver(PeerConnectionImpl *peerConnection,
+               const std::string &aName) :
+    AFakePCObserver(peerConnection, aName),
+    lastAddIceStatusCode(PeerConnectionImpl::kNoError),
+    peerAgent(nullptr),
+    trickleCandidates(true)
+    {}
+
+  size_t MatchingCandidates(const std::string& cand) {
+    size_t count = 0;
+
+    for (size_t i=0; i<candidates.size(); ++i) {
+      if (candidates[i].find(cand) != std::string::npos)
+        ++count;
+    }
+
+    return count;
+  }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_IMETHOD OnCreateOfferSuccess(const char* offer, ER&) override;
+  NS_IMETHOD OnCreateOfferError(uint32_t code, const char *msg, ER&) override;
+  NS_IMETHOD OnCreateAnswerSuccess(const char* answer, ER&) override;
+  NS_IMETHOD OnCreateAnswerError(uint32_t code, const char *msg, ER&) override;
+  NS_IMETHOD OnSetLocalDescriptionSuccess(ER&) override;
+  NS_IMETHOD OnSetRemoteDescriptionSuccess(ER&) override;
+  NS_IMETHOD OnSetLocalDescriptionError(uint32_t code, const char *msg, ER&) override;
+  NS_IMETHOD OnSetRemoteDescriptionError(uint32_t code, const char *msg, ER&) override;
+  NS_IMETHOD NotifyDataChannel(nsIDOMDataChannel *channel, ER&) override;
+  NS_IMETHOD OnStateChange(PCObserverStateType state_type, ER&, void*) override;
+  NS_IMETHOD OnAddStream(DOMMediaStream &stream, ER&) override;
+  NS_IMETHOD OnRemoveStream(DOMMediaStream &stream, ER&) override;
+  NS_IMETHOD OnAddTrack(MediaStreamTrack &track, ER&) override;
+  NS_IMETHOD OnRemoveTrack(MediaStreamTrack &track, ER&) override;
+  NS_IMETHOD OnReplaceTrackSuccess(ER&) override;
+  NS_IMETHOD OnReplaceTrackError(uint32_t code, const char *msg, ER&) override;
+  NS_IMETHOD OnAddIceCandidateSuccess(ER&) override;
+  NS_IMETHOD OnAddIceCandidateError(uint32_t code, const char *msg, ER&) override;
+  NS_IMETHOD OnIceCandidate(uint16_t level, const char *mid, const char *cand, ER&) override;
+  NS_IMETHOD OnNegotiationNeeded(ER&) override;
+
+  // Hack because add_ice_candidates can happen asynchronously with respect
+  // to the API calls. The whole test suite needs a refactor.
+  ResponseState addIceCandidateState;
+  PeerConnectionImpl::Error lastAddIceStatusCode;
+
+  SignalingAgent* peerAgent;
+  bool trickleCandidates;
+};
+
+NS_IMPL_ISUPPORTS(TestObserver, nsISupportsWeakReference)
+
+NS_IMETHODIMP
+TestObserver::OnCreateOfferSuccess(const char* offer, ER&)
+{
+  lastString = offer;
+  state = stateSuccess;
+  std::cout << name << ": onCreateOfferSuccess = " << std::endl << indent(offer)
+            << std::endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnCreateOfferError(uint32_t code, const char *message, ER&)
+{
+  lastStatusCode = static_cast<PeerConnectionImpl::Error>(code);
+  state = stateError;
+  std::cout << name << ": onCreateOfferError = " << code
+            << " (" << message << ")" << std::endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnCreateAnswerSuccess(const char* answer, ER&)
+{
+  lastString = answer;
+  state = stateSuccess;
+  std::cout << name << ": onCreateAnswerSuccess =" << std::endl
+            << indent(answer) << std::endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnCreateAnswerError(uint32_t code, const char *message, ER&)
+{
+  lastStatusCode = static_cast<PeerConnectionImpl::Error>(code);
+  std::cout << name << ": onCreateAnswerError = " << code
+            << " (" << message << ")" << std::endl;
+  state = stateError;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnSetLocalDescriptionSuccess(ER&)
+{
+  lastStatusCode = PeerConnectionImpl::kNoError;
+  state = stateSuccess;
+  std::cout << name << ": onSetLocalDescriptionSuccess" << std::endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnSetRemoteDescriptionSuccess(ER&)
+{
+  lastStatusCode = PeerConnectionImpl::kNoError;
+  state = stateSuccess;
+  std::cout << name << ": onSetRemoteDescriptionSuccess" << std::endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnSetLocalDescriptionError(uint32_t code, const char *message, ER&)
+{
+  lastStatusCode = static_cast<PeerConnectionImpl::Error>(code);
+  state = stateError;
+  std::cout << name << ": onSetLocalDescriptionError = " << code
+            << " (" << message << ")" << std::endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnSetRemoteDescriptionError(uint32_t code, const char *message, ER&)
+{
+  lastStatusCode = static_cast<PeerConnectionImpl::Error>(code);
+  state = stateError;
+  std::cout << name << ": onSetRemoteDescriptionError = " << code
+            << " (" << message << ")" << std::endl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::NotifyDataChannel(nsIDOMDataChannel *channel, ER&)
+{
+  std::cout << name << ": NotifyDataChannel" << std::endl;
+  return NS_OK;
+}
+
+static const char* PCImplSignalingStateStrings[] = {
+  "SignalingInvalid",
+  "SignalingStable",
+  "SignalingHaveLocalOffer",
+  "SignalingHaveRemoteOffer",
+  "SignalingHaveLocalPranswer",
+  "SignalingHaveRemotePranswer",
+  "SignalingClosed"
+};
+
+static const char* PCImplIceConnectionStateStrings[] = {
+  "new",
+  "checking",
+  "connected",
+  "completed",
+  "failed",
+  "disconnected",
+  "closed"
+};
+
+static const char* PCImplIceGatheringStateStrings[] = {
+  "new",
+  "gathering",
+  "complete"
+};
+
+#ifdef SIGNALING_UNITTEST_STANDALONE
+static_assert(ArrayLength(PCImplSignalingStateStrings) ==
+	      size_t(PCImplSignalingState::EndGuard_),
+	      "Table sizes must match");
+static_assert(ArrayLength(PCImplIceConnectionStateStrings) ==
+	      size_t(PCImplIceConnectionState::EndGuard_),
+	      "Table sizes must match");
+static_assert(ArrayLength(PCImplIceGatheringStateStrings) ==
+	      size_t(PCImplIceGatheringState::EndGuard_),
+	      "Table sizes must match");
+#endif // SIGNALING_UNITTEST_STANDALONE
+
+NS_IMETHODIMP
+TestObserver::OnStateChange(PCObserverStateType state_type, ER&, void*)
+{
+  nsresult rv;
+  PCImplIceConnectionState gotice;
+  PCImplIceGatheringState goticegathering;
+  PCImplSignalingState gotsignaling;
+
+  std::cout << name << ": ";
+
+  switch (state_type)
+  {
+  case PCObserverStateType::IceConnectionState:
+    MOZ_ASSERT(NS_IsMainThread());
+    rv = pc->IceConnectionState(&gotice);
+    NS_ENSURE_SUCCESS(rv, rv);
+    std::cout << "ICE Connection State: "
+              << PCImplIceConnectionStateStrings[int(gotice)]
+              << std::endl;
+    break;
+  case PCObserverStateType::IceGatheringState:
+    MOZ_ASSERT(NS_IsMainThread());
+    rv = pc->IceGatheringState(&goticegathering);
+    NS_ENSURE_SUCCESS(rv, rv);
+    std::cout
+        << "ICE Gathering State: "
+        << PCImplIceGatheringStateStrings[int(goticegathering)]
+        << std::endl;
+    break;
+  case PCObserverStateType::SdpState:
+    std::cout << "SDP State: " << std::endl;
+    // NS_ENSURE_SUCCESS(rv, rv);
+    break;
+  case PCObserverStateType::SignalingState:
+    MOZ_ASSERT(NS_IsMainThread());
+    rv = pc->SignalingState(&gotsignaling);
+    NS_ENSURE_SUCCESS(rv, rv);
+    std::cout << "Signaling State: "
+              << PCImplSignalingStateStrings[int(gotsignaling)]
+              << std::endl;
+    break;
+  default:
+    // Unknown State
+    MOZ_CRASH("Unknown state change type.");
+    break;
+  }
+
+  lastStateType = state_type;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+TestObserver::OnAddStream(DOMMediaStream &stream, ER&)
+{
+  std::cout << name << ": OnAddStream called hints=" << stream.GetHintContents()
+            << " thread=" << PR_GetCurrentThread() << std::endl ;
+
+  onAddStreamCalled = true;
+
+  streams.push_back(&stream);
+
+  // We know that the media stream is secretly a Fake_SourceMediaStream,
+  // so now we can start it pulling from us
+  RefPtr<Fake_SourceMediaStream> fs =
+    static_cast<Fake_SourceMediaStream *>(stream.GetStream());
+
+  test_utils->sts_target()->Dispatch(
+    WrapRunnable(fs, &Fake_SourceMediaStream::Start),
+    NS_DISPATCH_NORMAL);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnRemoveStream(DOMMediaStream &stream, ER&)
+{
+  state = stateSuccess;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnAddTrack(MediaStreamTrack &track, ER&)
+{
+  state = stateSuccess;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnRemoveTrack(MediaStreamTrack &track, ER&)
+{
+  state = stateSuccess;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnReplaceTrackSuccess(ER&)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnReplaceTrackError(uint32_t code, const char *message, ER&)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnAddIceCandidateSuccess(ER&)
+{
+  lastAddIceStatusCode = PeerConnectionImpl::kNoError;
+  addIceCandidateState = TestObserver::stateSuccess;
+  std::cout << name << ": onAddIceCandidateSuccess" << std::endl;
+  addIceSuccessCount++;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnAddIceCandidateError(uint32_t code, const char *message, ER&)
+{
+  lastAddIceStatusCode = static_cast<PeerConnectionImpl::Error>(code);
+  addIceCandidateState = TestObserver::stateError;
+  std::cout << name << ": onAddIceCandidateError = " << code
+            << " (" << message << ")" << std::endl;
+  return NS_OK;
+}
+
+class ParsedSDP {
+ public:
+
+  explicit ParsedSDP(const std::string &sdp)
+  {
+    Parse(sdp);
+  }
+
+  void DeleteLines(const std::string &objType,
+                   uint32_t limit = UINT32_MAX)
+  {
+    for (auto it = sdp_lines_.begin(); it != sdp_lines_.end() && limit;) {
+      auto temp = it;
+      ++it;
+      if (temp->first == objType) {
+        sdp_lines_.erase(temp);
+        --limit;
+      }
+    }
+  }
+
+  void DeleteLine(const std::string &objType)
+  {
+    DeleteLines(objType, 1);
+  }
+
+  // Replaces the index-th instance of objType in the SDP with
+  // a new string.
+  // If content is an empty string then the line will be removed
+  void ReplaceLine(const std::string &objType,
+                   const std::string &content,
+                   size_t index = 0)
+  {
+    auto it = FindLine(objType, index);
+    if(it != sdp_lines_.end()) {
+      if (content.empty()) {
+        sdp_lines_.erase(it);
+      } else {
+        (*it) = MakeKeyValue(content);
+      }
+    }
+  }
+
+  void AddLine(const std::string &content)
+  {
+    sdp_lines_.push_back(MakeKeyValue(content));
+  }
+
+  static std::pair<std::string, std::string> MakeKeyValue(
+      const std::string &content)
+  {
+    size_t whiteSpace = content.find(' ');
+    std::string key;
+    std::string value;
+    if (whiteSpace == std::string::npos) {
+      //this is the line with no extra contents
+      //example, v=0, a=sendrecv
+      key = content.substr(0,  content.size() - 2);
+      value = "\r\n"; // Checking code assumes this is here.
+    } else {
+      key = content.substr(0, whiteSpace);
+      value = content.substr(whiteSpace+1);
+    }
+    return std::make_pair(key, value);
+  }
+
+  std::list<std::pair<std::string, std::string>>::iterator FindLine(
+      const std::string& objType,
+      size_t index = 0)
+  {
+    for (auto it = sdp_lines_.begin(); it != sdp_lines_.end(); ++it) {
+      if (it->first == objType) {
+        if (index == 0) {
+          return it;
+        }
+        --index;
+      }
+    }
+    return sdp_lines_.end();
+  }
+
+  void InsertLineAfter(const std::string &objType,
+                       const std::string &content,
+                       size_t index = 0)
+  {
+    auto it = FindLine(objType, index);
+    if (it != sdp_lines_.end()) {
+      sdp_lines_.insert(++it, MakeKeyValue(content));
+    }
+  }
+
+  // Returns the values for all lines of the indicated type
+  // Removes trailing "\r\n" from values.
+  std::vector<std::string> GetLines(std::string objType) const
+  {
+    std::vector<std::string> values;
+    for (auto it = sdp_lines_.begin(); it != sdp_lines_.end(); ++it) {
+      if (it->first == objType) {
+        std::string value = it->second;
+        if (value.find("\r") != std::string::npos) {
+          value = value.substr(0, value.find("\r"));
+        } else {
+          ADD_FAILURE() << "SDP line had no endline; this should never happen.";
+        }
+        values.push_back(value);
+      }
+    }
+    return values;
+  }
+
+  //Parse SDP as std::string into map that looks like:
+  // key: sdp content till first space
+  // value: sdp content after the first space, _including_ \r\n
+  void Parse(const std::string &sdp)
+  {
+    size_t prev = 0;
+    size_t found = 0;
+    for(;;) {
+      found = sdp.find('\n', found + 1);
+      if (found == std::string::npos)
+        break;
+      std::string line = sdp.substr(prev, (found - prev) + 1);
+      sdp_lines_.push_back(MakeKeyValue(line));
+
+      prev = found + 1;
+    }
+  }
+
+  //Convert Internal SDP representation into String representation
+  std::string getSdp() const
+  {
+    std::string sdp;
+
+    for (auto it = sdp_lines_.begin(); it != sdp_lines_.end(); ++it) {
+      sdp += it->first;
+      if (it->second != "\r\n") {
+        sdp += " ";
+      }
+      sdp += it->second;
+    }
+
+    return sdp;
+  }
+
+  void IncorporateCandidate(uint16_t level, const std::string &candidate)
+  {
+    std::string candidate_attribute("a=" + candidate + "\r\n");
+    // InsertLineAfter is 0 indexed, but level is 1 indexed
+    // This assumes that we have only media-level c lines.
+    InsertLineAfter("c=IN", candidate_attribute, level - 1);
+  }
+
+  std::list<std::pair<std::string, std::string>> sdp_lines_;
+};
+
+
+// This class wraps the PeerConnection object and ensures that all calls
+// into it happen on the main thread.
+class PCDispatchWrapper : public nsSupportsWeakReference
+{
+ protected:
+  virtual ~PCDispatchWrapper() {}
+
+ public:
+  explicit PCDispatchWrapper(const RefPtr<PeerConnectionImpl>& peerConnection)
+    : pc_(peerConnection) {}
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  PeerConnectionImpl *pcImpl() const {
+    return pc_;
+  }
+
+  const RefPtr<PeerConnectionMedia>& media() const {
+    return pc_->media();
+  }
+
+  NS_IMETHODIMP Initialize(TestObserver* aObserver,
+                           nsGlobalWindow* aWindow,
+                           const PeerConnectionConfiguration& aConfiguration,
+                           nsIThread* aThread) {
+    nsresult rv;
+
+    observer_ = aObserver;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->Initialize(*aObserver, aWindow, aConfiguration, aThread);
+    } else {
+      // It would have been preferable here to dispatch directly to
+      // PeerConnectionImpl::Initialize but since all the PC methods
+      // have overrides clang will throw a 'couldn't infer template
+      // argument' error.
+      // Instead we are dispatching back to the same method for
+      // all of these.
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::Initialize,
+          aObserver, aWindow, aConfiguration, aThread),
+        NS_DISPATCH_SYNC);
+      rv = NS_OK;
+    }
+
+    return rv;
+  }
+
+  NS_IMETHODIMP CreateOffer(const mozilla::JsepOfferOptions& aOptions) {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->CreateOffer(aOptions);
+      EXPECT_EQ(NS_OK, rv);
+      if (NS_FAILED(rv))
+        return rv;
+      EXPECT_EQ(TestObserver::stateSuccess, observer_->state);
+      if (observer_->state != TestObserver::stateSuccess) {
+        return NS_ERROR_FAILURE;
+      }
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::CreateOffer, aOptions),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+  NS_IMETHODIMP CreateAnswer() {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->CreateAnswer();
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::CreateAnswer),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+  NS_IMETHODIMP SetLocalDescription (int32_t aAction, const char* aSDP) {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->SetLocalDescription(aAction, aSDP);
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::SetLocalDescription,
+          aAction, aSDP),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+  NS_IMETHODIMP SetRemoteDescription (int32_t aAction, const char* aSDP) {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->SetRemoteDescription(aAction, aSDP);
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::SetRemoteDescription,
+          aAction, aSDP),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+  NS_IMETHODIMP AddIceCandidate(const char* aCandidate, const char* aMid,
+                                unsigned short aLevel) {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->AddIceCandidate(aCandidate, aMid, aLevel);
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::AddIceCandidate,
+          aCandidate, aMid, aLevel),
+        NS_DISPATCH_SYNC);
+    }
+    return rv;
+  }
+
+  NS_IMETHODIMP AddTrack(MediaStreamTrack *aTrack,
+                         DOMMediaStream *aMediaStream)
+  {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->AddTrack(*aTrack, *aMediaStream);
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::AddTrack, aTrack,
+                        aMediaStream),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+  NS_IMETHODIMP RemoveTrack(MediaStreamTrack *aTrack) {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->RemoveTrack(*aTrack);
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::RemoveTrack, aTrack),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+  NS_IMETHODIMP GetLocalDescription(char** aSDP) {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->GetLocalDescription(aSDP);
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::GetLocalDescription,
+          aSDP),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+  NS_IMETHODIMP GetRemoteDescription(char** aSDP) {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->GetRemoteDescription(aSDP);
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::GetRemoteDescription,
+          aSDP),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+  mozilla::dom::PCImplSignalingState SignalingState() {
+    mozilla::dom::PCImplSignalingState result;
+
+    if (NS_IsMainThread()) {
+      result = pc_->SignalingState();
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&result, this, &PCDispatchWrapper::SignalingState),
+        NS_DISPATCH_SYNC);
+    }
+
+    return result;
+  }
+
+  mozilla::dom::PCImplIceConnectionState IceConnectionState() {
+    mozilla::dom::PCImplIceConnectionState result;
+
+    if (NS_IsMainThread()) {
+      result = pc_->IceConnectionState();
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&result, this, &PCDispatchWrapper::IceConnectionState),
+        NS_DISPATCH_SYNC);
+    }
+
+    return result;
+  }
+
+  mozilla::dom::PCImplIceGatheringState IceGatheringState() {
+    mozilla::dom::PCImplIceGatheringState result;
+
+    if (NS_IsMainThread()) {
+      result = pc_->IceGatheringState();
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&result, this, &PCDispatchWrapper::IceGatheringState),
+        NS_DISPATCH_SYNC);
+    }
+
+    return result;
+  }
+
+  NS_IMETHODIMP Close() {
+    nsresult rv;
+
+    if (NS_IsMainThread()) {
+      rv = pc_->Close();
+    } else {
+      gMainThread->Dispatch(
+        WrapRunnableRet(&rv, this, &PCDispatchWrapper::Close),
+        NS_DISPATCH_SYNC);
+    }
+
+    return rv;
+  }
+
+ private:
+  RefPtr<PeerConnectionImpl> pc_;
+  RefPtr<TestObserver> observer_;
+};
+
+NS_IMPL_ISUPPORTS(PCDispatchWrapper, nsISupportsWeakReference)
+
+
+struct Msid
+{
+  std::string streamId;
+  std::string trackId;
+  bool operator<(const Msid& other) const {
+    if (streamId < other.streamId) {
+      return true;
+    }
+
+    if (streamId > other.streamId) {
+      return false;
+    }
+
+    return trackId < other.trackId;
+  }
+};
+
+class SignalingAgent {
+ public:
+  explicit SignalingAgent(const std::string &aName,
+    const std::string stun_addr = g_stun_server_address,
+    uint16_t stun_port = g_stun_server_port) :
+    pc(nullptr),
+    name(aName),
+    mBundleEnabled(true),
+    mExpectedFrameRequestType(VideoSessionConduit::FrameRequestPli),
+    mExpectNack(true),
+    mExpectRtcpMuxAudio(true),
+    mExpectRtcpMuxVideo(true),
+    mRemoteDescriptionSet(false) {
+    cfg_.addStunServer(stun_addr, stun_port, kNrIceTransportUdp);
+    cfg_.addStunServer(stun_addr, stun_port, kNrIceTransportTcp);
+
+    PeerConnectionImpl *pcImpl =
+      PeerConnectionImpl::CreatePeerConnection();
+    EXPECT_TRUE(pcImpl);
+    pcImpl->SetAllowIceLoopback(true);
+    pcImpl->SetAllowIceLinkLocal(true);
+    pc = new PCDispatchWrapper(pcImpl);
+  }
+
+
+  ~SignalingAgent() {
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+      WrapRunnable(this, &SignalingAgent::Close));
+  }
+
+  void Init_m()
+  {
+    pObserver = new TestObserver(pc->pcImpl(), name);
+    ASSERT_TRUE(pObserver);
+
+    ASSERT_EQ(pc->Initialize(pObserver, nullptr, cfg_, gMainThread), NS_OK);
+  }
+
+  void Init()
+  {
+    mozilla::SyncRunnable::DispatchToThread(gMainThread,
+      WrapRunnable(this, &SignalingAgent::Init_m));
+  }
+
+  void SetBundleEnabled(bool enabled)
+  {
+    mBundleEnabled = enabled;
+  }
+
+  void SetBundlePolicy(JsepBundlePolicy policy)
+  {
+    cfg_.setBundlePolicy(policy);
+  }
+
+  void SetExpectedFrameRequestType(VideoSessionConduit::FrameRequestType type)
+  {
+    mExpectedFrameRequestType = type;
+  }
+
+  void WaitForGather() {
+    ASSERT_TRUE_WAIT(ice_gathering_state() == PCImplIceGatheringState::Complete,
+                     kDefaultTimeout);
+
+    std::cout << name << ": Init Complete" << std::endl;
+
+    // Check that the default candidate has been filled out with something
+    std::string localSdp = getLocalDescription();
+
+    std::cout << "Local SDP after gather: " << localSdp;
+    ASSERT_EQ(std::string::npos, localSdp.find("c=IN IP4 0.0.0.0"));
+    ASSERT_EQ(std::string::npos, localSdp.find("m=video 9 "));
+    ASSERT_EQ(std::string::npos, localSdp.find("m=audio 9 "));
+
+    // TODO(bug 1098584): Check for end-of-candidates attr
+  }
+
+  bool WaitForGatherAllowFail() {
+    EXPECT_TRUE_WAIT(
+        ice_gathering_state() == PCImplIceGatheringState::Complete ||
+        ice_connection_state() == PCImplIceConnectionState::Failed,
+        kDefaultTimeout);
+
+    if (ice_connection_state() == PCImplIceConnectionState::Failed) {
+      std::cout << name << ": Init Failed" << std::endl;
+      return false;
+    }
+
+    std::cout << name << "Init Complete" << std::endl;
+    return true;
+  }
+
+  void DropOutgoingTrickleCandidates() {
+    pObserver->trickleCandidates = false;
+  }
+
+  PCImplIceConnectionState ice_connection_state()
+  {
+    return pc->IceConnectionState();
+  }
+
+  PCImplIceGatheringState ice_gathering_state()
+  {
+    return pc->IceGatheringState();
+  }
+
+  PCImplSignalingState signaling_state()
+  {
+    return pc->SignalingState();
+  }
+
+  void Close()
+  {
+    std::cout << name << ": Close" << std::endl;
+
+    pc->Close();
+    pc = nullptr;
+    pObserver = nullptr;
+  }
+
+  bool OfferContains(const std::string& str) {
+    return offer().find(str) != std::string::npos;
+  }
+
+  bool AnswerContains(const std::string& str) {
+    return answer().find(str) != std::string::npos;
+  }
+
+  size_t MatchingCandidates(const std::string& cand) {
+    return pObserver->MatchingCandidates(cand);
+  }
+
+  const std::string& offer() const { return offer_; }
+  const std::string& answer() const { return answer_; }
+
+  std::string getLocalDescription() const {
+    char *sdp = nullptr;
+    pc->GetLocalDescription(&sdp);
+    if (!sdp) {
+      return "";
+    }
+    std::string result(sdp);
+    delete sdp;
+    return result;
+  }
+
+  std::string getRemoteDescription() const {
+    char *sdp = 0;
+    pc->GetRemoteDescription(&sdp);
+    if (!sdp) {
+      return "";
+    }
+    std::string result(sdp);
+    delete sdp;
+    return result;
+  }
+
+  std::string RemoveBundle(const std::string& sdp) const {
+    ParsedSDP parsed(sdp);
+    parsed.DeleteLines("a=group:BUNDLE");
+    return parsed.getSdp();
+  }
+
+  // Adds a stream to the PeerConnection.
+  void AddStream(uint32_t hint =
+         DOMMediaStream::HINT_CONTENTS_AUDIO |
+         DOMMediaStream::HINT_CONTENTS_VIDEO,
+       MediaStream *stream = nullptr) {
+
+    if (!stream && (hint & DOMMediaStream::HINT_CONTENTS_AUDIO)) {
+      // Useful default
+      // Create a media stream as if it came from GUM
+      Fake_AudioStreamSource *audio_stream =
+        new Fake_AudioStreamSource();
+
+      nsresult ret;
+      mozilla::SyncRunnable::DispatchToThread(
+        test_utils->sts_target(),
+        WrapRunnableRet(&ret, audio_stream, &Fake_MediaStream::Start));
+
+      ASSERT_TRUE(NS_SUCCEEDED(ret));
+      stream = audio_stream;
+    }
+
+    RefPtr<DOMMediaStream> domMediaStream = new DOMMediaStream(stream);
+    domMediaStream->SetHintContents(hint);
+
+    nsTArray<RefPtr<MediaStreamTrack>> tracks;
+    domMediaStream->GetTracks(tracks);
+    for (uint32_t i = 0; i < tracks.Length(); i++) {
+      Msid msid = {domMediaStream->GetId(), tracks[i]->GetId()};
+
+      ASSERT_FALSE(mAddedTracks.count(msid))
+        << msid.streamId << "/" << msid.trackId << " already added";
+
+      mAddedTracks[msid] = (tracks[i]->AsVideoStreamTrack() ?
+                            SdpMediaSection::kVideo :
+                            SdpMediaSection::kAudio);
+
+      ASSERT_EQ(pc->AddTrack(tracks[i], domMediaStream), NS_OK);
+    }
+    domMediaStreams_.push_back(domMediaStream);
+  }
+
+  // I would love to make this an overload of operator<<, but there's no way to
+  // declare it in a way that works with gtest's header files.
+  std::string DumpTracks(
+      const std::map<Msid, SdpMediaSection::MediaType>& tracks) const
+  {
+    std::ostringstream oss;
+    for (auto it = tracks.begin(); it != tracks.end(); ++it) {
+      oss << it->first.streamId << "/" << it->first.trackId
+          << " (" << it->second << ")" << std::endl;
+    }
+
+    return oss.str();
+  }
+
+  void ExpectMissingTracks(SdpMediaSection::MediaType type)
+  {
+    for (auto it = mAddedTracks.begin(); it != mAddedTracks.end();) {
+      if (it->second == type) {
+        auto temp = it;
+        ++it;
+        mAddedTracks.erase(temp);
+      } else {
+        ++it;
+      }
+    }
+  }
+
+  void CheckLocalPipeline(const std::string& streamId,
+                          const std::string& trackId,
+                          SdpMediaSection::MediaType type,
+                          int pipelineCheckFlags = 0) const
+  {
+    LocalSourceStreamInfo* info;
+    mozilla::SyncRunnable::DispatchToThread(
+      gMainThread, WrapRunnableRet(&info,
+        pc->media(), &PeerConnectionMedia::GetLocalStreamById,
+        streamId));
+
+    ASSERT_TRUE(info) << "No such local stream id: " << streamId;
+
+    RefPtr<MediaPipeline> pipeline;
+
+    mozilla::SyncRunnable::DispatchToThread(
+        gMainThread,
+        WrapRunnableRet(&pipeline, info,
+                        &SourceStreamInfo::GetPipelineByTrackId_m,
+                        trackId));
+
+    ASSERT_TRUE(pipeline) << "No such local track id: " << trackId;
+
+    if (type == SdpMediaSection::kVideo) {
+      ASSERT_TRUE(pipeline->IsVideo()) << "Local track " << trackId
+                                       << " was not video";
+      ASSERT_EQ(mExpectRtcpMuxVideo, pipeline->IsDoingRtcpMux())
+        << "Pipeline for remote track " << trackId
+        << " is" << (mExpectRtcpMuxVideo ? " not " : " ") << "using rtcp-mux";
+      // No checking for video RTP yet, since we don't have support for fake
+      // video here yet. (bug 1142320)
+    } else {
+      ASSERT_FALSE(pipeline->IsVideo()) << "Local track " << trackId
+                                        << " was not audio";
+      WAIT(pipeline->rtp_packets_sent() >= 4 &&
+           pipeline->rtcp_packets_received() >= 1,
+           kDefaultTimeout);
+      ASSERT_LE(4, pipeline->rtp_packets_sent())
+        << "Local track " << trackId << " isn't sending RTP";
+      ASSERT_LE(1, pipeline->rtcp_packets_received())
+        << "Local track " << trackId << " isn't receiving RTCP";
+      ASSERT_EQ(mExpectRtcpMuxAudio, pipeline->IsDoingRtcpMux())
+        << "Pipeline for remote track " << trackId
+        << " is" << (mExpectRtcpMuxAudio ? " not " : " ") << "using rtcp-mux";
+    }
+  }
+
+  void CheckRemotePipeline(const std::string& streamId,
+                           const std::string& trackId,
+                           SdpMediaSection::MediaType type,
+                           int pipelineCheckFlags = 0) const
+  {
+    RemoteSourceStreamInfo* info;
+    mozilla::SyncRunnable::DispatchToThread(
+      gMainThread, WrapRunnableRet(&info,
+        pc->media(), &PeerConnectionMedia::GetRemoteStreamById,
+        streamId));
+
+    ASSERT_TRUE(info) << "No such remote stream id: " << streamId;
+
+    RefPtr<MediaPipeline> pipeline;
+
+    mozilla::SyncRunnable::DispatchToThread(
+        gMainThread,
+        WrapRunnableRet(&pipeline, info,
+                        &SourceStreamInfo::GetPipelineByTrackId_m,
+                        trackId));
+
+    ASSERT_TRUE(pipeline) << "No such remote track id: " << trackId;
+
+    if (type == SdpMediaSection::kVideo) {
+      ASSERT_TRUE(pipeline->IsVideo()) << "Remote track " << trackId
+                                       << " was not video";
+      mozilla::MediaSessionConduit *conduit = pipeline->Conduit();
+      ASSERT_TRUE(conduit);
+      ASSERT_EQ(conduit->type(), mozilla::MediaSessionConduit::VIDEO);
+      mozilla::VideoSessionConduit *video_conduit =
+        static_cast<mozilla::VideoSessionConduit*>(conduit);
+      ASSERT_EQ(mExpectNack, video_conduit->UsingNackBasic());
+      ASSERT_EQ(mExpectedFrameRequestType,
+                video_conduit->FrameRequestMethod());
+      ASSERT_EQ(mExpectRtcpMuxVideo, pipeline->IsDoingRtcpMux())
+        << "Pipeline for remote track " << trackId
+        << " is" << (mExpectRtcpMuxVideo ? " not " : " ") << "using rtcp-mux";
+      // No checking for video RTP yet, since we don't have support for fake
+      // video here yet. (bug 1142320)
+    } else {
+      ASSERT_FALSE(pipeline->IsVideo()) << "Remote track " << trackId
+                                        << " was not audio";
+      WAIT(pipeline->rtp_packets_received() >= 4 &&
+           pipeline->rtcp_packets_sent() >= 1,
+           kDefaultTimeout);
+      ASSERT_LE(4, pipeline->rtp_packets_received())
+        << "Remote track " << trackId << " isn't receiving RTP";
+      ASSERT_LE(1, pipeline->rtcp_packets_sent())
+        << "Remote track " << trackId << " isn't sending RTCP";
+      ASSERT_EQ(mExpectRtcpMuxAudio, pipeline->IsDoingRtcpMux())
+        << "Pipeline for remote track " << trackId
+        << " is" << (mExpectRtcpMuxAudio ? " not " : " ") << "using rtcp-mux";
+    }
+  }
+
+  void RemoveTrack(size_t streamIndex, bool videoTrack = false)
+  {
+    ASSERT_LT(streamIndex, domMediaStreams_.size());
+    nsTArray<RefPtr<MediaStreamTrack>> tracks;
+    domMediaStreams_[streamIndex]->GetTracks(tracks);
+    for (size_t i = 0; i < tracks.Length(); ++i) {
+      if (!!tracks[i]->AsVideoStreamTrack() == videoTrack) {
+        Msid msid;
+        msid.streamId = domMediaStreams_[streamIndex]->GetId();
+        msid.trackId = tracks[i]->GetId();
+        mAddedTracks.erase(msid);
+        ASSERT_EQ(pc->RemoveTrack(tracks[i]), NS_OK);
+      }
+    }
+  }
+
+  void RemoveStream(size_t index) {
+    nsTArray<RefPtr<MediaStreamTrack>> tracks;
+    domMediaStreams_[index]->GetTracks(tracks);
+    for (uint32_t i = 0; i < tracks.Length(); i++) {
+      ASSERT_EQ(pc->RemoveTrack(tracks[i]), NS_OK);
+    }
+    domMediaStreams_.erase(domMediaStreams_.begin() + index);
+  }
+
+  // Removes the stream that was most recently added to the PeerConnection.
+  void RemoveLastStreamAdded() {
+    ASSERT_FALSE(domMediaStreams_.empty());
+    RemoveStream(domMediaStreams_.size() - 1);
+  }
+
+  void CreateOffer(OfferOptions& options,
+                   uint32_t offerFlags,
+                   PCImplSignalingState endState =
+                     PCImplSignalingState::SignalingStable) {
+
+    uint32_t aHintContents = 0;
+    if (offerFlags & OFFER_AUDIO) {
+      aHintContents |= DOMMediaStream::HINT_CONTENTS_AUDIO;
+    }
+    if (offerFlags & OFFER_VIDEO) {
+      aHintContents |= DOMMediaStream::HINT_CONTENTS_VIDEO;
+    }
+    AddStream(aHintContents);
+
+    // Now call CreateOffer as JS would
+    pObserver->state = TestObserver::stateNoResponse;
+    ASSERT_EQ(pc->CreateOffer(options), NS_OK);
+
+    ASSERT_EQ(pObserver->state, TestObserver::stateSuccess);
+    ASSERT_EQ(signaling_state(), endState);
+    offer_ = pObserver->lastString;
+    if (!mBundleEnabled) {
+      offer_ = RemoveBundle(offer_);
+    }
+  }
+
+  // sets the offer to match the local description
+  // which isn't good if you are the answerer
+  void UpdateOffer() {
+    offer_ = getLocalDescription();
+    if (!mBundleEnabled) {
+      offer_ = RemoveBundle(offer_);
+    }
+  }
+
+  void CreateAnswer(uint32_t offerAnswerFlags,
+                    PCImplSignalingState endState =
+                    PCImplSignalingState::SignalingHaveRemoteOffer) {
+    // Create a media stream as if it came from GUM
+    Fake_AudioStreamSource *audio_stream =
+      new Fake_AudioStreamSource();
+
+    nsresult ret;
+    mozilla::SyncRunnable::DispatchToThread(
+      test_utils->sts_target(),
+      WrapRunnableRet(&ret, audio_stream, &Fake_MediaStream::Start));
+
+    ASSERT_TRUE(NS_SUCCEEDED(ret));
+
+    uint32_t aHintContents = 0;
+    if (offerAnswerFlags & ANSWER_AUDIO) {
+      aHintContents |= DOMMediaStream::HINT_CONTENTS_AUDIO;
+    }
+    if (offerAnswerFlags & ANSWER_VIDEO) {
+      aHintContents |= DOMMediaStream::HINT_CONTENTS_VIDEO;
+    }
+    AddStream(aHintContents, audio_stream);
+
+    // Decide if streams are disabled for offer or answer
+    // then perform SDP checking based on which stream disabled
+    pObserver->state = TestObserver::stateNoResponse;
+    ASSERT_EQ(pc->CreateAnswer(), NS_OK);
+    ASSERT_EQ(pObserver->state, TestObserver::stateSuccess);
+    ASSERT_EQ(signaling_state(), endState);
+
+    answer_ = pObserver->lastString;
+    if (!mBundleEnabled) {
+      answer_ = RemoveBundle(answer_);
+    }
+  }
+
+  // sets the answer to match the local description
+  // which isn't good if you are the offerer
+  void UpdateAnswer() {
+    answer_ = getLocalDescription();
+    if (!mBundleEnabled) {
+      answer_ = RemoveBundle(answer_);
+    }
+  }
+
+  void CreateOfferRemoveTrack(OfferOptions& options, bool videoTrack) {
+
+    RemoveTrack(0, videoTrack);
+
+    // Now call CreateOffer as JS would
+    pObserver->state = TestObserver::stateNoResponse;
+    ASSERT_EQ(pc->CreateOffer(options), NS_OK);
+    ASSERT_TRUE(pObserver->state == TestObserver::stateSuccess);
+    offer_ = pObserver->lastString;
+    if (!mBundleEnabled) {
+      offer_ = RemoveBundle(offer_);
+    }
+  }
+
+  void SetRemote(TestObserver::Action action, const std::string& remote,
+                 bool ignoreError = false,
+                 PCImplSignalingState endState =
+                 PCImplSignalingState::SignalingInvalid) {
+
+    if (endState == PCImplSignalingState::SignalingInvalid) {
+      endState = (action == TestObserver::OFFER ?
+                  PCImplSignalingState::SignalingHaveRemoteOffer :
+                  PCImplSignalingState::SignalingStable);
+    }
+
+    pObserver->state = TestObserver::stateNoResponse;
+    ASSERT_EQ(pc->SetRemoteDescription(action, remote.c_str()), NS_OK);
+    ASSERT_EQ(signaling_state(), endState);
+    if (!ignoreError) {
+      ASSERT_EQ(pObserver->state, TestObserver::stateSuccess);
+    }
+
+    mRemoteDescriptionSet = true;
+    for (auto i = deferredCandidates_.begin();
+         i != deferredCandidates_.end();
+         ++i) {
+      AddIceCandidate(i->candidate.c_str(),
+                      i->mid.c_str(),
+                      i->level,
+                      i->expectSuccess);
+    }
+    deferredCandidates_.clear();
+  }
+
+  void SetLocal(TestObserver::Action action, const std::string& local,
+                bool ignoreError = false,
+                PCImplSignalingState endState =
+                PCImplSignalingState::SignalingInvalid) {
+
+    if (endState == PCImplSignalingState::SignalingInvalid) {
+      endState = (action == TestObserver::OFFER ?
+                  PCImplSignalingState::SignalingHaveLocalOffer :
+                  PCImplSignalingState::SignalingStable);
+    }
+
+    pObserver->state = TestObserver::stateNoResponse;
+    ASSERT_EQ(pc->SetLocalDescription(action, local.c_str()), NS_OK);
+    ASSERT_EQ(signaling_state(), endState);
+    if (!ignoreError) {
+      ASSERT_EQ(pObserver->state, TestObserver::stateSuccess);
+    }
+  }
+
+  typedef enum {
+    NORMAL_ENCODING,
+    CHROME_ENCODING
+  } TrickleEncoding;
+
+  bool IceCompleted() {
+    return pc->IceConnectionState() == PCImplIceConnectionState::Connected;
+  }
+
+  void AddIceCandidateStr(const std::string& candidate, const std::string& mid,
+                          unsigned short level) {
+    if (!mRemoteDescriptionSet) {
+      // Not time to add this, because the unit-test code hasn't set the
+      // description yet.
+      DeferredCandidate candidateStruct = {candidate, mid, level, true};
+      deferredCandidates_.push_back(candidateStruct);
+    } else {
+      AddIceCandidate(candidate, mid, level, true);
+    }
+  }
+
+  void AddIceCandidate(const std::string& candidate, const std::string& mid, unsigned short level,
+                       bool expectSuccess) {
+    PCImplSignalingState endState = signaling_state();
+    pObserver->addIceCandidateState = TestObserver::stateNoResponse;
+    pc->AddIceCandidate(candidate.c_str(), mid.c_str(), level);
+    ASSERT_TRUE(pObserver->addIceCandidateState ==
+                expectSuccess ? TestObserver::stateSuccess :
+                                TestObserver::stateError
+               );
+
+    // Verify that adding ICE candidates does not change the signaling state
+    ASSERT_EQ(signaling_state(), endState);
+    ASSERT_NE("", mid);
+  }
+
+  int GetPacketsReceived(const std::string& streamId) const
+  {
+    std::vector<DOMMediaStream *> streams = pObserver->GetStreams();
+
+    for (size_t i = 0; i < streams.size(); ++i) {
+      if (streams[i]->GetId() == streamId) {
+        return GetPacketsReceived(i);
+      }
+    }
+
+    EXPECT_TRUE(false);
+    return 0;
+  }
+
+  int GetPacketsReceived(size_t stream) const {
+    std::vector<DOMMediaStream *> streams = pObserver->GetStreams();
+
+    if (streams.size() <= stream) {
+      EXPECT_TRUE(false);
+      return 0;
+    }
+
+    return streams[stream]->GetStream()->AsSourceStream()->GetSegmentsAdded();
+  }
+
+  int GetPacketsSent(const std::string& streamId) const
+  {
+    for (size_t i = 0; i < domMediaStreams_.size(); ++i) {
+      if (domMediaStreams_[i]->GetId() == streamId) {
+        return GetPacketsSent(i);
+      }
+    }
+
+    EXPECT_TRUE(false);
+    return 0;
+  }
+
+  int GetPacketsSent(size_t stream) const {
+    if (stream >= domMediaStreams_.size()) {
+      EXPECT_TRUE(false);
+      return 0;
+    }
+
+    return static_cast<Fake_MediaStreamBase *>(
+        domMediaStreams_[stream]->GetStream())->GetSegmentsAdded();
+  }
+
+  //Stops generating new audio data for transmission.
+  //Should be called before Cleanup of the peer connection.
+  void CloseSendStreams() {
+    for (auto i = domMediaStreams_.begin(); i != domMediaStreams_.end(); ++i) {
+      static_cast<Fake_MediaStream*>((*i)->GetStream())->StopStream();
+    }
+  }
+
+  //Stops pulling audio data off the receivers.
+  //Should be called before Cleanup of the peer connection.
+  void CloseReceiveStreams() {
+    std::vector<DOMMediaStream *> streams =
+                            pObserver->GetStreams();
+    for (size_t i = 0; i < streams.size(); i++) {
+      streams[i]->GetStream()->AsSourceStream()->StopStream();
+    }
+  }
+
+  // Right now we have no convenient way for this unit-test to learn the track
+  // ids of the tracks, so they can be queried later. We could either expose
+  // the JsepSessionImpl in some way, or we could parse the identifiers out of
+  // the SDP. For now, we just specify audio/video, since a given DOMMediaStream
+  // can have only one of each anyway. Once this is fixed, we will need to
+  // pass a real track id if we want to test that case.
+  RefPtr<mozilla::MediaPipeline> GetMediaPipeline(
+    bool local, size_t stream, bool video) {
+    SourceStreamInfo* streamInfo;
+    if (local) {
+      mozilla::SyncRunnable::DispatchToThread(
+        gMainThread, WrapRunnableRet(&streamInfo,
+          pc->media(), &PeerConnectionMedia::GetLocalStreamByIndex,
+          stream));
+    } else {
+      mozilla::SyncRunnable::DispatchToThread(
+        gMainThread, WrapRunnableRet(&streamInfo,
+          pc->media(), &PeerConnectionMedia::GetRemoteStreamByIndex,
+          stream));
+    }
+
+    if (!streamInfo) {
+      return nullptr;
+    }
+
+    const auto &pipelines = streamInfo->GetPipelines();
+
+    for (auto i = pipelines.begin(); i != pipelines.end(); ++i) {
+      if (i->second->IsVideo() == video) {
+        std::cout << "Got MediaPipeline " << i->second->trackid();
+        return i->second;
+      }
+    }
+    return nullptr;
+  }
+
+  void SetPeer(SignalingAgent* peer) {
+    pObserver->peerAgent = peer;
+  }
+
+public:
+  RefPtr<PCDispatchWrapper> pc;
+  RefPtr<TestObserver> pObserver;
+  std::string offer_;
+  std::string answer_;
+  std::vector<RefPtr<DOMMediaStream>> domMediaStreams_;
+  PeerConnectionConfiguration cfg_;
+  const std::string name;
+  bool mBundleEnabled;
+  VideoSessionConduit::FrameRequestType mExpectedFrameRequestType;
+  bool mExpectNack;
+  bool mExpectRtcpMuxAudio;
+  bool mExpectRtcpMuxVideo;
+  bool mRemoteDescriptionSet;
+
+  std::map<Msid, SdpMediaSection::MediaType> mAddedTracks;
+
+  typedef struct {
+    std::string candidate;
+    std::string mid;
+    uint16_t level;
+    bool expectSuccess;
+  } DeferredCandidate;
+
+  std::list<DeferredCandidate> deferredCandidates_;
+};
+
+static void AddIceCandidateToPeer(nsWeakPtr weak_observer,
+                                  uint16_t level,
+                                  const std::string &mid,
+                                  const std::string &cand) {
+  nsCOMPtr<nsISupportsWeakReference> tmp = do_QueryReferent(weak_observer);
+  if (!tmp) {
+    return;
+  }
+
+  RefPtr<nsSupportsWeakReference> tmp2 = do_QueryObject(tmp);
+  RefPtr<TestObserver> observer = static_cast<TestObserver*>(&*tmp2);
+
+  if (!observer) {
+    return;
+  }
+
+  observer->candidates.push_back(cand);
+
+  if (!observer->peerAgent || !observer->trickleCandidates) {
+    return;
+  }
+
+  observer->peerAgent->AddIceCandidateStr(cand, mid, level);
+}
+
+
+NS_IMETHODIMP
+TestObserver::OnIceCandidate(uint16_t level,
+                             const char * mid,
+                             const char * candidate, ER&)
+{
+  if (strlen(candidate) != 0) {
+    std::cerr << name << ": got candidate: " << candidate << std::endl;
+    // Forward back to myself to unwind stack.
+    nsWeakPtr weak_this = do_GetWeakReference(this);
+    gMainThread->Dispatch(
+        WrapRunnableNM(
+            &AddIceCandidateToPeer,
+            weak_this,
+            level,
+            std::string(mid),
+            std::string(candidate)),
+        NS_DISPATCH_NORMAL);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TestObserver::OnNegotiationNeeded(ER&)
+{
+  return NS_OK;
+}
+
+class SignalingEnvironment : public ::testing::Environment {
+ public:
+  void TearDown() {
+    // Signaling is shut down in XPCOM shutdown
+  }
+};
+
+class SignalingAgentTest : public ::testing::Test {
+ public:
+  static void SetUpTestCase() {
+  }
+
+  void TearDown() {
+    // Delete all the agents.
+    for (size_t i=0; i < agents_.size(); i++) {
+      delete agents_[i];
+    }
+  }
+
+  bool CreateAgent() {
+    return CreateAgent(g_stun_server_address, g_stun_server_port);
+  }
+
+  bool CreateAgent(const std::string stun_addr, uint16_t stun_port) {
+    UniquePtr<SignalingAgent> agent(
+        new SignalingAgent("agent", stun_addr, stun_port));
+
+    agent->Init();
+
+    agents_.push_back(agent.release());
+
+    return true;
+  }
+
+  void CreateAgentNoInit() {
+    UniquePtr<SignalingAgent> agent(new SignalingAgent("agent"));
+    agents_.push_back(agent.release());
+  }
+
+  SignalingAgent *agent(size_t i) {
+    return agents_[i];
+  }
+
+ private:
+  std::vector<SignalingAgent *> agents_;
+};
+
+
+class SignalingTest : public ::testing::Test,
+                      public ::testing::WithParamInterface<std::string>
+{
+public:
+  SignalingTest()
+      : init_(false),
+        a1_(nullptr),
+        a2_(nullptr),
+        stun_addr_(g_stun_server_address),
+        stun_port_(g_stun_server_port) {}
+
+  SignalingTest(const std::string& stun_addr, uint16_t stun_port)
+      : a1_(nullptr),
+        a2_(nullptr),
+        stun_addr_(stun_addr),
+        stun_port_(stun_port) {}
+
+  ~SignalingTest() {
+    if (init_) {
+      mozilla::SyncRunnable::DispatchToThread(gMainThread,
+        WrapRunnable(this, &SignalingTest::Teardown_m));
+    }
+  }
+
+  void Teardown_m() {
+    a1_->SetPeer(nullptr);
+    a2_->SetPeer(nullptr);
+  }
+
+  static void SetUpTestCase() {
+  }
+
+  void EnsureInit() {
+
+    if (init_)
+      return;
+
+    a1_ = MakeUnique<SignalingAgent>(callerName, stun_addr_, stun_port_);
+    a2_ = MakeUnique<SignalingAgent>(calleeName, stun_addr_, stun_port_);
+
+    if (GetParam() == "no_bundle") {
+      a1_->SetBundleEnabled(false);
+    } else if(GetParam() == "reject_bundle") {
+      a2_->SetBundleEnabled(false);
+    } else if (GetParam() == "max-bundle") {
+      a1_->SetBundlePolicy(JsepBundlePolicy::kBundleMaxBundle);
+      a2_->SetBundlePolicy(JsepBundlePolicy::kBundleMaxBundle);
+    } else if (GetParam() == "balanced") {
+      a1_->SetBundlePolicy(JsepBundlePolicy::kBundleBalanced);
+      a2_->SetBundlePolicy(JsepBundlePolicy::kBundleBalanced);
+    } else if (GetParam() == "max-compat") {
+      a1_->SetBundlePolicy(JsepBundlePolicy::kBundleMaxCompat);
+      a2_->SetBundlePolicy(JsepBundlePolicy::kBundleMaxCompat);
+    }
+
+    a1_->Init();
+    a2_->Init();
+    a1_->SetPeer(a2_.get());
+    a2_->SetPeer(a1_.get());
+
+    init_ = true;
+  }
+
+  bool UseBundle()
+  {
+    return (GetParam() != "no_bundle") && (GetParam() != "reject_bundle");
+  }
+
+  void WaitForGather() {
+    a1_->WaitForGather();
+    a2_->WaitForGather();
+  }
+
+  static void TearDownTestCase() {
+  }
+
+  void CreateOffer(OfferOptions& options, uint32_t offerFlags) {
+    EnsureInit();
+    a1_->CreateOffer(options, offerFlags);
+  }
+
+  void CreateSetOffer(OfferOptions& options) {
+    EnsureInit();
+    a1_->CreateOffer(options, OFFER_AV);
+    a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  }
+
+  // Home for checks that we cannot perform by inspecting the various signaling
+  // classes. We should endeavor to make this function disappear, since SDP
+  // checking does not belong in these tests. That's the job of
+  // jsep_session_unittest.
+  void SDPSanityCheck(const std::string& sdp, uint32_t flags, bool offer)
+  {
+    std::cout << "SDPSanityCheck flags for "
+              << (offer ? "offer" : "answer")
+              << " = " << std::hex << std::showbase
+              << flags << std::dec
+              << ((flags & HAS_ALL_CANDIDATES)?" HAS_ALL_CANDIDATES":"")
+              << std::endl;
+
+    if (flags & HAS_ALL_CANDIDATES) {
+      ASSERT_NE(std::string::npos, sdp.find("a=candidate"))
+                << "should have at least one candidate";
+      ASSERT_NE(std::string::npos, sdp.find("a=end-of-candidates"));
+      ASSERT_EQ(std::string::npos, sdp.find("c=IN IP4 0.0.0.0"));
+    }
+  }
+
+  void CheckPipelines()
+  {
+    std::cout << "Checking pipelines..." << std::endl;
+    for (auto it = a1_->mAddedTracks.begin();
+         it != a1_->mAddedTracks.end();
+         ++it) {
+      a1_->CheckLocalPipeline(it->first.streamId, it->first.trackId, it->second);
+      a2_->CheckRemotePipeline(it->first.streamId, it->first.trackId, it->second);
+    }
+
+    for (auto it = a2_->mAddedTracks.begin();
+         it != a2_->mAddedTracks.end();
+         ++it) {
+      a2_->CheckLocalPipeline(it->first.streamId, it->first.trackId, it->second);
+      a1_->CheckRemotePipeline(it->first.streamId, it->first.trackId, it->second);
+    }
+    std::cout << "Done checking pipelines." << std::endl;
+  }
+
+  void CheckStreams(SignalingAgent& sender, SignalingAgent& receiver)
+  {
+    for (auto it = sender.mAddedTracks.begin();
+         it != sender.mAddedTracks.end();
+         ++it) {
+      // No checking for video yet, since we don't have support for fake video
+      // here yet. (bug 1142320)
+      if (it->second == SdpMediaSection::kAudio) {
+        int sendExpect = sender.GetPacketsSent(it->first.streamId) + 2;
+        int receiveExpect = receiver.GetPacketsReceived(it->first.streamId) + 2;
+
+        // TODO: Once we support more than one of each track type per stream,
+        // this will need to be updated.
+        WAIT(sender.GetPacketsSent(it->first.streamId) >= sendExpect &&
+             receiver.GetPacketsReceived(it->first.streamId) >= receiveExpect,
+             kDefaultTimeout);
+        ASSERT_LE(sendExpect, sender.GetPacketsSent(it->first.streamId))
+          << "Local track " << it->first.streamId << "/" << it->first.trackId
+          << " is not sending audio segments.";
+        ASSERT_LE(receiveExpect, receiver.GetPacketsReceived(it->first.streamId))
+          << "Remote track " << it->first.streamId << "/" << it->first.trackId
+          << " is not receiving audio segments.";
+      }
+    }
+  }
+
+  void CheckStreams()
+  {
+    std::cout << "Checking streams..." << std::endl;
+    CheckStreams(*a1_, *a2_);
+    CheckStreams(*a2_, *a1_);
+    std::cout << "Done checking streams." << std::endl;
+  }
+
+  void Offer(OfferOptions& options,
+             uint32_t offerAnswerFlags,
+             TrickleType trickleType = BOTH_TRICKLE) {
+    EnsureInit();
+    a1_->CreateOffer(options, offerAnswerFlags);
+    bool trickle = !!(trickleType & OFFERER_TRICKLES);
+    if (!trickle) {
+      a1_->pObserver->trickleCandidates = false;
+    }
+    a2_->mRemoteDescriptionSet = false;
+    a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+    if (!trickle) {
+      a1_->WaitForGather();
+      a1_->UpdateOffer();
+      SDPSanityCheck(a1_->getLocalDescription(), HAS_ALL_CANDIDATES, true);
+    }
+    a2_->SetRemote(TestObserver::OFFER, a1_->offer());
+  }
+
+  void Answer(OfferOptions& options,
+              uint32_t offerAnswerFlags,
+              TrickleType trickleType = BOTH_TRICKLE) {
+
+    a2_->CreateAnswer(offerAnswerFlags);
+    bool trickle = !!(trickleType & ANSWERER_TRICKLES);
+    if (!trickle) {
+      a2_->pObserver->trickleCandidates = false;
+    }
+    a1_->mRemoteDescriptionSet = false;
+    a2_->SetLocal(TestObserver::ANSWER, a2_->answer());
+    if (!trickle) {
+      a2_->WaitForGather();
+      a2_->UpdateAnswer();
+      SDPSanityCheck(a2_->getLocalDescription(), HAS_ALL_CANDIDATES, false);
+    }
+    a1_->SetRemote(TestObserver::ANSWER, a2_->answer());
+  }
+
+  void WaitForCompleted() {
+    ASSERT_TRUE_WAIT(a1_->IceCompleted() == true, kDefaultTimeout);
+    ASSERT_TRUE_WAIT(a2_->IceCompleted() == true, kDefaultTimeout);
+  }
+
+  void OfferAnswer(OfferOptions& options,
+                   uint32_t offerAnswerFlags,
+                   TrickleType trickleType = BOTH_TRICKLE) {
+    EnsureInit();
+    Offer(options, offerAnswerFlags, trickleType);
+    Answer(options, offerAnswerFlags, trickleType);
+    WaitForCompleted();
+    CheckPipelines();
+    CheckStreams();
+  }
+
+  void OfferAnswerTrickleChrome(OfferOptions& options,
+                                uint32_t offerAnswerFlags) {
+    EnsureInit();
+    Offer(options, offerAnswerFlags);
+    Answer(options, offerAnswerFlags);
+    WaitForCompleted();
+    CheckPipelines();
+    CheckStreams();
+  }
+
+  void CreateOfferRemoveTrack(OfferOptions& options, bool videoTrack) {
+    EnsureInit();
+    OfferOptions aoptions;
+    aoptions.setInt32Option("OfferToReceiveAudio", 1);
+    aoptions.setInt32Option("OfferToReceiveVideo", 1);
+    a1_->CreateOffer(aoptions, OFFER_AV);
+    a1_->CreateOfferRemoveTrack(options, videoTrack);
+  }
+
+  void CreateOfferAudioOnly(OfferOptions& options) {
+    EnsureInit();
+    a1_->CreateOffer(options, OFFER_AUDIO);
+  }
+
+  void CreateOfferAddCandidate(OfferOptions& options,
+                               const std::string& candidate, const std::string& mid,
+                               unsigned short level) {
+    EnsureInit();
+    a1_->CreateOffer(options, OFFER_AV);
+    a1_->AddIceCandidate(candidate, mid, level, true);
+  }
+
+  void AddIceCandidateEarly(const std::string& candidate, const std::string& mid,
+                            unsigned short level) {
+    EnsureInit();
+    a1_->AddIceCandidate(candidate, mid, level, false);
+  }
+
+  std::string SwapMsids(const std::string& sdp, bool swapVideo) const
+  {
+    SipccSdpParser parser;
+    UniquePtr<Sdp> parsed = parser.Parse(sdp);
+
+    SdpMediaSection* previousMsection = nullptr;
+    bool swapped = false;
+    for (size_t i = 0; i < parsed->GetMediaSectionCount(); ++i) {
+      SdpMediaSection* currentMsection = &parsed->GetMediaSection(i);
+      bool isVideo = currentMsection->GetMediaType() == SdpMediaSection::kVideo;
+      if (swapVideo == isVideo) {
+        if (previousMsection) {
+          UniquePtr<SdpMsidAttributeList> prevMsid(
+            new SdpMsidAttributeList(
+                previousMsection->GetAttributeList().GetMsid()));
+          UniquePtr<SdpMsidAttributeList> currMsid(
+            new SdpMsidAttributeList(
+                currentMsection->GetAttributeList().GetMsid()));
+          previousMsection->GetAttributeList().SetAttribute(currMsid.release());
+          currentMsection->GetAttributeList().SetAttribute(prevMsid.release());
+          swapped = true;
+        }
+        previousMsection = currentMsection;
+      }
+    }
+
+    EXPECT_TRUE(swapped);
+
+    return parsed->ToString();
+  }
+
+  void CheckRtcpFbSdp(const std::string &sdp,
+                      const std::set<std::string>& expected) {
+
+    std::set<std::string>::const_iterator it;
+
+    // Iterate through the list of expected feedback types and ensure
+    // that none of them are missing.
+    for (it = expected.begin(); it != expected.end(); ++it) {
+      std::string attr = std::string("\r\na=rtcp-fb:120 ") + (*it) + "\r\n";
+      std::cout << " - Checking for a=rtcp-fb: '" << *it << "'" << std::endl;
+      ASSERT_NE(sdp.find(attr), std::string::npos);
+    }
+
+    // Iterate through all of the rtcp-fb lines in the SDP and ensure
+    // that all of them are expected.
+    ParsedSDP sdpWrapper(sdp);
+    std::vector<std::string> values = sdpWrapper.GetLines("a=rtcp-fb:120");
+    std::vector<std::string>::iterator it2;
+    for (it2 = values.begin(); it2 != values.end(); ++it2) {
+      std::cout << " - Verifying that rtcp-fb is okay: '" << *it2
+                << "'" << std::endl;
+      ASSERT_NE(0U, expected.count(*it2));
+    }
+  }
+
+  std::string HardcodeRtcpFb(const std::string& sdp,
+                             const std::set<std::string>& feedback) {
+    ParsedSDP sdpWrapper(sdp);
+
+    // Strip out any existing rtcp-fb lines
+    sdpWrapper.DeleteLines("a=rtcp-fb:120");
+    sdpWrapper.DeleteLines("a=rtcp-fb:126");
+    sdpWrapper.DeleteLines("a=rtcp-fb:97");
+
+    // Add rtcp-fb lines for the desired feedback types
+    // We know that the video section is generated second (last),
+    // so appending these to the end of the SDP has the desired effect.
+    std::set<std::string>::const_iterator it;
+    for (it = feedback.begin(); it != feedback.end(); ++it) {
+      sdpWrapper.AddLine(std::string("a=rtcp-fb:120 ") + (*it) + "\r\n");
+      sdpWrapper.AddLine(std::string("a=rtcp-fb:126 ") + (*it) + "\r\n");
+      sdpWrapper.AddLine(std::string("a=rtcp-fb:97 ") + (*it) + "\r\n");
+    }
+
+    std::cout << "Modified SDP " << std::endl
+              << indent(sdpWrapper.getSdp()) << std::endl;
+
+    // Double-check that the offered SDP matches what we expect
+    CheckRtcpFbSdp(sdpWrapper.getSdp(), feedback);
+
+    return sdpWrapper.getSdp();
+  }
+
+  void TestRtcpFbAnswer(const std::set<std::string>& feedback,
+      bool expectNack,
+      VideoSessionConduit::FrameRequestType frameRequestType) {
+    EnsureInit();
+    OfferOptions options;
+
+    a1_->CreateOffer(options, OFFER_AV);
+    a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+
+    a2_->SetRemote(TestObserver::OFFER, a1_->offer());
+    a2_->CreateAnswer(OFFER_AV | ANSWER_AV);
+
+    a2_->SetLocal(TestObserver::ANSWER, a2_->answer());
+
+    std::string modifiedAnswer(HardcodeRtcpFb(a2_->answer(), feedback));
+
+    a1_->SetRemote(TestObserver::ANSWER, modifiedAnswer);
+
+    a1_->SetExpectedFrameRequestType(frameRequestType);
+    a1_->mExpectNack = expectNack;
+    // Since we don't support rewriting rtcp-fb in answers, a2 still thinks it
+    // will be doing all of the normal rtcp-fb
+
+    WaitForCompleted();
+    CheckPipelines();
+
+    CloseStreams();
+  }
+
+  void TestRtcpFbOffer(
+      const std::set<std::string>& feedback,
+      bool expectNack,
+      VideoSessionConduit::FrameRequestType frameRequestType) {
+    EnsureInit();
+    OfferOptions options;
+
+    a1_->CreateOffer(options, OFFER_AV);
+    a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+
+    std::string modifiedOffer = HardcodeRtcpFb(a1_->offer(), feedback);
+
+    a2_->SetRemote(TestObserver::OFFER, modifiedOffer);
+    a1_->SetExpectedFrameRequestType(frameRequestType);
+    a1_->mExpectNack = expectNack;
+    a2_->SetExpectedFrameRequestType(frameRequestType);
+    a2_->mExpectNack = expectNack;
+
+    a2_->CreateAnswer(OFFER_AV | ANSWER_AV);
+
+    a2_->SetLocal(TestObserver::ANSWER, a2_->answer());
+    a1_->SetRemote(TestObserver::ANSWER, a2_->answer());
+
+    WaitForCompleted();
+
+    CheckPipelines();
+    CloseStreams();
+  }
+
+  void SetTestStunServer() {
+    stun_addr_ = TestStunServer::GetInstance()->addr();
+    stun_port_ = TestStunServer::GetInstance()->port();
+
+    TestStunServer::GetInstance()->SetActive(false);
+    TestStunServer::GetInstance()->SetResponseAddr(
+        kBogusSrflxAddress, kBogusSrflxPort);
+  }
+
+  // Check max-fs and max-fr in SDP
+  void CheckMaxFsFrSdp(const std::string sdp,
+                       int format,
+                       int max_fs,
+                       int max_fr) {
+    ParsedSDP sdpWrapper(sdp);
+    std::stringstream ss;
+    ss << "a=fmtp:" << format;
+    std::vector<std::string> lines = sdpWrapper.GetLines(ss.str());
+
+    // Both max-fs and max-fr not exist
+    if (lines.empty()) {
+      ASSERT_EQ(max_fs, 0);
+      ASSERT_EQ(max_fr, 0);
+      return;
+    }
+
+    // At most one instance allowed for each format
+    ASSERT_EQ(lines.size(), 1U);
+
+    std::string line = lines.front();
+
+    // Make sure that max-fs doesn't exist
+    if (max_fs == 0) {
+      ASSERT_EQ(line.find("max-fs="), std::string::npos);
+    }
+    // Check max-fs value
+    if (max_fs > 0) {
+      std::stringstream ss;
+      ss << "max-fs=" << max_fs;
+      ASSERT_NE(line.find(ss.str()), std::string::npos);
+    }
+    // Make sure that max-fr doesn't exist
+    if (max_fr == 0) {
+      ASSERT_EQ(line.find("max-fr="), std::string::npos);
+    }
+    // Check max-fr value
+    if (max_fr > 0) {
+      std::stringstream ss;
+      ss << "max-fr=" << max_fr;
+      ASSERT_NE(line.find(ss.str()), std::string::npos);
+    }
+  }
+
+  void CloseStreams()
+  {
+    a1_->CloseSendStreams();
+    a2_->CloseSendStreams();
+    a1_->CloseReceiveStreams();
+    a2_->CloseReceiveStreams();
+  }
+
+ protected:
+  bool init_;
+  UniquePtr<SignalingAgent> a1_;  // Canonically "caller"
+  UniquePtr<SignalingAgent> a2_;  // Canonically "callee"
+  std::string stun_addr_;
+  uint16_t stun_port_;
+};
+
+static void SetIntPrefOnMainThread(nsCOMPtr<nsIPrefBranch> prefs,
+  const char *pref_name,
+  int new_value) {
+  MOZ_ASSERT(NS_IsMainThread());
+  prefs->SetIntPref(pref_name, new_value);
+}
+
+static void SetMaxFsFr(nsCOMPtr<nsIPrefBranch> prefs,
+  int max_fs,
+  int max_fr) {
+  gMainThread->Dispatch(
+    WrapRunnableNM(SetIntPrefOnMainThread,
+      prefs,
+      "media.navigator.video.max_fs",
+      max_fs),
+    NS_DISPATCH_SYNC);
+
+  gMainThread->Dispatch(
+    WrapRunnableNM(SetIntPrefOnMainThread,
+      prefs,
+      "media.navigator.video.max_fr",
+      max_fr),
+    NS_DISPATCH_SYNC);
+}
+
+class FsFrPrefClearer {
+  public:
+    explicit FsFrPrefClearer(nsCOMPtr<nsIPrefBranch> prefs): mPrefs(prefs) {}
+    ~FsFrPrefClearer() {
+      gMainThread->Dispatch(
+        WrapRunnableNM(FsFrPrefClearer::ClearUserPrefOnMainThread,
+          mPrefs,
+          "media.navigator.video.max_fs"),
+        NS_DISPATCH_SYNC);
+      gMainThread->Dispatch(
+        WrapRunnableNM(FsFrPrefClearer::ClearUserPrefOnMainThread,
+          mPrefs,
+          "media.navigator.video.max_fr"),
+        NS_DISPATCH_SYNC);
+    }
+
+    static void ClearUserPrefOnMainThread(nsCOMPtr<nsIPrefBranch> prefs,
+      const char *pref_name) {
+      MOZ_ASSERT(NS_IsMainThread());
+      prefs->ClearUserPref(pref_name);
+    }
+  private:
+    nsCOMPtr<nsIPrefBranch> mPrefs;
+};
+
+TEST_P(SignalingTest, JustInit)
+{
+}
+
+TEST_P(SignalingTest, CreateSetOffer)
+{
+  OfferOptions options;
+  CreateSetOffer(options);
+}
+
+TEST_P(SignalingTest, CreateOfferAudioVideoOptionUndefined)
+{
+  OfferOptions options;
+  CreateOffer(options, OFFER_AV);
+}
+
+TEST_P(SignalingTest, CreateOfferNoVideoStreamRecvVideo)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  CreateOffer(options, OFFER_AUDIO);
+}
+
+TEST_P(SignalingTest, CreateOfferNoAudioStreamRecvAudio)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  CreateOffer(options, OFFER_VIDEO);
+}
+
+TEST_P(SignalingTest, CreateOfferNoVideoStream)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 0);
+  CreateOffer(options, OFFER_AUDIO);
+}
+
+TEST_P(SignalingTest, CreateOfferNoAudioStream)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 0);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  CreateOffer(options, OFFER_VIDEO);
+}
+
+TEST_P(SignalingTest, CreateOfferDontReceiveAudio)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 0);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  CreateOffer(options, OFFER_AV);
+}
+
+TEST_P(SignalingTest, CreateOfferDontReceiveVideo)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 0);
+  CreateOffer(options, OFFER_AV);
+}
+
+TEST_P(SignalingTest, CreateOfferRemoveAudioTrack)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  CreateOfferRemoveTrack(options, false);
+}
+
+TEST_P(SignalingTest, CreateOfferDontReceiveAudioRemoveAudioTrack)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 0);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  CreateOfferRemoveTrack(options, false);
+}
+
+TEST_P(SignalingTest, CreateOfferDontReceiveVideoRemoveVideoTrack)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 0);
+  CreateOfferRemoveTrack(options, true);
+}
+
+TEST_P(SignalingTest, OfferAnswerNothingDisabled)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+}
+
+TEST_P(SignalingTest, OfferAnswerNoTrickle)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV, NO_TRICKLE);
+}
+
+TEST_P(SignalingTest, OfferAnswerOffererTrickles)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV, OFFERER_TRICKLES);
+}
+
+TEST_P(SignalingTest, OfferAnswerAnswererTrickles)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV, ANSWERER_TRICKLES);
+}
+
+TEST_P(SignalingTest, OfferAnswerBothTrickle)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV, BOTH_TRICKLE);
+}
+
+TEST_P(SignalingTest, OfferAnswerAudioBothTrickle)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AUDIO | ANSWER_AUDIO, BOTH_TRICKLE);
+}
+
+
+TEST_P(SignalingTest, OfferAnswerNothingDisabledFullCycle)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+  // verify the default codec priorities
+  ASSERT_NE(a1_->getLocalDescription().find("UDP/TLS/RTP/SAVPF 109 9 0 8\r"),
+            std::string::npos);
+  ASSERT_NE(a2_->getLocalDescription().find("UDP/TLS/RTP/SAVPF 109\r"),
+            std::string::npos);
+}
+
+TEST_P(SignalingTest, OfferAnswerAudioInactive)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  OfferAnswer(options, OFFER_VIDEO | ANSWER_VIDEO);
+}
+
+TEST_P(SignalingTest, OfferAnswerVideoInactive)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  OfferAnswer(options, OFFER_AUDIO | ANSWER_AUDIO);
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, CreateOfferAddCandidate)
+{
+  OfferOptions options;
+  CreateOfferAddCandidate(options, strSampleCandidate,
+                          strSampleMid, nSamplelevel);
+}
+
+TEST_P(SignalingTest, AddIceCandidateEarly)
+{
+  OfferOptions options;
+  AddIceCandidateEarly(strSampleCandidate,
+                       strSampleMid, nSamplelevel);
+}
+
+TEST_P(SignalingTest, OfferAnswerDontAddAudioStreamOnAnswerNoOptions)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  OfferAnswer(options, OFFER_AV | ANSWER_VIDEO);
+}
+
+TEST_P(SignalingTest, OfferAnswerDontAddVideoStreamOnAnswerNoOptions)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  OfferAnswer(options, OFFER_AV | ANSWER_AUDIO);
+}
+
+TEST_P(SignalingTest, OfferAnswerDontAddAudioVideoStreamsOnAnswerNoOptions)
+{
+  OfferOptions options;
+  options.setInt32Option("OfferToReceiveAudio", 1);
+  options.setInt32Option("OfferToReceiveVideo", 1);
+  OfferAnswer(options, OFFER_AV | ANSWER_NONE);
+}
+
+TEST_P(SignalingTest, RenegotiationOffererAddsTracks)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+  // OFFER_AV causes a new stream + tracks to be added
+  OfferAnswer(options, OFFER_AV);
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, RenegotiationOffererRemovesTrack)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  a1_->RemoveTrack(0, false);
+
+  OfferAnswer(options, OFFER_NONE);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, RenegotiationBothRemoveThenAddTrack)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  a1_->RemoveTrack(0, false);
+  a2_->RemoveTrack(0, false);
+
+  OfferAnswer(options, OFFER_NONE);
+
+  // OFFER_AUDIO causes a new audio track to be added on both sides
+  OfferAnswer(options, OFFER_AUDIO);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, RenegotiationOffererReplacesTrack)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  a1_->RemoveTrack(0, false);
+
+  // OFFER_AUDIO causes a new audio track to be added on both sides
+  OfferAnswer(options, OFFER_AUDIO);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, RenegotiationOffererSwapsMsids)
+{
+  OfferOptions options;
+
+  EnsureInit();
+  a1_->AddStream(DOMMediaStream::HINT_CONTENTS_AUDIO |
+                 DOMMediaStream::HINT_CONTENTS_VIDEO);
+
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  a1_->CreateOffer(options, OFFER_NONE);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  std::string audioSwapped = SwapMsids(a1_->offer(), false);
+  std::string audioAndVideoSwapped = SwapMsids(audioSwapped, true);
+  std::cout << "Msids swapped: " << std::endl << audioAndVideoSwapped << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, audioAndVideoSwapped);
+  Answer(options, OFFER_NONE, BOTH_TRICKLE);
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, RenegotiationAnswererAddsTracks)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  options.setInt32Option("OfferToReceiveAudio", 2);
+  options.setInt32Option("OfferToReceiveVideo", 2);
+
+  // ANSWER_AV causes a new stream + tracks to be added
+  OfferAnswer(options, ANSWER_AV);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, RenegotiationAnswererRemovesTrack)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  a2_->RemoveTrack(0, false);
+
+  OfferAnswer(options, OFFER_NONE);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, RenegotiationAnswererReplacesTrack)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  a2_->RemoveTrack(0, false);
+
+  // ANSWER_AUDIO causes a new audio track to be added
+  OfferAnswer(options, ANSWER_AUDIO);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, BundleRenegotiation)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  // If we did bundle before, turn it off, if not, turn it on
+  if (a1_->mBundleEnabled && a2_->mBundleEnabled) {
+    a1_->SetBundleEnabled(false);
+  } else {
+    a1_->SetBundleEnabled(true);
+    a2_->SetBundleEnabled(true);
+  }
+
+  OfferAnswer(options, OFFER_NONE);
+}
+
+TEST_P(SignalingTest, FullCallAudioOnly)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AUDIO | ANSWER_AUDIO);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, FullCallVideoOnly)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_VIDEO | ANSWER_VIDEO);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, OfferAndAnswerWithExtraCodec)
+{
+  EnsureInit();
+  OfferOptions options;
+  Offer(options, OFFER_AUDIO);
+
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer());
+  ParsedSDP sdpWrapper(a2_->answer());
+  sdpWrapper.ReplaceLine("m=audio",
+                         "m=audio 65375 UDP/TLS/RTP/SAVPF 109 8\r\n");
+  sdpWrapper.AddLine("a=rtpmap:8 PCMA/8000\r\n");
+  std::cout << "Modified SDP " << std::endl
+            << indent(sdpWrapper.getSdp()) << std::endl;
+
+  a1_->SetRemote(TestObserver::ANSWER, sdpWrapper.getSdp());
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, FullCallTrickle)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  std::cerr << "ICE handshake completed" << std::endl;
+
+  CloseStreams();
+}
+
+// Offer answer with trickle but with chrome-style candidates
+TEST_P(SignalingTest, DISABLED_FullCallTrickleChrome)
+{
+  OfferOptions options;
+  OfferAnswerTrickleChrome(options, OFFER_AV | ANSWER_AV);
+
+  std::cerr << "ICE handshake completed" << std::endl;
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, FullCallTrickleBeforeSetLocal)
+{
+  OfferOptions options;
+  Offer(options, OFFER_AV | ANSWER_AV);
+  // ICE will succeed even if one side fails to trickle, so we need to disable
+  // one side before performing a test that might cause candidates to be
+  // dropped
+  a2_->DropOutgoingTrickleCandidates();
+  // Wait until all of a1's candidates have been trickled to a2, _before_ a2
+  // has called CreateAnswer/SetLocal (ie; the ICE stack is not running yet)
+  a1_->WaitForGather();
+  Answer(options, OFFER_AV | ANSWER_AV);
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  std::cerr << "ICE handshake completed" << std::endl;
+
+  CloseStreams();
+}
+
+// This test comes from Bug 810220
+// TODO: Move this to jsep_session_unittest
+TEST_P(SignalingTest, AudioOnlyG711Call)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  const std::string& offer(strG711SdpOffer);
+
+  std::cout << "Setting offer to:" << std::endl << indent(offer) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, offer);
+
+  std::cout << "Creating answer:" << std::endl;
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  std::string answer = a2_->answer();
+
+  // They didn't offer opus, so our answer shouldn't include it.
+  ASSERT_EQ(answer.find(" opus/"), std::string::npos);
+
+  // They also didn't offer video or application
+  ASSERT_EQ(answer.find("video"), std::string::npos);
+  ASSERT_EQ(answer.find("application"), std::string::npos);
+
+  // We should answer with PCMU and telephone-event
+  ASSERT_NE(answer.find(" PCMU/8000"), std::string::npos);
+
+  // Double-check the directionality
+  ASSERT_NE(answer.find("\r\na=sendrecv"), std::string::npos);
+
+}
+
+TEST_P(SignalingTest, IncomingOfferIceLite)
+{
+  EnsureInit();
+
+  std::string offer =
+    "v=0\r\n"
+    "o=- 1936463 1936463 IN IP4 148.147.200.251\r\n"
+    "s=-\r\n"
+    "c=IN IP4 148.147.200.251\r\n"
+    "t=0 0\r\n"
+    "a=ice-lite\r\n"
+    "a=fingerprint:sha-1 "
+      "E7:FA:17:DA:3F:3C:1E:D8:E4:9C:8C:4C:13:B9:2E:D5:C6:78:AB:B3\r\n"
+    "m=audio 40014 UDP/TLS/RTP/SAVPF 8 0 101\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:101 telephone-event/8000\r\n"
+    "a=fmtp:101 0-15\r\n"
+    "a=ptime:20\r\n"
+    "a=sendrecv\r\n"
+    "a=ice-ufrag:bf2LAgqBZdiWFR2r\r\n"
+    "a=ice-pwd:ScxgaNzdBOYScR0ORleAvt1x\r\n"
+    "a=candidate:1661181211 1 udp 10 148.147.200.251 40014 typ host\r\n"
+    "a=candidate:1661181211 2 udp 9 148.147.200.251 40015 typ host\r\n"
+    "a=setup:actpass\r\n";
+
+  std::cout << "Setting offer to:" << std::endl << indent(offer) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, offer);
+
+  std::cout << "Creating answer:" << std::endl;
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer());
+
+  ASSERT_EQ(a2_->pc->media()->ice_ctx()->GetControlling(),
+            NrIceCtx::ICE_CONTROLLING);
+}
+
+// This test comes from Bug814038
+TEST_P(SignalingTest, ChromeOfferAnswer)
+{
+  EnsureInit();
+
+  // This is captured SDP from an early interop attempt with Chrome.
+  std::string offer =
+    "v=0\r\n"
+    "o=- 1713781661 2 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "a=group:BUNDLE audio video\r\n"
+
+    "m=audio 1 UDP/TLS/RTP/SAVPF 103 104 111 0 8 107 106 105 13 126\r\n"
+    "a=fingerprint:sha-1 4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:"
+      "5D:49:6B:19:E5:7C:AB\r\n"
+    "a=setup:active\r\n"
+    "c=IN IP4 0.0.0.0\r\n"
+    "a=rtcp:1 IN IP4 0.0.0.0\r\n"
+    "a=ice-ufrag:lBrbdDfrVBH1cldN\r\n"
+    "a=ice-pwd:rzh23jet4QpCaEoj9Sl75pL3\r\n"
+    "a=ice-options:google-ice\r\n"
+    "a=sendrecv\r\n"
+    "a=mid:audio\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:"
+      "RzrYlzpkTsvgYFD1hQqNCzQ7y4emNLKI1tODsjim\r\n"
+    "a=rtpmap:103 ISAC/16000\r\n"
+    "a=rtpmap:104 ISAC/32000\r\n"
+    // NOTE: the actual SDP that Chrome sends at the moment
+    // doesn't indicate two channels. I've amended their SDP
+    // here, under the assumption that the constraints
+    // described in draft-spittka-payload-rtp-opus will
+    // eventually be implemented by Google.
+    "a=rtpmap:111 opus/48000/2\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:107 CN/48000\r\n"
+    "a=rtpmap:106 CN/32000\r\n"
+    "a=rtpmap:105 CN/16000\r\n"
+    "a=rtpmap:13 CN/8000\r\n"
+    "a=rtpmap:126 telephone-event/8000\r\n"
+    "a=ssrc:661333377 cname:KIXaNxUlU5DP3fVS\r\n"
+    "a=ssrc:661333377 msid:A5UL339RyGxT7zwgyF12BFqesxkmbUsaycp5 a0\r\n"
+    "a=ssrc:661333377 mslabel:A5UL339RyGxT7zwgyF12BFqesxkmbUsaycp5\r\n"
+    "a=ssrc:661333377 label:A5UL339RyGxT7zwgyF12BFqesxkmbUsaycp5a0\r\n"
+
+    "m=video 1 UDP/TLS/RTP/SAVPF 100 101 102\r\n"
+    "a=fingerprint:sha-1 4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:"
+      "6B:19:E5:7C:AB\r\n"
+    "a=setup:active\r\n"
+    "c=IN IP4 0.0.0.0\r\n"
+    "a=rtcp:1 IN IP4 0.0.0.0\r\n"
+    "a=ice-ufrag:lBrbdDfrVBH1cldN\r\n"
+    "a=ice-pwd:rzh23jet4QpCaEoj9Sl75pL3\r\n"
+    "a=ice-options:google-ice\r\n"
+    "a=sendrecv\r\n"
+    "a=mid:video\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:"
+      "RzrYlzpkTsvgYFD1hQqNCzQ7y4emNLKI1tODsjim\r\n"
+    "a=rtpmap:100 VP8/90000\r\n"
+    "a=rtpmap:101 red/90000\r\n"
+    "a=rtpmap:102 ulpfec/90000\r\n"
+    "a=rtcp-fb:100 nack\r\n"
+    "a=rtcp-fb:100 ccm fir\r\n"
+    "a=ssrc:3012607008 cname:KIXaNxUlU5DP3fVS\r\n"
+    "a=ssrc:3012607008 msid:A5UL339RyGxT7zwgyF12BFqesxkmbUsaycp5 v0\r\n"
+    "a=ssrc:3012607008 mslabel:A5UL339RyGxT7zwgyF12BFqesxkmbUsaycp5\r\n"
+    "a=ssrc:3012607008 label:A5UL339RyGxT7zwgyF12BFqesxkmbUsaycp5v0\r\n";
+
+
+  std::cout << "Setting offer to:" << std::endl << indent(offer) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, offer);
+
+  std::cout << "Creating answer:" << std::endl;
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  std::string answer = a2_->answer();
+}
+
+
+TEST_P(SignalingTest, FullChromeHandshake)
+{
+  EnsureInit();
+
+  std::string offer = "v=0\r\n"
+      "o=- 3835809413 2 IN IP4 127.0.0.1\r\n"
+      "s=-\r\n"
+      "t=0 0\r\n"
+      "a=group:BUNDLE audio video\r\n"
+      "a=msid-semantic: WMS ahheYQXHFU52slYMrWNtKUyHCtWZsOJgjlOH\r\n"
+      "m=audio 1 UDP/TLS/RTP/SAVPF 103 104 111 0 8 107 106 105 13 126\r\n"
+      "c=IN IP4 1.1.1.1\r\n"
+      "a=rtcp:1 IN IP4 1.1.1.1\r\n"
+      "a=ice-ufrag:jz9UBk9RT8eCQXiL\r\n"
+      "a=ice-pwd:iscXxsdU+0gracg0g5D45orx\r\n"
+      "a=ice-options:google-ice\r\n"
+      "a=fingerprint:sha-256 A8:76:8C:4C:FA:2E:67:D7:F8:1D:28:4E:90:24:04:"
+        "12:EB:B4:A6:69:3D:05:92:E4:91:C3:EA:F9:B7:54:D3:09\r\n"
+      "a=setup:active\r\n"
+      "a=sendrecv\r\n"
+      "a=mid:audio\r\n"
+      "a=rtcp-mux\r\n"
+      "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:/he/v44FKu/QvEhex86zV0pdn2V"
+        "4Y7wB2xaZ8eUy\r\n"
+      "a=rtpmap:103 ISAC/16000\r\n"
+      "a=rtpmap:104 ISAC/32000\r\n"
+      "a=rtpmap:111 opus/48000/2\r\n"
+      "a=rtpmap:0 PCMU/8000\r\n"
+      "a=rtpmap:8 PCMA/8000\r\n"
+      "a=rtpmap:107 CN/48000\r\n"
+      "a=rtpmap:106 CN/32000\r\n"
+      "a=rtpmap:105 CN/16000\r\n"
+      "a=rtpmap:13 CN/8000\r\n"
+      "a=rtpmap:126 telephone-event/8000\r\n"
+      "a=ssrc:3389377748 cname:G5I+Jxz4rcaq8IIK\r\n"
+      "a=ssrc:3389377748 msid:ahheYQXHFU52slYMrWNtKUyHCtWZsOJgjlOH a0\r\n"
+      "a=ssrc:3389377748 mslabel:ahheYQXHFU52slYMrWNtKUyHCtWZsOJgjlOH\r\n"
+      "a=ssrc:3389377748 label:ahheYQXHFU52slYMrWNtKUyHCtWZsOJgjlOHa0\r\n"
+      "m=video 1 UDP/TLS/RTP/SAVPF 100 116 117\r\n"
+      "c=IN IP4 1.1.1.1\r\n"
+      "a=rtcp:1 IN IP4 1.1.1.1\r\n"
+      "a=ice-ufrag:jz9UBk9RT8eCQXiL\r\n"
+      "a=ice-pwd:iscXxsdU+0gracg0g5D45orx\r\n"
+      "a=ice-options:google-ice\r\n"
+      "a=fingerprint:sha-256 A8:76:8C:4C:FA:2E:67:D7:F8:1D:28:4E:90:24:04:"
+        "12:EB:B4:A6:69:3D:05:92:E4:91:C3:EA:F9:B7:54:D3:09\r\n"
+      "a=setup:active\r\n"
+      "a=sendrecv\r\n"
+      "a=mid:video\r\n"
+      "a=rtcp-mux\r\n"
+      "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:/he/v44FKu/QvEhex86zV0pdn2V"
+        "4Y7wB2xaZ8eUy\r\n"
+      "a=rtpmap:100 VP8/90000\r\n"
+      "a=rtpmap:116 red/90000\r\n"
+      "a=rtpmap:117 ulpfec/90000\r\n"
+      "a=ssrc:3613537198 cname:G5I+Jxz4rcaq8IIK\r\n"
+      "a=ssrc:3613537198 msid:ahheYQXHFU52slYMrWNtKUyHCtWZsOJgjlOH v0\r\n"
+      "a=ssrc:3613537198 mslabel:ahheYQXHFU52slYMrWNtKUyHCtWZsOJgjlOH\r\n"
+      "a=ssrc:3613537198 label:ahheYQXHFU52slYMrWNtKUyHCtWZsOJgjlOHv0\r\n";
+
+  std::cout << "Setting offer to:" << std::endl << indent(offer) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, offer);
+
+  std::cout << "Creating answer:" << std::endl;
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  std::cout << "Setting answer" << std::endl;
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer());
+
+  std::string answer = a2_->answer();
+  ASSERT_NE(answer.find("111 opus/"), std::string::npos);
+}
+
+// Disabled pending resolution of bug 818640.
+// Actually, this test is completely broken; you can't just call
+// SetRemote/CreateAnswer over and over again.
+// If we were to test this sort of thing, it would belong in
+// jsep_session_unitest
+TEST_P(SignalingTest, DISABLED_OfferAllDynamicTypes)
+{
+  EnsureInit();
+
+  std::string offer;
+  for (int i = 96; i < 128; i++)
+  {
+    std::stringstream ss;
+    ss << i;
+    std::cout << "Trying dynamic pt = " << i << std::endl;
+    offer =
+      "v=0\r\n"
+      "o=- 1 1 IN IP4 148.147.200.251\r\n"
+      "s=-\r\n"
+      "b=AS:64\r\n"
+      "t=0 0\r\n"
+      "a=fingerprint:sha-256 F3:FA:20:C0:CD:48:C4:5F:02:5F:A5:D3:21:D0:2D:48:"
+        "7B:31:60:5C:5A:D8:0D:CD:78:78:6C:6D:CE:CC:0C:67\r\n"
+      "m=audio 9000 RTP/AVP " + ss.str() + "\r\n"
+      "c=IN IP4 148.147.200.251\r\n"
+      "b=TIAS:64000\r\n"
+      "a=rtpmap:" + ss.str() +" opus/48000/2\r\n"
+      "a=candidate:0 1 udp 2130706432 148.147.200.251 9000 typ host\r\n"
+      "a=candidate:0 2 udp 2130706432 148.147.200.251 9005 typ host\r\n"
+      "a=ice-ufrag:cYuakxkEKH+RApYE\r\n"
+      "a=ice-pwd:bwtpzLZD+3jbu8vQHvEa6Xuq\r\n"
+      "a=sendrecv\r\n";
+
+      /*
+      std::cout << "Setting offer to:" << std::endl
+                << indent(offer) << std::endl;
+      */
+      a2_->SetRemote(TestObserver::OFFER, offer);
+
+      //std::cout << "Creating answer:" << std::endl;
+      a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+      std::string answer = a2_->answer();
+
+      ASSERT_NE(answer.find(ss.str() + " opus/"), std::string::npos);
+  }
+
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, ipAddrAnyOffer)
+{
+  EnsureInit();
+
+  std::string offer =
+    "v=0\r\n"
+    "o=- 1 1 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "b=AS:64\r\n"
+    "t=0 0\r\n"
+    "a=fingerprint:sha-256 F3:FA:20:C0:CD:48:C4:5F:02:5F:A5:D3:21:D0:2D:48:"
+      "7B:31:60:5C:5A:D8:0D:CD:78:78:6C:6D:CE:CC:0C:67\r\n"
+    "m=audio 9000 RTP/AVP 99\r\n"
+    "c=IN IP4 0.0.0.0\r\n"
+    "a=rtpmap:99 opus/48000/2\r\n"
+    "a=ice-ufrag:cYuakxkEKH+RApYE\r\n"
+    "a=ice-pwd:bwtpzLZD+3jbu8vQHvEa6Xuq\r\n"
+    "a=setup:active\r\n"
+    "a=sendrecv\r\n";
+
+    a2_->SetRemote(TestObserver::OFFER, offer);
+    ASSERT_TRUE(a2_->pObserver->state == TestObserver::stateSuccess);
+    a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+    ASSERT_TRUE(a2_->pObserver->state == TestObserver::stateSuccess);
+    std::string answer = a2_->answer();
+    ASSERT_NE(answer.find("a=sendrecv"), std::string::npos);
+}
+
+static void CreateSDPForBigOTests(std::string& offer, const std::string& number) {
+  offer =
+    "v=0\r\n"
+    "o=- ";
+  offer += number;
+  offer += " ";
+  offer += number;
+  offer += " IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "b=AS:64\r\n"
+    "t=0 0\r\n"
+    "a=fingerprint:sha-256 F3:FA:20:C0:CD:48:C4:5F:02:5F:A5:D3:21:D0:2D:48:"
+      "7B:31:60:5C:5A:D8:0D:CD:78:78:6C:6D:CE:CC:0C:67\r\n"
+    "m=audio 9000 RTP/AVP 99\r\n"
+    "c=IN IP4 0.0.0.0\r\n"
+    "a=rtpmap:99 opus/48000/2\r\n"
+    "a=ice-ufrag:cYuakxkEKH+RApYE\r\n"
+    "a=ice-pwd:bwtpzLZD+3jbu8vQHvEa6Xuq\r\n"
+    "a=setup:active\r\n"
+    "a=sendrecv\r\n";
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, BigOValues)
+{
+  EnsureInit();
+
+  std::string offer;
+
+  CreateSDPForBigOTests(offer, "12345678901234567");
+
+  a2_->SetRemote(TestObserver::OFFER, offer);
+  ASSERT_EQ(a2_->pObserver->state, TestObserver::stateSuccess);
+}
+
+// TODO: Move to jsep_session_unittest
+// We probably need to retain at least one test case for each API entry point
+// that verifies that errors are propagated correctly, though.
+TEST_P(SignalingTest, BigOValuesExtraChars)
+{
+  EnsureInit();
+
+  std::string offer;
+
+  CreateSDPForBigOTests(offer, "12345678901234567FOOBAR");
+
+  // The signaling state will remain "stable" because the unparsable
+  // SDP leads to a failure in SetRemoteDescription.
+  a2_->SetRemote(TestObserver::OFFER, offer, true,
+                 PCImplSignalingState::SignalingStable);
+  ASSERT_TRUE(a2_->pObserver->state == TestObserver::stateError);
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, BigOValuesTooBig)
+{
+  EnsureInit();
+
+  std::string offer;
+
+  CreateSDPForBigOTests(offer, "18446744073709551615");
+
+  // The signaling state will remain "stable" because the unparsable
+  // SDP leads to a failure in SetRemoteDescription.
+  a2_->SetRemote(TestObserver::OFFER, offer, true,
+                 PCImplSignalingState::SignalingStable);
+  ASSERT_TRUE(a2_->pObserver->state == TestObserver::stateError);
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, SetLocalAnswerInStable)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  CreateOffer(options, OFFER_AUDIO);
+
+  // The signaling state will remain "stable" because the
+  // SetLocalDescription call fails.
+  a1_->SetLocal(TestObserver::ANSWER, a1_->offer(), true,
+                PCImplSignalingState::SignalingStable);
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kInvalidState);
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, SetRemoteAnswerInStable) {
+  EnsureInit();
+
+  // The signaling state will remain "stable" because the
+  // SetRemoteDescription call fails.
+  a1_->SetRemote(TestObserver::ANSWER, strSampleSdpAudioVideoNoIce, true,
+                PCImplSignalingState::SignalingStable);
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kInvalidState);
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, SetLocalAnswerInHaveLocalOffer) {
+  OfferOptions options;
+  CreateOffer(options, OFFER_AUDIO);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  // The signaling state will remain "have-local-offer" because the
+  // SetLocalDescription call fails.
+  a1_->SetLocal(TestObserver::ANSWER, a1_->offer(), true,
+                PCImplSignalingState::SignalingHaveLocalOffer);
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kInvalidState);
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, SetRemoteOfferInHaveLocalOffer) {
+  OfferOptions options;
+  CreateOffer(options, OFFER_AUDIO);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  // The signaling state will remain "have-local-offer" because the
+  // SetRemoteDescription call fails.
+  a1_->SetRemote(TestObserver::OFFER, a1_->offer(), true,
+                 PCImplSignalingState::SignalingHaveLocalOffer);
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kInvalidState);
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, SetLocalOfferInHaveRemoteOffer) {
+  OfferOptions options;
+  CreateOffer(options, OFFER_AUDIO);
+  a2_->SetRemote(TestObserver::OFFER, a1_->offer());
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  // The signaling state will remain "have-remote-offer" because the
+  // SetLocalDescription call fails.
+  a2_->SetLocal(TestObserver::OFFER, a1_->offer(), true,
+                PCImplSignalingState::SignalingHaveRemoteOffer);
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kInvalidState);
+}
+
+// TODO: Move to jsep_session_unittest
+TEST_P(SignalingTest, SetRemoteAnswerInHaveRemoteOffer) {
+  OfferOptions options;
+  CreateOffer(options, OFFER_AUDIO);
+  a2_->SetRemote(TestObserver::OFFER, a1_->offer());
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  // The signaling state will remain "have-remote-offer" because the
+  // SetRemoteDescription call fails.
+  a2_->SetRemote(TestObserver::ANSWER, a1_->offer(), true,
+               PCImplSignalingState::SignalingHaveRemoteOffer);
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kInvalidState);
+}
+
+// Disabled until the spec adds a failure callback to addStream
+// Actually, this is allowed I think, it just triggers a negotiationneeded
+TEST_P(SignalingTest, DISABLED_AddStreamInHaveLocalOffer) {
+  OfferOptions options;
+  CreateOffer(options, OFFER_AUDIO);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+  a1_->AddStream();
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kInvalidState);
+}
+
+// Disabled until the spec adds a failure callback to removeStream
+// Actually, this is allowed I think, it just triggers a negotiationneeded
+TEST_P(SignalingTest, DISABLED_RemoveStreamInHaveLocalOffer) {
+  OfferOptions options;
+  CreateOffer(options, OFFER_AUDIO);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+  a1_->RemoveLastStreamAdded();
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kInvalidState);
+}
+
+TEST_P(SignalingTest, AddCandidateInHaveLocalOffer) {
+  OfferOptions options;
+  CreateOffer(options, OFFER_AUDIO);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  ASSERT_EQ(a1_->pObserver->lastAddIceStatusCode,
+            PeerConnectionImpl::kNoError);
+  a1_->AddIceCandidate(strSampleCandidate,
+                      strSampleMid, nSamplelevel, false);
+  ASSERT_EQ(PeerConnectionImpl::kInvalidState,
+            a1_->pObserver->lastAddIceStatusCode);
+}
+
+TEST_F(SignalingAgentTest, CreateOffer) {
+  CreateAgent(TestStunServer::GetInstance()->addr(),
+              TestStunServer::GetInstance()->port());
+  OfferOptions options;
+  agent(0)->CreateOffer(options, OFFER_AUDIO);
+}
+
+TEST_F(SignalingAgentTest, SetLocalWithoutCreateOffer) {
+  CreateAgent(TestStunServer::GetInstance()->addr(),
+              TestStunServer::GetInstance()->port());
+  CreateAgent(TestStunServer::GetInstance()->addr(),
+              TestStunServer::GetInstance()->port());
+  OfferOptions options;
+  agent(0)->CreateOffer(options, OFFER_AUDIO);
+  agent(1)->SetLocal(TestObserver::OFFER,
+                     agent(0)->offer(),
+                     true,
+                     PCImplSignalingState::SignalingStable);
+}
+
+TEST_F(SignalingAgentTest, SetLocalWithoutCreateAnswer) {
+  CreateAgent(TestStunServer::GetInstance()->addr(),
+              TestStunServer::GetInstance()->port());
+  CreateAgent(TestStunServer::GetInstance()->addr(),
+              TestStunServer::GetInstance()->port());
+  CreateAgent(TestStunServer::GetInstance()->addr(),
+              TestStunServer::GetInstance()->port());
+  OfferOptions options;
+  agent(0)->CreateOffer(options, OFFER_AUDIO);
+  agent(1)->SetRemote(TestObserver::OFFER, agent(0)->offer());
+  agent(1)->CreateAnswer(ANSWER_AUDIO);
+  agent(2)->SetRemote(TestObserver::OFFER, agent(0)->offer());
+  // Use agent 1's answer on agent 2, should fail
+  agent(2)->SetLocal(TestObserver::ANSWER,
+                     agent(1)->answer(),
+                     true,
+                     PCImplSignalingState::SignalingHaveRemoteOffer);
+}
+
+TEST_F(SignalingAgentTest, CreateOfferSetLocalTrickleTestServer) {
+  TestStunServer::GetInstance()->SetActive(false);
+  TestStunServer::GetInstance()->SetResponseAddr(
+      kBogusSrflxAddress, kBogusSrflxPort);
+
+  CreateAgent(
+      TestStunServer::GetInstance()->addr(),
+      TestStunServer::GetInstance()->port());
+
+  OfferOptions options;
+  agent(0)->CreateOffer(options, OFFER_AUDIO);
+
+  // Verify that the bogus addr is not there.
+  ASSERT_FALSE(agent(0)->OfferContains(kBogusSrflxAddress));
+
+  // Now enable the STUN server.
+  TestStunServer::GetInstance()->SetActive(true);
+
+  agent(0)->SetLocal(TestObserver::OFFER, agent(0)->offer());
+  agent(0)->WaitForGather();
+
+  // Verify that we got our candidates.
+  ASSERT_LE(2U, agent(0)->MatchingCandidates(kBogusSrflxAddress));
+
+  // Verify that the candidates appear in the offer.
+  size_t match;
+  match = agent(0)->getLocalDescription().find(kBogusSrflxAddress);
+  ASSERT_LT(0U, match);
+}
+
+
+TEST_F(SignalingAgentTest, CreateAnswerSetLocalTrickleTestServer) {
+  TestStunServer::GetInstance()->SetActive(false);
+  TestStunServer::GetInstance()->SetResponseAddr(
+      kBogusSrflxAddress, kBogusSrflxPort);
+
+  CreateAgent(
+      TestStunServer::GetInstance()->addr(),
+      TestStunServer::GetInstance()->port());
+
+  std::string offer(strG711SdpOffer);
+  agent(0)->SetRemote(TestObserver::OFFER, offer, true,
+                 PCImplSignalingState::SignalingHaveRemoteOffer);
+  ASSERT_EQ(agent(0)->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  agent(0)->CreateAnswer(ANSWER_AUDIO);
+
+  // Verify that the bogus addr is not there.
+  ASSERT_FALSE(agent(0)->AnswerContains(kBogusSrflxAddress));
+
+  // Now enable the STUN server.
+  TestStunServer::GetInstance()->SetActive(true);
+
+  agent(0)->SetLocal(TestObserver::ANSWER, agent(0)->answer());
+  agent(0)->WaitForGather();
+
+  // Verify that we got our candidates.
+  ASSERT_LE(2U, agent(0)->MatchingCandidates(kBogusSrflxAddress));
+
+  // Verify that the candidates appear in the answer.
+  size_t match;
+  match = agent(0)->getLocalDescription().find(kBogusSrflxAddress);
+  ASSERT_LT(0U, match);
+}
+
+
+
+TEST_F(SignalingAgentTest, CreateLotsAndWait) {
+  int i;
+
+  for (i=0; i < 100; i++) {
+    if (!CreateAgent())
+      break;
+    std::cerr << "Created agent " << i << std::endl;
+  }
+  PR_Sleep(1000);  // Wait to see if we crash
+}
+
+// Test for bug 856433.
+TEST_F(SignalingAgentTest, CreateNoInit) {
+  CreateAgentNoInit();
+}
+
+
+/*
+ * Test for Bug 843595
+ */
+TEST_P(SignalingTest, missingUfrag)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  std::string offer =
+    "v=0\r\n"
+    "o=Mozilla-SIPUA 2208 0 IN IP4 0.0.0.0\r\n"
+    "s=SIP Call\r\n"
+    "t=0 0\r\n"
+    "a=ice-pwd:4450d5a4a5f097855c16fa079893be18\r\n"
+    "a=fingerprint:sha-256 23:9A:2E:43:94:42:CF:46:68:FC:62:F9:F4:48:61:DB:"
+      "2F:8C:C9:FF:6B:25:54:9D:41:09:EF:83:A8:19:FC:B6\r\n"
+    "m=audio 56187 UDP/TLS/RTP/SAVPF 109 0 8 101\r\n"
+    "c=IN IP4 77.9.79.167\r\n"
+    "a=rtpmap:109 opus/48000/2\r\n"
+    "a=ptime:20\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:101 telephone-event/8000\r\n"
+    "a=fmtp:101 0-15\r\n"
+    "a=sendrecv\r\n"
+    "a=candidate:0 1 UDP 2113601791 192.168.178.20 56187 typ host\r\n"
+    "a=candidate:1 1 UDP 1694236671 77.9.79.167 56187 typ srflx raddr "
+      "192.168.178.20 rport 56187\r\n"
+    "a=candidate:0 2 UDP 2113601790 192.168.178.20 52955 typ host\r\n"
+    "a=candidate:1 2 UDP 1694236670 77.9.79.167 52955 typ srflx raddr "
+      "192.168.178.20 rport 52955\r\n"
+    "m=video 49929 UDP/TLS/RTP/SAVPF 120\r\n"
+    "c=IN IP4 77.9.79.167\r\n"
+    "a=rtpmap:120 VP8/90000\r\n"
+    "a=recvonly\r\n"
+    "a=candidate:0 1 UDP 2113601791 192.168.178.20 49929 typ host\r\n"
+    "a=candidate:1 1 UDP 1694236671 77.9.79.167 49929 typ srflx raddr "
+      "192.168.178.20 rport 49929\r\n"
+    "a=candidate:0 2 UDP 2113601790 192.168.178.20 50769 typ host\r\n"
+    "a=candidate:1 2 UDP 1694236670 77.9.79.167 50769 typ srflx raddr "
+      "192.168.178.20 rport 50769\r\n"
+    "m=application 54054 DTLS/SCTP 5000\r\n"
+    "c=IN IP4 77.9.79.167\r\n"
+    "a=fmtp:HuRUu]Dtcl\\zM,7(OmEU%O$gU]x/z\tD protocol=webrtc-datachannel;"
+      "streams=16\r\n"
+    "a=sendrecv\r\n";
+
+  // Need to create an offer, since that's currently required by our
+  // FSM. This may change in the future.
+  a1_->CreateOffer(options, OFFER_AV);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer(), true);
+  // We now detect the missing ICE parameters at SetRemoteDescription
+  a2_->SetRemote(TestObserver::OFFER, offer, true,
+                 PCImplSignalingState::SignalingStable);
+  ASSERT_TRUE(a2_->pObserver->state == TestObserver::stateError);
+}
+
+TEST_P(SignalingTest, AudioOnlyCalleeNoRtcpMux)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer(), false);
+  ParsedSDP sdpWrapper(a1_->offer());
+  sdpWrapper.DeleteLine("a=rtcp-mux");
+  std::cout << "Modified SDP " << std::endl
+            << indent(sdpWrapper.getSdp()) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, sdpWrapper.getSdp(), false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  a1_->mExpectRtcpMuxAudio = false;
+  a2_->mExpectRtcpMuxAudio = false;
+
+  // Answer should not have a=rtcp-mux
+  ASSERT_EQ(a2_->getLocalDescription().find("\r\na=rtcp-mux"),
+            std::string::npos) << "SDP was: " << a2_->getLocalDescription();
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+
+
+TEST_P(SignalingTest, AudioOnlyG722Only)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer(), false);
+  ParsedSDP sdpWrapper(a1_->offer());
+  sdpWrapper.ReplaceLine("m=audio",
+                         "m=audio 65375 UDP/TLS/RTP/SAVPF 9\r\n");
+  std::cout << "Modified SDP " << std::endl
+            << indent(sdpWrapper.getSdp()) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, sdpWrapper.getSdp(), false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+  ASSERT_NE(a2_->getLocalDescription().find("UDP/TLS/RTP/SAVPF 9\r"),
+            std::string::npos);
+  ASSERT_NE(a2_->getLocalDescription().find("a=rtpmap:9 G722/8000"), std::string::npos);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, AudioOnlyG722MostPreferred)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer(), false);
+  ParsedSDP sdpWrapper(a1_->offer());
+  sdpWrapper.ReplaceLine("m=audio",
+                         "m=audio 65375 UDP/TLS/RTP/SAVPF 9 0 8 109\r\n");
+  std::cout << "Modified SDP " << std::endl
+            << indent(sdpWrapper.getSdp()) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, sdpWrapper.getSdp(), false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+  ASSERT_NE(a2_->getLocalDescription().find("UDP/TLS/RTP/SAVPF 9"),
+            std::string::npos);
+  ASSERT_NE(a2_->getLocalDescription().find("a=rtpmap:9 G722/8000"), std::string::npos);
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, AudioOnlyG722Rejected)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+  // creating different SDPs as a workaround for rejecting codecs
+  // this way the answerer should pick a codec with lower priority
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer(), false);
+  ParsedSDP sdpWrapper(a1_->offer());
+  sdpWrapper.ReplaceLine("m=audio",
+                         "m=audio 65375 UDP/TLS/RTP/SAVPF 0 8\r\n");
+  std::cout << "Modified SDP offer " << std::endl
+            << indent(sdpWrapper.getSdp()) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, sdpWrapper.getSdp(), false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+  // TODO(bug 814227): Use commented out code instead.
+  ASSERT_NE(a2_->getLocalDescription().find("UDP/TLS/RTP/SAVPF 0\r"),
+            std::string::npos);
+  // ASSERT_NE(a2_->getLocalDescription().find("UDP/TLS/RTP/SAVPF 0 8\r"), std::string::npos);
+  ASSERT_NE(a2_->getLocalDescription().find("a=rtpmap:0 PCMU/8000"), std::string::npos);
+  ASSERT_EQ(a2_->getLocalDescription().find("a=rtpmap:109 opus/48000/2"), std::string::npos);
+  ASSERT_EQ(a2_->getLocalDescription().find("a=rtpmap:9 G722/8000"), std::string::npos);
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, RestartIce)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  options.setBoolOption("IceRestart", true);
+  OfferAnswer(options, OFFER_NONE);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, FullCallAudioNoMuxVideoMux)
+{
+  if (UseBundle()) {
+    // This test doesn't make sense for bundle
+    return;
+  }
+
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AV);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer(), false);
+  ParsedSDP sdpWrapper(a1_->offer());
+  sdpWrapper.DeleteLine("a=rtcp-mux");
+  std::cout << "Modified SDP " << std::endl
+            << indent(sdpWrapper.getSdp()) << std::endl;
+  a2_->SetRemote(TestObserver::OFFER, sdpWrapper.getSdp(), false);
+  a2_->CreateAnswer(OFFER_AV | ANSWER_AV);
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  // Answer should have only one a=rtcp-mux line
+  size_t match = a2_->getLocalDescription().find("\r\na=rtcp-mux");
+  ASSERT_NE(match, std::string::npos);
+  match = a2_->getLocalDescription().find("\r\na=rtcp-mux", match + 1);
+  ASSERT_EQ(match, std::string::npos);
+
+  a1_->mExpectRtcpMuxAudio = false;
+  a2_->mExpectRtcpMuxAudio = false;
+
+  WaitForCompleted();
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+// TODO: Move to jsep_sesion_unittest
+TEST_P(SignalingTest, RtcpFbInOffer)
+{
+  EnsureInit();
+  OfferOptions options;
+  a1_->CreateOffer(options, OFFER_AV);
+  const char *expected[] = { "nack", "nack pli", "ccm fir" };
+  CheckRtcpFbSdp(a1_->offer(), ARRAY_TO_SET(std::string, expected));
+}
+
+TEST_P(SignalingTest, RtcpFbOfferAll)
+{
+  const char *feedbackTypes[] = { "nack", "nack pli", "ccm fir" };
+  TestRtcpFbOffer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  true,
+                  VideoSessionConduit::FrameRequestPli);
+}
+
+TEST_P(SignalingTest, RtcpFbOfferNoNackBasic)
+{
+  const char *feedbackTypes[] = { "nack pli", "ccm fir" };
+  TestRtcpFbOffer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  false,
+                  VideoSessionConduit::FrameRequestPli);
+}
+
+TEST_P(SignalingTest, RtcpFbOfferNoNackPli)
+{
+  const char *feedbackTypes[] = { "nack", "ccm fir" };
+  TestRtcpFbOffer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  true,
+                  VideoSessionConduit::FrameRequestFir);
+}
+
+TEST_P(SignalingTest, RtcpFbOfferNoCcmFir)
+{
+  const char *feedbackTypes[] = { "nack", "nack pli" };
+  TestRtcpFbOffer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  true,
+                  VideoSessionConduit::FrameRequestPli);
+}
+
+TEST_P(SignalingTest, RtcpFbOfferNoNack)
+{
+  const char *feedbackTypes[] = { "ccm fir" };
+  TestRtcpFbOffer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  false,
+                  VideoSessionConduit::FrameRequestFir);
+}
+
+TEST_P(SignalingTest, RtcpFbOfferNoFrameRequest)
+{
+  const char *feedbackTypes[] = { "nack" };
+  TestRtcpFbOffer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  true,
+                  VideoSessionConduit::FrameRequestNone);
+}
+
+TEST_P(SignalingTest, RtcpFbOfferPliOnly)
+{
+  const char *feedbackTypes[] = { "nack pli" };
+  TestRtcpFbOffer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  false,
+                  VideoSessionConduit::FrameRequestPli);
+}
+
+TEST_P(SignalingTest, RtcpFbOfferNoFeedback)
+{
+  const char *feedbackTypes[] = { };
+  TestRtcpFbOffer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  false,
+                  VideoSessionConduit::FrameRequestNone);
+}
+
+TEST_P(SignalingTest, RtcpFbAnswerAll)
+{
+  const char *feedbackTypes[] = { "nack", "nack pli", "ccm fir" };
+  TestRtcpFbAnswer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  true,
+                  VideoSessionConduit::FrameRequestPli);
+}
+
+TEST_P(SignalingTest, RtcpFbAnswerNoNackBasic)
+{
+  const char *feedbackTypes[] = { "nack pli", "ccm fir" };
+  TestRtcpFbAnswer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  false,
+                  VideoSessionConduit::FrameRequestPli);
+}
+
+TEST_P(SignalingTest, RtcpFbAnswerNoNackPli)
+{
+  const char *feedbackTypes[] = { "nack", "ccm fir" };
+  TestRtcpFbAnswer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  true,
+                  VideoSessionConduit::FrameRequestFir);
+}
+
+TEST_P(SignalingTest, RtcpFbAnswerNoCcmFir)
+{
+  const char *feedbackTypes[] = { "nack", "nack pli" };
+  TestRtcpFbAnswer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  true,
+                  VideoSessionConduit::FrameRequestPli);
+}
+
+TEST_P(SignalingTest, RtcpFbAnswerNoNack)
+{
+  const char *feedbackTypes[] = { "ccm fir" };
+  TestRtcpFbAnswer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  false,
+                  VideoSessionConduit::FrameRequestFir);
+}
+
+TEST_P(SignalingTest, RtcpFbAnswerNoFrameRequest)
+{
+  const char *feedbackTypes[] = { "nack" };
+  TestRtcpFbAnswer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  true,
+                  VideoSessionConduit::FrameRequestNone);
+}
+
+TEST_P(SignalingTest, RtcpFbAnswerPliOnly)
+{
+  const char *feedbackTypes[] = { "nack pli" };
+  TestRtcpFbAnswer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  0,
+                  VideoSessionConduit::FrameRequestPli);
+}
+
+TEST_P(SignalingTest, RtcpFbAnswerNoFeedback)
+{
+  const char *feedbackTypes[] = { };
+  TestRtcpFbAnswer(ARRAY_TO_SET(std::string, feedbackTypes),
+                  0,
+                  VideoSessionConduit::FrameRequestNone);
+}
+
+// In this test we will change the offer SDP's a=setup value
+// from actpass to passive.  This will make the answer do active.
+TEST_P(SignalingTest, AudioCallForceDtlsRoles)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+
+  // By default the offer should give actpass
+  std::string offer(a1_->offer());
+  match = offer.find("\r\na=setup:actpass");
+  ASSERT_NE(match, std::string::npos);
+  // Now replace the actpass with passive so that the answer will
+  // return active
+  offer.replace(match, strlen("\r\na=setup:actpass"),
+    "\r\na=setup:passive");
+  std::cout << "Modified SDP " << std::endl
+            << indent(offer) << std::endl;
+
+  a1_->SetLocal(TestObserver::OFFER, offer, false);
+  a2_->SetRemote(TestObserver::OFFER, offer, false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  // Now the answer should contain a=setup:active
+  std::string answer(a2_->answer());
+  match = answer.find("\r\na=setup:active");
+  ASSERT_NE(match, std::string::npos);
+
+  // This should setup the DTLS with the same roles
+  // as the regular tests above.
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+// In this test we will change the offer SDP's a=setup value
+// from actpass to active.  This will make the answer do passive
+TEST_P(SignalingTest, AudioCallReverseDtlsRoles)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+
+  // By default the offer should give actpass
+  std::string offer(a1_->offer());
+  match = offer.find("\r\na=setup:actpass");
+  ASSERT_NE(match, std::string::npos);
+  // Now replace the actpass with active so that the answer will
+  // return passive
+  offer.replace(match, strlen("\r\na=setup:actpass"),
+    "\r\na=setup:active");
+  std::cout << "Modified SDP " << std::endl
+            << indent(offer) << std::endl;
+
+  a1_->SetLocal(TestObserver::OFFER, offer, false);
+  a2_->SetRemote(TestObserver::OFFER, offer, false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  // Now the answer should contain a=setup:passive
+  std::string answer(a2_->answer());
+  match = answer.find("\r\na=setup:passive");
+  ASSERT_NE(match, std::string::npos);
+
+  // This should setup the DTLS with the opposite roles
+  // than the regular tests above.
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+// In this test we will change the answer SDP's a=setup value
+// from active to passive.  This will make both sides do
+// active and should not connect.
+TEST_P(SignalingTest, AudioCallMismatchDtlsRoles)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+
+  // By default the offer should give actpass
+  std::string offer(a1_->offer());
+  match = offer.find("\r\na=setup:actpass");
+  ASSERT_NE(match, std::string::npos);
+  a1_->SetLocal(TestObserver::OFFER, offer, false);
+  a2_->SetRemote(TestObserver::OFFER, offer, false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  // Now the answer should contain a=setup:active
+  std::string answer(a2_->answer());
+  match = answer.find("\r\na=setup:active");
+  ASSERT_NE(match, std::string::npos);
+  a2_->SetLocal(TestObserver::ANSWER, answer, false);
+
+  // Now replace the active with passive so that the offerer will
+  // also do active.
+  answer.replace(match, strlen("\r\na=setup:active"),
+    "\r\na=setup:passive");
+  std::cout << "Modified SDP " << std::endl
+            << indent(answer) << std::endl;
+
+  // This should setup the DTLS with both sides playing active
+  a1_->SetRemote(TestObserver::ANSWER, answer, false);
+
+  WaitForCompleted();
+
+  // Not using ASSERT_TRUE_WAIT here because we expect failure
+  PR_Sleep(500); // Wait for some data to get written
+
+  CloseStreams();
+
+  ASSERT_GE(a1_->GetPacketsSent(0), 4);
+  // In this case we should receive nothing.
+  ASSERT_EQ(a2_->GetPacketsReceived(0), 0);
+}
+
+// In this test we will change the offer SDP's a=setup value
+// from actpass to garbage.  It should ignore the garbage value
+// and respond with setup:active
+TEST_P(SignalingTest, AudioCallGarbageSetup)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+
+  // By default the offer should give actpass
+  std::string offer(a1_->offer());
+  match = offer.find("\r\na=setup:actpass");
+  ASSERT_NE(match, std::string::npos);
+  // Now replace the actpass with a garbage value
+  offer.replace(match, strlen("\r\na=setup:actpass"),
+    "\r\na=setup:G4rb4g3V4lu3");
+  std::cout << "Modified SDP " << std::endl
+            << indent(offer) << std::endl;
+
+  a1_->SetLocal(TestObserver::OFFER, offer, false);
+  a2_->SetRemote(TestObserver::OFFER, offer, false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  // Now the answer should contain a=setup:active
+  std::string answer(a2_->answer());
+  match = answer.find("\r\na=setup:active");
+  ASSERT_NE(match, std::string::npos);
+
+  // This should setup the DTLS with the same roles
+  // as the regular tests above.
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+// In this test we will change the offer SDP to remove the
+// a=setup line.  Answer should respond with a=setup:active.
+TEST_P(SignalingTest, AudioCallOfferNoSetupOrConnection)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+
+  std::string offer(a1_->offer());
+  a1_->SetLocal(TestObserver::OFFER, offer, false);
+
+  // By default the offer should give setup:actpass
+  match = offer.find("\r\na=setup:actpass");
+  ASSERT_NE(match, std::string::npos);
+  // Remove the a=setup line
+  offer.replace(match, strlen("\r\na=setup:actpass"), "");
+  std::cout << "Modified SDP " << std::endl
+            << indent(offer) << std::endl;
+
+  a2_->SetRemote(TestObserver::OFFER, offer, false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  // Now the answer should contain a=setup:active
+  std::string answer(a2_->answer());
+  match = answer.find("\r\na=setup:active");
+  ASSERT_NE(match, std::string::npos);
+
+  // This should setup the DTLS with the same roles
+  // as the regular tests above.
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+// In this test we will change the answer SDP to remove the
+// a=setup line.  ICE should still connect since active will
+// be assumed.
+TEST_P(SignalingTest, AudioCallAnswerNoSetupOrConnection)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AUDIO);
+
+  // By default the offer should give setup:actpass
+  std::string offer(a1_->offer());
+  match = offer.find("\r\na=setup:actpass");
+  ASSERT_NE(match, std::string::npos);
+
+  a1_->SetLocal(TestObserver::OFFER, offer, false);
+  a2_->SetRemote(TestObserver::OFFER, offer, false);
+  a2_->CreateAnswer(OFFER_AUDIO | ANSWER_AUDIO);
+
+  // Now the answer should contain a=setup:active
+  std::string answer(a2_->answer());
+  match = answer.find("\r\na=setup:active");
+  ASSERT_NE(match, std::string::npos);
+  // Remove the a=setup line
+  answer.replace(match, strlen("\r\na=setup:active"), "");
+  std::cout << "Modified SDP " << std::endl
+            << indent(answer) << std::endl;
+
+  // This should setup the DTLS with the same roles
+  // as the regular tests above.
+  a2_->SetLocal(TestObserver::ANSWER, answer, false);
+  a1_->SetRemote(TestObserver::ANSWER, answer, false);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+
+TEST_P(SignalingTest, FullCallRealTrickle)
+{
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, FullCallRealTrickleTestServer)
+{
+  SetTestStunServer();
+
+  OfferOptions options;
+  OfferAnswer(options, OFFER_AV | ANSWER_AV);
+
+  TestStunServer::GetInstance()->SetActive(true);
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, hugeSdp)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  std::string offer =
+    "v=0\r\n"
+    "o=- 1109973417102828257 2 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "a=group:BUNDLE audio video\r\n"
+    "a=msid-semantic: WMS 1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP\r\n"
+    "m=audio 32952 UDP/TLS/RTP/SAVPF 111 103 104 0 8 107 106 105 13 126\r\n"
+    "c=IN IP4 128.64.32.16\r\n"
+    "a=rtcp:32952 IN IP4 128.64.32.16\r\n"
+    "a=candidate:77142221 1 udp 2113937151 192.168.137.1 54081 typ host generation 0\r\n"
+    "a=candidate:77142221 2 udp 2113937151 192.168.137.1 54081 typ host generation 0\r\n"
+    "a=candidate:983072742 1 udp 2113937151 172.22.0.56 54082 typ host generation 0\r\n"
+    "a=candidate:983072742 2 udp 2113937151 172.22.0.56 54082 typ host generation 0\r\n"
+    "a=candidate:2245074553 1 udp 1845501695 32.64.128.1 62397 typ srflx raddr 192.168.137.1 rport 54081 generation 0\r\n"
+    "a=candidate:2245074553 2 udp 1845501695 32.64.128.1 62397 typ srflx raddr 192.168.137.1 rport 54081 generation 0\r\n"
+    "a=candidate:2479353907 1 udp 1845501695 32.64.128.1 54082 typ srflx raddr 172.22.0.56 rport 54082 generation 0\r\n"
+    "a=candidate:2479353907 2 udp 1845501695 32.64.128.1 54082 typ srflx raddr 172.22.0.56 rport 54082 generation 0\r\n"
+    "a=candidate:1243276349 1 tcp 1509957375 192.168.137.1 0 typ host generation 0\r\n"
+    "a=candidate:1243276349 2 tcp 1509957375 192.168.137.1 0 typ host generation 0\r\n"
+    "a=candidate:1947960086 1 tcp 1509957375 172.22.0.56 0 typ host generation 0\r\n"
+    "a=candidate:1947960086 2 tcp 1509957375 172.22.0.56 0 typ host generation 0\r\n"
+    "a=candidate:1808221584 1 udp 33562367 128.64.32.16 32952 typ relay raddr 32.64.128.1 rport 62398 generation 0\r\n"
+    "a=candidate:1808221584 2 udp 33562367 128.64.32.16 32952 typ relay raddr 32.64.128.1 rport 62398 generation 0\r\n"
+    "a=candidate:507872740 1 udp 33562367 128.64.32.16 40975 typ relay raddr 32.64.128.1 rport 54085 generation 0\r\n"
+    "a=candidate:507872740 2 udp 33562367 128.64.32.16 40975 typ relay raddr 32.64.128.1 rport 54085 generation 0\r\n"
+    "a=ice-ufrag:xQuJwjX3V3eMA81k\r\n"
+    "a=ice-pwd:ZUiRmjS2GDhG140p73dAsSVP\r\n"
+    "a=ice-options:google-ice\r\n"
+    "a=fingerprint:sha-256 59:4A:8B:73:A7:73:53:71:88:D7:4D:58:28:0C:79:72:31:29:9B:05:37:DD:58:43:C2:D4:85:A2:B3:66:38:7A\r\n"
+    "a=setup:active\r\n"
+    "a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n"
+    "a=sendrecv\r\n"
+    "a=mid:audio\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:/U44g3ULdtapeiSg+T3n6dDLBKIjpOhb/NXAL/2b\r\n"
+    "a=rtpmap:111 opus/48000/2\r\n"
+    "a=fmtp:111 minptime=10\r\n"
+    "a=rtpmap:103 ISAC/16000\r\n"
+    "a=rtpmap:104 ISAC/32000\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:107 CN/48000\r\n"
+    "a=rtpmap:106 CN/32000\r\n"
+    "a=rtpmap:105 CN/16000\r\n"
+    "a=rtpmap:13 CN/8000\r\n"
+    "a=rtpmap:126 telephone-event/8000\r\n"
+    "a=maxptime:60\r\n"
+    "a=ssrc:2271517329 cname:mKDNt7SQf6pwDlIn\r\n"
+    "a=ssrc:2271517329 msid:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP 1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIPa0\r\n"
+    "a=ssrc:2271517329 mslabel:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP\r\n"
+    "a=ssrc:2271517329 label:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIPa0\r\n"
+    "m=video 32952 UDP/TLS/RTP/SAVPF 100 116 117\r\n"
+    "c=IN IP4 128.64.32.16\r\n"
+    "a=rtcp:32952 IN IP4 128.64.32.16\r\n"
+    "a=candidate:77142221 1 udp 2113937151 192.168.137.1 54081 typ host generation 0\r\n"
+    "a=candidate:77142221 2 udp 2113937151 192.168.137.1 54081 typ host generation 0\r\n"
+    "a=candidate:983072742 1 udp 2113937151 172.22.0.56 54082 typ host generation 0\r\n"
+    "a=candidate:983072742 2 udp 2113937151 172.22.0.56 54082 typ host generation 0\r\n"
+    "a=candidate:2245074553 1 udp 1845501695 32.64.128.1 62397 typ srflx raddr 192.168.137.1 rport 54081 generation 0\r\n"
+    "a=candidate:2245074553 2 udp 1845501695 32.64.128.1 62397 typ srflx raddr 192.168.137.1 rport 54081 generation 0\r\n"
+    "a=candidate:2479353907 1 udp 1845501695 32.64.128.1 54082 typ srflx raddr 172.22.0.56 rport 54082 generation 0\r\n"
+    "a=candidate:2479353907 2 udp 1845501695 32.64.128.1 54082 typ srflx raddr 172.22.0.56 rport 54082 generation 0\r\n"
+    "a=candidate:1243276349 1 tcp 1509957375 192.168.137.1 0 typ host generation 0\r\n"
+    "a=candidate:1243276349 2 tcp 1509957375 192.168.137.1 0 typ host generation 0\r\n"
+    "a=candidate:1947960086 1 tcp 1509957375 172.22.0.56 0 typ host generation 0\r\n"
+    "a=candidate:1947960086 2 tcp 1509957375 172.22.0.56 0 typ host generation 0\r\n"
+    "a=candidate:1808221584 1 udp 33562367 128.64.32.16 32952 typ relay raddr 32.64.128.1 rport 62398 generation 0\r\n"
+    "a=candidate:1808221584 2 udp 33562367 128.64.32.16 32952 typ relay raddr 32.64.128.1 rport 62398 generation 0\r\n"
+    "a=candidate:507872740 1 udp 33562367 128.64.32.16 40975 typ relay raddr 32.64.128.1 rport 54085 generation 0\r\n"
+    "a=candidate:507872740 2 udp 33562367 128.64.32.16 40975 typ relay raddr 32.64.128.1 rport 54085 generation 0\r\n"
+    "a=ice-ufrag:xQuJwjX3V3eMA81k\r\n"
+    "a=ice-pwd:ZUiRmjS2GDhG140p73dAsSVP\r\n"
+    "a=ice-options:google-ice\r\n"
+    "a=fingerprint:sha-256 59:4A:8B:73:A7:73:53:71:88:D7:4D:58:28:0C:79:72:31:29:9B:05:37:DD:58:43:C2:D4:85:A2:B3:66:38:7A\r\n"
+    "a=setup:active\r\n"
+    "a=extmap:2 urn:ietf:params:rtp-hdrext:toffset\r\n"
+    "a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n"
+    "a=sendrecv\r\n"
+    "a=mid:video\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:/U44g3ULdtapeiSg+T3n6dDLBKIjpOhb/NXAL/2b\r\n"
+    "a=rtpmap:100 VP8/90000\r\n"
+    "a=rtcp-fb:100 ccm fir\r\n"
+    "a=rtcp-fb:100 nack\r\n"
+    "a=rtcp-fb:100 goog-remb\r\n"
+    "a=rtpmap:116 red/90000\r\n"
+    "a=rtpmap:117 ulpfec/90000\r\n"
+    "a=ssrc:54724160 cname:mKDNt7SQf6pwDlIn\r\n"
+    "a=ssrc:54724160 msid:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP 1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIPv0\r\n"
+    "a=ssrc:54724160 mslabel:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP\r\n"
+    "a=ssrc:54724160 label:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIPv0\r\n";
+
+  a1_->CreateOffer(options, OFFER_AV);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer(), true);
+
+  a2_->SetRemote(TestObserver::OFFER, offer, true);
+  ASSERT_GE(a2_->getRemoteDescription().length(), 4096U);
+  a2_->CreateAnswer(OFFER_AV);
+}
+
+// Test max_fs and max_fr prefs have proper impact on SDP offer
+TEST_P(SignalingTest, MaxFsFrInOffer)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
+  ASSERT_TRUE(prefs);
+  FsFrPrefClearer prefClearer(prefs);
+
+  SetMaxFsFr(prefs, 300, 30);
+
+  a1_->CreateOffer(options, OFFER_AV);
+
+  // Verify that SDP contains correct max-fs and max-fr
+  CheckMaxFsFrSdp(a1_->offer(), 120, 300, 30);
+}
+
+// Test max_fs and max_fr prefs have proper impact on SDP answer
+TEST_P(SignalingTest, MaxFsFrInAnswer)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
+  ASSERT_TRUE(prefs);
+  FsFrPrefClearer prefClearer(prefs);
+
+  a1_->CreateOffer(options, OFFER_AV);
+
+  SetMaxFsFr(prefs, 600, 60);
+
+  a2_->SetRemote(TestObserver::OFFER, a1_->offer());
+
+  a2_->CreateAnswer(OFFER_AV | ANSWER_AV);
+
+  // Verify that SDP contains correct max-fs and max-fr
+  CheckMaxFsFrSdp(a2_->answer(), 120, 600, 60);
+}
+
+// Test SDP offer has proper impact on callee's codec configuration
+TEST_P(SignalingTest, MaxFsFrCalleeCodec)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
+  ASSERT_TRUE(prefs);
+  FsFrPrefClearer prefClearer(prefs);
+
+  SetMaxFsFr(prefs, 300, 30);
+  a1_->CreateOffer(options, OFFER_AV);
+
+  CheckMaxFsFrSdp(a1_->offer(), 120, 300, 30);
+
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+
+  SetMaxFsFr(prefs, 3601, 31);
+  a2_->SetRemote(TestObserver::OFFER, a1_->offer());
+
+  a2_->CreateAnswer(OFFER_AV | ANSWER_AV);
+
+  CheckMaxFsFrSdp(a2_->answer(), 120, 3601, 31);
+
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer());
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer());
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  // Checking callee's video sending configuration does respect max-fs and
+  // max-fr in SDP offer.
+  RefPtr<mozilla::MediaPipeline> pipeline =
+    a2_->GetMediaPipeline(1, 0, 1);
+  ASSERT_TRUE(pipeline);
+  mozilla::MediaSessionConduit *conduit = pipeline->Conduit();
+  ASSERT_TRUE(conduit);
+  ASSERT_EQ(conduit->type(), mozilla::MediaSessionConduit::VIDEO);
+  mozilla::VideoSessionConduit *video_conduit =
+    static_cast<mozilla::VideoSessionConduit*>(conduit);
+
+  ASSERT_EQ(video_conduit->SendingMaxFs(), (unsigned short) 300);
+  ASSERT_EQ(video_conduit->SendingMaxFr(), (unsigned short) 30);
+}
+
+// Test SDP answer has proper impact on caller's codec configuration
+TEST_P(SignalingTest, MaxFsFrCallerCodec)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
+  ASSERT_TRUE(prefs);
+  FsFrPrefClearer prefClearer(prefs);
+
+  a1_->CreateOffer(options, OFFER_AV);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+
+  SetMaxFsFr(prefs, 600, 60);
+  a2_->SetRemote(TestObserver::OFFER, a1_->offer());
+
+  a2_->CreateAnswer(OFFER_AV | ANSWER_AV);
+
+  // Double confirm that SDP answer contains correct max-fs and max-fr
+  CheckMaxFsFrSdp(a2_->answer(), 120, 600, 60);
+
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer());
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer());
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  // Checking caller's video sending configuration does respect max-fs and
+  // max-fr in SDP answer.
+  RefPtr<mozilla::MediaPipeline> pipeline =
+    a1_->GetMediaPipeline(1, 0, 1);
+  ASSERT_TRUE(pipeline);
+  mozilla::MediaSessionConduit *conduit = pipeline->Conduit();
+  ASSERT_TRUE(conduit);
+  ASSERT_EQ(conduit->type(), mozilla::MediaSessionConduit::VIDEO);
+  mozilla::VideoSessionConduit *video_conduit =
+    static_cast<mozilla::VideoSessionConduit*>(conduit);
+
+  ASSERT_EQ(video_conduit->SendingMaxFs(), (unsigned short) 600);
+  ASSERT_EQ(video_conduit->SendingMaxFr(), (unsigned short) 60);
+}
+
+// Validate offer with multiple video codecs
+TEST_P(SignalingTest, ValidateMultipleVideoCodecsInOffer)
+{
+  EnsureInit();
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AV);
+  std::string offer = a1_->offer();
+
+#ifdef H264_P0_SUPPORTED
+  ASSERT_NE(offer.find("UDP/TLS/RTP/SAVPF 120 126 97") ||
+            offer.find("UDP/TLS/RTP/SAVPF 120 121 126 97"), std::string::npos);
+#else
+  ASSERT_NE(offer.find("UDP/TLS/RTP/SAVPF 120 126") ||
+            offer.find("UDP/TLS/RTP/SAVPF 120 121 126"), std::string::npos);
+#endif
+  ASSERT_NE(offer.find("a=rtpmap:120 VP8/90000"), std::string::npos);
+  ASSERT_NE(offer.find("a=rtpmap:126 H264/90000"), std::string::npos);
+  ASSERT_NE(offer.find("a=fmtp:126 profile-level-id="), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:120 nack"), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:120 nack pli"), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:120 ccm fir"), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:126 nack"), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:126 nack pli"), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:126 ccm fir"), std::string::npos);
+#ifdef H264_P0_SUPPORTED
+  ASSERT_NE(offer.find("a=rtpmap:97 H264/90000"), std::string::npos);
+  ASSERT_NE(offer.find("a=fmtp:97 profile-level-id="), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:97 nack"), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:97 nack pli"), std::string::npos);
+  ASSERT_NE(offer.find("a=rtcp-fb:97 ccm fir"), std::string::npos);
+#endif
+}
+
+// Remove VP8 from offer and check that answer negotiates H264 P1 correctly and ignores unknown params
+TEST_P(SignalingTest, RemoveVP8FromOfferWithP1First)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AV);
+
+  // Remove VP8 from offer
+  std::string offer = a1_->offer();
+  match = offer.find("UDP/TLS/RTP/SAVPF 120");
+  if (match != std::string::npos) {
+    offer.replace(match, strlen("UDP/TLS/RTP/SAVPF 120"), "UDP/TLS/RTP/SAVPF");
+  }
+  match = offer.find("UDP/TLS/RTP/SAVPF 121");
+  if (match != std::string::npos) {
+    offer.replace(match, strlen("UDP/TLS/RTP/SAVPF 121"), "UDP/TLS/RTP/SAVPF");
+  }
+  match = offer.find("UDP/TLS/RTP/SAVPF 126");
+  ASSERT_NE(std::string::npos, match);
+
+  match = offer.find("profile-level-id");
+  ASSERT_NE(std::string::npos, match);
+  offer.replace(match,
+                strlen("profile-level-id"),
+                "max-foo=1234;profile-level-id");
+
+  ParsedSDP sdpWrapper(offer);
+  sdpWrapper.DeleteLines("a=rtcp-fb:120");
+  sdpWrapper.DeleteLine("a=rtpmap:120");
+
+  std::cout << "Modified SDP " << std::endl
+            << indent(sdpWrapper.getSdp()) << std::endl;
+
+  // P1 should be offered first
+  ASSERT_NE(offer.find("UDP/TLS/RTP/SAVPF 126"), std::string::npos);
+
+  a1_->SetLocal(TestObserver::OFFER, sdpWrapper.getSdp());
+  a2_->SetRemote(TestObserver::OFFER, sdpWrapper.getSdp(), false);
+  a2_->CreateAnswer(OFFER_AV|ANSWER_AV);
+
+  std::string answer(a2_->answer());
+
+  // Validate answer SDP
+  ASSERT_NE(answer.find("UDP/TLS/RTP/SAVPF 126"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtpmap:126 H264/90000"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:126 nack"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:126 nack pli"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:126 ccm fir"), std::string::npos);
+  // Ensure VP8 removed
+  ASSERT_EQ(answer.find("a=rtpmap:120 VP8/90000"), std::string::npos);
+  ASSERT_EQ(answer.find("a=rtcp-fb:120"), std::string::npos);
+}
+
+// Insert H.264 before VP8 in Offer, check answer selects H.264
+TEST_P(SignalingTest, OfferWithH264BeforeVP8)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AV);
+
+  // Swap VP8 and P1 in offer
+  std::string offer = a1_->offer();
+#ifdef H264_P0_SUPPORTED
+  match = offer.find("UDP/TLS/RTP/SAVPF 120 126 97");
+  ASSERT_NE(std::string::npos, match);
+  offer.replace(match,
+                strlen("UDP/TLS/RTP/SAVPF 126 120 97"),
+                "UDP/TLS/RTP/SAVPF 126 120 97");
+#else
+  match = offer.find("UDP/TLS/RTP/SAVPF 120 126");
+  ASSERT_NE(std::string::npos, match);
+  offer.replace(match,
+                strlen("UDP/TLS/RTP/SAVPF 126 120"),
+                "UDP/TLS/RTP/SAVPF 126 120");
+#endif
+
+  match = offer.find("a=rtpmap:126 H264/90000");
+  ASSERT_NE(std::string::npos, match);
+  offer.replace(match,
+                strlen("a=rtpmap:120 VP8/90000"),
+                "a=rtpmap:120 VP8/90000");
+
+  match = offer.find("a=rtpmap:120 VP8/90000");
+  ASSERT_NE(std::string::npos, match);
+  offer.replace(match,
+                strlen("a=rtpmap:126 H264/90000"),
+                "a=rtpmap:126 H264/90000");
+
+  std::cout << "Modified SDP " << std::endl
+            << indent(offer) << std::endl;
+
+  // P1 should be offered first
+#ifdef H264_P0_SUPPORTED
+  ASSERT_NE(offer.find("UDP/TLS/RTP/SAVPF 126 120 97"), std::string::npos);
+#else
+  ASSERT_NE(offer.find("UDP/TLS/RTP/SAVPF 126 120"), std::string::npos);
+#endif
+
+  a1_->SetLocal(TestObserver::OFFER, offer);
+  a2_->SetRemote(TestObserver::OFFER, offer, false);
+  a2_->CreateAnswer(OFFER_AV|ANSWER_AV);
+
+  std::string answer(a2_->answer());
+
+  // Validate answer SDP
+  ASSERT_NE(answer.find("UDP/TLS/RTP/SAVPF 126"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtpmap:126 H264/90000"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:126 nack"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:126 nack pli"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:126 ccm fir"), std::string::npos);
+}
+
+#ifdef H264_P0_SUPPORTED
+// Remove H.264 P1 and VP8 from offer, check answer negotiates H.264 P0
+TEST_P(SignalingTest, OfferWithOnlyH264P0)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  size_t match;
+
+  a1_->CreateOffer(options, OFFER_AV);
+
+  // Remove VP8 from offer
+  std::string offer = a1_->offer();
+  match = offer.find("UDP/TLS/RTP/SAVPF 120 126");
+  ASSERT_NE(std::string::npos, match);
+  offer.replace(match,
+                strlen("UDP/TLS/RTP/SAVPF 120 126"),
+                "UDP/TLS/RTP/SAVPF");
+
+  ParsedSDP sdpWrapper(offer);
+  sdpWrapper.DeleteLines("a=rtcp-fb:120");
+  sdpWrapper.DeleteLine("a=rtpmap:120");
+  sdpWrapper.DeleteLines("a=rtcp-fb:126");
+  sdpWrapper.DeleteLine("a=rtpmap:126");
+  sdpWrapper.DeleteLine("a=fmtp:126");
+
+  std::cout << "Modified SDP " << std::endl
+            << indent(sdpWrapper.getSdp()) << std::endl;
+
+  // Offer shouldn't have P1 or VP8 now
+  offer = sdpWrapper.getSdp();
+  ASSERT_EQ(offer.find("a=rtpmap:126 H264/90000"), std::string::npos);
+  ASSERT_EQ(offer.find("a=rtpmap:120 VP8/90000"), std::string::npos);
+
+  // P0 should be offered first
+  ASSERT_NE(offer.find("UDP/TLS/RTP/SAVPF 97"), std::string::npos);
+
+  a1_->SetLocal(TestObserver::OFFER, offer);
+  a2_->SetRemote(TestObserver::OFFER, offer, false);
+  a2_->CreateAnswer(OFFER_AV|ANSWER_AV);
+
+  std::string answer(a2_->answer());
+
+  // validate answer SDP
+  ASSERT_NE(answer.find("UDP/TLS/RTP/SAVPF 97"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtpmap:97 H264/90000"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:97 nack"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:97 nack pli"), std::string::npos);
+  ASSERT_NE(answer.find("a=rtcp-fb:97 ccm fir"), std::string::npos);
+  // Ensure VP8 and P1 removed
+  ASSERT_EQ(answer.find("a=rtpmap:126 H264/90000"), std::string::npos);
+  ASSERT_EQ(answer.find("a=rtpmap:120 VP8/90000"), std::string::npos);
+  ASSERT_EQ(answer.find("a=rtcp-fb:120"), std::string::npos);
+  ASSERT_EQ(answer.find("a=rtcp-fb:126"), std::string::npos);
+}
+#endif
+
+// Test negotiating an answer which has only H.264 P1
+// Which means replace VP8 with H.264 P1 in answer
+TEST_P(SignalingTest, AnswerWithoutVP8)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AV);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  a2_->SetRemote(TestObserver::OFFER, a1_->offer(), false);
+  a2_->CreateAnswer(OFFER_AV|ANSWER_AV);
+
+  std::string answer(a2_->answer());
+
+  // Ensure answer has VP8
+  ASSERT_NE(answer.find("\r\na=rtpmap:120 VP8/90000"), std::string::npos);
+
+  // Replace VP8 with H.264 P1
+  ParsedSDP sdpWrapper(a2_->answer());
+  sdpWrapper.AddLine("a=fmtp:126 profile-level-id=42e00c;level-asymmetry-allowed=1;packetization-mode=1\r\n");
+  size_t match;
+  answer = sdpWrapper.getSdp();
+
+  match = answer.find("UDP/TLS/RTP/SAVPF 120");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("UDP/TLS/RTP/SAVPF 120"),
+                 "UDP/TLS/RTP/SAVPF 126");
+
+  match = answer.find("\r\na=rtpmap:120 VP8/90000");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("\r\na=rtpmap:126 H264/90000"),
+                 "\r\na=rtpmap:126 H264/90000");
+
+  match = answer.find("\r\na=rtcp-fb:120 nack");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("\r\na=rtcp-fb:126 nack"),
+                 "\r\na=rtcp-fb:126 nack");
+
+  match = answer.find("\r\na=rtcp-fb:120 nack pli");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("\r\na=rtcp-fb:126 nack pli"),
+                 "\r\na=rtcp-fb:126 nack pli");
+
+  match = answer.find("\r\na=rtcp-fb:120 ccm fir");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("\r\na=rtcp-fb:126 ccm fir"),
+                 "\r\na=rtcp-fb:126 ccm fir");
+
+  std::cout << "Modified SDP " << std::endl << indent(answer) << std::endl;
+
+  a2_->SetLocal(TestObserver::ANSWER, answer, false);
+
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  a1_->SetRemote(TestObserver::ANSWER, answer, false);
+
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  WaitForCompleted();
+
+  // We cannot check pipelines/streams since the H264 stuff won't init.
+
+  CloseStreams();
+}
+
+// Test using a non preferred dynamic video payload type on answer negotiation
+TEST_P(SignalingTest, UseNonPrefferedPayloadTypeOnAnswer)
+{
+  EnsureInit();
+
+  OfferOptions options;
+  a1_->CreateOffer(options, OFFER_AV);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+  a2_->SetRemote(TestObserver::OFFER, a1_->offer(), false);
+  a2_->CreateAnswer(OFFER_AV|ANSWER_AV);
+
+  std::string answer(a2_->answer());
+
+  // Ensure answer has VP8
+  ASSERT_NE(answer.find("\r\na=rtpmap:120 VP8/90000"), std::string::npos);
+
+  // Replace VP8 Payload Type with a non preferred value
+  size_t match;
+  match = answer.find("UDP/TLS/RTP/SAVPF 120");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("UDP/TLS/RTP/SAVPF 121"),
+                 "UDP/TLS/RTP/SAVPF 121");
+
+  match = answer.find("\r\na=rtpmap:120 VP8/90000");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("\r\na=rtpmap:121 VP8/90000"),
+                 "\r\na=rtpmap:121 VP8/90000");
+
+  match = answer.find("\r\na=rtcp-fb:120 nack");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("\r\na=rtcp-fb:121 nack"),
+                 "\r\na=rtcp-fb:121 nack");
+
+  match = answer.find("\r\na=rtcp-fb:120 nack pli");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("\r\na=rtcp-fb:121 nack pli"),
+                 "\r\na=rtcp-fb:121 nack pli");
+
+  match = answer.find("\r\na=rtcp-fb:120 ccm fir");
+  ASSERT_NE(std::string::npos, match);
+  answer.replace(match,
+                 strlen("\r\na=rtcp-fb:121 ccm fir"),
+                 "\r\na=rtcp-fb:121 ccm fir");
+
+  std::cout << "Modified SDP " << std::endl
+            << indent(answer) << std::endl;
+
+  a2_->SetLocal(TestObserver::ANSWER, answer, false);
+
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  a1_->SetRemote(TestObserver::ANSWER, answer, false);
+
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, VideoNegotiationFails)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AV);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+
+  ParsedSDP parsedOffer(a1_->offer());
+  parsedOffer.DeleteLines("a=rtcp-fb:120");
+  parsedOffer.DeleteLines("a=rtcp-fb:126");
+  parsedOffer.DeleteLines("a=rtcp-fb:97");
+  parsedOffer.DeleteLines("a=rtpmap:120");
+  parsedOffer.DeleteLines("a=rtpmap:126");
+  parsedOffer.DeleteLines("a=rtpmap:97");
+  parsedOffer.AddLine("a=rtpmap:120 VP9/90000\r\n");
+  parsedOffer.AddLine("a=rtpmap:126 VP10/90000\r\n");
+  parsedOffer.AddLine("a=rtpmap:97 H265/90000\r\n");
+
+  std::cout << "Modified offer: " << std::endl << parsedOffer.getSdp()
+    << std::endl;
+
+  a2_->SetRemote(TestObserver::OFFER, parsedOffer.getSdp(), false);
+  a2_->CreateAnswer(OFFER_AV|ANSWER_AUDIO);
+
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  a1_->ExpectMissingTracks(SdpMediaSection::kVideo);
+  a2_->ExpectMissingTracks(SdpMediaSection::kVideo);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  // TODO: (bug 1140089) a2 is not seeing audio segments in this test.
+  // CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, AudioNegotiationFails)
+{
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AV);
+  a1_->SetLocal(TestObserver::OFFER, a1_->offer());
+
+  ParsedSDP parsedOffer(a1_->offer());
+  parsedOffer.ReplaceLine("a=rtpmap:0", "a=rtpmap:0 G728/8000");
+  parsedOffer.ReplaceLine("a=rtpmap:8", "a=rtpmap:8 G729/8000");
+  parsedOffer.ReplaceLine("a=rtpmap:9", "a=rtpmap:9 GSM/8000");
+  parsedOffer.ReplaceLine("a=rtpmap:109", "a=rtpmap:109 LPC/8000");
+
+  a2_->SetRemote(TestObserver::OFFER, parsedOffer.getSdp(), false);
+  a2_->CreateAnswer(OFFER_AV|ANSWER_VIDEO);
+
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  a1_->ExpectMissingTracks(SdpMediaSection::kAudio);
+  a2_->ExpectMissingTracks(SdpMediaSection::kAudio);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, BundleStreamCorrelationBySsrc)
+{
+  if (!UseBundle()) {
+    return;
+  }
+
+  EnsureInit();
+
+  a1_->AddStream(DOMMediaStream::HINT_CONTENTS_AUDIO);
+  a1_->AddStream(DOMMediaStream::HINT_CONTENTS_AUDIO);
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_NONE);
+  ParsedSDP parsedOffer(a1_->offer());
+
+  // Sabotage mid-based matching
+  std::string modifiedOffer = parsedOffer.getSdp();
+  size_t midExtStart =
+    modifiedOffer.find("urn:ietf:params:rtp-hdrext:sdes:mid");
+  if (midExtStart != std::string::npos) {
+    // Just garble it a little
+    modifiedOffer[midExtStart] = 'q';
+  }
+
+  a1_->SetLocal(TestObserver::OFFER, modifiedOffer);
+
+  a2_->SetRemote(TestObserver::OFFER, modifiedOffer, false);
+  a2_->CreateAnswer(ANSWER_AUDIO);
+
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+TEST_P(SignalingTest, BundleStreamCorrelationByUniquePt)
+{
+  if (!UseBundle()) {
+    return;
+  }
+
+  EnsureInit();
+
+  OfferOptions options;
+
+  a1_->CreateOffer(options, OFFER_AV);
+  ParsedSDP parsedOffer(a1_->offer());
+
+  std::string modifiedOffer = parsedOffer.getSdp();
+  // Sabotage ssrc matching
+  size_t ssrcStart =
+    modifiedOffer.find("a=ssrc:");
+  ASSERT_NE(std::string::npos, ssrcStart);
+  // Garble
+  modifiedOffer[ssrcStart+2] = 'q';
+
+  // Sabotage mid-based matching
+  size_t midExtStart =
+    modifiedOffer.find("urn:ietf:params:rtp-hdrext:sdes:mid");
+  if (midExtStart != std::string::npos) {
+    // Just garble it a little
+    modifiedOffer[midExtStart] = 'q';
+  }
+
+  a1_->SetLocal(TestObserver::OFFER, modifiedOffer);
+
+  a2_->SetRemote(TestObserver::OFFER, modifiedOffer, false);
+  a2_->CreateAnswer(OFFER_AV|ANSWER_AV);
+
+  a2_->SetLocal(TestObserver::ANSWER, a2_->answer(), false);
+
+  ASSERT_EQ(a2_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  a1_->SetRemote(TestObserver::ANSWER, a2_->answer(), false);
+
+  ASSERT_EQ(a1_->pObserver->lastStatusCode,
+            PeerConnectionImpl::kNoError);
+
+  WaitForCompleted();
+
+  CheckPipelines();
+  CheckStreams();
+
+  CloseStreams();
+}
+
+INSTANTIATE_TEST_CASE_P(Variants, SignalingTest,
+                        ::testing::Values("max-bundle",
+                                          "balanced",
+                                          "max-compat",
+                                          "no_bundle",
+                                          "reject_bundle"));
+
+} // End namespace test.
+
+bool is_color_terminal(const char *terminal) {
+  if (!terminal) {
+    return false;
+  }
+  const char *color_terms[] = {
+    "xterm",
+    "xterm-color",
+    "xterm-256color",
+    "screen",
+    "linux",
+    "cygwin",
+    0
+  };
+  const char **p = color_terms;
+  while (*p) {
+    if (!strcmp(terminal, *p)) {
+      return true;
+    }
+    p++;
+  }
+  return false;
+}
+
+static std::string get_environment(const char *name) {
+  char *value = getenv(name);
+
+  if (!value)
+    return "";
+
+  return value;
+}
+
+// This exists to send as an event to trigger shutdown.
+static void tests_complete() {
+  gTestsComplete = true;
+}
+
+// The GTest thread runs this instead of the main thread so it can
+// do things like ASSERT_TRUE_WAIT which you could not do on the main thread.
+static int gtest_main(int argc, char **argv) {
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  ::testing::InitGoogleTest(&argc, argv);
+
+  for(int i=0; i<argc; i++) {
+    if (!strcmp(argv[i],"-t")) {
+      kDefaultTimeout = 20000;
+    }
+   }
+
+  ::testing::AddGlobalTestEnvironment(new test::SignalingEnvironment);
+  int result = RUN_ALL_TESTS();
+
+  test_utils->sts_target()->Dispatch(
+    WrapRunnableNM(&TestStunServer::ShutdownInstance), NS_DISPATCH_SYNC);
+
+  // Set the global shutdown flag and tickle the main thread
+  // The main thread did not go through Init() so calling Shutdown()
+  // on it will not work.
+  gMainThread->Dispatch(WrapRunnableNM(tests_complete), NS_DISPATCH_SYNC);
+
+  return result;
+}
+
+#ifdef SIGNALING_UNITTEST_STANDALONE
+static void verifyStringTable(const EnumEntry* bindingTable,
+			      const char** ourTable)
+{
+  while (bindingTable->value) {
+    if (strcmp(bindingTable->value, *ourTable)) {
+      MOZ_CRASH("Our tables are out of sync with the bindings");
+    }
+    ++bindingTable;
+    ++ourTable;
+  }
+}
+#endif // SIGNALING_UNITTEST_STANDALONE
+
+int main(int argc, char **argv) {
+
+  // This test can cause intermittent oranges on the builders
+  CHECK_ENVIRONMENT_FLAG("MOZ_WEBRTC_TESTS")
+
+  if (isatty(STDOUT_FILENO) && is_color_terminal(getenv("TERM"))) {
+    std::string ansiMagenta = "\x1b[35m";
+    std::string ansiCyan = "\x1b[36m";
+    std::string ansiColorOff = "\x1b[0m";
+    callerName = ansiCyan + callerName + ansiColorOff;
+    calleeName = ansiMagenta + calleeName + ansiColorOff;
+  }
+
+#ifdef SIGNALING_UNITTEST_STANDALONE
+  // Verify our string tables are correct.
+  verifyStringTable(PCImplSignalingStateValues::strings,
+		    test::PCImplSignalingStateStrings);
+  verifyStringTable(PCImplIceConnectionStateValues::strings,
+		    test::PCImplIceConnectionStateStrings);
+  verifyStringTable(PCImplIceGatheringStateValues::strings,
+		    test::PCImplIceGatheringStateStrings);
+#endif // SIGNALING_UNITTEST_STANDALONE
+
+  std::string tmp = get_environment("STUN_SERVER_ADDRESS");
+  if (tmp != "")
+    g_stun_server_address = tmp;
+
+  tmp = get_environment("STUN_SERVER_PORT");
+  if (tmp != "")
+      g_stun_server_port = atoi(tmp.c_str());
+
+  test_utils = new MtransportTestUtils();
+  NSS_NoDB_Init(nullptr);
+  NSS_SetDomesticPolicy();
+
+  ::testing::TestEventListeners& listeners =
+        ::testing::UnitTest::GetInstance()->listeners();
+  // Adds a listener to the end.  Google Test takes the ownership.
+  listeners.Append(new test::RingbufferDumper(test_utils));
+  test_utils->sts_target()->Dispatch(
+    WrapRunnableNM(&TestStunServer::GetInstance, AF_INET), NS_DISPATCH_SYNC);
+
+  // Set the main thread global which is this thread.
+  nsIThread *thread;
+  NS_GetMainThread(&thread);
+  gMainThread = thread;
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Now create the GTest thread and run all of the tests on it
+  // When it is complete it will set gTestsComplete
+  NS_NewNamedThread("gtest_thread", &thread);
+  gGtestThread = thread;
+
+  int result;
+  gGtestThread->Dispatch(
+    WrapRunnableNMRet(&result, gtest_main, argc, argv), NS_DISPATCH_NORMAL);
+
+  // Here we handle the event queue for dispatches to the main thread
+  // When the GTest thread is complete it will send one more dispatch
+  // with gTestsComplete == true.
+  while (!gTestsComplete && NS_ProcessNextEvent());
+
+  gGtestThread->Shutdown();
+
+  PeerConnectionCtx::Destroy();
+  delete test_utils;
+
+  return result;
+}