Add m-esr52 at 52.6.0

1 files changed, 1672 insertions, 0 deletions

diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
new file mode 100644
index 000000000..4f42b0bb7
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
@@ -0,0 +1,1672 @@
+/* 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 <ostream>
+#include <string>
+#include <vector>
+
+#include "CSFLog.h"
+
+#include "nspr.h"
+
+#include "nricectx.h"
+#include "nricemediastream.h"
+#include "MediaPipelineFactory.h"
+#include "PeerConnectionImpl.h"
+#include "PeerConnectionMedia.h"
+#include "AudioConduit.h"
+#include "VideoConduit.h"
+#include "runnable_utils.h"
+#include "transportlayerice.h"
+#include "transportlayerdtls.h"
+#include "signaling/src/jsep/JsepSession.h"
+#include "signaling/src/jsep/JsepTransport.h"
+
+#ifdef USE_FAKE_STREAMS
+#include "DOMMediaStream.h"
+#include "FakeMediaStreams.h"
+#else
+#include "MediaSegment.h"
+#ifdef MOZILLA_INTERNAL_API
+#include "MediaStreamGraph.h"
+#endif
+#endif
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+#include "MediaStreamGraphImpl.h"
+#endif
+
+#include "nsNetCID.h"
+#include "nsNetUtil.h"
+#include "nsIURI.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsICancelable.h"
+#include "nsILoadInfo.h"
+#include "nsIContentPolicy.h"
+#include "nsIProxyInfo.h"
+#include "nsIProtocolProxyService.h"
+
+#include "nsProxyRelease.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "MediaStreamList.h"
+#include "nsIScriptGlobalObject.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "MediaStreamTrack.h"
+#include "VideoStreamTrack.h"
+#include "MediaStreamError.h"
+#include "MediaManager.h"
+#endif
+
+
+
+namespace mozilla {
+using namespace dom;
+
+static const char* logTag = "PeerConnectionMedia";
+
+nsresult
+PeerConnectionMedia::ReplaceTrack(const std::string& aOldStreamId,
+                                  const std::string& aOldTrackId,
+                                  MediaStreamTrack& aNewTrack,
+                                  const std::string& aNewStreamId,
+                                  const std::string& aNewTrackId)
+{
+  RefPtr<LocalSourceStreamInfo> oldInfo(GetLocalStreamById(aOldStreamId));
+
+  if (!oldInfo) {
+    CSFLogError(logTag, "Failed to find stream id %s", aOldStreamId.c_str());
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsresult rv = AddTrack(*aNewTrack.mOwningStream, aNewStreamId,
+                         aNewTrack, aNewTrackId);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<LocalSourceStreamInfo> newInfo(GetLocalStreamById(aNewStreamId));
+
+  if (!newInfo) {
+    CSFLogError(logTag, "Failed to add track id %s", aNewTrackId.c_str());
+    MOZ_ASSERT(false);
+    return NS_ERROR_FAILURE;
+  }
+
+  rv = newInfo->TakePipelineFrom(oldInfo, aOldTrackId, aNewTrack, aNewTrackId);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return RemoveLocalTrack(aOldStreamId, aOldTrackId);
+}
+
+static void
+PipelineReleaseRef_m(RefPtr<MediaPipeline> pipeline)
+{}
+
+static void
+PipelineDetachTransport_s(RefPtr<MediaPipeline> pipeline,
+                          nsCOMPtr<nsIThread> mainThread)
+{
+  pipeline->DetachTransport_s();
+  mainThread->Dispatch(
+      // Make sure we let go of our reference before dispatching
+      // If the dispatch fails, well, we're hosed anyway.
+      WrapRunnableNM(PipelineReleaseRef_m, pipeline.forget()),
+      NS_DISPATCH_NORMAL);
+}
+
+void
+SourceStreamInfo::EndTrack(MediaStream* stream, dom::MediaStreamTrack* track)
+{
+  if (!stream || !stream->AsSourceStream()) {
+    return;
+  }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  class Message : public ControlMessage {
+   public:
+    Message(MediaStream* stream, TrackID track)
+      : ControlMessage(stream),
+        track_id_(track) {}
+
+    virtual void Run() override {
+      mStream->AsSourceStream()->EndTrack(track_id_);
+    }
+   private:
+    TrackID track_id_;
+  };
+
+  stream->GraphImpl()->AppendMessage(
+      MakeUnique<Message>(stream, track->mTrackID));
+#endif
+
+}
+
+void
+SourceStreamInfo::RemoveTrack(const std::string& trackId)
+{
+  mTracks.erase(trackId);
+
+  RefPtr<MediaPipeline> pipeline = GetPipelineByTrackId_m(trackId);
+  if (pipeline) {
+    mPipelines.erase(trackId);
+    pipeline->ShutdownMedia_m();
+    mParent->GetSTSThread()->Dispatch(
+        WrapRunnableNM(PipelineDetachTransport_s,
+                       pipeline.forget(),
+                       mParent->GetMainThread()),
+        NS_DISPATCH_NORMAL);
+  }
+}
+
+void SourceStreamInfo::DetachTransport_s()
+{
+  ASSERT_ON_THREAD(mParent->GetSTSThread());
+  // walk through all the MediaPipelines and call the shutdown
+  // transport functions. Must be on the STS thread.
+  for (auto it = mPipelines.begin(); it != mPipelines.end(); ++it) {
+    it->second->DetachTransport_s();
+  }
+}
+
+void SourceStreamInfo::DetachMedia_m()
+{
+  ASSERT_ON_THREAD(mParent->GetMainThread());
+
+  // walk through all the MediaPipelines and call the shutdown
+  // media functions. Must be on the main thread.
+  for (auto it = mPipelines.begin(); it != mPipelines.end(); ++it) {
+    it->second->ShutdownMedia_m();
+  }
+  mMediaStream = nullptr;
+}
+
+already_AddRefed<PeerConnectionImpl>
+PeerConnectionImpl::Constructor(const dom::GlobalObject& aGlobal, ErrorResult& rv)
+{
+  RefPtr<PeerConnectionImpl> pc = new PeerConnectionImpl(&aGlobal);
+
+  CSFLogDebug(logTag, "Created PeerConnection: %p", pc.get());
+
+  return pc.forget();
+}
+
+PeerConnectionImpl* PeerConnectionImpl::CreatePeerConnection()
+{
+  PeerConnectionImpl *pc = new PeerConnectionImpl();
+
+  CSFLogDebug(logTag, "Created PeerConnection: %p", pc);
+
+  return pc;
+}
+
+NS_IMETHODIMP PeerConnectionMedia::ProtocolProxyQueryHandler::
+OnProxyAvailable(nsICancelable *request,
+                 nsIChannel *aChannel,
+                 nsIProxyInfo *proxyinfo,
+                 nsresult result) {
+
+  if (!pcm_->mProxyRequest) {
+    // PeerConnectionMedia is no longer waiting
+    return NS_OK;
+  }
+
+  CSFLogInfo(logTag, "%s: Proxy Available: %d", __FUNCTION__, (int)result);
+
+  if (NS_SUCCEEDED(result) && proxyinfo) {
+    SetProxyOnPcm(*proxyinfo);
+  }
+
+  pcm_->mProxyResolveCompleted = true;
+  pcm_->mProxyRequest = nullptr;
+  pcm_->FlushIceCtxOperationQueueIfReady();
+
+  return NS_OK;
+}
+
+void
+PeerConnectionMedia::ProtocolProxyQueryHandler::SetProxyOnPcm(
+    nsIProxyInfo& proxyinfo)
+{
+  CSFLogInfo(logTag, "%s: Had proxyinfo", __FUNCTION__);
+  nsresult rv;
+  nsCString httpsProxyHost;
+  int32_t httpsProxyPort;
+
+  rv = proxyinfo.GetHost(httpsProxyHost);
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: Failed to get proxy server host", __FUNCTION__);
+    return;
+  }
+
+  rv = proxyinfo.GetPort(&httpsProxyPort);
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: Failed to get proxy server port", __FUNCTION__);
+    return;
+  }
+
+  if (pcm_->mIceCtxHdlr.get()) {
+    assert(httpsProxyPort >= 0 && httpsProxyPort < (1 << 16));
+    // Note that this could check if PrivacyRequested() is set on the PC and
+    // remove "webrtc" from the ALPN list.  But that would only work if the PC
+    // was constructed with a peerIdentity constraint, not when isolated
+    // streams are added.  If we ever need to signal to the proxy that the
+    // media is isolated, then we would need to restructure this code.
+    pcm_->mProxyServer.reset(
+      new NrIceProxyServer(httpsProxyHost.get(),
+                           static_cast<uint16_t>(httpsProxyPort),
+                           "webrtc,c-webrtc"));
+  } else {
+    CSFLogError(logTag, "%s: Failed to set proxy server (ICE ctx unavailable)",
+        __FUNCTION__);
+  }
+}
+
+NS_IMPL_ISUPPORTS(PeerConnectionMedia::ProtocolProxyQueryHandler, nsIProtocolProxyCallback)
+
+PeerConnectionMedia::PeerConnectionMedia(PeerConnectionImpl *parent)
+    : mParent(parent),
+      mParentHandle(parent->GetHandle()),
+      mParentName(parent->GetName()),
+      mIceCtxHdlr(nullptr),
+      mDNSResolver(new NrIceResolver()),
+      mUuidGen(MakeUnique<PCUuidGenerator>()),
+      mMainThread(mParent->GetMainThread()),
+      mSTSThread(mParent->GetSTSThread()),
+      mProxyResolveCompleted(false),
+      mIceRestartState(ICE_RESTART_NONE) {
+}
+
+nsresult
+PeerConnectionMedia::InitProxy()
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  // Allow mochitests to disable this, since mochitest configures a fake proxy
+  // that serves up content.
+  bool disable = Preferences::GetBool("media.peerconnection.disable_http_proxy",
+                                      false);
+  if (disable) {
+    mProxyResolveCompleted = true;
+    return NS_OK;
+  }
+#endif
+
+  nsresult rv;
+  nsCOMPtr<nsIProtocolProxyService> pps =
+    do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv);
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: Failed to get proxy service: %d", __FUNCTION__, (int)rv);
+    return NS_ERROR_FAILURE;
+  }
+
+  // We use the following URL to find the "default" proxy address for all HTTPS
+  // connections.  We will only attempt one HTTP(S) CONNECT per peer connection.
+  // "example.com" is guaranteed to be unallocated and should return the best default.
+  nsCOMPtr<nsIURI> fakeHttpsLocation;
+  rv = NS_NewURI(getter_AddRefs(fakeHttpsLocation), "https://example.com");
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: Failed to set URI: %d", __FUNCTION__, (int)rv);
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIScriptSecurityManager> secMan(
+      do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv));
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: Failed to get IOService: %d",
+        __FUNCTION__, (int)rv);
+    CSFLogError(logTag, "%s: Failed to get securityManager: %d", __FUNCTION__, (int)rv);
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPrincipal> systemPrincipal;
+  rv = secMan->GetSystemPrincipal(getter_AddRefs(systemPrincipal));
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: Failed to get systemPrincipal: %d", __FUNCTION__, (int)rv);
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = NS_NewChannel(getter_AddRefs(channel),
+                     fakeHttpsLocation,
+                     systemPrincipal,
+                     nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+                     nsIContentPolicy::TYPE_OTHER);
+
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: Failed to get channel from URI: %d",
+                __FUNCTION__, (int)rv);
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<ProtocolProxyQueryHandler> handler = new ProtocolProxyQueryHandler(this);
+  rv = pps->AsyncResolve(channel,
+                         nsIProtocolProxyService::RESOLVE_PREFER_HTTPS_PROXY |
+                         nsIProtocolProxyService::RESOLVE_ALWAYS_TUNNEL,
+                         handler, getter_AddRefs(mProxyRequest));
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: Failed to resolve protocol proxy: %d", __FUNCTION__, (int)rv);
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+nsresult PeerConnectionMedia::Init(const std::vector<NrIceStunServer>& stun_servers,
+                                   const std::vector<NrIceTurnServer>& turn_servers,
+                                   NrIceCtx::Policy policy)
+{
+  nsresult rv = InitProxy();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  bool ice_tcp = Preferences::GetBool("media.peerconnection.ice.tcp", false);
+#else
+  bool ice_tcp = false;
+#endif
+
+  // TODO(ekr@rtfm.com): need some way to set not offerer later
+  // Looks like a bug in the NrIceCtx API.
+  mIceCtxHdlr = NrIceCtxHandler::Create("PC:" + mParentName,
+                                        true, // Offerer
+                                        mParent->GetAllowIceLoopback(),
+                                        ice_tcp,
+                                        mParent->GetAllowIceLinkLocal(),
+                                        policy);
+  if(!mIceCtxHdlr) {
+    CSFLogError(logTag, "%s: Failed to create Ice Context", __FUNCTION__);
+    return NS_ERROR_FAILURE;
+  }
+
+  if (NS_FAILED(rv = mIceCtxHdlr->ctx()->SetStunServers(stun_servers))) {
+    CSFLogError(logTag, "%s: Failed to set stun servers", __FUNCTION__);
+    return rv;
+  }
+  // Give us a way to globally turn off TURN support
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  bool disabled = Preferences::GetBool("media.peerconnection.turn.disable", false);
+#else
+  bool disabled = false;
+#endif
+  if (!disabled) {
+    if (NS_FAILED(rv = mIceCtxHdlr->ctx()->SetTurnServers(turn_servers))) {
+      CSFLogError(logTag, "%s: Failed to set turn servers", __FUNCTION__);
+      return rv;
+    }
+  } else if (turn_servers.size() != 0) {
+    CSFLogError(logTag, "%s: Setting turn servers disabled", __FUNCTION__);
+  }
+  if (NS_FAILED(rv = mDNSResolver->Init())) {
+    CSFLogError(logTag, "%s: Failed to initialize dns resolver", __FUNCTION__);
+    return rv;
+  }
+  if (NS_FAILED(rv =
+      mIceCtxHdlr->ctx()->SetResolver(mDNSResolver->AllocateResolver()))) {
+    CSFLogError(logTag, "%s: Failed to get dns resolver", __FUNCTION__);
+    return rv;
+  }
+  ConnectSignals(mIceCtxHdlr->ctx().get());
+
+  return NS_OK;
+}
+
+void
+PeerConnectionMedia::EnsureTransports(const JsepSession& aSession)
+{
+  auto transports = aSession.GetTransports();
+  for (size_t i = 0; i < transports.size(); ++i) {
+    RefPtr<JsepTransport> transport = transports[i];
+    RUN_ON_THREAD(
+        GetSTSThread(),
+        WrapRunnable(RefPtr<PeerConnectionMedia>(this),
+                     &PeerConnectionMedia::EnsureTransport_s,
+                     i,
+                     transport->mComponents),
+        NS_DISPATCH_NORMAL);
+  }
+
+  GatherIfReady();
+}
+
+void
+PeerConnectionMedia::EnsureTransport_s(size_t aLevel, size_t aComponentCount)
+{
+  RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aLevel));
+  if (!stream) {
+    CSFLogDebug(logTag, "%s: Creating ICE media stream=%u components=%u",
+                mParentHandle.c_str(),
+                static_cast<unsigned>(aLevel),
+                static_cast<unsigned>(aComponentCount));
+
+    std::ostringstream os;
+    os << mParentName << " aLevel=" << aLevel;
+    RefPtr<NrIceMediaStream> stream =
+      mIceCtxHdlr->CreateStream(os.str().c_str(),
+                                aComponentCount);
+
+    if (!stream) {
+      CSFLogError(logTag, "Failed to create ICE stream.");
+      return;
+    }
+
+    stream->SetLevel(aLevel);
+    stream->SignalReady.connect(this, &PeerConnectionMedia::IceStreamReady_s);
+    stream->SignalCandidate.connect(this,
+                                    &PeerConnectionMedia::OnCandidateFound_s);
+    mIceCtxHdlr->ctx()->SetStream(aLevel, stream);
+  }
+}
+
+void
+PeerConnectionMedia::ActivateOrRemoveTransports(const JsepSession& aSession)
+{
+  auto transports = aSession.GetTransports();
+  for (size_t i = 0; i < transports.size(); ++i) {
+    RefPtr<JsepTransport> transport = transports[i];
+
+    std::string ufrag;
+    std::string pwd;
+    std::vector<std::string> candidates;
+
+    if (transport->mComponents) {
+      MOZ_ASSERT(transport->mIce);
+      CSFLogDebug(logTag, "Transport %u is active", static_cast<unsigned>(i));
+      ufrag = transport->mIce->GetUfrag();
+      pwd = transport->mIce->GetPassword();
+      candidates = transport->mIce->GetCandidates();
+    } else {
+      CSFLogDebug(logTag, "Transport %u is disabled", static_cast<unsigned>(i));
+      // Make sure the MediaPipelineFactory doesn't try to use these.
+      RemoveTransportFlow(i, false);
+      RemoveTransportFlow(i, true);
+    }
+
+    RUN_ON_THREAD(
+        GetSTSThread(),
+        WrapRunnable(RefPtr<PeerConnectionMedia>(this),
+                     &PeerConnectionMedia::ActivateOrRemoveTransport_s,
+                     i,
+                     transport->mComponents,
+                     ufrag,
+                     pwd,
+                     candidates),
+        NS_DISPATCH_NORMAL);
+  }
+
+  // We can have more streams than m-lines due to rollback.
+  RUN_ON_THREAD(
+      GetSTSThread(),
+      WrapRunnable(RefPtr<PeerConnectionMedia>(this),
+                   &PeerConnectionMedia::RemoveTransportsAtOrAfter_s,
+                   transports.size()),
+      NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::ActivateOrRemoveTransport_s(
+    size_t aMLine,
+    size_t aComponentCount,
+    const std::string& aUfrag,
+    const std::string& aPassword,
+    const std::vector<std::string>& aCandidateList) {
+
+  if (!aComponentCount) {
+    CSFLogDebug(logTag, "%s: Removing ICE media stream=%u",
+                mParentHandle.c_str(),
+                static_cast<unsigned>(aMLine));
+    mIceCtxHdlr->ctx()->SetStream(aMLine, nullptr);
+    return;
+  }
+
+  RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aMLine));
+  if (!stream) {
+    MOZ_ASSERT(false);
+    return;
+  }
+
+  if (!stream->HasParsedAttributes()) {
+    CSFLogDebug(logTag, "%s: Activating ICE media stream=%u components=%u",
+                mParentHandle.c_str(),
+                static_cast<unsigned>(aMLine),
+                static_cast<unsigned>(aComponentCount));
+
+    std::vector<std::string> attrs;
+    for (auto i = aCandidateList.begin(); i != aCandidateList.end(); ++i) {
+      attrs.push_back("candidate:" + *i);
+    }
+    attrs.push_back("ice-ufrag:" + aUfrag);
+    attrs.push_back("ice-pwd:" + aPassword);
+
+    nsresult rv = stream->ParseAttributes(attrs);
+    if (NS_FAILED(rv)) {
+      CSFLogError(logTag, "Couldn't parse ICE attributes, rv=%u",
+                          static_cast<unsigned>(rv));
+    }
+
+    for (size_t c = aComponentCount; c < stream->components(); ++c) {
+      // components are 1-indexed
+      stream->DisableComponent(c + 1);
+    }
+  }
+}
+
+void
+PeerConnectionMedia::RemoveTransportsAtOrAfter_s(size_t aMLine)
+{
+  for (size_t i = aMLine; i < mIceCtxHdlr->ctx()->GetStreamCount(); ++i) {
+    mIceCtxHdlr->ctx()->SetStream(i, nullptr);
+  }
+}
+
+nsresult PeerConnectionMedia::UpdateMediaPipelines(
+    const JsepSession& session) {
+  auto trackPairs = session.GetNegotiatedTrackPairs();
+  MediaPipelineFactory factory(this);
+  nsresult rv;
+
+  for (auto i = trackPairs.begin(); i != trackPairs.end(); ++i) {
+    JsepTrackPair pair = *i;
+
+    if (pair.mReceiving) {
+      rv = factory.CreateOrUpdateMediaPipeline(pair, *pair.mReceiving);
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+    }
+
+    if (pair.mSending) {
+      rv = factory.CreateOrUpdateMediaPipeline(pair, *pair.mSending);
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+    }
+  }
+
+  for (auto& stream : mRemoteSourceStreams) {
+    stream->StartReceiving();
+  }
+
+  return NS_OK;
+}
+
+void
+PeerConnectionMedia::StartIceChecks(const JsepSession& aSession)
+{
+  nsCOMPtr<nsIRunnable> runnable(
+      WrapRunnable(
+        RefPtr<PeerConnectionMedia>(this),
+        &PeerConnectionMedia::StartIceChecks_s,
+        aSession.IsIceControlling(),
+        aSession.RemoteIsIceLite(),
+        // Copy, just in case API changes to return a ref
+        std::vector<std::string>(aSession.GetIceOptions())));
+
+  PerformOrEnqueueIceCtxOperation(runnable);
+}
+
+void
+PeerConnectionMedia::StartIceChecks_s(
+    bool aIsControlling,
+    bool aIsIceLite,
+    const std::vector<std::string>& aIceOptionsList) {
+
+  CSFLogDebug(logTag, "Starting ICE Checking");
+
+  std::vector<std::string> attributes;
+  if (aIsIceLite) {
+    attributes.push_back("ice-lite");
+  }
+
+  if (!aIceOptionsList.empty()) {
+    attributes.push_back("ice-options:");
+    for (auto i = aIceOptionsList.begin(); i != aIceOptionsList.end(); ++i) {
+      attributes.back() += *i + ' ';
+    }
+  }
+
+  nsresult rv = mIceCtxHdlr->ctx()->ParseGlobalAttributes(attributes);
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "%s: couldn't parse global parameters", __FUNCTION__ );
+  }
+
+  mIceCtxHdlr->ctx()->SetControlling(aIsControlling ?
+                                     NrIceCtx::ICE_CONTROLLING :
+                                     NrIceCtx::ICE_CONTROLLED);
+
+  mIceCtxHdlr->ctx()->StartChecks();
+}
+
+bool
+PeerConnectionMedia::IsIceRestarting() const
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  return (mIceRestartState != ICE_RESTART_NONE);
+}
+
+PeerConnectionMedia::IceRestartState
+PeerConnectionMedia::GetIceRestartState() const
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  return mIceRestartState;
+}
+
+void
+PeerConnectionMedia::BeginIceRestart(const std::string& ufrag,
+                                     const std::string& pwd)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  if (IsIceRestarting()) {
+    return;
+  }
+
+  RefPtr<NrIceCtx> new_ctx = mIceCtxHdlr->CreateCtx(ufrag, pwd);
+
+  RUN_ON_THREAD(GetSTSThread(),
+                WrapRunnable(
+                    RefPtr<PeerConnectionMedia>(this),
+                    &PeerConnectionMedia::BeginIceRestart_s,
+                    new_ctx),
+                NS_DISPATCH_NORMAL);
+
+  mIceRestartState = ICE_RESTART_PROVISIONAL;
+}
+
+void
+PeerConnectionMedia::BeginIceRestart_s(RefPtr<NrIceCtx> new_ctx)
+{
+  ASSERT_ON_THREAD(mSTSThread);
+
+  // hold the original context so we can disconnect signals if needed
+  RefPtr<NrIceCtx> originalCtx = mIceCtxHdlr->ctx();
+
+  if (mIceCtxHdlr->BeginIceRestart(new_ctx)) {
+    ConnectSignals(mIceCtxHdlr->ctx().get(), originalCtx.get());
+  }
+}
+
+void
+PeerConnectionMedia::CommitIceRestart()
+{
+  ASSERT_ON_THREAD(mMainThread);
+  if (mIceRestartState != ICE_RESTART_PROVISIONAL) {
+    return;
+  }
+
+  mIceRestartState = ICE_RESTART_COMMITTED;
+}
+
+void
+PeerConnectionMedia::FinalizeIceRestart()
+{
+  ASSERT_ON_THREAD(mMainThread);
+  if (!IsIceRestarting()) {
+    return;
+  }
+
+  RUN_ON_THREAD(GetSTSThread(),
+                WrapRunnable(
+                    RefPtr<PeerConnectionMedia>(this),
+                    &PeerConnectionMedia::FinalizeIceRestart_s),
+                NS_DISPATCH_NORMAL);
+
+  mIceRestartState = ICE_RESTART_NONE;
+}
+
+void
+PeerConnectionMedia::FinalizeIceRestart_s()
+{
+  ASSERT_ON_THREAD(mSTSThread);
+
+  // reset old streams since we don't need them anymore
+  for (auto i = mTransportFlows.begin();
+       i != mTransportFlows.end();
+       ++i) {
+    RefPtr<TransportFlow> aFlow = i->second;
+    if (!aFlow) continue;
+    TransportLayerIce* ice =
+      static_cast<TransportLayerIce*>(aFlow->GetLayer(TransportLayerIce::ID()));
+    ice->ResetOldStream();
+  }
+
+  mIceCtxHdlr->FinalizeIceRestart();
+}
+
+void
+PeerConnectionMedia::RollbackIceRestart()
+{
+  ASSERT_ON_THREAD(mMainThread);
+  if (mIceRestartState != ICE_RESTART_PROVISIONAL) {
+    return;
+  }
+
+  RUN_ON_THREAD(GetSTSThread(),
+                WrapRunnable(
+                    RefPtr<PeerConnectionMedia>(this),
+                    &PeerConnectionMedia::RollbackIceRestart_s),
+                NS_DISPATCH_NORMAL);
+
+  mIceRestartState = ICE_RESTART_NONE;
+}
+
+void
+PeerConnectionMedia::RollbackIceRestart_s()
+{
+  ASSERT_ON_THREAD(mSTSThread);
+
+  // hold the restart context so we can disconnect signals
+  RefPtr<NrIceCtx> restartCtx = mIceCtxHdlr->ctx();
+
+  // restore old streams since we're rolling back
+  for (auto i = mTransportFlows.begin();
+       i != mTransportFlows.end();
+       ++i) {
+    RefPtr<TransportFlow> aFlow = i->second;
+    if (!aFlow) continue;
+    TransportLayerIce* ice =
+      static_cast<TransportLayerIce*>(aFlow->GetLayer(TransportLayerIce::ID()));
+    ice->RestoreOldStream();
+  }
+
+  mIceCtxHdlr->RollbackIceRestart();
+  ConnectSignals(mIceCtxHdlr->ctx().get(), restartCtx.get());
+}
+
+bool
+PeerConnectionMedia::GetPrefDefaultAddressOnly() const
+{
+  ASSERT_ON_THREAD(mMainThread); // will crash on STS thread
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  uint64_t winId = mParent->GetWindow()->WindowID();
+
+  bool default_address_only = Preferences::GetBool(
+    "media.peerconnection.ice.default_address_only", false);
+  default_address_only |=
+    !MediaManager::Get()->IsActivelyCapturingOrHasAPermission(winId);
+#else
+  bool default_address_only = true;
+#endif
+  return default_address_only;
+}
+
+bool
+PeerConnectionMedia::GetPrefProxyOnly() const
+{
+  ASSERT_ON_THREAD(mMainThread); // will crash on STS thread
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+  return Preferences::GetBool("media.peerconnection.ice.proxy_only", false);
+#else
+  return false;
+#endif
+}
+
+void
+PeerConnectionMedia::ConnectSignals(NrIceCtx *aCtx, NrIceCtx *aOldCtx)
+{
+  aCtx->SignalGatheringStateChange.connect(
+      this,
+      &PeerConnectionMedia::IceGatheringStateChange_s);
+  aCtx->SignalConnectionStateChange.connect(
+      this,
+      &PeerConnectionMedia::IceConnectionStateChange_s);
+
+  if (aOldCtx) {
+    MOZ_ASSERT(aCtx != aOldCtx);
+    aOldCtx->SignalGatheringStateChange.disconnect(this);
+    aOldCtx->SignalConnectionStateChange.disconnect(this);
+
+    // if the old and new connection state and/or gathering state is
+    // different fire the state update.  Note: we don't fire the update
+    // if the state is *INIT since updates for the INIT state aren't
+    // sent during the normal flow. (mjf)
+    if (aOldCtx->connection_state() != aCtx->connection_state() &&
+        aCtx->connection_state() != NrIceCtx::ICE_CTX_INIT) {
+      aCtx->SignalConnectionStateChange(aCtx, aCtx->connection_state());
+    }
+
+    if (aOldCtx->gathering_state() != aCtx->gathering_state() &&
+        aCtx->gathering_state() != NrIceCtx::ICE_CTX_GATHER_INIT) {
+      aCtx->SignalGatheringStateChange(aCtx, aCtx->gathering_state());
+    }
+  }
+}
+
+void
+PeerConnectionMedia::AddIceCandidate(const std::string& candidate,
+                                     const std::string& mid,
+                                     uint32_t aMLine) {
+  RUN_ON_THREAD(GetSTSThread(),
+                WrapRunnable(
+                    RefPtr<PeerConnectionMedia>(this),
+                    &PeerConnectionMedia::AddIceCandidate_s,
+                    std::string(candidate), // Make copies.
+                    std::string(mid),
+                    aMLine),
+                NS_DISPATCH_NORMAL);
+}
+void
+PeerConnectionMedia::AddIceCandidate_s(const std::string& aCandidate,
+                                       const std::string& aMid,
+                                       uint32_t aMLine) {
+  RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aMLine));
+  if (!stream) {
+    CSFLogError(logTag, "No ICE stream for candidate at level %u: %s",
+                        static_cast<unsigned>(aMLine), aCandidate.c_str());
+    return;
+  }
+
+  nsresult rv = stream->ParseTrickleCandidate(aCandidate);
+  if (NS_FAILED(rv)) {
+    CSFLogError(logTag, "Couldn't process ICE candidate at level %u",
+                static_cast<unsigned>(aMLine));
+    return;
+  }
+}
+
+void
+PeerConnectionMedia::FlushIceCtxOperationQueueIfReady()
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  if (IsIceCtxReady()) {
+    for (auto i = mQueuedIceCtxOperations.begin();
+         i != mQueuedIceCtxOperations.end();
+         ++i) {
+      GetSTSThread()->Dispatch(*i, NS_DISPATCH_NORMAL);
+    }
+    mQueuedIceCtxOperations.clear();
+  }
+}
+
+void
+PeerConnectionMedia::PerformOrEnqueueIceCtxOperation(nsIRunnable* runnable)
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  if (IsIceCtxReady()) {
+    GetSTSThread()->Dispatch(runnable, NS_DISPATCH_NORMAL);
+  } else {
+    mQueuedIceCtxOperations.push_back(runnable);
+  }
+}
+
+void
+PeerConnectionMedia::GatherIfReady() {
+  ASSERT_ON_THREAD(mMainThread);
+
+  nsCOMPtr<nsIRunnable> runnable(WrapRunnable(
+        RefPtr<PeerConnectionMedia>(this),
+        &PeerConnectionMedia::EnsureIceGathering_s,
+        GetPrefDefaultAddressOnly(),
+        GetPrefProxyOnly()));
+
+  PerformOrEnqueueIceCtxOperation(runnable);
+}
+
+void
+PeerConnectionMedia::EnsureIceGathering_s(bool aDefaultRouteOnly,
+                                          bool aProxyOnly) {
+  if (mProxyServer) {
+    mIceCtxHdlr->ctx()->SetProxyServer(*mProxyServer);
+  } else if (aProxyOnly) {
+    IceGatheringStateChange_s(mIceCtxHdlr->ctx().get(),
+                              NrIceCtx::ICE_CTX_GATHER_COMPLETE);
+    return;
+  }
+
+  // Start gathering, but only if there are streams
+  for (size_t i = 0; i < mIceCtxHdlr->ctx()->GetStreamCount(); ++i) {
+    if (mIceCtxHdlr->ctx()->GetStream(i)) {
+      mIceCtxHdlr->ctx()->StartGathering(aDefaultRouteOnly, aProxyOnly);
+      return;
+    }
+  }
+
+  // If there are no streams, we're probably in a situation where we've rolled
+  // back while still waiting for our proxy configuration to come back. Make
+  // sure content knows that the rollback has stuck wrt gathering.
+  IceGatheringStateChange_s(mIceCtxHdlr->ctx().get(),
+                            NrIceCtx::ICE_CTX_GATHER_COMPLETE);
+}
+
+nsresult
+PeerConnectionMedia::AddTrack(DOMMediaStream& aMediaStream,
+                              const std::string& streamId,
+                              MediaStreamTrack& aTrack,
+                              const std::string& trackId)
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  CSFLogDebug(logTag, "%s: MediaStream: %p", __FUNCTION__, &aMediaStream);
+
+  RefPtr<LocalSourceStreamInfo> localSourceStream =
+    GetLocalStreamById(streamId);
+
+  if (!localSourceStream) {
+    localSourceStream = new LocalSourceStreamInfo(&aMediaStream, this, streamId);
+    mLocalSourceStreams.AppendElement(localSourceStream);
+  }
+
+  localSourceStream->AddTrack(trackId, &aTrack);
+  return NS_OK;
+}
+
+nsresult
+PeerConnectionMedia::RemoveLocalTrack(const std::string& streamId,
+                                      const std::string& trackId)
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  CSFLogDebug(logTag, "%s: stream: %s track: %s", __FUNCTION__,
+                      streamId.c_str(), trackId.c_str());
+
+  RefPtr<LocalSourceStreamInfo> localSourceStream =
+    GetLocalStreamById(streamId);
+  if (!localSourceStream) {
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  localSourceStream->RemoveTrack(trackId);
+  if (!localSourceStream->GetTrackCount()) {
+    mLocalSourceStreams.RemoveElement(localSourceStream);
+  }
+  return NS_OK;
+}
+
+nsresult
+PeerConnectionMedia::RemoveRemoteTrack(const std::string& streamId,
+                                       const std::string& trackId)
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  CSFLogDebug(logTag, "%s: stream: %s track: %s", __FUNCTION__,
+                      streamId.c_str(), trackId.c_str());
+
+  RefPtr<RemoteSourceStreamInfo> remoteSourceStream =
+    GetRemoteStreamById(streamId);
+  if (!remoteSourceStream) {
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  remoteSourceStream->RemoveTrack(trackId);
+  if (!remoteSourceStream->GetTrackCount()) {
+    mRemoteSourceStreams.RemoveElement(remoteSourceStream);
+  }
+  return NS_OK;
+}
+
+void
+PeerConnectionMedia::SelfDestruct()
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  CSFLogDebug(logTag, "%s: ", __FUNCTION__);
+
+  // Shut down the media
+  for (uint32_t i=0; i < mLocalSourceStreams.Length(); ++i) {
+    mLocalSourceStreams[i]->DetachMedia_m();
+  }
+
+  for (uint32_t i=0; i < mRemoteSourceStreams.Length(); ++i) {
+    mRemoteSourceStreams[i]->DetachMedia_m();
+  }
+
+  if (mProxyRequest) {
+    mProxyRequest->Cancel(NS_ERROR_ABORT);
+    mProxyRequest = nullptr;
+  }
+
+  // Shutdown the transport (async)
+  RUN_ON_THREAD(mSTSThread, WrapRunnable(
+      this, &PeerConnectionMedia::ShutdownMediaTransport_s),
+                NS_DISPATCH_NORMAL);
+
+  CSFLogDebug(logTag, "%s: Media shut down", __FUNCTION__);
+}
+
+void
+PeerConnectionMedia::SelfDestruct_m()
+{
+  CSFLogDebug(logTag, "%s: ", __FUNCTION__);
+
+  ASSERT_ON_THREAD(mMainThread);
+
+  mLocalSourceStreams.Clear();
+  mRemoteSourceStreams.Clear();
+
+  mMainThread = nullptr;
+
+  // Final self-destruct.
+  this->Release();
+}
+
+void
+PeerConnectionMedia::ShutdownMediaTransport_s()
+{
+  ASSERT_ON_THREAD(mSTSThread);
+
+  CSFLogDebug(logTag, "%s: ", __FUNCTION__);
+
+  // Here we access m{Local|Remote}SourceStreams off the main thread.
+  // That's OK because by here PeerConnectionImpl has forgotten about us,
+  // so there is no chance of getting a call in here from outside.
+  // The dispatches from SelfDestruct() and to SelfDestruct_m() provide
+  // memory barriers that protect us from badness.
+  for (uint32_t i=0; i < mLocalSourceStreams.Length(); ++i) {
+    mLocalSourceStreams[i]->DetachTransport_s();
+  }
+
+  for (uint32_t i=0; i < mRemoteSourceStreams.Length(); ++i) {
+    mRemoteSourceStreams[i]->DetachTransport_s();
+  }
+
+  disconnect_all();
+  mTransportFlows.clear();
+  mIceCtxHdlr = nullptr;
+
+  mMainThread->Dispatch(WrapRunnable(this, &PeerConnectionMedia::SelfDestruct_m),
+                        NS_DISPATCH_NORMAL);
+}
+
+LocalSourceStreamInfo*
+PeerConnectionMedia::GetLocalStreamByIndex(int aIndex)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  if(aIndex < 0 || aIndex >= (int) mLocalSourceStreams.Length()) {
+    return nullptr;
+  }
+
+  MOZ_ASSERT(mLocalSourceStreams[aIndex]);
+  return mLocalSourceStreams[aIndex];
+}
+
+LocalSourceStreamInfo*
+PeerConnectionMedia::GetLocalStreamById(const std::string& id)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  for (size_t i = 0; i < mLocalSourceStreams.Length(); ++i) {
+    if (id == mLocalSourceStreams[i]->GetId()) {
+      return mLocalSourceStreams[i];
+    }
+  }
+
+  return nullptr;
+}
+
+LocalSourceStreamInfo*
+PeerConnectionMedia::GetLocalStreamByTrackId(const std::string& id)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  for (RefPtr<LocalSourceStreamInfo>& info : mLocalSourceStreams) {
+    if (info->HasTrack(id)) {
+      return info;
+    }
+  }
+
+  return nullptr;
+}
+
+RemoteSourceStreamInfo*
+PeerConnectionMedia::GetRemoteStreamByIndex(size_t aIndex)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  MOZ_ASSERT(mRemoteSourceStreams.SafeElementAt(aIndex));
+  return mRemoteSourceStreams.SafeElementAt(aIndex);
+}
+
+RemoteSourceStreamInfo*
+PeerConnectionMedia::GetRemoteStreamById(const std::string& id)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  for (size_t i = 0; i < mRemoteSourceStreams.Length(); ++i) {
+    if (id == mRemoteSourceStreams[i]->GetId()) {
+      return mRemoteSourceStreams[i];
+    }
+  }
+
+  return nullptr;
+}
+
+RemoteSourceStreamInfo*
+PeerConnectionMedia::GetRemoteStreamByTrackId(const std::string& id)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  for (RefPtr<RemoteSourceStreamInfo>& info : mRemoteSourceStreams) {
+    if (info->HasTrack(id)) {
+      return info;
+    }
+  }
+
+  return nullptr;
+}
+
+
+nsresult
+PeerConnectionMedia::AddRemoteStream(RefPtr<RemoteSourceStreamInfo> aInfo)
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  mRemoteSourceStreams.AppendElement(aInfo);
+
+  return NS_OK;
+}
+
+void
+PeerConnectionMedia::IceGatheringStateChange_s(NrIceCtx* ctx,
+                                               NrIceCtx::GatheringState state)
+{
+  ASSERT_ON_THREAD(mSTSThread);
+
+  if (state == NrIceCtx::ICE_CTX_GATHER_COMPLETE) {
+    // Fire off EndOfLocalCandidates for each stream
+    for (size_t i = 0; ; ++i) {
+      RefPtr<NrIceMediaStream> stream(ctx->GetStream(i));
+      if (!stream) {
+        break;
+      }
+
+      NrIceCandidate candidate;
+      NrIceCandidate rtcpCandidate;
+      GetDefaultCandidates(*stream, &candidate, &rtcpCandidate);
+      EndOfLocalCandidates(candidate.cand_addr.host,
+                           candidate.cand_addr.port,
+                           rtcpCandidate.cand_addr.host,
+                           rtcpCandidate.cand_addr.port,
+                           i);
+    }
+  }
+
+  // ShutdownMediaTransport_s has not run yet because it unhooks this function
+  // from its signal, which means that SelfDestruct_m has not been dispatched
+  // yet either, so this PCMedia will still be around when this dispatch reaches
+  // main.
+  GetMainThread()->Dispatch(
+    WrapRunnable(this,
+                 &PeerConnectionMedia::IceGatheringStateChange_m,
+                 ctx,
+                 state),
+    NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::IceConnectionStateChange_s(NrIceCtx* ctx,
+                                                NrIceCtx::ConnectionState state)
+{
+  ASSERT_ON_THREAD(mSTSThread);
+  // ShutdownMediaTransport_s has not run yet because it unhooks this function
+  // from its signal, which means that SelfDestruct_m has not been dispatched
+  // yet either, so this PCMedia will still be around when this dispatch reaches
+  // main.
+  GetMainThread()->Dispatch(
+    WrapRunnable(this,
+                 &PeerConnectionMedia::IceConnectionStateChange_m,
+                 ctx,
+                 state),
+    NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::OnCandidateFound_s(NrIceMediaStream *aStream,
+                                        const std::string &aCandidateLine)
+{
+  ASSERT_ON_THREAD(mSTSThread);
+  MOZ_ASSERT(aStream);
+  MOZ_RELEASE_ASSERT(mIceCtxHdlr);
+
+  CSFLogDebug(logTag, "%s: %s", __FUNCTION__, aStream->name().c_str());
+
+  NrIceCandidate candidate;
+  NrIceCandidate rtcpCandidate;
+  GetDefaultCandidates(*aStream, &candidate, &rtcpCandidate);
+
+  // ShutdownMediaTransport_s has not run yet because it unhooks this function
+  // from its signal, which means that SelfDestruct_m has not been dispatched
+  // yet either, so this PCMedia will still be around when this dispatch reaches
+  // main.
+  GetMainThread()->Dispatch(
+    WrapRunnable(this,
+                 &PeerConnectionMedia::OnCandidateFound_m,
+                 aCandidateLine,
+                 candidate.cand_addr.host,
+                 candidate.cand_addr.port,
+                 rtcpCandidate.cand_addr.host,
+                 rtcpCandidate.cand_addr.port,
+                 aStream->GetLevel()),
+    NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::EndOfLocalCandidates(const std::string& aDefaultAddr,
+                                          uint16_t aDefaultPort,
+                                          const std::string& aDefaultRtcpAddr,
+                                          uint16_t aDefaultRtcpPort,
+                                          uint16_t aMLine)
+{
+  GetMainThread()->Dispatch(
+    WrapRunnable(this,
+                 &PeerConnectionMedia::EndOfLocalCandidates_m,
+                 aDefaultAddr,
+                 aDefaultPort,
+                 aDefaultRtcpAddr,
+                 aDefaultRtcpPort,
+                 aMLine),
+    NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::GetDefaultCandidates(const NrIceMediaStream& aStream,
+                                          NrIceCandidate* aCandidate,
+                                          NrIceCandidate* aRtcpCandidate)
+{
+  nsresult res = aStream.GetDefaultCandidate(1, aCandidate);
+  // Optional; component won't exist if doing rtcp-mux
+  if (NS_FAILED(aStream.GetDefaultCandidate(2, aRtcpCandidate))) {
+    aRtcpCandidate->cand_addr.host.clear();
+    aRtcpCandidate->cand_addr.port = 0;
+  }
+  if (NS_FAILED(res)) {
+    aCandidate->cand_addr.host.clear();
+    aCandidate->cand_addr.port = 0;
+    CSFLogError(logTag, "%s: GetDefaultCandidates failed for level %u, "
+                        "res=%u",
+                        __FUNCTION__,
+                        static_cast<unsigned>(aStream.GetLevel()),
+                        static_cast<unsigned>(res));
+  }
+}
+
+void
+PeerConnectionMedia::IceGatheringStateChange_m(NrIceCtx* ctx,
+                                               NrIceCtx::GatheringState state)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  SignalIceGatheringStateChange(ctx, state);
+}
+
+void
+PeerConnectionMedia::IceConnectionStateChange_m(NrIceCtx* ctx,
+                                                NrIceCtx::ConnectionState state)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  SignalIceConnectionStateChange(ctx, state);
+}
+
+void
+PeerConnectionMedia::IceStreamReady_s(NrIceMediaStream *aStream)
+{
+  MOZ_ASSERT(aStream);
+
+  CSFLogDebug(logTag, "%s: %s", __FUNCTION__, aStream->name().c_str());
+}
+
+void
+PeerConnectionMedia::OnCandidateFound_m(const std::string& aCandidateLine,
+                                        const std::string& aDefaultAddr,
+                                        uint16_t aDefaultPort,
+                                        const std::string& aDefaultRtcpAddr,
+                                        uint16_t aDefaultRtcpPort,
+                                        uint16_t aMLine)
+{
+  ASSERT_ON_THREAD(mMainThread);
+  if (!aDefaultAddr.empty()) {
+    SignalUpdateDefaultCandidate(aDefaultAddr,
+                                 aDefaultPort,
+                                 aDefaultRtcpAddr,
+                                 aDefaultRtcpPort,
+                                 aMLine);
+  }
+  SignalCandidate(aCandidateLine, aMLine);
+}
+
+void
+PeerConnectionMedia::EndOfLocalCandidates_m(const std::string& aDefaultAddr,
+                                            uint16_t aDefaultPort,
+                                            const std::string& aDefaultRtcpAddr,
+                                            uint16_t aDefaultRtcpPort,
+                                            uint16_t aMLine) {
+  ASSERT_ON_THREAD(mMainThread);
+  if (!aDefaultAddr.empty()) {
+    SignalUpdateDefaultCandidate(aDefaultAddr,
+                                 aDefaultPort,
+                                 aDefaultRtcpAddr,
+                                 aDefaultRtcpPort,
+                                 aMLine);
+  }
+  SignalEndOfLocalCandidates(aMLine);
+}
+
+void
+PeerConnectionMedia::DtlsConnected_s(TransportLayer *layer,
+                                     TransportLayer::State state)
+{
+  MOZ_ASSERT(layer->id() == "dtls");
+  TransportLayerDtls* dtlsLayer = static_cast<TransportLayerDtls*>(layer);
+  dtlsLayer->SignalStateChange.disconnect(this);
+
+  bool privacyRequested = (dtlsLayer->GetNegotiatedAlpn() == "c-webrtc");
+  GetMainThread()->Dispatch(
+    WrapRunnableNM(&PeerConnectionMedia::DtlsConnected_m,
+                   mParentHandle, privacyRequested),
+    NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::DtlsConnected_m(const std::string& aParentHandle,
+                                     bool aPrivacyRequested)
+{
+  PeerConnectionWrapper pcWrapper(aParentHandle);
+  PeerConnectionImpl* pc = pcWrapper.impl();
+  if (pc) {
+    pc->SetDtlsConnected(aPrivacyRequested);
+  }
+}
+
+void
+PeerConnectionMedia::AddTransportFlow(int aIndex, bool aRtcp,
+                                      const RefPtr<TransportFlow> &aFlow)
+{
+  int index_inner = GetTransportFlowIndex(aIndex, aRtcp);
+
+  MOZ_ASSERT(!mTransportFlows[index_inner]);
+  mTransportFlows[index_inner] = aFlow;
+
+  GetSTSThread()->Dispatch(
+    WrapRunnable(this, &PeerConnectionMedia::ConnectDtlsListener_s, aFlow),
+    NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::RemoveTransportFlow(int aIndex, bool aRtcp)
+{
+  int index_inner = GetTransportFlowIndex(aIndex, aRtcp);
+  NS_ProxyRelease(GetSTSThread(), mTransportFlows[index_inner].forget());
+}
+
+void
+PeerConnectionMedia::ConnectDtlsListener_s(const RefPtr<TransportFlow>& aFlow)
+{
+  TransportLayer* dtls = aFlow->GetLayer(TransportLayerDtls::ID());
+  if (dtls) {
+    dtls->SignalStateChange.connect(this, &PeerConnectionMedia::DtlsConnected_s);
+  }
+}
+
+nsresult
+LocalSourceStreamInfo::TakePipelineFrom(RefPtr<LocalSourceStreamInfo>& info,
+                                        const std::string& oldTrackId,
+                                        MediaStreamTrack& aNewTrack,
+                                        const std::string& newTrackId)
+{
+  if (mPipelines.count(newTrackId)) {
+    CSFLogError(logTag, "%s: Pipeline already exists for %s/%s",
+                __FUNCTION__, mId.c_str(), newTrackId.c_str());
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<MediaPipeline> pipeline(info->ForgetPipelineByTrackId_m(oldTrackId));
+
+  if (!pipeline) {
+    // Replacetrack can potentially happen in the middle of offer/answer, before
+    // the pipeline has been created.
+    CSFLogInfo(logTag, "%s: Replacing track before the pipeline has been "
+                       "created, nothing to do.", __FUNCTION__);
+    return NS_OK;
+  }
+
+  nsresult rv =
+    static_cast<MediaPipelineTransmit*>(pipeline.get())->ReplaceTrack(aNewTrack);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mPipelines[newTrackId] = pipeline;
+
+  return NS_OK;
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+/**
+ * Tells you if any local track is isolated to a specific peer identity.
+ * Obviously, we want all the tracks to be isolated equally so that they can
+ * all be sent or not.  We check once when we are setting a local description
+ * and that determines if we flip the "privacy requested" bit on.  Once the bit
+ * is on, all media originating from this peer connection is isolated.
+ *
+ * @returns true if any track has a peerIdentity set on it
+ */
+bool
+PeerConnectionMedia::AnyLocalTrackHasPeerIdentity() const
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  for (uint32_t u = 0; u < mLocalSourceStreams.Length(); u++) {
+    for (auto pair : mLocalSourceStreams[u]->GetMediaStreamTracks()) {
+      if (pair.second->GetPeerIdentity() != nullptr) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+void
+PeerConnectionMedia::UpdateRemoteStreamPrincipals_m(nsIPrincipal* aPrincipal)
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  for (uint32_t u = 0; u < mRemoteSourceStreams.Length(); u++) {
+    mRemoteSourceStreams[u]->UpdatePrincipal_m(aPrincipal);
+  }
+}
+
+void
+PeerConnectionMedia::UpdateSinkIdentity_m(MediaStreamTrack* aTrack,
+                                          nsIPrincipal* aPrincipal,
+                                          const PeerIdentity* aSinkIdentity)
+{
+  ASSERT_ON_THREAD(mMainThread);
+
+  for (uint32_t u = 0; u < mLocalSourceStreams.Length(); u++) {
+    mLocalSourceStreams[u]->UpdateSinkIdentity_m(aTrack, aPrincipal,
+                                                 aSinkIdentity);
+  }
+}
+
+void
+LocalSourceStreamInfo::UpdateSinkIdentity_m(MediaStreamTrack* aTrack,
+                                            nsIPrincipal* aPrincipal,
+                                            const PeerIdentity* aSinkIdentity)
+{
+  for (auto it = mPipelines.begin(); it != mPipelines.end(); ++it) {
+    MediaPipelineTransmit* pipeline =
+      static_cast<MediaPipelineTransmit*>((*it).second.get());
+    pipeline->UpdateSinkIdentity_m(aTrack, aPrincipal, aSinkIdentity);
+  }
+}
+
+void RemoteSourceStreamInfo::UpdatePrincipal_m(nsIPrincipal* aPrincipal)
+{
+  // This blasts away the existing principal.
+  // We only do this when we become certain that the all tracks are safe to make
+  // accessible to the script principal.
+  for (auto& trackPair : mTracks) {
+    MOZ_RELEASE_ASSERT(trackPair.second);
+    RemoteTrackSource& source =
+      static_cast<RemoteTrackSource&>(trackPair.second->GetSource());
+    source.SetPrincipal(aPrincipal);
+
+    RefPtr<MediaPipeline> pipeline = GetPipelineByTrackId_m(trackPair.first);
+    if (pipeline) {
+      MOZ_ASSERT(pipeline->direction() == MediaPipeline::RECEIVE);
+      static_cast<MediaPipelineReceive*>(pipeline.get())
+        ->SetPrincipalHandle_m(MakePrincipalHandle(aPrincipal));
+    }
+  }
+}
+#endif // MOZILLA_INTERNAL_API
+
+bool
+PeerConnectionMedia::AnyCodecHasPluginID(uint64_t aPluginID)
+{
+  for (uint32_t i=0; i < mLocalSourceStreams.Length(); ++i) {
+    if (mLocalSourceStreams[i]->AnyCodecHasPluginID(aPluginID)) {
+      return true;
+    }
+  }
+  for (uint32_t i=0; i < mRemoteSourceStreams.Length(); ++i) {
+    if (mRemoteSourceStreams[i]->AnyCodecHasPluginID(aPluginID)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool
+SourceStreamInfo::AnyCodecHasPluginID(uint64_t aPluginID)
+{
+  // Scan the videoConduits for this plugin ID
+  for (auto it = mPipelines.begin(); it != mPipelines.end(); ++it) {
+    if (it->second->Conduit()->CodecPluginID() == aPluginID) {
+      return true;
+    }
+  }
+  return false;
+}
+
+nsresult
+SourceStreamInfo::StorePipeline(
+    const std::string& trackId,
+    const RefPtr<mozilla::MediaPipeline>& aPipeline)
+{
+  MOZ_ASSERT(mPipelines.find(trackId) == mPipelines.end());
+  if (mPipelines.find(trackId) != mPipelines.end()) {
+    CSFLogError(logTag, "%s: Storing duplicate track", __FUNCTION__);
+    return NS_ERROR_FAILURE;
+  }
+
+  mPipelines[trackId] = aPipeline;
+  return NS_OK;
+}
+
+void
+RemoteSourceStreamInfo::DetachMedia_m()
+{
+  for (auto& webrtcIdAndTrack : mTracks) {
+    EndTrack(mMediaStream->GetInputStream(), webrtcIdAndTrack.second);
+  }
+  SourceStreamInfo::DetachMedia_m();
+}
+
+void
+RemoteSourceStreamInfo::RemoveTrack(const std::string& trackId)
+{
+  auto it = mTracks.find(trackId);
+  if (it != mTracks.end()) {
+    EndTrack(mMediaStream->GetInputStream(), it->second);
+  }
+
+  SourceStreamInfo::RemoveTrack(trackId);
+}
+
+void
+RemoteSourceStreamInfo::SyncPipeline(
+  RefPtr<MediaPipelineReceive> aPipeline)
+{
+  // See if we have both audio and video here, and if so cross the streams and
+  // sync them
+  // TODO: Do we need to prevent multiple syncs if there is more than one audio
+  // or video track in a single media stream? What are we supposed to do in this
+  // case?
+  for (auto i = mPipelines.begin(); i != mPipelines.end(); ++i) {
+    if (i->second->IsVideo() != aPipeline->IsVideo()) {
+      // Ok, we have one video, one non-video - cross the streams!
+      WebrtcAudioConduit *audio_conduit =
+        static_cast<WebrtcAudioConduit*>(aPipeline->IsVideo() ?
+                                                  i->second->Conduit() :
+                                                  aPipeline->Conduit());
+      WebrtcVideoConduit *video_conduit =
+        static_cast<WebrtcVideoConduit*>(aPipeline->IsVideo() ?
+                                                  aPipeline->Conduit() :
+                                                  i->second->Conduit());
+      video_conduit->SyncTo(audio_conduit);
+      CSFLogDebug(logTag, "Syncing %p to %p, %s to %s",
+                          video_conduit, audio_conduit,
+                          i->first.c_str(), aPipeline->trackid().c_str());
+    }
+  }
+}
+
+void
+RemoteSourceStreamInfo::StartReceiving()
+{
+  if (mReceiving || mPipelines.empty()) {
+    return;
+  }
+
+  mReceiving = true;
+
+  SourceMediaStream* source = GetMediaStream()->GetInputStream()->AsSourceStream();
+  source->SetPullEnabled(true);
+  // AdvanceKnownTracksTicksTime(HEAT_DEATH_OF_UNIVERSE) means that in
+  // theory per the API, we can't add more tracks before that
+  // time. However, the impl actually allows it, and it avoids a whole
+  // bunch of locking that would be required (and potential blocking)
+  // if we used smaller values and updated them on each NotifyPull.
+  source->AdvanceKnownTracksTime(STREAM_TIME_MAX);
+  CSFLogDebug(logTag, "Finished adding tracks to MediaStream %p", source);
+}
+
+RefPtr<MediaPipeline> SourceStreamInfo::GetPipelineByTrackId_m(
+    const std::string& trackId) {
+  ASSERT_ON_THREAD(mParent->GetMainThread());
+
+  // Refuse to hand out references if we're tearing down.
+  // (Since teardown involves a dispatch to and from STS before MediaPipelines
+  // are released, it is safe to start other dispatches to and from STS with a
+  // RefPtr<MediaPipeline>, since that reference won't be the last one
+  // standing)
+  if (mMediaStream) {
+    if (mPipelines.count(trackId)) {
+      return mPipelines[trackId];
+    }
+  }
+
+  return nullptr;
+}
+
+already_AddRefed<MediaPipeline>
+LocalSourceStreamInfo::ForgetPipelineByTrackId_m(const std::string& trackId)
+{
+  ASSERT_ON_THREAD(mParent->GetMainThread());
+
+  // Refuse to hand out references if we're tearing down.
+  // (Since teardown involves a dispatch to and from STS before MediaPipelines
+  // are released, it is safe to start other dispatches to and from STS with a
+  // RefPtr<MediaPipeline>, since that reference won't be the last one
+  // standing)
+  if (mMediaStream) {
+    if (mPipelines.count(trackId)) {
+      RefPtr<MediaPipeline> pipeline(mPipelines[trackId]);
+      mPipelines.erase(trackId);
+      return pipeline.forget();
+    }
+  }
+
+  return nullptr;
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+auto
+RemoteTrackSource::ApplyConstraints(
+    nsPIDOMWindowInner* aWindow,
+    const dom::MediaTrackConstraints& aConstraints) -> already_AddRefed<PledgeVoid>
+{
+  RefPtr<PledgeVoid> p = new PledgeVoid();
+  p->Reject(new dom::MediaStreamError(aWindow,
+                                      NS_LITERAL_STRING("OverconstrainedError"),
+                                      NS_LITERAL_STRING("")));
+  return p.forget();
+}
+#endif
+
+} // namespace mozilla