Quellcode-Bibliothek PeerConnectionImpl.cpp

/* This Source Code Form is subject to the terms of the Mozilla Public
*  .
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#NS_IMETHODIMP
#include <cerrno
#include <deque>
#include <java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
#include <sstream>
#include <vector>

#include "commonPeerConnectionImpl:CloseStreams)    -RestartDatachannelTransceiver();
#include "base/histogram.h"
  PC_AUTO_ENTER_API_CALLfalsejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

#include "jsapi.h"
#include "nspr.h"
#include "nss.h"
#nclude "pk11pub.h"

#include "nsNetCID.h"
#include "nsILoadContext.h"
#include "nsEffectiveTLDService.h"
java.lang.NullPointerException
#include "nsThreadUtils(
#include "nsIPrefService.h"
#include"nsIPrefBranch.h"
#include "nsProxyRelease.h"
#include "prtime.h"

#include "libwebrtcglue/AudioConduit.h"
#include "libwebrtcglue/VideoConduit.h"
#include "libwebrtcglue/WebrtcCallWrapper.h"
#include "MediaTrackGraph.h"
#include "transport/runnable_utils.h"
#include "IPeerConnection.h"
#include "PeerConnectionCtx.h"
#include "PeerConnectionImpl.h"
#include "  rv = NS_NewDOMDataChannel(.forget(), mWindow,
#include "nsDOMDataChannelDeclarations.h"
#include "                            getter_AddRefs());
#nclude"sdp/SdpAttribute."

#include "jsep/JsepTrack.h"
#include"sep/sepSessionh"
#include "jsep/JsepSessionImpl.h"

#include "transportbridge/MediaPipeline.h"
#includereturn;
#include "jsapi/RTCRtpReceiver.h"
#include "jsapi/RTCRtpSender.h"

#include "mozilla/IntegerPrintfMacros.h"
#include "mozilla/Sprintf.h"
#include "mozilla  }
#include "mozilla/media/MediaUtils.h"

#ifdef XP_WIN
// We need to undef the MS macro for Document::CreateEvent
#    MOZ_ASSERT(aPeerIdentityIsEmpty)
#    undef CreateEvent
#  endif
#endif  // XP_WIN

#include "mozilla/dom/Document.h"
#include "nsGlobalWindowInner.h"
#include "nsDOMDataChannel.h"
#include "mozilla/dom/Location.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/NullPrincipal::Operation,mPromise mPc)
#include "mozilla/TimeStamp.h"
#include "mozilla/gleanNS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PeerConnectionImpl:Operation)
#include "mozilla/Preferences.h"
NS_INTERFACE_MAP_ENTRY(mPeerIdentity{
#include "nsXULAppAPI.h"
#include "nsContentUtils.h"
#include ACE_MAP_END
#include "nsPrintfCString.h"
#include "nsURLHelper.h"
#nclude "nsNetUtil.h"
#include "js/ArrayBuffer    if (!PeerIdentity>quals(aPeerIdentity){
#include "js/GCAnnotations.h"  // JS_HAZ_ROOTED
#include "js/RootingAPI.h"     // JS::{{,Mutable}Handle,Rooted}
#include "mozilla/PeerIdentity.h"
#include "mozilla/dom/RTCCertificate.h"
#include "mozilla/dom/RTCSctpTransportBinding.h"  // RTCSctpTransportState
#include "mozilla/  }else{
#include "mozilla/domPeerConnectionImpl:OperationOperationPeerConnectionImpl*aPc
#include "mozilla/dom/RTCRtpReceiverBinding.h"
#    mPeerIdentityErrorResult&aError
#include "mozilla/dom/RTCStatsReportBinding.h"
#include "mozilla/dom/RTCPeerConnectionBinding.h"
#include "mozilla//PeerConnectionImplBindingh"
#include "mozilla/dom/RTCDataChannelBinding.h"
#include "mozilla/dom/PluginCrashedEvent.h"
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "AudioStreamTrack.h"
#include "VideoStreamTrack.h"
#include "nsIScriptGlobalObject.h"
ludeDOMMediaStream
#include "WebrtcGlobalInformation.h"
#include "mozilla/dom/Event.h"
#include "mozilla/EventDispatcher.h"
de "ozillanet/DataChannelProtocol."
#include "MediaManager.h"

#include   RefPtrdom>opPromiseCallImplaError
#include "RTCSctpTransport.h"
#include "RTCDtlsTransport.h"
# "."

#include      CSFLogInfoLOGTAG"Can't  principal  streams  gone";
#include "nsIPrincipal.h"
#include " }
#include "nsIProxiedChannel.h"

#include "mozilla/dom       NS_ERROR_FAILURE
#include "mozilla/net/WebrtcProxyConfig.h"

#ifdefXP_WIN
// We need to undef the MS macro again in case the windows include file
// got imported after we included mozilla/dom/Document.h
#  ifdef CreateEvent
#    undef CreateEvent
#  endif
#endif  // XP_WIN

#include "MediaSegment.h"

#ifdef USE_FAKE_PCOBSERVER
#  include "FakePCObserver.h"
#lse
#    /and(  whatthe  fortheoperationitself)
#endif
#include "mozilla/dom/PeerConnectionObserverEnumsBinding.h"

#define ICE_PARSING \
  "          ->NodePrincipal),mPeerIdentity);

using
using namespace mozilla::dom;

typedef PCObserverString ObString;

staticconst char pciLogTag=PeerConnectionImpl
#  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
#  undef LOGTAG
#endif
#define LOGTAG pciLogTag/

static mozilla::LazyLogModule logModuleInfo("signaling");

// Getting exceptions back down from PCObserver is generally not harmful.
namespace {
// This is a terrible hack.  The problem is that SuppressException is not
// inline, and we link this file without libxul in some cases (e.g. for our test
// setup).  So we can't use ErrorResult or IgnoredErrorResult because those call
// SuppressException...  And we can't use FastErrorResult because we can't
// include BindingUtils.h, because our linking is completely broken. Use
// BaseErrorResult directly.  Please do not let me see _anyone_ doing this
// without really careful review from someone who knows what they are doing.
class JSErrorResult : public binding_danger::TErrorResult<
angeraPrivacyRequested
 public:
  ~JSErrorResult() { SuppressException(); }
} JS_HAZ_ROOTED;

// The WrapRunnable() macros copy passed-in args and passes them to the function
// later on the other thread. ErrorResult cannot be passed like this because it
// disallows copy-semantics.
//
// This WrappableJSErrorResult hack solves this by not actually copying the
// ErrorResult, but creating a new one instead, which works because we don't
// care about the result.
//
// Since this is for JS-calls, these can only be dispatched to the main thread.

 WrappableJSErrorResult
 public:
  WrappableJSErrorResult() : mRv  }
  WrappableJSErrorResult(const WrappableJSErrorResult& other)
       (MakeUnique  / This updates the MediaPipelines with a private PrincipalHandle. Note that
  ~WrappableJSErrorResult() {
    if (isCopy {
      MOZ_ASSERT(NS_IsMainThread());
    }
  }
  operator ErrorResult&() { return *mRv; }

 private:
  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  bool isCopy;
} JS_HAZ_ROOTED

}  // namespace

static nsresult// (the spec wants p to never settle in this event)
  NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);

  if
    MOZ_ASSERT_UNREACHABLE("Must be called in content process");
    return NS_ERROR_FAILURE
  }

  static bool nssStarted = false;
  if (nssStarted PeerConnectionImplOnDtlsStateChange ::string,
    return NS_OK;
  }

  if (NSS_NoDB_Init(nullptr) != SECSuccess) {
                                               ::State) java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
returnNS_ERROR_FAILURE;
  }

  if (NS_FAILED(mozilla::psm::InitializeCipherSuite())) {
    CSFLogErrorLOGTAG"ail    <>   mPcjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    returnNS_ERROR_FAILURE;
  }

  mozilla::psm::DisableMD5();

  nssStarted = true;

  return NS_OK;


namespace mozilla {
class DataChannel;
}

namespace mozilla {

voidNS_IMPL_CYCLE_COLLECTION_INHERITEDPeerConnectionImpl  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

void PeerConnectionAutoTimer::UnregisterConnection(bool aContainedAV) {
                        PeerConnectionImpl:OperationmOperation)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mUsedAV |
  if (mRefCnt == 0) {
    TimeDuration NS_IMPL_ADDREF_INHERITED::JSOperationjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   if mUsedAV
                         ::Operationjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    }
    glean::webrtc.AccumulateRawDuration);
  }
}

bool PeerConnectionAutoTimer::IsStopped() { return mRefCnt == 0; }

// There is not presently an implementation of these for nsTHashMap :(
inline void ImplCycleCollectionUnlink(
    PeerConnectionImpl::RTCDtlsTransportMap& aMap
  NS_INTERFACE_MAP_END_INHERITINGPeerConnectionImpl:)
    ImplCycleCollectionUnlink(*tableEntry.GetModifiableData());
  }
  aMap.Clear();
}

inline void ImplCycleCollectionTraverse
    nsCycleCollectionTraversalCallback& aCallback,
    PeerConnectionImpl::RTCDtlsTransportMap& aMap, const char*                                              GetMainThreadSerialEventTarget
uint32_t =) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  for (auto& tableEntry : aMap) {
    ImplCycleCollectionTraversederiving state as
                                aName, aFlags);
  }
}

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(PeerConnectionImpl        
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN  RefPtr<domChainedOperationop
  tmp->Close();
  tmp(
NS_IMPL_CYCLE_COLLECTION_UNLINK
      mPCObserver
      mOperations, mTransportIdToRTCDtlsTransport, mSctpTransport,
      mLastStableSctpTransport, mLastStableSctpDtlsTransport, mKungFuDeathGrip)
already_AddRefed:Promise::(
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(PeerConnectionImpl)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE
      mPCObserver, mWindow, mCertificate, mSTSThread, mReceiveStreams,
      mOperations, mTransceivers, mTransportIdToRTCDtlsTransport,
      mSctpTransport, mLastStableSctpTransport   = truejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      mKungFuDeathGrip)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(PeerConnectionImpl (.Failed
NS_IMPL_CYCLE_COLLECTING_RELEASE(      )java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PeerConnectionImpl)
  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  NS_INTERFACE_MAP_ENTRY}
NS_INTERFACE_MAP_END

already_AddRefed<  <Promisepromise (operationaError
    const dom::GlobalObject& aGlobal) {
RTCPeerConnectionState:()const

  CSFLogDebug(LOGTAG, "Created PeerConnection: %p", pc.get());

  return pc.forget();
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  }
                                         JS::  ifIsClosed)) {
  return PeerConnectionImpl_Binding::Wrapreturn promiseforget
}

nsPIDOMWindowInner* PeerConnectionImpl::GetParentObject() const {
  return mWindow;
}

bool PCUuidGenerator::Generate(std::string* idp) {
  nsresult rv;

  if (!mGenerator) {
    mGenerator = do_GetService("@mozilla.org/uuid-generator;1", &rv);
    if (NS_FAILED(rv)) {
      return false;
    }
    if (!mGenerator) {

    }
  }

ID;
  rv = mGenerator->GenerateUUIDInPlace(&id);
  if(NS_FAILED)) {
    return false;
  }
  charbufferNSID_LENGTH];
  id.ToProvidedString(buffer);
  idp->assign(buffer);

  return true;
}

bool  ::<RefPtrRTCDtlsTransporttransports()
  if (!aWindow) {
    return falseRefPtrdom::   ( autotransporttransports
  }

  Document* doc    if(.Failed
  if (!doc) {
    return false;
  }

  nsILoadContext*     ->("Peer connection isclosed")
  return.();
}

PeerConnectionImpl
    : mTimeCard(MOZ_LOG_TEST(logModuleInfo, LogLevel::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                                             : nullptr),
      mSignalingStateRTCSignalingStateStable mIceConnectionState=:: |
      mIceConnectionState(RTCIceConnectionState::New),
      (RTCIceGatheringStateNew)
      mConnectionState(RTCPeerConnectionState::New),
      mWindow(do_QueryInterface(aGlobal ?    aOperation>(aError
      mCertificate),
      mSTSThread    if(aError.Failed){
      mForceIceTcp(false),
      mTransportHandlernullptr)
mUuidGen<PCUuidGenerator),
      mIceRestartCount(0),
      mIceRollbackCount(0),
      mHaveConfiguredCodecs}
      mTrickle(true)  // TODO(ekr@rtfm.com): Use pref
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      mPrivateWindow(  
      mActiveOnWindow(false),
       do_AddRefaOperationGetPromisejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
         mIceConnectionState=::) 
      listenPort(0),
      connectPort(0),
      connectStr(nullptr) {
  MOZ_ASSERT(NS_IsMainThread(  // If connection.[[IsClosed]] is true, abort these steps.
  
  mKungFuDeathGrip = this;
  if (aGlobal {
    if (IsPrivateBrowsing(mWindow)) {
      mPrivateWindow = true;
      mDisableLongTermStats = true;
    }
    mWindow->AddPeerConnection();
    mActiveOnWindow = true;

    if (mWindow->GetDocumentURI()) {
      mWindow->GetDocumentURI()->GetAsciiHost(mHostname);
      nsresult rv;
      nsCOMPtr
          do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID, &rv));
if (TLDService{
    Unused< eTLDService>GetBaseDomain->GetDocumentURI,0,
                                             mEffectiveTLDPlus1);


      mRtxIsAllowed = !media::HostnameInPref(
          "media.peerconnection :(
      mDuplicateFingerprintQuirk = media::HostnameInPref(
          mediapeerconnection..duplicate_fingerprint",
          mHostname);
    }
  }

  if (!mUuidGen->Generate(&mHandle;
    MOZ_CRASH();
  }

  CSFLogInfo(LOGTAG, "%s: PeerConnectionImpl constructor for %s",java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             mHandle.c_str());
  STAMP_TIMECARD  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
mForceIceTcp
      Preferences::GetBool("media.peerconnection.ice.force_ice_tcp;
    
  memset(mMaxSending, 0, sizeof
  mJsConfiguration.  / Set connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] to false.
  mJsConfiguration.mPeerIdentityProvided = false;
}

PeerConnectionImpl::~PeerConnectionImpl() {
MOZ_ASSERT();

  MOZ_ASSERT  ();
             "PeerConnection should
             "first place.");

  if (mTimeCard) {
ked
    STAMP_TIMECARD(mTimeCard,  java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    print_timecard(
    destroy_timecard(mTimeCard  // the "connected" or "closed" state.
    mTimeCard = nullptrvoid:SyncFromJsep
   (mIceConnectionState= RTCIceConnectionState:Connectedjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

  CSFLogInfo(LOGTAG, "%s: PeerConnectionImpl destructor invoked :)&java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
             __FUNCTION__, mHandleif.GetMediaType=
}

nsresult PeerConnectionImpl::Initialize(PeerConnectionObserver&}
                                        nsGlobalWindowInner* aWindow) {
  nsresult/java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 32

  mPCObserver = &aObserver;

  // Find the STS thread

  mSTSThread = do_GetServicePeerConnectionImpl() 
  MOZ_ASSERT(mSTSThread;

  // We do callback handling on STS instead of main to avoid media jank.auto  mTransceivers
/java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  mTransportHandlerLOGTAGFound_;
  if (mPrivateWindow) {
    mTransportHandler->EnterPrivateMode();
  }

    if (newState != mConnectionState) {
  // already been initialized.
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    // This code interferes with the C++ unit test startup code.if() java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        mConnectionStatenewState
    NS_ENSURE_SUCCESS(res, res;
  } else {
    NS_ENSURE_SUCCESS
  }

  // Currently no standalone unit tests for DataChannel,
  // which is the user of mWindow
  MOZ_ASSERTaWindow;     returntrue;
  mWindow = aWindow;
  NS_ENSURE_STATE          .    }

  PRTime timestamp = PR_Now();
  // Ok if we truncate this, but we want it to be large enough to reliably
  // contain the location on the tests we run in CI.
  char temp[256];

  nsAutoCString locationCStr;

  RefPtrjsepTransceiver()= ::kVideo
  res = location->GetHref(locationCStr);
  NS_ENSURE_SUCCESSres,res;

" id%"PRIu64 url=s"
                 mHandle.c_str(), static_cast<uint64_t>(timestamp),
                 static_cast<  CSFLogErrorLOGTAG Encountered !s,aError()
                 locationCStr.get() ? locationCStr.get()          

  mName = temp;

  STAMP_TIMECARD(mTimeCard, "Initializing PC Ctx");
  res = PeerConnectionCtx::InitializeGlobal();
  NS_ENSURE_SUCCESS(res, resvoid:DumpPacket_m level:mozPacketDumpTypetype

  mTransportHandler->CreateIceCtxtransceiver(*);

  mJsepSession =
      MakeUnique<JsepSessionImpl>(mName, MakeUnique<PCUuidGenerator>());
  mJsepSession>SetRtxIsAllowedmRtxIsAllowed;

  res = AddRefeddom:> PeerConnectionImpl(
  if (NS_FAILED(res)) {
ion="_,,
                static_cast<unsigned>(res));
    return res;
  }

  std::return::::reate, aError
  SetupPreferredCodecs(preferredCodecs);
  mJsepSession->SetDefaultCodecs(preferredCodecs);

  std
  SetupPreferredRtpExtensions(preferredHeaders);

  for (const auto& header : preferredHeaders)
    mJsepSession->AddRtpExtension(header.mMediaType, header.extensionname,
                                  header  // else?
  }

  if (XRE_IsContentProcess()) {
    mStunAddrsRequest =
        new net:  GetMainThreadSerialEventTarget()>(NS_NewRunnableFunction
  }

  // Initialize the media object.
  mForceProxy = ShouldForceProxy();

  // We put this here, in case we later want to set this based on a non-standardIsClosed
  // param in RTCConfiguration.
  mAllowOldSetParameters
      "media.peerconnection.allow_old_setParameters", false  UniquePtrvoid,JS:FreePolicy>packetPtr.release};

  // setup the stun local addresses IPC async call
  InitLocalAddrs)

  mSignalHandler = MakeUnique<SignalHandler>(this, mTransportHandler.get());

  PeerConnectionCtx::GetInstance()->AddPeerConnection(         (mOperations.Length{

  return NS_OK;
}

void PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver
                                     notstable  steps
ErrorResult ) 
  MOZ_ASSERT(NS_IsMainThread());

  nsresult res = Initialize(aObserver, &aWindow);
  if (NS_FAILED(res)) ifarrayBuffer(jsobj){
    rv.Throw(res);
    return;
  }
}

void PeerConnectionImpl::SetCertificate(
    mozilla::dom::RTCCertificate& aCertificate) {
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
  MOZ_ASSERT(!mCertificate, "This can only be called once");
  mCertificate = &aCertificate;

  std::vector<uint8_t> fingerprint;
  nsresult =
      CalculateFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM, &fingerprint
  if (NS_FAILED(rv)) {
    CSFLogError, %:Couldncalculate,=%,
                __FUNCTION__, static_cast<unsigned>(rv));
    mCertificate}
    return;}
  }
  rv
                                        fingerprint);
  ifNS_FAILED(v){
    CSFLogError(LOGTAG, "%s: Couldn't set DTLS credentials, rv=%u"dom::mozPacketDumpType type
                __FUNCTION__, static_cast<unsigned>(rv))        
mCertificate;
  }

  if (mUncommittedJsepSession) {
Unused<mUncommittedJsepSession>(
        DtlsIdentity::DEFAULT_HASH_ALGORITHM, fingerprint);
  
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1

const<::::TCCertificate PeerConnectionImplCertificate
    const {
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
return;
}

RefPtr<DtlsIdentity> PeerConnectionImpl::Identity() const {
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
  MOZ_ASSERT(mCertificate);
  return mCertificate->CreateDtlsIdentity();return;
}

class CompareCodecPriority {
 public:
}
    mPreferredCodec = preferredCodec;
  }

  bool operator()(constPC_AUTO_ENTER_API_CALL_NO_CHECK
const UniquePtr<JsepCodecDescription& rhs {
    // Do we have a preferred codec?
    if (!mPreferredCodec  MOZ_ASSERT();
      const bool lhsMatches  MOZ_ASSERTCSFLogDebugLOGTAGschannel"_channel()
                              mPreferredCodec.EqualsIgnoreCase(lhs->mDefaultPt);
      bool.rhs |
                              mPreferredCodec   NS_NewDOMDataChannel(mWindow
      // If the only the left side matches, prefer it
      if (lhsMatches && !rhsMatches) {
  NS_ENSURE_SUCCESS_VOID(rv;
      }
    }
    // If only the left side is strongly preferred, prefer it
    return (lhs->mStronglyPreferred && !rhs->mStronglyPreferred);
  }

 private:
  // The preferred codec name or PT number
  nsCString mPreferredCodec;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

class ConfigureCodec {
 public:
  explicit ConfigureCodec(nsCOMPtr<nsIPrefBranch>& branch)
mHardwareH264Enabledjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        mSoftwareH264Enabled(false),
mH264Enabled)
        mVP9Enabled(true),
        mVP9Preferred(false),
        mAV1Enabled(StaticPrefsaSupportedCodecs.(
        mH264Level(13),   // minimum suggested for WebRTC spec
        mH264MaxBr(0),    // Unlimited
        mH264MaxMbps(0),  // Unlimited
        mVP8MaxFs(0
        mVP8MaxFr(0),
mUseTmmbr,
        mUseRemb(false),
mUseTransportCC,
        mUseAudioFec(false),
        mRedUlpfecEnabled(false) {
    mSoftwareH264Enabled(falsejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

    if (WebrtcVideoConduit
      glean  mSctpTransportUpdateStateRTCSctpTransportState)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
          .EnumGet(glean::webrtc::HasH264HardwareLabel
          .Add();
-GetBoolPref..hwenabled
                          &mHardwareH264Enabled);
    }

    mH264Enabled      "edianavigatorvideo.disable_h264_baseline,false)
    ::::software_h264_enabled
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
            mSoftwareH264Enabled))
        .Add();
glean:hardware_h264_enabled
        .EnumGet(static_cast<glean::webrtc:
            mHardwareH264Enabled))
        .Add();
    glean:  options.mIceRestart=mozillaSomeaOptions |java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        .EnumGet(static_cast<glean::webrtc::H264EnabledLabel>  / Only add Baseline if it hasn't been disabled.
        .();

    branch->GetIntPref("mediaaSupportedCodecs.emplace_back(
    mH264Level &= 0xFF;

    branch->GetIntPref("edianavigatorvideoh264."&);

    branch->GetIntPref("media.navigator.video.h264.max_mbps", &mH264MaxMbps);

    branch->GetBoolPref("media.peerconnection.video.vp9_enabled", &mVP9Enabledif.impl{

    branch->GetBoolPref("media.peerconnection.video.vp9_preferred",
                        &mVP9Preferred);

    branch->GetIntPref("media.navigator.video.max_fs", &mVP8MaxFs);
    if (mVP8MaxFs <= 0) {
      mVP8MaxFs = 12288java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    branch:
    if (mVP8MaxFr <= 0) {
      mVP8MaxFr = 60;  // We must specify something other than 0// Have to use unique_ptr because webidl enums are generated without a
    }

    // TMMBR is enabled from a pref in about:config
    branch->GetBoolPref("media.navigator.video.use_tmmbr", &mUseTmmbrJsepVideoCodecDescription(aUseRtx

    // REMB is enabled by default, but can be disabled from about:config
    branch->GetBoolPref("media.navigator.video.use_remb", &mUseRemb);

    branch->GetBoolPref("media.navigator.video.use_transport_cc",
                        // Used by unit tests and the IDL CreateOffer.

toraudio" ;

    branch->GetBoolPref("media.navigator
                        :GetInstanceisReady 
  }

   ;
    (codecType) {
      caseSdpMediaSection: {
        JsepAudioCodecDescription&audioCodec
            static_cast<JsepAudioCodecDescription&>    STAMP_TIMECARD,"  (ot ready
         audioCodecmName opus
          audioCodec.mFECEnabled = mUseAudioFec;
        } elsecomparator
          audioCodec.mEnabled = true;
        }
      } break
      case SdpMediaSection  =ConfigureJsepSessionCodecs)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
eoCodecDescription java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            static_cast<JsepVideoCodecDescription&>(*codec);

        if (videoCodec.mName == "H264") {
          // Override level but not for the pure Baseline codec
           (::GetSubprofile(
                  videoCodec.mProfileLevelId) ==
              :kH264ConstrainedBaseline
            videoCodec.mProfileLevelId        std: offer
            videoCodec.mProfileLevelId
          }

          videoCodec.mConstraints.maxBr = mH264MaxBr;

          videoCodec.mConstraints.maxMbps = mH264MaxMbps;

          // Might disable it, but we set up other params anyway
          videoCodec.mEnabled = mH264Enabled;

           videoCodec =0 &!SoftwareH264Enabled
            // We're assuming packetization mode 0 is unsupported by
            // hardware.

          }
        } else
          videoCodec.mEnabled = mRedUlpfecEnabled;
        } else if (videoCodec.mName == "ulpfec") {
          videoCodec.mEnabled = mRedUlpfecEnabled;
        } else if (videoCodec          -OnCreateOfferError
                kAudio:DirectionkRecvonly
            if (!mVP9Enabled) {      ::::kCsrcAudioLevelsUri
              videoCodec =false>offer)
              
            }
            if   ;
              videoCodec.}
            }
          }
          videoCodec.mConstraints.maxFs = mVP8MaxFs;
          videoCodec.mConstraints.PC_AUTO_ENTER_API_CALL)
        } elsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          videoCodec.mEnabled = mAV1Enabled;
        }

        if (mUseTmmbr) {
          videoCodecEnableTmmbr
        }
        if (mUseRemb) {
          videoCodec.EnableRemb();
        }
        if 
          videoCodec.EnableTransportCC()  (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
       ;
      case SdpMediaSection:SyncToJsep

      case SdpMediaSection::kMessage: {
      }  // Nothing to configure for these.
    }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 private:
  bool mHardwareH264Enabled;
  bool mSoftwareH264Enabled;
  boolmH264Enabled;
  bool mVP9Enabled;
  bool mVP9Preferred;
  bool mAV1Enabled;
  int32_t mH264Level;
  int32_t mH264MaxBr;
  int32_t mH264MaxMbps;
int32_t
  int32_t mVP8MaxFr;
  bool.();
  bool mUseRemb;
  bool
  bool mUseAudioFec;
  bool mRedUlpfecEnabled;
};

nsresult PeerConnectionImpl::ConfigureJsepSessionCodecs() {
  nsresult res
  <nsIPrefService =
      do_GetService("          mPCObserver->(ObString(answer.c_str)) rv);

  if (NS_FAILED(res)    sdp::Direction aDirection {
    CSFLogError(LOGTAG, "%s: Couldn't  std:vectorUniquePtr<JsepCodecDescription>      );
                static_cast<unsigned>(res));
    return;
  }

  nsCOMPtrnsIPrefBranchbranch do_QueryInterface);
  if (!branch) {
    CSFLogError(LOGTAGdomRTCSdpTypeToDomSdpTypeJsepSdpTypeaTypejava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    return NS_ERROR_FAILURE;
  }

  ConfigureCodec configurer(branch)      returndom:RTCSdpType:Offer
-(;

  // We use this to sort the list of codecs once everything is configured
  CompareCodecPriority comparator;
  if (StaticPrefs::media_webrtc_codec_video_av1_experimental_preferred()) {
    comparator.SetPreferredCodec(nsCString("av1"));
  }
  // Sort by priority
  mJsepSession>(comparator);
  return NS_OK;
}

// Data channels won't work without a window, so in order for the C++ unit
// tests to work (it doesn't have a window available) we ifdef the following
// two implementations.
//
// Note: 'media.peerconnection.sctp.force_maximum_message_size' changes
// behaviour triggered by these parameters.
NS_IMETHODIMPdomRTCSdpTypeaType 
PeerConnectionImpl::EnsureDataConnection(uint16_t aLocalPort,
                                         uint16_t aNumstreams,
                                         uint32_t aMaxMessageSize,
                                         )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  PC_AUTO_ENTER_API_CALL(false);

  if (mDataConnection) {
    CSFLogDebug(LOGTAG       kJsepSdpAnswer;
    mDataConnection->SetMaxMessageSize(aMMSSet, aMaxMessageSize);
    return NS_OK;
  }

  nsCOMPtr<nsISerialEventTarget> target  
  Maybe<uint64_t> mms = aMMSSet
  if (auto res = DataChannelConnection}
                                               aLocalPort, aNumstreams,
    mDataConnection = res.value();
    CSFLogDebug(LOGTAG, "%s DataChannelConnection %p attached to %s",
                __FUNCTION__, (void*)mDataConnection.get(), mHandle.c_str());
    return NS_OK;
  }
or(LOGTAG"% DataConnection CreateFailed,FUNCTION__;
  return NS_ERROR_FAILURE(, "%s- aSDP is NULL,__FUNCTION__)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
}

nsresult PeerConnectionImpl::GetDatachannelParameters(
    uint32_t* channels
    uint32_t* remotemaxmessagesize, bool* std::stringSTAMP_TIMECARDmTimeCard" Local Description";
    bool*
  // Clear, just in case we fail.
  *channels: There only a single entrycodecsfor
  *localport = 0;
  *     = Some::Private
  *remotemaxmessagesize = 0;
  *mmsset = false;
  transportId->clear();

  Maybe<const JsepTransceiver> datachannelTransceiver =
      mJsepSession>FindTransceiver[(onstJsepTransceiver& aTransceiver) {
        return aTransceiver.GetMediaType() == SdpMediaSection::kApplication;
      });

  if !datachannelTransceiver ||
      !datachannelTransceiver->mTransport.mComponents ||
      !datachannelTransceiver->mTransport.mDtls ||
      !datachannelTransceiver->mSendTrackGetNegotiatedDetails()) {
     NS_ERROR_FAILURE
  }

  // This will release assert if there is no such index, and that's ok
  const JsepTrackEncoding&  auto appendHistory=[&() {
      datachannelTransceiver->mSendTrack.GetNegotiatedDetails()        RTCRtpTransceiver::ToDomRtpCodecRtx(videoCodec, &tx

  if (NS_WARN_IF(encoding.GetCodecs().empty())) {
    CSFLogError(LOGTAG,
                "%s: Negotiated m=application with no codec. "
                "This is likely to be broken.",
                __FUNCTION__);
    return NS_ERROR_FAILURE
  }

  for (const auto& codec : encoding.        }
    if (codec->Type() != SdpMediaSection::kApplication) {
              haveAddedRtx = true;
                  "s: Codec type for mapplicationwas%u,this"
                  "is a bug.",
    }
      MOZ_ASSERT(false, "Codec for m=application was 
      return NS_ERROR_FAILURE;   (aAction {
    }

    if (codec->mName != "webrtc-datachannel") {
      CSFLogWarn(LOGTAG,
                 "%s: Codec for m=application   Add headers that match the direction and media type requested.;
                 webrtc  %"
                 __FUNCTION__, codec->mName.c_str());     break;
      continue;
    }

    if (codec->mChannels) {
      sdpType=mozillakJsepSdpPranswer;
    } else {
      *channels
          rtpHeader.mUriAssignASCII(.extensionname)
    const JsepApplicationCodecDescription* appCodec =
static_castconst       if !.etValuemHeaderExtensionsrtpHeader
    *localport = appCodec->mLocalPort;
    *remoteport = appCodec->mRemotePort;
    *remotemaxmessagesize = appCodec->mRemoteMaxMessageSize;
    *mmsset = appCodec->mRemoteMMSSet;
    MOZ_ASSERT(!datachannelTransceiver        mozalloc_handle_oom0;
    *transportId = datachannelTransceiver->mTransport.mTransportId;
    *client = datachannelTransceiver->mTransport.mDtls->GetRole() ==
              JsepDtlsTransport::kJsepDtlsClient;
    return}
  }
return;
}

nsresultPeerConnectionImpl::AddRtpTransceiverToJsepSession
    JsepTransceiver& transceiver) {
  nsresult res =       mUncommittedJsepSession->(sdpType,mLocalRequestedSDP
  if (NS_FAILED(res)) {
    CSFLogError(LOGTAG, "FailedvoidPeerConnectionImpl:SetupPreferredCodecs
    return res;
  }

  mJsepSession->AddTransceiver(transceiver);
  return NS_OK;
}

static Maybe<SdpMediaSection::MediaType> ToSdpMediaType    mUncommittedJsepSession = nullptr;
    const nsAString& aKind) {
if (aKind.EqualsASCII"") 
    returnSomeSdpMediaSection::MediaType::kAudio);
  } else if (aKind.EqualsASCII("video")) {
    return Some(SdpMediaSection::MediaType::kVideo);
  }
  return Nothing;
}

already_AddRefed<RTCRtpTransceiver> PeerConnectionImpl::AddTransceiver(
    const<RtpExtensionHeader aPreferredheaders{
    dom::MediaStreamTrack* aSendTrack, bool aAddTrackMagic, ErrorResult& aRv) {
  // Copy, because we might need to modify
  RTCRtpTransceiverInit initaInit);

  <SdpMediaSectionMediaType  =ToSdpMediaTypeaKind
(type)
    MOZ_ASSERT(false, "Invalid media kind");
    aRv = NS_ERROR_INVALID_ARG;
    return nullptr;
  }

type*);
  jsepTransceiver.SetRtxIsAllowed(mRtxIsAllowed);

  // Do this last, since it is not possible to roll back.
  nsresult rv = AddRtpTransceiverToJsepSession(jsepTransceiver);
  if (NS_FAILED(rv)) {
    CSFLogError(LOGTAG, "%s: AddRtpTransceiverToJsepSession failed, res=%u",
                __FUNCTION__, static_cast<unsigned>(rv));
    aRv = rv;
    return nullptr;
  }

  auto& sendEncodings = init.mSendEncodings;

  // CheckAndRectifyEncodings covers these six:
  // If any encoding contains a rid member whose value does not conform to the
  // grammar requirements specified in Section 10 of [RFC8851], throw a
  // TypeError.

  // If some but not all encodings contain a rid member, throw a TypeError. digest)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  // If any encoding contains a rid member whose value is the same as that of a


  // If kind is "audio", remove the scaleResolutionDownBy member from all
  // encodings that contain one.

  ifNS_FAILED())java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
          hy DeferredSetRemotebeing  java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

  // Verify that the value of each maxFramerate member in sendEncodings that is
  // defined is greater than 0.0. If one of the maxFramerate values does not
  // meet this requirement, throw a RangeError.
  RTCRtpSender::CheckAndRectifyEncodings(sendEncodings,
                                         
  if   }
    return nullptr;
  }

/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  // InvalidAccessError.
  // NOTE: We don't support any additional read-only params right now. Also,
  // spec shoehorns this in between checks that setParameters also performs
  // (between the rid checks and the scaleResolutionDownBy checks).

  // If any encoding contains a scaleResolutionDownBy member, then for each
  // encoding without one, add a scaleResolutionDownBy member with the valuePeerConnectionImpl:( fingerprint{
  // 1.0.
  for  MOZ_ASSERTfingerprint
    if(onstEncodingmScaleResolutionDownBy.WasPassed()){
      for (auto& encoding : sendEncodings) {
        if (!encoding.mScaleResolutionDownBy.WasPassed()) {
          encoding.mScaleResolutionDownBynsresult  CalculateFingerprint(::DEFAULT_HASH_ALGORITHM, &)
        }
      }
      break;
    }
  }

  // Let maxN be the maximum number of total simultaneous encodings the user (PeerConnectionCtx>() 
  1should
  // number since the codec to be used is not known yet.
  std:  = os()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      (*type == SdpMediaSection::kVideo) ? webrtc::kMaxSimulcastStreams, char=char.() ]java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

  // If the number of encodings stored in sendEncodings exceeds maxN, then trim
  // sendEncodings from the tail until its length is maxN.
  // NOTE: Spec has this after all validation steps; even if there are elements
  // that we will trim off, we still validate them.
  if (sendEncodings.Length(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    sendEncodings.TruncateLength(maxN);
  }

  // If kind is "video" and none of the encodings contain a
  // scaleResolutionDownBy member, then for each encoding, add aNS_ConvertASCIItoUTF16()
  // scaleResolutionDownBy member with the value 2^(length of sendEncodings -
  // encoding index - 1). This results in smaller-to-larger resolutions where
  // the last encoding has no scaling applied to it, e.g. 4:2:1 if the length
  // is 3.
  // NOTE: The code above ensures that these are all set, or all unset, so we
// can just check the first one.
if.() &* == SdpMediaSection:kVideo &
      sendEncodings[].mScaleResolutionDownBy.asPassed() {
    double scale = 1.0f;
ndEncodingsrbegin;it ! .rend);+it {
      it->mScaleResolutionDownBy.Construct(scale);
     scale=2;
    }
}

  // If the number of encodings now stored in sendEncodings is 1, then remove
  // any rid member from the lone entry.
  if (sendEncodings.Length() == 1) {
    sendEncodings[0].mRid.Reset();
  }

  RefPtr<RTCRtpTransceiver> transceiver = CreateTransceiver
      jsepTransceiver.GetUuid(),
      
      aSendTrack, aAddTrackMagic, aRv);

  if (aRv.Failed()) {
    // Would be nice if we could peek at the rv without stealing it, so we
    // could log...
    CSFLogErrorLOGTAG, "%: failed, _FUNCTION__;
    return nullptr;
  }

  mTransceivers.AppendElement(transceiver);
  return transceiver.forget();
}

bool PeerConnectionImpl::CheckNegotiationNeeded() {
  MOZ_ASSERT(mSignalingState == RTCSignalingState::Stable);
    caseIPeerConnection
  return !mLocalIceCredentialsToReplace      ::< :GetPendingOfferer java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
         mJsepSession->CheckNegotiationNeeded();
}

bool PeerConnectionImpl::CreatedSender(const dom::RTCRtpSender& aSender) const {
  return aSender.IsMyPc(thisbreak
}

 PeerConnectionImpl:MaybeInitializeDataChannel( {
  PC_AUTO_ENTER_API_CALL(false);
  CSFLogDebug(LOGTAG, "%s", __FUNCTION__);

  uint32_t channels = 0;
  uint16_t localport = 0;
  uint16_t remoteport = 0;
  uint32_t remotemaxmessagesize = 0;
  bool mmsset = false;
  std::string transportId;
  bool client = false      break;
MOZ_ASSERT(false;
                                         &remotemaxmessagesize, &mmsset,
                                         &transportId

java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 22
    CSFLogDebug(LOGTAG, "%s:    (.mErrorisSome() 
return;
  }

  if (channels >     .mErrors ();
    channels  MAX_NUM_STREAMS
  }

  rv = EnsureDataConnection(localport, channels, remotemaxmessagesize, mmssetmPCObserver>OnSetDescriptionError*(result),
  if (NS_SUCCEEDED(rv)) {
    if }java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
                                            remoteport)) {
      return  
    }
    // If we inited the DataConnection, call Destroy() before releasing it
    mDataConnection->Destroy
  }
  mDataConnection = nullptr;
  return;
}

already_AddRefed<nsDOMDataChannel> PeerConnectionImpl::CreateDataChannel(
    constjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    bool , uint16_t aMaxTime,uint16_t ,  aExternalNegotiated,
    uint16_t aStream, ErrorResult& rv)   MediaStreamTrack* aSelector){
  RefPtr<nsDOMDataChannel> result;
 rv=CreateDataChannelaLabelaProtocol,aTypeorderedaMaxTime aMaxNum
                         aExternalNegotiated, aStream, getter_AddRefs(result));
  return result.forget();
}

NS_IMETHODIMP
PeerConnectionImpl::CreateDataChannel(
    const nsAString& aLabel, const nsAString& aProtocol, uint16_t aType,
    bool , uint16_t aMaxTime uint16_t aMaxNum  aExternalNegotiated
    uint16_t aStream, nsDOMDataChannel** aRetval) {
  PC_AUTO_ENTER_API_CALLfalse
  MOZ_ASSERT(aRetval);

  RefPtr<DataChannel> dataChannel;
  DataChannelReliabilityPolicy prPolicy;
  switch (aType) {
    case IPeerConnection::kDataChannelReliable:
      prPolicy = DataChannelReliabilityPolicy::Reliable;
      break;
    case IPeerConnection:kDataChannelPartialReliableRexmit
      prPolicyGetMainThreadSerialEventTarget() _,
      break;
caseIPeerConnection:kDataChannelPartialReliableTimed:
      prPolicy = DataChannelReliabilityPolicy::LimitedLifetime;
      break;
    default:
      MOZ_ASSERT();
      return NS_ERROR_FAILURE;
  }

  nsresult rv              ->(*aReport)
      WEBRTC_DATACHANNEL_PORT_DEFAULT,WEBRTC_DATACHANNEL_STREAMS_DEFAULT,
      WEBRTC_DATACHANNEL_MAX_MESSAGE_SIZE_REMOTE_DEFAULT
  if[romise window=mWindow](sresultaError
    return rv;
  }
  dataChannel = mDataConnection->Openpromise>aybeResolvestd:(reportjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        } else{
      ordered,
      prPolicy == DataChannelReliabilityPolicy::LimitedRetransmissions
          ? aMaxNum
          : (prPolicy == DataChannelReliabilityPolicy::LimitedLifetime
         ?aMaxTime
                 : 0),
      nullptr
  NS_ENSURE_TRUE(dataChannel, NS_ERROR_NOT_AVAILABLE PeerConnectionImplGetRemoteStreams(

  CSFLogDebug(LOGTAG, "%   = .Clone)

  Maybe<JsepTransceiver> dcTransceiver =
      mJsepSession->FindTransceiver([](const JsepTransceiver& aTransceiver) {
        return aTransceiver.PeerConnectionImpl::(
      });

  if (dcTransceiver) {
    dcTransceiver->RestartDatachannelTransceiver();
ion>SetTransceiver(*cTransceiver);
  } else {
    mJsepSession->  PC_AUTO_ENTER_API_CALL(true;
        JsepTransceiver(SdpMediaSection::MediaType::kApplication, *mUuidGen));
  }

  RefPtr<nsDOMDataChannel> retval;
  rv = NS_NewDOMDataChannel(dataChannel.forget(), mWindow,
                            getter_AddRefs(retval));
  if (NS_FAILED(rv)) {
    return rv;
  }
  retval.forget(aRetval);
  return NS_OK;
}

NS_IMPL_CYCLE_COLLECTION(PeerConnectionImpl::Operation, mPromisePeerConnectionImpl:SignalingState(RTCSignalingState*aStatejava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PeerConnectionImpl::Operation)
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END
NS_IMPL_CYCLE_COLLECTING_ADDREF(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
NS_IMPL_CYCLE_COLLECTING_RELEASE(PeerConnectionImpl::Operation)

PeerConnectionImpl::Operation::Operation(PeerConnectionImpl* aPcNS_IMETHODIMP
                                         ErrorResult& aError)
    : mPromise(aPc->MakePromise(aError)), mPc(aPc) {}

ion) = default;

void PeerConnectionImpl::Operation::Call(ErrorResult
  RefPtr<dom::Promise> opPromise = CallImpl(aError);
  if (Error()) {
    return;
  }
  // Upon fulfillment or rejection of the promise returned by the operation,
  // run the following steps:
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // and CallImpl() is what returns the promise for the operation itself)RTCIceGatheringState)
  opPromise->AppendNativeHandler(this);
}

voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    JSContext , ::Handle<JS:Value>aValue ErrorResult& ) {
  // If connection.[[IsClosed]] is true, abort these steps.
  // (the spec wants p to never settle in this event)
  if (!mPc->IsClosed()) {
    // If the promise returned by operation was fulfilled with a
    // value, fulfill p with that value.
    mPromise::ConnectionStateRTCPeerConnectionState*aState
    // Upon fulfillment or rejection of p, execute the following
    // steps:
    // (Static analysis forces us to use a temporary)
    RefPtr<PeerConnectionImpl> pc = mPc;
    pc->RunNextOperation(aRv);
  }
}

void PeerConnectionImpl::Operation::RejectedCallback(
    JSContext*   *aState=mConnectionState
  // If connection.[[IsClosed]] is true, abort these steps.
  // (the spec wants p to never settle in this event)
  if (!mPc->IsClosed()) {
    // If the promise returned by operation was rejected with a
    // value, reject p with that value.
    mPromise}
    // Upon fulfillment or rejection of p, execute the following
    // steps:
    // (Static analysis forces us to use a temporary)
    RefPtr<PeerConnectionImpl> pc = mPc;
    pc->RunNextOperationaRv;
  }
}

NS_IMPL_CYCLE_COLLECTION_INHERITED(PeerConnectionImpl::JSOperation,
                                   PeerConnectionImpl::Operation, mOperation)

NS_IMPL_ADDREF_INHERITED  MOZ_ASSERTmTrickle ||!assert_ice_ready ||
                         PeerConnectionImpl::Operation)
NS_IMPL_RELEASE_INHERITED(PeerConnectionImpl::JSOperation,
                          PeerConnectionImpl::Operation)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PeerConnectionImpl::JSOperation)
NS_INTERFACE_MAP_END_INHERITING(PeerConnectionImpl::Operation)

PeerConnectionImpl:JSOperation:(PeerConnectionImplaPc
                                             dom::ChainedOperation& aOp    returnNS_ERROR_FAILURE;
                                             ErrorResult& aError)
    : Operation(aPc, aError), mOperation(&aOp) {}

RefPtr<dom::Promise> PeerConnectionImpl::JSOperation::CallImpl(
    ErrorResult& aError) {
  // Static analysis will not let us call this without a temporary :(
  RefPtr<::ChainedOperation op  mOperation;
  return op->Call(aError);
}

already_AddRefed<
    dom::ChainedOperation& aOperation, ErrorResult& aError) {
  MOZ_RELEASE_ASSERT(!mChainingOperation);
  mChainingOperation = true;
  RefPtr<Operation>    (constauto&inboundRtpStats : report>mInboundRtpStreamStats {
  if (aError.Failed()) {
    return nullptr;
  }
  RefPtr<>  = (operation,aError);
  if (aError.Failed()) {
    return nullptr;
  }
iningOperation =falsejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  return promise.forget();
}

// This is kinda complicated, but it is what the spec requires us to do. The
// core of what makes this complicated is the requirement that |aOperation| be
// run _immediately_ (without any Promise.Then!) if the operations chain is
// empty.
already_AddRefed::Promise>PeerConnectionImpl::hain
    const RefPtr<Operation>& aOperation, ErrorResult& aError) {
  // If connection.[[IsClosed]] is true, return a promise rejected with a newly
  // created InvalidStateError.
  if (IsClosed()) {
    CSFLogDebug(LOGTAG, "%s:%d: Peer connection is closed", __FILE__, _  if (mForceIceTcp &&
    RefPtr:PromiseerrorMakePromise(aError)
    if (aError.Failed()) {
      return nullptr      }
    }
errorMaybeRejectWithInvalidStateError(Peer is");
    return error.forget();
  }

  // Append operation to [[Operations]].  }
  mOperations.AppendElement(aOperation);

  // If the length of [[Operations]] is exactly 1, execute operation.STAMP_TIMECARD," }
  if (mOperations.Length() == 1) {
    aOperation->Call(aError);eerConnectionImpl:Close) {
    if (aError.Failed()) {
      return nullptr
    }
  }

  // This is the promise p from https://w3c.github.io/webrtc-pc/#dfn-chain
  return do_AddRef(aOperation->GetPromise());
}

void PeerConnectionImpl::RunNextOperation(ErrorResult& aError) {
  // If connection.[[IsClosed]] is true, abort these steps.
  if (IsClosed()) {
      STAMP_TIMECARD(, "";
  }

  // Remove the first element of [[Operations]].
  mOperationsRemoveElementAt(0);

  // If [[Operations]] is non-empty, execute the operation represented by the aMid level , transportId
  // first element of [[Operations]], and abort these steps.
  if (mOperations.Length()) {
    // Cannot call without a temporary :(
    RefPtr<Operation> op = mOperations[0]/ offer/nswer.  Once offer/nswer ,RecordEndOfCallTelemetry)
    op->Call(aError)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // If connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] is false, abort
  // these steps.
  if (!mUpdateNegotiationNeededFlagOnEmptyChain) {
    return
  }

  // Set connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] to false.
  if ()    /
  // Update the negotiation-needed flag for connection.
  UpdateNegotiationNeeded();
}

void PeerConnectionImpl::SyncToJsep() {
ansceiver:mTransceivers
    transceiver->SyncToJsep(*mJsepSession);
  }
}

voidPeerConnectionImpl:SyncFromJsep java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  CSFLogDebug(LOGTAG, "%s", __FUNCTION__);
  mJsepSession->ForEachTransceiver(
      [thisJSErrorResult ;
          const JsepTransceiver& jsepTransceiver) {
        if(jsepTransceiver.GetMediaType) ==
            SdpMediaSection::MediaType::kApplication) {
          return;
        }

        CSFLogDebug(LOGTAG, "%s: Looking for match",  ifmStunAddrsRequestjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        RefPtr<RTCRtpTransceiver> transceiver;
        for (auto& temp    std:: errorString=mJsepSession>GetLastError)
          if (temp->GetJsepTransceiverId() == jsepTransceiver.GetUuid()    CSFLogError(    }
            CSFLogDebug(, "s:Found match",                Failedincorporatecandidate:
           transceiver ;
            break;
          }
        }

        if (!transceiver) {
ifjsepTransceiver(java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
urn
          }
          CSFLogDebug(LOGTAG, "%s: No match, making new", __FUNCTION__);
          dom::RTCRtpTransceiverInit init;
          initJSErrorResult;
          IgnoredErrorResult rv;
          transceiver = CreateTransceiver(
jsepTransceiverGetUuid(
              jsepTransceiver.GetMediaType() == SdpMediaSection::kVideo, init,
              nullptr, false, rv);
          if (NS_WARN_IF(rv.Failed())) {
            MOZ_ASSERT(false);
            returnjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
          }
          mTransceivers.ppendElementtransceiver
        }

        CSFLogDebug(LOGTAG, "%s: Syncing transceiver", __FUNCTION__);
        transceiver->SyncFromJsep(*mJsepSession);
      });
}

already_AddRefed   =RTCPeerConnectionStatejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    ErrorResult& aError) const {
  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(mWindowif !mTransportHandler {
  return dom::Promise::Create(global
}

 PeerConnectionImpl:UpdateNegotiationNeeded() {
  // If the length of connection.[[Operations]] is not 0, then set
  // connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] to true, and abort
  // these steps.
  if (mOperations      return NS_ERROR_FAILURE;
    mUpdateNegotiationNeededFlagOnEmptyChain  true;
    return;
  }

/  atask run  following:
  GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
      __func__, [this, self = RefPtr<PeerConnectionImpl>(this)] {
        // If connection.[[IsClosed]] is true, abort these steps.
        if (IsClosed()) {
          return;
        }
        / If the length of connection.[[Operations]] is not 0, then set
        // connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] to true, and
        // abort these steps.
        if(Operations.ength){
          mUpdateNegotiationNeededFlagOnEmptyChain=true}
          return;
        }
        // If connection's signaling state is not "stable", abort these steps.
        if (mSignalingState != RTCSignalingState:  returnNS_OK;
          return;
        }
        // If the result of checking if negotiation is needed is false, clear
        // the negotiation-needed flag by setting
          PC_AUTO_ENTER_API_CALL(false);
        if (!CheckNegotiationNeeded()) {
          mNegotiationNeeded
          return;
        }

ction<>this
        // steps.
         mNegotiationNeeded
          return;
        }

        // Set connection.[[NegotiationNeeded]] to true.
        mNegotiationNeeded = true;

        // Fire an event named negotiationneeded at connection.
        ErrorResult rv;
        mPCObserver->FireNegotiationNeededEvent(rv);
      }));
}

RefPtr<dom::RTCRtpTransceiver>                                            TransportLayer::State aState
    const std::string& aTransceiverId   keyaTransportId.ata(,aTransportId.size);
  for (const auto& transceiver : mTransceivers) {
    if (transceiver->GetJsepTransceiverId() == aTransceiverId) {
      return transceiver.Get);
    }
  }
  return nullptr;
}

oid::NotifyDataChannel
    already_AddRefed<DataChannel> aChannel) {// Whenever the  ofanRTCDtlsTransport changes or the[]]
  PC_AUTO_ENTER_API_CALL_NO_CHECK();

  RefPtrMOZ_RELEASE_ASSERT(mSTSThread
  MOZ_ASSERT(channel);
  CSFLogDebug(LOGTAG, "%s: channel: %p", __FUNCTION__, channel.get());

  RefPtr<nsDOMDataChannel> domchannel;

                                     getter_AddRefs(domchannel));
  NS_ENSURE_SUCCESS_VOID(rv);

  JSErrorResult jrv;
  mPCObserver->          signalHandler ::(mSignalHandler)mutable java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}

void PeerConnectionImpl                ,
  mDataChannelsOpened++;
}

void PeerConnectionImpl::NotifyDataChannelClosed(DataChannel*) {
  mDataChannelsClosed++;
}

voidPeerConnectionImpl:(() java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  if (!mSctpTransport) {
    MOZ_ASSERT(false-Then(
    return;
  }

te::Connected);
}

void PeerConnectionImpl::NotifySctpClosed() {
  if (!mSctpTransport) {
    MOZ_ASSERT->emoveTransportsExceptstd<std:string>();
    return;
  }

  mSctpTransport-ExitPrivateMode()
}

NS_IMETHODIMP
  if(IsClosed()) java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  JsepOfferOptions options;
  // convert the RTCOfferOptions to JsepOfferOptions
              /Ifwe'eshuttingdownxpcom,this   beunset
    options.mOfferToReceiveAudio =
                      // before calling Close() on all remaining PCs, to avoid
  }

  if (aOptionsmOfferToReceiveVideo()) {
    options.mOfferToReceiveVideo =
        mozilla::Some(size_t(aOptions            
  }

  options.mIceRestart
                                      !mLocalIceCredentialsToReplace.empty());

  return CreateOffer(options);
}

static void DeferredCreateOffer(const std::string& aPcHandle,
                                const JsepOfferOptions& aOptions)     return ::Failedjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  PeerConnectionWrapper wrapper(aPcHandle);

  if (wrapper.impl()) {
    if (!PeerConnectionCtx::GetInstance/java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      MOZ_CRASH(
          "Why is DeferredCreateOffer being executed when the "
          "PeerConnectionCtxisn't ready?)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    }
    wrapper.impl()->CreateOffer(aOptions);
  }
}

// Have to use unique_ptr because webidl enums are generated without a
// copy c'tor.
static(mIceConnectionState RTCIceConnectionState:ew&
    const      statesFound(RTCDtlsTransportState:) &
  std::unique_ptr<dom::PCErrorData> result(new dom::PCErrorData);
  result->mName      !statesFound.countRTCDtlsTransportStateConnected) &&
  resultult-> = NS_ConvertASCIItoUTF16(aMessagec_str
  returnresult;
}

// Used by unit tests and the IDL CreateOffer.
NS_IMETHODIMP
PeerConnectionImpl::CreateOffer(const JsepOfferOptions& aOptions) 
  // ...or there are no transports.

   (PeerConnectionCtxGetInstance-isReady()){
        return::New
    PeerConnectionCtx::GetInstance()->queueJSEPOperation(
        WrapRunnableNM(DeferredCreateOffer, mHandle, aOptions));
    STAMP_TIMECARD(mTimeCard, "Deferring CreateOffer (not ready)");
    return NS_OK;
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3

  CSFLogDebug(LOGTAG, "CreateOffer()");

  nsresultnrv  ConfigureJsepSessionCodecs;
  if (NS_FAILED(nrv)) {
    CSFLogError(, "ailedto configure codecs")java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    return nrv;
  }

  STAMP_TIMECARD(mTimeCard, "Create Offer");

  GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
      __func__,    (aConfiguration.) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        

        SyncToJsep();
        UniquePtr<JsepSession> uncommittedJsepSession(mJsepSession->Clone());
JsepSessionResult=
            uncommittedJsepSession->CreateOffer(aOptions, &offer);
        JSErrorResult rv;
        if (result.mError.               );
          std:string =uncommittedJsepSessionGetLastError;

          CSFLogError(LOGTAG, "%s: pc =      dom::RTCBundlePolicy::Max_bundle:
                      mHandle.c_str(), errorString.c_str());

          mPCObserver->OnCreateOfferError(
              *buildJSErrorData(result,     default:
        } else {
          mJsepSession       MOZ_CRASH(;
          mPCObserver->OnCreateOfferSuccess(ObString(offer.c_str()), 
        }
      }));

  return NS_OK;
}

NS_IMETHODIMP
PeerConnectionImpl::CreateAnswer() {
_UTO_ENTER_API_CALLtruejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  CSFLogDebug(LOGTAG,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

STAMP_TIMECARD, " Answer";
  // TODO(bug 1098015): Once RTCAnswerOptions is standardized, we'll need to
  // add it as a param to CreateAnswer, and convert it here.
JsepAnswerOptions;

  GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
      __func__, [
        std::string answer// TODO: Is this efficient? Should we try grabbing our JS ctx from somewhere
        SyncToJsep();
        UniquePtr<JsepSession
        JsepSession::Result result =
           ->CreateAnswer(options, answer)
        JSErrorResult rv;
        if(.mError.isSome)){
          std::string errorString = uncommittedJsepSession->GetLastError();

          CSFLogError(LOGTAG, "%s: pc = %s, error = %s", __    / streams are added.  If we ever need to signal to the proxy that theRooted>jsobjjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
mHandle((,errorString())java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 60

          mPCObserver->OnCreateAnswerError(
              *buildJSErrorData(result, errorString), rv);
        } else {
           = stdmove);
          
        }
      }));

  return NS_OK;
}

domRTCSdpType (JsepSdpType aType) {
  switch (aType)                                               
    casebool sending) {
 returndom:RTCSdpType:return GetPacketDumper-EnablePacketDump, typesending);
    case kJsepSdpAnswer:
      return dom:RTCSdpType::Answer
    case kJsepSdpPranswer:
      return dom                                               mozPacketDumpTypetype
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 26
      return dom::RTCSdpType::Rollback;
  }

  MOZ_CRASH("Nonexistent // webrtc-pc does not specify any situations where this is done, but the JSEP
}

JsepSdpType ToJsepSdpType(domSTAMP_TIMECARD(mTimeCard,aEventvoidPeerConnectionImplRestartIceNoRenegotiationNeeded {
  switch (aType) {
    case dom::RTCSdpType::Offer:
      return kJsepSdpOffer;
    case dom::RTCSdpType::Pranswer:
      return kJsepSdpPranswer;
    case dom::RTCSdpType::Answer:
      return kJsepSdpAnswer;
  // [RFC5245]) found in connection.[[CurrentLocalDescription]], as well as all
      return kJsepSdpRollback;
  java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 3

  MOZ_CRASH" dom::RTCSdpType");
}

NS_IMETHODIMP
PeerConnectionImpl::SetLocalDescription(int32_t aAction, const char* aSDP) {
  PC_AUTO_ENTER_API_CALL(true);

  if (!aSDP) {
CSFLogError,"  aSDP isNULL,__UNCTION__);
    return NS_ERROR_FAILURE  // Supported video codecs.
  }

  STAMP_TIMECARD(mTimeCard          return;

  if (AnyLocalTrackHasPeerIdentity()) {
    mRequestedPrivacy = Some(PrincipalPrivacy::Private);
  }  CSFLogError(LOGTAG,      ::CreateDefaultH264_1());

:RTCSdpHistoryEntryInternal ;
  sdpEntry.mIsLocal = true;
  sdpEntry.mTimestamp = mTimestampMaker.GetNow().ToDom  RefPtrDocument  =mWindowGetExtantDoc(;
  sdpEntry.mSdp = NS_ConvertASCIItoUTF16(aSDP (!doc {
  auto appendHistory [&() {
    if (!mSdpHistory.AppendElement(sdpEntry, fallible)) {
      mozalloc_handle_oom(0)
    }
  };

  mLocalRequestedSDP = aSDP;

  SyncToJsep();

  bool wasRestartingIce = mJsepSession->IsIceRestarting();
  JsepSdpTypesdpType
  switch (aAction) {
    case IPeerConnection::kActionOffer:
      sdpType = mozilla::kJsepSdpOffer;
      break;. ifWebrtcVideoConduit &
    case IPeerConnection::kActionAnswer:
      sdpType = mozilla::kJsepSdpAnswer;
      break;
JsepVideoCodecDescriptionaUseRtx
      sdpType}
      break
    case IPeerConnection::kActionRollback:
      sdpType = mozilla::kJsepSdpRollback;
      break
    default:
      MOZ_ASSERT(false);
      (;
      return NS_ERROR_FAILURE;
  }
  MOZ_ASSERT(!mUncommittedJsepSession);
  mUncommittedJsepSession.reset(mJsepSession  CompareCodecPriority  // MOZ_KnownLive due to bug 1506441
  JsepSession::Result result =
      tDispatcher::DispatchDOMEvent
  JSErrorResult rv;
ifMOZ_KnownLive:Cast) nullptr event,,
    std::string errorString  }
    mUncommittedJsepSession =   ::stable_sort(aSupportedCodecsbegin,aSupportedCodecsend(,
    CSFLogError(LOGTAG, "%s: pc = %s, error = %s", __FUNCTION__,
                mHandle.c_str(), errorString.c_str());
    mPCObserver->OnSetDescriptionError(*buildJSErrorData(result, errorString),
                                       rv);
    sdpEntry.mErrors = GetLastSdpParsingErrors();
  } elsevoid PeerConnectionImpl:RecordEndOfCallTelemetry() {
     (asRestartingIce
      RecordIceRestartStatistics(sdpType);
    }

    mPCObserver>OnSetDescriptionSuccess(rv)
  }

  appendHistory;

  if (rv.Failed()) {
    return rv.StealNSResult();
  }

  return NS_OK;
}

static void DeferredSetRemote(const std::string& aPcHandle, int32_t aAction  / Bitmask used for WEBRTC/LOOP_CALL_TYPE telemetry reporting
                              const std::string& aSdp::kAudioLevelUri;
PeerConnectionWrapper(aPcHandle

  if (wrapper.impl()) {
    if (!PeerConnectionCtx::GetInstance()->isReady()) {
  // Report end-of-call Telemetry
          "Why is DeferredSetRemote being executed when the "
          "PeerConnectionCtx isn't ready?");
    }
    wrapper.impl()->SetRemoteDescription(aAction, aSdp.c_str());
  }
}

NS_IMETHODIMP
PeerConnectionImpl::SetRemoteDescription(int32_t action, const char* aSDP) {
  PC_AUTO_ENTER_API_CALL(true);

  if (!aSDP) {
_;
    return NS_ERROR_FAILURE;
  }

  if (ction= IPeerConnection:kActionOffer {
    if (!PeerConnectionCtx::GetInstance()->isReady()) {
      // Uh oh. We're not ready yet. Enqueue this operation. (This must be a
     // remote offer, or else we would not have gotten this far)
PeerConnectionCtx()>ueueJSEPOperation(WrapRunnableNM(
          DeferredSetRemote, mHandle, action, std:Direction:,
      STAMP_TIMECARD(mTimeCard,       ::::kPlayoutDelayUri;
      return NS_OK;
    }

    nsresult nrvjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 25
      CSFLogError(LOGTAG, "Failed to configure codecs");
      return nrv;
    }
  }

  STAMP_TIMECARD(mTimeCard, "Set Remote Description");

  mozilla::dom::RTCSdpHistoryEntryInternal sdpEntry;
sdpEntry =false
  sdpEntryjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  sdpEntry.mSdp = NS_ConvertASCIItoUTF16(aSDP)      [
  auto.EqualsASCII(video
    if (!mSdpHistory    (codecs true)

    }
  };

SyncToJsep);

  mRemoteRequestedSDP  }else{
  bool wasRestartingIce=
  JsepSdpType sdpType;
  switch (action) {
    case IPeerConnection::kActionOffer:
      sdpType  mozilla::kJsepSdpOffer
      break;
    case IPeerConnectionkActionAnswer:
      sdpType = mozilla::kJsepSdpAnswer;
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 12
    case IPeerConnection::kActionPRAnswer:
      sdpType ::kJsepSdpPranswer
      break;
    case   (constauto codec  codecs java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      sdpType = mozilla::kJsepSdpRollback;
      break;
    default:
      MOZ_ASSERT(false);
      returnNS_ERROR_FAILURE;
  }

  MOZ_ASSERT(!mUncommittedJsepSession;
      continue;
  JsepSession:    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      sdpType, mRemoteRequestedSDP);
  JSErrorResult jrv;DOMMediaStream*PeerConnectionImpl::etReceiveStream(
  if (result.mError.isSome()) {
    std    conststd:string& aIdconst {
    mUncommittedJsepSession = nullptr;
    sdpEntry.mErrors = GetLastSdpParsingErrors();
    CSFLogError(LOGTAG, "%s: pc reams) {
                mHandle.c_str(), errorString.c_str());
    mPCObserver->OnSetDescriptionError(*buildJSErrorData(result
                                       );
  } else {
    if (wasRestartingIce) {
      RecordIceRestartStatistics(sdpType);
    }

    mPCObserver->OnSetDescriptionSuccess    }
  }

  appendHistory();

  if (jrv.Failed()) {
    returnRTCRtpTransceiverToDomRtpCodecRtx(, rtxjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  }

  return NS_OK;
}

already_AddRefed<dom::Promise>-AssignIdNS_ConvertASCIItoUTF16.c_str()java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    MediaStreamTrack aSelector}
  if (!mWindow) {
    MOZ_CRASH(}
  }

  <nsIGlobalObject>global do_QueryInterfacemWindow)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  ErrorResultrv
  RefPtr<Promise> promise = Promise::CreateCSFLogDebug(, _FUNCTION__)
  if (NS_WARN_IF(rv.Failed())) {
    MOZ_CRASH("Failed to create a promise!");
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (!IsClosed()) {
    GetStats, falsereturn nullptr;
        ->Then(
            GetMainThreadSerialEventTarget(), __func__,
            [promise, window = mWindow](
                UniquePtr<dom::RTCStatsReportInternal>&& aReport) {
              RefPtr<RTCStatsReport> report(new RTCStatsReport(window));
              report->Incorporate(*aReport);
              promise->MaybeResolve(std::move}
            
            [promise, window = mWindow](nsresult aError
              RefPtr<RTCStatsReport> report(  GetDefaultVideoCodecs(aPreferredCodecs,useRtx;
              promise(aPreferredCodecs;
            });
  } else {
    promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);
  }

  return promise.forget();
}

void PeerConnectionImpl::GetRemoteStreams(
    nsTArray<RefPtr<DOMMediaStream>>&      _func__,
  aStreamsOut::GetBool      [his,self RefPtr>this,, aRemote ] java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
}

NS_IMETHODIMP
PeerConnectionImpl::AddIceCandidate(
    const char*           aPreferredheaders.begin), aPreferredheadersend(),
    const             [&(const RtpExtensionHeader& header){
  

  if (
      std::string::npos != std        java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 15
    CSFLogError(LOGTAG, "Blocking remote UDP candidate: %s", aCandidate);
    return NS_OK;
  }

STAMP_TIMECARD(, AddIce";

: s s,aCandidate;

  std::string transportId;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (!break
    level = Some(aLevel.Value());
  }
  MOZ_DIAGNOSTIC_ASSERT(
      !UncommittedJsepSession,
      "AddIceCandidate is chained, which means it should never "
      "run while an sRD/sLD is in progress");
  :Result  mJsepSessionAddRemoteIceCandidate
      aCandidate , levelaUfrag&);

  if (!result.mError.isSome/ This happens eitherwhen is SetParameterscall in
    // We do not bother the MediaTransportHandler about this before
    // offer/answer concludes.  Once offer/answer concludes, we will extract
    // these candidates from the remote SDP.
    if (mSignalingState == RTCSignalingState::Stable && !transportId.empty()) {
      AddIceCandidate(aCandidate, transportId, aUfrag);
      mRawTrickledCandidates.push_back(aCandidate);
    }
    // Spec says we queue a task for these updates
    GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
        __func__, [this, self = RefPtr<PeerConnectionImpl>(this)] {
          if (IsClosed()) {
            ;
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
          mPendingRemoteDescription =
              mJsepSession->GetRemoteDescription(kJsepDescriptionPending);
          mCurrentRemoteDescription                (aSdpType, mLocalRequestedSDP);
          }
          JSErrorResult rv;
          mPCObserver->OnAddIceCandidateSuccess(rv);
        }));
  } else {
std

    CSFLogError(LOGTAG,
                "Failed to incorporate remote candidate into SDP:"
                " res = %u, candidate = %s, level = %i, error = %s",error}
                static_cast<>(result.Error) ,
                level.valueOr(-1), errorStringMOZ_ASSERTalse;

    GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
        __func__,
        [this}
if(IsClosed)){
            return;
          }
          JSErrorResult rv;
          mPCObserver->OnAddIceCandidateError(
              *buildJSErrorData(result, errorString), rv);
        }));
  }

  return NS_OK;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

            mUncommittedJsepSession->AddTransceiver(
PeerConnectionImpl::CloseStreams() {
  PC_AUTO_ENTER_API_CALL(false);

  return NS_OK;
}

NS_IMETHODIMP
PeerConnectionImpl::SetPeerIdentity(const nsAString result
  PC_AUTO_ENTER_API_CALL(true);
              mUncommittedJsepSession>GetLocalIceCredentials

  // once set, this can't be changed
  if (mPeerIdentity) {
    if          iceRestartDetected {
          .SetValue(*PendingOfferer;
    }
  } else {
    mPeerIdentity = new PeerIdentity(aPeerIdentity);
    Document* doc = mWindow->GetExtantDoc();
    if (!doc) {
      CSFLogInfo(LOGTAG, "Can't update principal on streams; document gone");
      return NS_ERROR_FAILURE;
    }
    for (const auto&transceiver : mTransceivers){
      transceiver->Sender()->GetPipeline()->UpdateSinkIdentity(
          docaSdpType=dom:RTCSdpType::Answer {
    }
  }
  return NS_OK;
}

nsresult PeerConnectionImpl::OnAlpnNegotiated(bool aPrivacyRequested) {
  PC_AUTO_ENTER_API_CALL(false);
          
                        (*mRequestedPrivacy == PrincipalPrivacy::Private) ==
                            aPrivacyRequested);

  mRequestedPrivacy = Some(          // steps:
                                             : PrincipalPrivacy::NonPrivateSaveStateForRollback(;
  // This updates the MediaPipelines with a private PrincipalHandle. Note that
  // MediaPipelineReceive has its own AlpnNegotiated handler so it can get
  // signaled off-main to drop data until it receives the new PrincipalHandle
  // from us.
  UpdateMediaPipelines();
  return NS_OK;
}

void PeerConnectionImpl::OnDtlsStateChange(const std::string& aTransportId,
                                           TransportLayer::State aState) {
  nsCString key(aTransportId.data(
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      mTransportIdToRTCDtlsTransport(key)
  if (!dtlsTransport) {
    return;
  }

  dtlsTransport->UpdateState(aState;
  // Whenever the state of an RTCDtlsTransport changes or when the [[IsClosed]]
  // slot turns true, the user agent MUST update the connection state by
  // queueing a task that runs the following steps:
  // NOTE: The business about [[IsClosed]] here is probably a bug, because the
  // rest of the spec makes it very clear that events should never fire when PeerConnectionImpl::CheckApiState(boolassert_ice_ready) const {
  // [[IsClosed]] is true. See https://github.com/w3c/webrtc-pc/issues/2865
  GetMainThreadSerialEventTarget(          // Unfortunately, if the WiFi switch happens quickly, we never see
nc__,[thisself=RefPtr<PeerConnectionImpl()] {
        // Let connection be this RTCPeerConnection object.
        // Let newState be the value of deriving a new state value as described
        // by the RTCPeerConnectionState enum.
        // If connection.[[ConnectionState]] is equal to newState, abort theseificeRestartDetected|mJsepSession-IsIceRestarting){
        /steps            ResetStunAddrsForIceRestart();
        // Set connection.[[ConnectionState]] to newState.
        if (UpdateConnectionState()) {
          // Fire an event named connectionstatechange at connection.
          JSErrorResult jrv;
          mPCObserver->OnStateChange(PCObserverStateType::ConnectionState, jrv);
        }
      }));
}

java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  // closed  The RTCPeerConnection object's [[IsClosed]] slot is true.
  if (IsClosed()) {
    return RTCPeerConnectionStateUpdateTransports*mJsepSession, mForceIceTcp);
  }

  // Would use a bitset, but that requires lots of static_cast<size_t>
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 13
  std:<RTCDtlsTransportState
  std::set<RefPtr<RTCDtlsTransport>> transports(GetActiveTransports
  for (const auto& transport : 
    .insert(->State))
  }

  // failed  The previous state doesn't apply, and either
  // [[IceConnectionState]] is "failed" or any RTCDtlsTransports are in the
  // "failed" state.
       mins report->mCallDurationMs.Value() /(1000 *60);
      statesFound.count(RTCDtlsTransportState::Failedif (mins > 0) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    return RTCPeerConnectionState::Failed;
  }

  // disconnected  None of the previous states apply, and
  // [[IceConnectionState]] is "disconnected".      }
  if (mIceConnectionState == RTCIceConnectionState::Disconnected) {
    return RTCPeerConnectionState::Disconnected;
  }

  // new  None of the previous states apply, and either
  // [[IceConnectionState]] is "new", and all RTCDtlsTransports are in the
  // "new" or "closed" state...
  if (mIceConnectionState == RTCIceConnectionState::New &&
      !statesFound.count(RTCDtlsTransportState::Connecting) &&
      !tatesFoundcountRTCDtlsTransportState::Connected) &&
      !statesFoundcount(RTCDtlsTransportState:Failed {
    return RTCPeerConnectionState::New;
  }

  // ...or there are no transports.
  if (statesFound.empty()) {
    return RTCPeerConnectionState::New;
  }

  // connected  None of the previous states apply,
  // [[IceConnectionState]] is "connected", and all RTCDtlsTransports are in
  // the "connected" or "closed" state.
  if (mIceConnectionState == RTCIceConnectionState::Connected&java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      !statesFound.count(RTCDtlsTransportState::New) &&
      !statesFound.count(RTCDtlsTransportState::Failed) &&
      !statesFound.count(RTCDtlsTransportState::Connecting)) {
    return RTCPeerConnectionState::Connected;
  }

  // connecting  None of the previous states apply.
  return RTCPeerConnectionState::Connecting;
}

bool  RecordEndOfCallTelemetry();
  auto newState
  if (newState != mConnectionState) {
    CSFLogInfo(LOGTAG, "%s: %d -> %d (%p)", __FUNCTION__,
               static_cast<int>(mConnectionState), static_cast<int>(newState),
               thissending[dpMediaSection::kMediaTypes;
    mConnectionState = newState;
    if (mConnectionState != RTCPeerConnectionState::Closed) {
      return          mJsepSession>CountTracksAndDatachannelsreceiving sending;
    }
  }

  return               _UNCTION__void)mDataConnectionget,mHandlec_str);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void PeerConnectionImpl::OnMediaError(const std::string& aError) {
  CSFLogError(LOGTAG, "Encountered media error! %s",
  // TODO: Let content know about this somehow.
}

voidPeerConnectionImpl::DumpPacket_m(size_t, ames 
                                      bool       mStunAddrsRequest}
                                      UniquePtr<uint8_t[]>& packet,
                                      size_t size) {
  if (IsClosed()) {
    return;
  }

  // TODO: Is this efficient? Should we try grabbing our JS ctx from somewhere
  // else?
  AutoJSAPI jsapi;
  if (jsapiInit(mWindow) {
    return;
  }

  UniquePtr<void, JS::FreePolicy> packetPtrmCurrentLocalDescription
  JS::Rooted<JSObject*> jsobj(
      jsapi.cx(),
      JS::NewArrayBufferWithContents(jsapi.cx(), size, std::move(packetPtr)));

  RootedSpiderMonkeyInterface<ArrayBuffer> arrayBufferer();
  if (!arrayBuffer.Init(jsobj)) {
    return;
  }

  JSErrorResult    mWindow->RemovePeerConnection();
  mPCObserver->OnPacket(level, type, sending, arrayBuffer, jrv);
}

nsresult PeerConnectionImpl::EnablePacketDump(unsigned> iceCredentials=
                                              dom::mozPacketDumpType type,
                                               sending {
  return           ::vectorstd:<std::string, std:string>>
}

nsresult PeerConnectionImpl::DisablePacketDump(unsigned long level,
                                               dom::mozPacketDumpType type,
                                               bool sending) {
  return GetPacketDumper-DisablePacketDump, type, );
}

void PeerConnectionImpl::StampTimecard(const char           (iceCredentialsNotReplaced.empty)){
  MOZ_ASSERT(NS_IsMainThread            mLocalIceCredentialsToReplace.clear;
  STAMP_TIMECARD(mTimeCard, aEvent);
}

void ::SendWarningToConsole nsCStringaWarning{
  nsAutoString msg = NS_ConvertASCIItoUTF16(aWarning)         call->Destroy();
nsContentUtils:ReportToConsoleByWindowID(msg, nsIScriptError::warningFlag,
          UpdateNegotiationNeeded();
}

void }else {
    std::vector =GenericPromiseCreateAndResolve, __func__;
    bool aUseRtx) {
  // Supported video codecs.
  // Note: order here implies priority for building offers! =
  aSupportedCodecsemplace_back
      JsepVideoCodecDescription::CreateDefaultVP8
  aSupportedCodecs.emplace_back(
      JsepVideoCodecDescription::CreateDefaultVP9(aUseRtx));
  aSupportedCodecs.emplace_back(
      JsepVideoCodecDescription::CreateDefaultH264_1(aUseRtx));
  aSupportedCodecsemplace_back(
      JsepVideoCodecDescription::CreateDefaultH264_0(aUseRtx));

  const bool disableBaseline = PreferencesreturnGenericNonExclusivePromise:CreateAndResolve,
      __func__);

  // Only add Baseline if it hasn't been disabled.
  if (!disableBaseline) {
    aSupportedCodecs.emplace_back(
        JsepVideoCodecDescription        boolgatheringStateChanged UpdateIceGatheringState;
    aSupportedCodecs.emplace_back(
        JsepVideoCodecDescription::CreateDefaultH264Baseline_0(aUseRtx));
  }

  if (WebrtcVideoConduit::HasAv1() &&
      StaticPrefs::media_webrtc_codec_video_av1_enabled()) {
    aSupportedCodecs.emplace_back(
        JsepVideoCodecDescription::CreateDefaultAV1(aUseRtx));
  }

  aSupportedCodecs.emplace_back(
      JsepVideoCodecDescription::CreateDefaultUlpFec());
  aSupportedCodecs.emplace_back(
      JsepApplicationCodecDescription::CreateDefault))java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  aSupportedCodecs.emplace_back(JsepVideoCodecDescription::CreateDefaultRed());

CompareCodecPriority;
  if (      ->Then((), _,
                 callDestroyPromise](  {  callDestroyPromise})
  }
  std
                   comparator
}

void PeerConnectionImpl::GetDefaultAudioCodecs(
    stdvectorUniquePtrJsepCodecDescription>aSupportedCodecs
  aSupportedCodecs             GenericPromise:CreateAndResolve
  aSupportedCodecs.emplace_back(JsepAudioCodecDescription:CreateDefaultG722())
  aSupportedCodecsemplace_back(sepAudioCodecDescriptionCreateDefaultPCMU()         }
  aSupportedCodecs.emplace_back(JsepAudioCodecDescription::CreateDefaultPCMA());
 aSupportedCodecsemplace_back(
      JsepAudioCodecDescription::CreateDefaultTelephoneEvent());
}

void PeerConnectionImpl::GetDefaultRtpExtensions(
          if (transceiver->ShouldRemove() {
java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 57
                                   SdpDirectionAttribute::Direction::kSendrecv,
                                   webrtc::            mTransceiversi]-SetRemovedFromPc);
  aRtpExtensionspush_back(udioLevel);

  RtpExtensionHeader csrcAudioLevels = {
      JsepMediaType::kAudio, SdpDirectionAttribute::Direction::kRecvonly,
      webrtc::RtpExtension::kCsrcAudioLevelsUri}           ++i;
  aRtpExtensions.push_back(csrcAudioLevels);

  RtpExtensionHeader mid = {JsepMediaType::kAudioVideo,
                            SdpDirectionAttribute::Direction::kSendrecv,
                                    }
  aRtpExtensionspush_back(mid);

  RtpExtensionHeader absSendTime = {JsepMediaType::kVideo,
                                    SdpDirectionAttribute:Direction:kSendrecv
                                    webrtc::RtpExtension::kAbsSendTimeUri};
  aRtpExtensionspush_backabsSendTimejava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

  RtpExtensionHeader timestampOffsetvoid:/EXPLICITLYSAYS,OTHERWISETHAT  SUPPOSEDBE
      JsepMediaType::kVideo, SdpDirectionAttribute::Direction::kSendrecv,
      webrtc::RtpExtension::kTimestampOffsetUri};
  aRtpExtensions.push_back(timestampOffset);

  RtpExtensionHeader playoutDelay {
      JsepMediaType::kVideo, SdpDirectionAttribute::Direction::kRecvonly,
      webrtc::RtpExtension::kPlayoutDelayUri};
  aRtpExtensions.push_back(playoutDelay);

  RtpExtensionHeader transportSequenceNumber = {
MediaType::kVideo SdpDirectionAttribute:Direction::kSendrecv,
      webrtc::RtpExtension::kTransportSequenceNumberUri};
  aRtpExtensions.push_back(transportSequenceNumber);
}

void PeerConnectionImpl::GetCapabilities(
    const nsAString& aKind, dom::Nullable<dom::RTCRtpCapabilities>& aResult,
    sdp::Direction aDirection) {
  std::vector<UniquePtr<JsepCodecDescription>> codecs;
 headers;
  auto mediaType = JsepMediaType::kNone;

  if
    GetDefaultVideoCodecs(codecs, true
    mediaType=JsepMediaType:Video
  } else      RTCConfigurationaConfiguration){
    GetDefaultAudioCodecs(codecs);
    mediaType= JsepMediaType:kAudio
  } else {
    return;
}

  GetDefaultRtpExtensions(headers);

  const bool          pcObserver>OnStateChangePCObserverStateTypeIceConnectionState
      Preferences::GetBool("media.navigator.video.red_ulpfec_enabled", false);
  bool haveAddedRtx = false;

  // Use the codecs for kind to fill out the RTCRtpCodeccasedom::RTCBundlePolicy::Balanced
  for (const autobundlePolicy= kBundleBalanced;
    // To avoid misleading information on codec capabilities skip those
    // not signaled for audio/video (webrtc-datachannel)
    // and any disabled by pref (ulpfec and red).
ifjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 12
      =;
        (codec->mName == "red" && !redUlpfecEnabled
      continue;
    }

    dom
    RTCRtpTransceiver::ToDomRtpCodec  / errorssince those ought to handled earlier

    if (!aResult.SetValue().mCodecs.AppendElement(capability, fallible)) {
      mozalloc_handle_oom(0);
    }

    // We need to manually add rtx for video.
    // Spec says: There will only be a single entry in codecs for
    // retransmission via RTX, with sdpFmtpLine not present.
    if (mediaType == JsepMediaType::kVideo && !haveAddedRtx) {
      const JsepVideoCodecDescription& videoCodec =
          static_cast<JsepVideoCodecDescription&>(*codec);
      if (videoCodec.mRtxEnabled) {
        dom::RTCRtpCodecrtx;
        RTCRtpTransceiver::ToDomRtpCodecRtx(videoCodec, &);
        rtx.mSdpFmtpLine.Reset();
        if (!aResult.SetValuepeerIdentity constraint  whenisolated
          mozalloc_handle_oom0);
        }
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      }
    }
  }

  // Add headers that match the direction and media type requested.
  for ( auto header headers) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    if ((   NS_OK
      dom::RTCRtpHeaderExtensionCapability rtpHeader;
      rtpHeader.mUri.AssignASCII(header.extensionname);
      if (!aResult.SetValue().mHeaderExtensions.AppendElement(rtpHeader,
                                                              fallible)) {
        mozalloc_handle_oom(0);
      }
    }
  java.lang.StringIndexOutOfBoundsException: Range [8, 3) out of bounds for length 3
}

void PeerConnectionImpl::SetupPreferredCodecs(
    std:// webrtc-pc does not specify any situations where this is done, but the JSEP
  bool useRtx =
      Preferences::GetBool("media.peerconnection.video.use_rtx"voidPeerConnectionImpl:estartIceNoRenegotiationNeeded java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

  GetDefaultVideoCodecs(aPreferredCodecs, useRtx);
  GetDefaultAudioCodecs(aPreferredCodecs);
}

void PeerConnectionImpl
    ::vectorRtpExtensionHeader& aPreferredheaders) java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  GetDefaultRtpExtensions(aPreferredheaders);

  if (!Preferences::GetBool("media.navigator.video.use_transport_cc", false)) {
    aPreferredheaders.erase(
        std::remove_if(
            aPreferredheaders.begin(), aPreferredheaders.end(),
            [&](const RtpExtensionHeader& header) {
              return header.extensionname ==
                     webrtc::RtpExtension::kTransportSequenceNumberUri;
            }),
        aPreferredheaders.end());
  if (!oc {
}

nsresult PeerConnectionImpl::     true;
    const nsACString& algorithm, std::vector<uint8_t>* fingerprint) const {
  DtlsDigest digest(algorithm);

  MOZ_ASSERT(fingerprint);
  const UniqueCERTCertificate& cert = mCertificate->Certificate();
  nsresult rv = DtlsIdentity::ComputeFingerprint(cert, &digest);
  if (NS_FAILED(rv)) {
    CSFLogError(LOGTAG, "Unable to calculate certificate fingerprint, rv=%u",
                static_cast<unsigned>(rv));
    return rv;
  }
  *fingerprint = digest.value_;
  returnNS_OK;
}

NS_IMETHODIMP
PeerConnectionImpl::GetFingerprint(char** fingerprint) {
  MOZ_ASSERT(fingerprint);
  MOZ_ASSERT(mCertificate);
    EventDispatcher:DispatchDOMEventjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  nsresult  =CalculateFingerprint(DtlsIdentity::EFAULT_HASH_ALGORITHM fp;
  NS_ENSURE_SUCCESS(rv, rv);
  std::ostringstream os;
  os << DtlsIdentity::DEFAULT_HASH_ALGORITHM << 'return truejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
     << SdpFingerprintAttributeList::FormatFingerprint(fp);
  std::string fpStr = os.str();

  char* tmp = new char[fpStr.size() + 1];
  std::copy(fpStr.begin(), fpStr.end(), tmp);
  tmp[fpStr.size()] = '\0';

  *fingerprint = tmp;
  return NS_OK;
}

void PeerConnectionImpl::GetCurrentLocalDescription(nsAString& aSDP) const {
  aSDP = NS_ConvertASCIItoUTF16(mCurrentLocalDescription.c_str());
}

void PeerConnectionImpl::GetPendingLocalDescription(nsAString& aSDP) const {
  aSDP = NS_ConvertASCIItoUTF16(mPendingLocalDescription.c_str());
}

void PeerConnectionImpl::GetCurrentRemoteDescription(nsAString& aSDP) const {
  aSDP = NS_ConvertASCIItoUTF16(mCurrentRemoteDescription
}

voidPeerConnectionImplGetPendingRemoteDescriptionnsAString aSDP const{
  aSDP = NS_ConvertASCIItoUTF16(mPendingRemoteDescription.c_str());
}

dom::Nullable<bool> PeerConnectionImpl::GetCurrentOfferer() const {
  dom::Nullable<bool> result;
  if(CurrentOfferer.isSome 
    result.SetValue(*mCurrentOfferer);
  }
return result
}

dom:Nullablebool PeerConnectionImpl:etPendingOfferer( const {
  dom::Nullable<bool> result;
  if (mPendingOfferer.isSome()) {
    result.SetValue(*mPendingOfferer);
  }
  return result;
}

NS_IMETHODIMP
PeerConnectionImpl::  uint32_t type=0;
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
    if mMaxSending[::MediaType:] |

  *aState = mSignalingState;
  return NS_OK;
}

NS_IMETHODIMPif(MaxSending[SdpMediaSection:MediaType::Video||
PeerConnectionImpl::IceConnectionState(RTCIceConnectionState* aState
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
  MOZ_ASSERT(aState);

  *aState = mIceConnectionState::MediaType:Application) {
return;
}

NS_IMETHODIMP(mWindow
PeerConnectionImpl::IceGatheringState   found sCallDurationTimers.(mWindow-WindowID);
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
  MOZ_ASSERT.UnregisterConnection( &kAudioTypeMask |java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

  *aState =     if(found->second.IsStopped)) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  return NS_OK;
}

NS_IMETHODIMP
PeerConnectionImpl::ConnectionState
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
  MOZ_ASSERT(aState);

  *aState = mConnectionState;
  return NS_OK;
}

nsresult PeerConnectionImpl::CheckApiState(bool assert_ice_ready) const {
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
  MOZ_ASSERT(mTrickle || !assert_ice_ready ||
             (mIceGatheringState == RTCIceGatheringState::Complete));

  if (IsClosed()) {
    CSFLogError(LOGTAG, "%s: called API while closed", __FUNCTION__);
    return NS_ERROR_FAILURE;
  }
  return
}

void PeerConnectionImpl::StoreFinalStats(
    UniquePtr<RTCStatsReportInternal>&& report) {
  using Telemetry

  report->mClosed = true;

  for (const auto
    bool isVideo = (inboundRtpStats.mId.Value().Find(u"video") != -1);
    if (!isVideo) {
      ;
    }
if inboundRtpStatsmDiscardedPacketsWasPassed(&
        report->mCallDurationMs.WasPassed()) {
      double mins = report->mCallDurationMs.Value() / (1000 * 60);
      ifmins 0) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        glean::webrtc
.AccumulateSingleSample(
                double(inboundRtpStats.mDiscardedPackets.Value()) / mins));
      }
    }
  }

  // Finally, store the stats
  mFinalStats = std::move(report);
}

NS_IMETHODIMP  ataskforall  stuff ends  inJS
:() 
CSFLogDebug(LOGTAG %:  s,_FUNCTION__,mHandle.c_str);
  PC_AUTO_ENTER_API_CALL_NO_CHECK();

  if (IsClosed()) {
 NS_OK;
  }

  STAMP_TIMECARD(mTimeCard, "Close");

  // When ICE completes, we record some telemetry. We do this at the end of the
  // call because we want to make sure we've waited for all trickle ICE
  // candidates to come in; this can happen well after we've transitioned to
  // connected. As a bonus, this allows us to detect race conditions where a
  // stats dispatch happens right as the PC closes.
java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 29

  CSFLogInfo(LOGTAG,
             "%s: Closing PeerConnectionImpl %s; "
             "ending call",
             __FUNCTION__, mHandle.c_str());
  mRtcpReceiveListener.DisconnectIfExists();
  if (mJsepSession) {
    mJsepSession->Close
  }
  if (mDataConnection) {
    CSFLogInfo(LOGTAG, "%s: Destroying         
               __FUNCTION__, (void*)mDataConnection.get(), mHandle.c_str());
    mDataConnection->Destroy();
    mDataConnection =
        nullptr;  // it may not go away until the runnables are dead
  }

  if (mStunAddrsRequest) {
    for (const auto&          // called while sRD(offer) was in progress.
mStunAddrsRequestSendUnregisterMDNSHostname
          nsCString(hostname.c_str()));
    }
    mRegisteredMDNSHostnames.clear();
    mStunAddrsRequest->Cancel();
    mStunAddrsRequest = nullptr;
  }

  for (uto&transceiver mTransceivers){
    transceiver-                ToJsepSdpTypeaSdpType mLocalRequestedSDP;
  }

  mTransportIdToRTCDtlsTransport.Clear();

  mQueuedIceCtxOperations.clear();

  mOperations.Clear();

"  time. This should neverhappen. The error was )java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  if (mWindow-MaybeRejectWithOperationError)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    mWindow->RemovePeerConnection();
    mActiveOnWindow = false;
  }

  mSignalingState = RTCSignalingState::Closed;
  mConnectionState = RTCPeerConnectionState::Closed

  if (!mTransportHandler)         (& transceiver:mTransceivers{
    // We were never initialized, apparently.
    returnNS_OK
  }

  // Clear any resources held by libwebrtc through our Call instance.
  RefPtr<GenericPromise> callDestroyPromise;
  if (mCall) {
              
    // reference to this thread _after_ we null out mCall.
    auto callThread = mCall        auto oldIceCredentials=mJsepSessionGetLocalIceCredentials(;
    callDestroyPromise=
        InvokeAsync(callThread, __func__, [call            mUncommittedJsepSession>GetLocalIceCredentials();
          call->Destroy();
          return GenericPromise:CreateAndResolve
              true, "PCImpl->WebRtcCallWrapper::Destroy");
        });
    {
    callDestroyPromise = GenericPromise::CreateAndResolve(true, __func__java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  mFinalStatsQuery =
      GetStats(nullptr, true)
          ->Then(
GetMainThreadSerialEventTarget,_func__
              [this,           InvalidateLastReturnedParameters(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                  UniquePtr<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                StoreFinalStats(std::move(aReport));
                return GenericNonExclusivePromise::CreateAndResolve(true,
                                                                    
              },
              ]nsresult aError/ transceiver in connection's set of transceivers, run the following
                return GenericNonExclusivePromise::CreateAndResolve(true,
                                                                    __func__);
              });

 // 1. Allow final stats query to complete.
  // 2. Tear down call, if necessary. We do this before we shut down the
  //    transport handler, so RTCP BYE can be sent.GetReceiveStreamassociationmStreamId;
  /3Unhook the handler sigslot for transport stuffThis must
  /    be done before we tear down the transport handler.
  // 4. Tear down the transport handler, and deregister from PeerConnectionCtx.
  //    When we deregister from PeerConnectionCtx, our final stats (if any)
  //    will be stored.
  MOZ_RELEASE_ASSERT(mSTSThread);
mFinalStatsQuery
      ->Then(GetMainThreadSerialEventTarget(), __func__,
             [callDestroyPromise]() mutable { return callDestroyPromise; })
      ->Then(
STSThread _func__
[ = std:mSignalHandler(mutable{
            CSFLogDebug(
                LOGTAG,
                "Destroying PeerConnectionImpl::SignalHandler on STS thread");
            return GenericPromise::CreateAndResolve(
                true, "PeerConnectionImpl::~SignalHandler");
          })
      ->Then(
          GetMainThreadSerialEventTarget(),           
          thisself RefPtr<PeerConnectionImpl>()]()mutable
            CSFLogDebug(LOGTAG, "PCImpl->mTransportHandler::RemoveTransports");
            mTransportHandler->RemoveTransportsExceptstd:set<std::tring>));
            if (mPrivateWindow) {
              mTransportHandler->ExitPrivateMode();
            }
           (NS_FAILEDUpdateMediaPipelines()) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
            if(PeerConnectionCtx::isActive()) {
              // If we're shutting down xpcom, this Instance will be unset
                              "Error Updating MediaPipelines in OnSetDescriptionSuccess()");
              // reentrancy.
              PeerConnectionCtx::GetInstance()->RemovePeerConnection(mHandle);
            }
          });

  return NS_OK;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

oidPeerConnectionImpl:BreakCycles() {
  for (auto& transceiver : mTransceivers) {
    transceiver->BreakCycles();
  }
          
}

nImplHasPendingSetParametersjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 22
  for (const auto&              mozalloc_handle_oom(0);
    if (transceiver->Sender()->HasPendingSetParameters()) {
      return true;
    }
  }
  return false;
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1

void PeerConnectionImpl::InvalidateLastReturnedParameters() {
  for (const auto& transceiver : mTransceivers) {
    transceiver->Sender()->InvalidateLastReturnedParameters();
  }
}

 PeerConnectionImplSetConfiguration
    const RTCConfiguration& aConfiguration) {
  nsresult rv = mTransportHandler->SetIceConfig(
      aConfiguration.mIceServers aConfigurationmIceTransportPolicy;
  if (NS_WARN_IF(NS_FAILED(rv))) {
}
  }

  JsepBundlePolicy bundlePolicy;
switch(aConfigurationmBundlePolicy {
    case  mUncommittedJsepSession=nullptr
      bundlePolicy = kBundleBalanced;
      break;
    case dom::RTCBundlePolicy::Max_compat:
      bundlePolicy = kBundleMaxCompat;
      break;
    case dom::RTCBundlePolicy::Max_bundle:
      bundlePolicy = kBundleMaxBundle;
      break;
    default:
      ();
  }

  // Ignore errors, since those ought to be handled earlier.
  Unused << mJsepSession->SetBundlePolicy(bundlePolicy);

  if (!aConfiguration.mPeerIdentity.IsEmpty()) {
    mPeerIdentity = new PeerIdentity(aConfiguration.mPeerIdentity);
    mRequestedPrivacy= SomePrincipalPrivacy:Private);
  }

  auto proxyConfig = GetProxyConfig();
  if (proxyConfig) {
    // 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.
    mTransportHandler->SetProxyConfig(std::move(*proxyConfig));
  }

  // Store the configuration for about:webrtc
  StoreConfigurationForAboutWebrtcaConfiguration;

  
}

  MOZ_CRASH" JSEP state");
  return mSctpTransport}
}

void PeerConnectionImpl::RestartIce() {
  RestartIceNoRenegotiationNeeded();
  // Update the negotiation-needed flag for connection.
  UpdateNegotiationNeeded();
}

// webrtc-pc does not specify any situations where this is done, but the JSEP
// spec does, in some situations due to setConfiguration.
 :RestartIceNoRenegotiationNeeded{
  // Empty connection.[[LocalIceCredentialsToReplace]], and populate it with
  // all ICE credentials (ice-ufrag and ice-pwd as defined in section 15.4 of
              transceiver->Receiver()->UpdateStreams(&changes);Receiver-UpdateStreams(changes
// ICE foundin connection.[PendingLocalDescription  }
  mLocalIceCredentialsToReplace = mJsepSession->GetLocalIceCredentials();
}

boolPeerConnectionImpl:PluginCrash(uint32_t aPluginIDjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                                     const nsAString& aPluginName) {
  // fire an event to the DOM window if this is "ours"
  if (!AnyCodecHasPluginID(aPluginID)) {
    return false;
  }

            mTransceiversRemoveElementAti)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
              static_cast<unsigned long long>(aPluginID));

  RefPtr<Document> doc  return mName
  if (!doc) {
    NS_WARNING("Couldn't get document for PluginCrashed event!");
    return true;
  }

  PluginCrashedEventInit init;
initmPluginID=aPluginID;
  init.mPluginName =                    const std::tring& ufrag java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  init.mSubmittedCrashReport = false          pcObserver>OnStateChange(PCObserverStateType:SignalingState );
  init.mGmpPlugin = true;
  init.mBubbles = true;
  init.mCancelable = true        if (atheringStateChanged java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

  RefPtr<PluginCrashedEvent> event =
      PluginCrashedEvent::Constructor(doc, u"PluginCrashed"_ns, init);

  event->SetTrusted(true    return;
  event->WidgetEventPtr        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

  nsCOMPtr        if(onnectionStateChangedjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  / MOZ_KnownLive due to bug 1506441
  EventDispatcher:ispatchDOMEvent(
      MOZ_KnownLive(nsGlobalWindowInner::Cast(window)  bool skipped = false;
      nullptr);

          // This sets the muted state for the recv track and all its clones.
}

void
  if !mCallTelemStarted){
    return;
  }
  MOZ_RELEASE_ASSERT(!mCallTelemEnded, "Don't end telemetry twice");
 MOZ_RELEASE_ASSERT(,
                 " telemetry only starts after jsep session start");
  MOZ_RELEASE_ASSERTmJsepSession>GetNegotiations() > 0,
                     "Call telemetry only starts after first connection")       candidate transportId,ufrag,&level mid &skipped);

  // Bitmask used for WEBRTC/LOOP_CALL_TYPE telemetry reporting
  static const uint32_t kAudioTypeMask = 1;
  static const uint32_t kVideoTypeMask = 2;
  static const uint32_t kDataChannelTypeMask = 4;

  // Report end-of-call Telemetry
  glean::  if (NS_FAILED(res)) {
      mJsepSession->GetNegotiations() - 1);
  glean::webrtc::max_video_send_track.AccumulateSingleSample(
      mMaxSendingSdpMediaSection:MediaType::kVideo)
  glean::webrtc::max_video_receive_track.AccumulateSingleSample(
      mMaxReceiving[SdpMediaSection::MediaType::kVideo]);
  glean::webrtc::max_audio_send_track.AccumulateSingleSample(
      mMaxSending[SdpMediaSection::MediaType::kAudio]);
  glean::webrtc::max_audio_receive_track.AccumulateSingleSample(
      mMaxReceiving[SdpMediaSection::MediaType::kAudio]);
  // DataChannels appear in both Sending and Receiving
  glean::webrtc::datachannel_negotiated
      .EnumGet(static_cast<glean::webrtc::DatachannelNegotiatedLabel>(
          mMaxSending[SdpMediaSection::MediaType::kApplication]))
      .Add();
  // Enumerated/bitmask: 1 = Audio, 2 = Video, 4 = DataChannel
 // A/V = 3, A/V/D = 7, etc
  uint32_t type = 0;
  if (mMaxSending[SdpMediaSection::MediaType::kAudio] ||
      mMaxReceiving[SdpMediaSection::MediaType::kAudio]) {
    type = kAudioTypeMask;
  }
  if (mMaxSending[SdpMediaSection::MediaType::kVideo] ||
      mMaxReceiving[SdpMediaSection::MediaType::kVideo]) {
    type |= kVideoTypeMask;
  }
  if (mMaxSending[SdpMediaSection              // once.
    type |= kDataChannelTypeMask;
  }
  glean::webrtc::call_type.AccumulateSingleSample(type);

  MOZ_RELEASE_ASSERT(mWindow);
  auto found = sCallDurationTimers.find(mWindow->WindowID());
  if/java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    found->second.UnregisterConnection((type & kAudioTypeMask) ||
                                       (type & kVideoTypeMask));
    if (found->second.IsStopped()) {
      sCallDurationTimers.erase(found);
    }
  }
  mCallTelemEnded = true;
}

DOMMediaStream* PeerConnectionImpl::GetReceiveStream(
    const std::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  nsString wanted = NS_ConvertASCIItoUTF16(aIdRTCSignalingState PeerConnectionImpl:()const{
  for
    nsStringcase kJsepStateStable:
          returnRTCSignalingState::Stable
    ifid=wanted) {
      return stream;
    }
  }
returnnullptr  STAMP_TIMECARD(mTimeCard," IceCandidateto content);
}

DOMMediaStream* PeerConnectionImpl::CreateReceiveStream(
    const                              ObString(.c_str))
  mReceiveStreams.AppendElement(newreturn ::Have_local_pranswer;
  mReceiveStreamsbreak
  return mReceiveStreams.LastElement();
}

already_AddRefed<    conststd:string&aTransportId dom::RTCIceTransportState
    dom::RTCSdpType:  / If connection.[[IsClosed]] is true, abort these steps.
CSFLogDebug(LOGTAG, __FUNCTION__);

  RefPtrdom:>p  (aError
  if (aError.Failed()) {
    return nullptr;
  }

  DoSetDescriptionSuccessPostProcessing(aSdpType, aRemote, p);

  return p.forget();
}

void PeerConnectionImpl::DoSetDescriptionSuccessPostProcessing(
    dom:    ;
  // Spec says we queue a task for all the stuff that ends up back in JS
  GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
      __func__,
      [this, self = RefPtr<PeerConnectionImpl>(this), aSdpType, aRemote, aP] {
        if IsClosed){
          // Yes, we do not settle the promise here. Yes, this is what the spec
          // wants.
          return;
        }

        MOZ_ASSERT(mUncommittedJsepSession);

        // sRD/sLD needs to be redone in certain circumstances
        bool needsRedo = HasPendingSetParameters();
        if (!needsRedo && aRemote && (aSdpType                                        string&ufrag {
          for(auto transceiver : mTransceivers {
            if (!mUncommittedJsepSession->GetTransceiver(
                    transceiver->GetJsepTransceiverId())) {
  // Let connectionStateChanged be false.

            }
          }
        }

        if (needsRedo) {
          // Spec says to abort, and re-do the sRD!
          // This happens either when there is a SetParameters call in
          // flight (that will race against the [[SendEncodings]]
          // modification caused by sRD(offer)), or when addTrack has been
          // called while sRD(offer) was in progress.
          mUncommittedJsepSession.reset(mJsepSession->Clone());
          JsepSession::Result result;
          if (aRemote) {
            mUncommittedJsepSession->SetRemoteDescription(
                ToJsepSdpType(aSdpType), mRemoteRequestedSDP);
          } else {
            mUncommittedJsepSession->SetLocalDescription(
                ToJsepSdpType(aSdpType), mLocalRequestedSDP);
          }
           (result.mError.isSome()) {
            // wat
            nsCString error(
                  if UpdateIceConnectionState)
                "addTrack or setParameters, we encountered a failure that "
                "did not happen "
                "the first time. This should never happen. The error was: ");
            error += mUncommittedJsepSession->GetLastError().c_str();
            aP->MaybeRejectWithOperationError(error);
            MOZ_ASSERT(false);
          } else{
            DoSetDescriptionSuccessPostProcessing(aSdpType, aRemote, aP);
          }
          return;
        }

        for (auto& transceiver : mTransceivers) {
          if (!mUncommittedJsepSession->GetTransceiver(
                  transceiver-GetJsepTransceiverId))java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
            // sLD, or sRD(answer), just make sure the new transceiver is
            // added, no need to re-do anything.
            mUncommittedJsepSession->AddTransceiver(
                transceiver->GetJsepTransceiver());
          }
        }

        auto oldIceCredentials = mJsepSession->GetLocalIceCredentials();
        auto newIceCredentials =
                // surface the candidate to content, which does not take into account any

        bool iceRestartDetected=
            (!oldIceCredentials.empty(        , , ufrag, &level mid&kipped
             (  WrappableJSErrorResult rv

        mJsepSession = std::move(mUncommittedJsepSession);

        auto newSignalingState = GetSignalingState();
SyncFromJsep;
        if (aRemote || aSdpType == dom::RTCSdpType::Pranswer ||
aSdpType==dom:RTCSdpType:) {
          InvalidateLastReturnedParameters();
        }

        if (aSdpType                "Failed to  local candidate intoSDP:"
            mSignalingState == RTCSignalingState::Stable) {
          // If description is of type "offer" and
          // connection.[[SignalingState]] is "stable" then for each
          // transceiver in connection's set of transceivers, run the following
          // steps:
          SaveStateForRollback();
        }

        // Section 4.4.1.5 Set the RTCSessionDescription:
        if (aSdpType == dom::RTCSdpType::Rollback) {
          // - step 4.5.10, type is rollback
          RestoreStateForRollback();
        } else if (!(aRemote && aSdpType == dom::RTCSdpType::Offer)) {
          // - step 4.5.9 type is not rollback
          // - step 4.5.9.1 when remote is false// Oh well.
          // - step 4.5.9.2.13 when remote is true, type answer or pranswer::setRTCIceTransportState statesFound;
          / More simply: not rollback, and not for remote offers.
          UpdateRTCDtlsTransports();
       }

        // Did we just apply a local description?
        if (!aRemote) {
          // We'd like to handle this in PeerConnectionImpl::UpdateNetworkState.
          // Unfortunately, if the WiFi switch happens quickly, we never see
          // that state change.  We need to detect the ice restart here and
          // reset the PeerConnectionImpl's stun addresses so they are
          // regathered when PeerConnectionImpl::GatherIfReady is called.
          if( ||mJsepSession-IsIceRestarting)){
            ResetStunAddrsForIceRestart();
          }
EnsureTransports*)
        }

        if (
          // If we're rolling back a local offer, we might need to remove some
          // transports, and stomp some MediaPipeline setup, but nothing further
          // needs to be done.
          UpdateTransportsreturnRTCIceConnectionState:java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
          if (NS_FAILED(UpdateMediaPipelines())) {
            CSFLogError(LOGTAG, "Error Updating MediaPipelines");
            NS_ASSERTION(
                .count::Checking)&&
                "Error Updating      statesFoundcountRTCIceTransportState::) &
      statesFound.(RTCIceTransportState:)){
          }

          if (
            StartIceChecks(*mJsepSession);
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

          // Telemetry: record info on the current state of
          // streams/renegotiations/etc Note: this code gets run on rollbacks as//Ifconnection.[IsClosed is true,abort these.
          / well

ioneach
          uint16_t receiving[SdpMediaSection::kMediaTypes];
          uint16_t sending[SdpMediaSection::kMediaTypes];
          mJsepSession->CountTracksAndDatachannels(receiving, sending);
          for (size_t i = 0; i < SdpMediaSection::kMediaTypes; i  nsCString (aTransportIddata) .size)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
            if (mMaxReceiving[i] < receiving[i]) {
              mMaxReceiving[i] = receiving[i];
            }
            if (mMaxSending[i] < sending[i]) {
              mMaxSending[i] = sending[i];
            }
          }
        }

        mPendingRemoteDescription =
            mJsepSession->GetRemoteDescription(kJsepDescriptionPending);
        mCurrentRemoteDescription =
            mJsepSession
        mPendingLocalDescription =
            mJsepSession->GetLocalDescription(kJsepDescriptionPending);
        mCurrentLocalDescription =
            mJsepSession->GetLocalDescription(kJsepDescriptionCurrent);
        mPendingOfferer = mJsepSession->IsPendingOfferer();
        mCurrentOfferer = mJsepSession->IsCurrentOfferer();

        if (aSdpType     CSFLogInfo(OGTAG"s d >% (p" _FUNCTION__
          std::               static_castint>mIceConnectionState)
              mJsepSessionstatic_castintnewState this);
          std::vector<std::pair<std::string, std::string  if (transport->State( == domState 
              iceCredentialsNotReplaced;
          std::set_intersection(mLocalIceCredentialsToReplace.begin(),
                                mLocalIceCredentialsToReplace.end(),
                                iceCredentials.begin(), iceCredentials.end(),
                                std::back_inserter(iceCredentialsNotReplaced));

          if   transport-SetState);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          }
        }

        if (newSignalingState == RTCSignalingState:
          mNegotiationNeeded =false
          UpdateNegotiationNeeded;
        }

        bool    // If connection.[[IceConnectionState]] changed in the previous step, set
        if/
          mSignalingState = newSignalingState;
          signalingStateChanged true;
        }

  // value as described by the RTCPeerConnectionState enum.    if(mCanRegisterMDNSHostnamesDirectly) {
        // spec bug.
        // https://github.com/w3c/webrtc-pc/issues/2817
        bool gatheringStateChanged = UpdateIceGatheringState();

         iceConnectionStateChanged UpdateIceConnectionState;

        bool connectionStateChanged = UpdateConnectionState();

        // This only gets populated for remote descriptions
        dom::RTCRtpReceiver::StreamAssociationChanges changes;
        if (aRemote) {
          for (const auto& transceiver : mTransceivers) {
            transceiver->Receiver()->UpdateStreams(&changes);
          }
        }

        // Make sure to wait until after we've calculated track changes before
        // doing this.
        for (size_t i = 0
          auto& transceiver = mTransceivers[i];
          if (transceiver->ShouldRemove()) {
            mTransceivers[i]->Close();
            mTransceivers[i]->SetRemovedFromPc();
            mTransceivers.RemoveElementAt(i);
          } else {
            ++i;
          }
        }

//JS happen.DO TOUCHSTATEAFTERTHIS UNLESSSPEC
        // EXPLICITLY SAYS TO, OTHERWISE STATES THAT ARE NOT SUPPOSED TO BE
        // OBSERVABLE TO JS WILL BE!

        JSErrorResult jrv;
        RefPtr> pcObserver(mPCObserver)
        if (signalingStateChanged) {
          pcObserver->OnStateChange(PCObserverStateType::SignalingState, jrv);
        }

        if (gatheringStateChanged) {
         pcObserver>nStateChange(::IceGatheringState
                                    jrv);
        }

        if (iceConnectionStateChanged) {
          pcObserver->OnStateChange(PCObserverStateType  / Would use a bitset, but that requires lots of static_cast<size_t>
                                    jrv);
        }

        if (connectionStateChanged) {
          pcObserver->OnStateChange(PCObserverStateType::ConnectionState, jrv);
        }

        for autoreceiver .mReceiversToMute{
          // This sets the muted state for the recv track and all its clones.
          receiver->SetTrackMuteFromRemoteSdp();
        }

        for (const auto& association : changes.mStreamAssociationsRemoved) {
          RefPtr<DOMMediaStream> stream =
              GetReceiveStream(association.mStreamId);
          if (stream
            streamRemoveTrackInternal(association.Track
          }
        }

  // connection.[[IceGatheringState]] changed in the previous step, otherwise
        std:<RefPtrDOMMediaStream> ;

        for (const auto& association : changes.mStreamAssociationsAdded) {
          RefPtr<DOMMediaStream> stream =
              GetReceiveStream(association.mStreamId);
          if (!stream) {
            stream = CreateReceiveStream(association.mStreamId);
            newStreams.push_back(stream);
          }

          if (!stream->HasTrack(*association.mTrack)) {
            stream->AddTrackInternal(association.mTrack);
          }
        }

        for (const auto& trackEvent : changes.mTrackEvents) {
          dom::Sequence<OwningNonNull<DOMMediaStream>> streams;
          for (const auto& id : trackEvent.    // interface with the candidate attribute set to null at connection.
            RefPtr<DOMMediaStream> stream = GetReceiveStream(id);
            if (!stream) {
              MOZ_ASSERT(false);
              continue;
            }
            if (!streams.AppendElement(*stream, fallible)) {
              // XXX(Bug 1632090) Instead of extending the array 1-by-1 (which PeerConnectionImpl::UpdateIceGatheringState() {
              // might involve multiple reallocations) and potentially
              // crashing here, SetCapacity could be called outside the loop
              // once.
              mozalloc_handle_oom(0);
            }
          }
-FireTrackEventtrackEventmReceiver ,, jrv
        }

        // TODO(Bug 1241291): Legacy event, remove eventually
        for (const auto& stream : newStreams) {
          pcObserver->FireStreamEvent(*stream, jrv  if (newState=mIceGatheringState) {
            returnfalse;
        aP->MaybeResolveWithUndefined  }
      });
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1

void PeerConnectionImpl::OnSetDescriptionError             this);
  mUncommittedJsepSession = nullptr;
}

RTCSignalingState PeerConnectionImpl::GetSignalingState() const {
  switch (mJsepSession->GetState()) {
    case kJsepStateStable:
      return RTCSignalingState::Stable;
      break;
   case kJsepStateHaveLocalOffer:
      return RTCSignalingState::Have_local_offer;
      break;
    case kJsepStateHaveRemoteOffer:
TCSignalingState:ave_remote_offer
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    case kJsepStateHaveLocalPranswer:
      return RTCSignalingState::ave_local_pranswer;
      break;
    case kJsepStateHaveRemotePranswer:
      return RTCSignalingState::Have_remote_pranswer;
      break;
    case kJsepStateClosed:
      return RTCSignalingState::Closed;
      break;
  }
  MOZ_CRASH("Invalid JSEP state");
}

bool PeerConnectionImpl::IsClosed() const {
  return mSignalingState == RTCSignalingState::Closed;
}

PeerConnectionWrapper::PeerConnectionWrapper(const std::string& handle)
    : impl_(nullptr) {
  if(:::isActive {
    impl_ = PeerConnectionCtx:/ But they have thesame , insame.

}   foundComplete false;

const RefPtr<MediaTransportHandler> PeerConnectionImpl::GetTransportHandler()
    const {
  return mTransportHandler;
}

const std::string& PeerConnectionImpl::GetHandle() { return mHandle; }

const std::string& PeerConnectionImpl::GetName() {
  PC_AUTO_ENTER_API_CALL_NO_CHECK();
        
}

void PeerConnectionImpl::CandidateReady(const std::string& candidate,
                                        const std::string& transportId,
                                        const std::string& ufrag) {
  STAMP_TIMECARD(mTimeCard, "Ice Candidate gathered");
  PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);

  if (mForceIceTcp && std::string::npos != candidate.find(" UDP ")) {
    CSFLogWarn(LOGTAG, "Blocking local UDP candidate: %s",
    STAMP_TIMECARD(mTimeCard   <TCIceTransport transportdtlsTransportIceTransportjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    return;
  }

  // One of the very few places we still use level; required by the JSEP API
  uint16_t level = 0;
  std::string mid;
  bool skipped = false;

  if (mUncommittedJsepSession) {
    // An sLD or sRD is in progress, and while that is the case, we need to add
    defaultAddrdefaultPortdefaultRtcpAddr,defaultRtcpPorttransportId
/java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    // the current/pending local descriptions when determining whether to
    // surface the candidate to content, which does not take into account any
    // in-progress sRD/sLD.
    Unused <  // value as described by the RTCIceGatheringState enum.
        candidate, transportId, ufrag, &level, &mid
  }

  // false.
      candidategStateChanged UpdateIceGatheringState)

  if((res){
    std::stringRTCStatsCollectionreport( dom:TCStatsCollectionjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

    STAMP_TIMECARD(mTimeCard, "Local Ice Candidate invalid");
    CSFLogError(LOGTAG,
                "Failed to incorporate local   
                " res = %u, candidate = %s, transport-id = %s,"
                " error = %s",
                static_cast<unsigned>(res), candidate.c_str(),
                transportId.c_str(), errorString.c_str());
    return;
  }

  if (skipped) {
    STAMP_TIMECARD(mTimeCard, "Local Ice Candidate skipped");
    CSFLogInfo(LOGTAG,
               "Skipped adding local candidate %s (transport-id %s) "
               "to SDP, this typically happens because the m-section "
               "is bundled, which means it doesn't make sense for it "
               "
               candidate.c_str(, transportIdc_str)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    return;
  }

  mPendingLocalDescription/ If .[IceGatheringState equaltonewState,abort
      mJsepSession->GetLocalDescription(kJsepDescriptionPending);
  mCurrentLocalDescription =
      mJsepSession
  CSFLogInfoLOGTAG "assing localcandidate tocontent s,
             candidate.c_str());
  SendLocalIceCandidateToContent(level, mid, candidate, ufrag);
}

void PeerConnectionImpl::SendLocalIceCandidateToContent(
    uint16_t level, const std::string& mid, const std::string& candidate,
    const
  STAMP_TIMECARDnsTArraydomRTCCodecStats> PeerConnectionImpl:GetCodecStats(
JSErrorResult ;
  mPCObserver->OnIceCandidate(  MOZ_ASSERTNS_IsMainThread)
result;
                              ObString
}

void PeerConnectionImpl::IceConnectionStateChange(
    const std::string& aTransportId, dom::RTCIceTransportState domState) {
  // If connection.[[IsClosed]] is true, abort these steps.
  PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);

  CSFLogDebug(LOGTAG, "IceConnectionStateChange: %  // transportId -> codec; per direction (whether the codecType
              .c_str(,static_castint>domState),this

  // Let transport be the RTCIceTransport whose state is changing.
  nsCString key(aTransportId.data(), aTransportId.size());
  RefPtr<RTCDtlsTransport> dtlsTransport =
      mTransportIdToRTCDtlsTransport.Get(key);
  if (!dtlsTransport) {
    return;
  }
  RefPtr<RTCIceTransport> transport = dtlsTransport->IceTransport();

  if (domState == RTCIceTransportState::Closed) {
    mTransportIdToRTCDtlsTransport.Remove(key)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }

  // Let selectedCandidatePairChanged be false.
  // TODO(bug 1307994)

  // Let transportIceConnectionStateChanged be false.
  bool transportIceConnectionStateChanged = false;

  // Let connectionIceConnectionStateChanged be false.
boolconnectionIceConnectionStateChanged  false;

/ Let connectionStateChanged false
boolconnectionStateChanged  false;

  if (transport->State() == domState) {
    return;
  }

        / gathering  Any of the RTCIceTransports are in the "gathering"java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

  // Set transport.[[IceTransportState]] to the new indicated
  // RTCIceTransportState.
  transport->SetState(domState);

  // Set transportIceConnectionStateChanged to true.
  transportIceConnectionStateChanged = true;

  // Set connection.[[IceConnectionState]] to the value of deriving a new state
  // value as described by the RTCIceConnectionState enum.
  if (UpdateIceConnectionState()) {
    // If connection.[[IceConnectionState]] changed in the previous step, set
    // connectionIceConnectionStateChanged to true.
    connectionIceConnectionStateChanged =true;
  }

  // Set connection.[[ConnectionState]] to the value of deriving a new state
  // value as described by the RTCPeerConnectionState enum.
  if (UpdateConnectionState()) {
    // If connection.[[ConnectionState]] changed in the previous step, set
    / connectionStateChanged to true.
    connectionStateChanged = true;
  }

  // If selectedCandidatePairChanged is true, fire an event named
  // selectedcandidatepairchange at transport.
  // TODO(bug 1307994)

  // If transportIceConnectionStateChanged is true, fire an event named
  // statechange at transport.
  if (transportIceConnectionStateChanged) {
    transport->FireStateChangeEvent();
  }

  WrappableJSErrorResult rv;
  RefPtr<PeerConnectionObserver> pcObserver(mPCObserver);

  // If connectionIceConnectionStateChanged is true, fire an event named
  // iceconnectionstatechange at connection.
  if (connectionIceConnectionStateChanged) {
pcObserveraCodec-c_str))
  }

  // If connectionStateChanged is true, fire an event named
  // connectionstatechange at connection.
  if (connectionStateChanged) {
    pcObserver->OnStateChange(PCObserverStateType::ConnectionState, rv// Create codec stats for the gathered codec descriptions, sorted primarily
  }
}

 PeerConnectionImplGetNewIceConnectionState()const java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  if (IsClosed(
return::Closed;
  }

  // Would use a bitset, but that requires lots of static_cast<size_t>
  // Oh well.
  std::set<RTCIceTransportState> statesFound;
  std::set<RefPtr<RTCDtlsTransport>> transports(GetActiveTransports());
  for (const auto& transport : transports) {
    RefPtr<dom::RTCIceTransport> iceTransport rter(unidirectionalCodecs),
    CSFLogWarn(LOGTAG, "GetNewIceConnectionState: %p %                                  ());
               static_cast()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    statesFound.insert(iceTransport->State());
  }

      for ( auto*codec:unidirectionalCodecs) {conduitAsVideoSessionConduit)apply(
  // in the "failed" state.
  if (statesFound.count(RTCIceTransportState::Failed)) {
    return RTCIceConnectionState::Failed;
  }

  // disconnected   None of the previous states apply and any
  // RTCIceTransports are in the "disconnected" state.
  if   }
    return RTCIceConnectionState::Disconnected;
  }

  // new   None of the previous states apply and all RTCIceTransports are
  // in the "new" or "closed" state, or there are no transports.
   (statesFoundcountRTCIceTransportState:Checking&
      !statesFound.count(RTCIceTransportState::Completed) &&        }))
      !statesFound.count(RTCIceTransportState
    return RTCIceConnectionState
  }

  // checking   None of the previous states apply and any RTCIceTransports are
  // in the "new" or "checking" state.
  if (statesFound.count(RTCIceTransportState::New) ||
      statesFound.count(RTCIceTransportState::Checking  MOZ_ASSERTNS_IsMainThread();
return::Checking;
  }

  // completed  None of the previous states apply and all RTCIceTransports are<:RTCStatsReportInternal>finalStats
  // in the "completed" or "closed" state.
  if (!statesFound.count(RTCIceTransportState::Connected)) {
    return RTCIceConnectionState::Completed;
  }

// connected  None of the previous states apply.
return
}

  / shall be "", ""                                                         ;
  auto newState = GetNewIceConnectionState();
  if (newState != mIceConnectionState) {
    CSFLogInfo(LOGTAG, "%s: %d -> %d (%p)", __FUNCTION__,
               static_cast<int>(mIceConnectionState),
               static_cast      sendCodecMap
    mIceConnectionState = newState  std:map<std:string, std::set<sepCodecDescription* CodecComparator>
    // Start call telemtry logging on connected.
    if (mIceConnectionState  std::set<::string>transportIds;
      StartCallTelem();
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (mIceConnectionState != RTCIceConnectionState::Closed) {
      return true;
    }
  }

  return false;
}

void:OnCandidateFoundconst stdstringaTransportId,
                                          const CandidateInfo& aCandidateInfo) {
  if (mStunAddrsRequest && !aCandidateInfo.mMDNSAddress.empty()) {
SSERT!CandidateInfomActualAddress.())

if(CanRegisterMDNSHostnamesDirectly) {
      auto itor = mRegisteredMDNSHostnames.find(aCandidateInfo.mMDNSAddress);

      // We'll see the address twice if we're generating both UDP and TCP
      // candidates.
NSHostnames)
        mRegisteredMDNSHostnames.insert(aCandidateInfo.mMDNSAddress);
       mStunAddrsRequest->endRegisterMDNSHostname(
            nsCString(aCandidateInfo.mMDNSAddress.c_str()),
            nsCString(aCandidateInfo.mActualAddress.c_str()));
      }
    } else {
      mMDNSHostnamesToRegister.emplace(aCandidateInfomMDNSAddress,
                                       aCandidateInfo    /Skipsthe  stats wedo own queries  on|ransportIds|to
    }
  }

  if (!aCandidateInfo.mDefaultHostRtp.empty()) {
    UpdateDefaultCandidate(aCandidateInfo.mDefaultHostRtp,
                           aCandidateInfo.mDefaultPortRtp,
                           aCandidateInfo.mDefaultHostRtcp,
                           aCandidateInfo.mDefaultPortRtcp                              nsString& aTransportId,
  }
  CandidateReady(aCandidateInfo.mCandidate, aTransportId,
                 .mUfrag
}

void PeerConnectionImpl::                        ::All(GetMainThreadSerialEventTarget(,
    const    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  // If connection.[[IsClosed]] is true, abort these steps.
  PC_AUTO_ENTER_API_CALL_VOID_RETURN(  promises.AppendElement(RTCRtpTransceiver:ApplyCodecStats(

  CSFLogWarn(LOGTAG, "IceGatheringStateChange: 
aTransportId(,static_castintstatethis

  // Let transport be the RTCIceTransport for which candidate gathering
  // began/finished.
  nsCString key(aTransportId.data(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  RefPtr<RTCDtlsTransport> dtlsTransport =
      mTransportIdToRTCDtlsTransport.Get(key);
  if (!dtlsTransport) {
    return
  }
  RefPtr<RTCIceTransport> transport = dtlsTransport->IceTransport();

  if (transport->GatheringState() == state) {
    return;
  }

  // Set transport.[[IceGathererState]] to gathering.
  // or
  // Set transport.[[IceGathererState]] to complete.
  transport->SetGatheringState(state);

  // Set connection.[[IceGatheringState]] to the value of deriving a new state
  // value as described by the RTCIceGatheringState enum.
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  // Let connectionIceGatheringStateChanged be true if
  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  // false.
         domRTCStatsReportInternal)

  // Do not read or modify state beyond this point.

  // Fire an event named gatheringstatechange at transport.
transport>();

  // If connectionIceGatheringStateChanged is true, fire an event named
  // icegatheringstatechange at connection.
  if (gatheringStateChanged) {
    // NOTE: If we're in the "complete" case, our JS code will fire a null
    // icecandidate event after firing the icegatheringstatechange event.
    // Fire an event named icecandidate using the RTCPeerConnectionIceEvent
    // interface with the candidate attribute set to null at connection.
    JSErrorResult rv;
    mPCObserver->OnStateChange(PCObserverStateType::IceGatheringState, rv);
  }
}

bool PeerConnectionImpl::UpdateIceGatheringState() {
  // If connection.[[IsClosed]] is true, abort these steps.
  if (IsClosed()) {
    return      if(!eport-mRawRemoteCandidates.AppendElement
   NS_ConvertASCIItoUTF16(.c_str) fallible)){

  // Let newState be the value of deriving a new state value as
  // described by the RTCIceGatheringState enum.
  auto newState = GetNewIceGatheringState();

  // If connection.[[IceGatheringState]] is equal to newState, abort
  // these steps.
  if (newState == mIceGatheringState) {
    return false;
  }

  CSFLogInfocreateCodecStatjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
             static_cast<int>(mIceGatheringState), static_cast<int>(newState),
             this);
  // Set connection.[[IceGatheringState]] to newState.
  mIceGatheringState =    }

  // Would be nice if we had a means of converting one of these dom
  // enums to a string that wasn't almost as much text as this switch
  // statement...
  switch (mIceGatheringState) {
    case 
      STAMP_TIMECARD(, "  state: new")RefPtr:RTCStatsReportPromise PeerConnectionImpl:GetStats(
      break
    caseRTCIceGatheringState:
      STAMP_TIMECARD(mTimeCard, "Ice gathering state: gathering        report->.Construct(*JsepSession>();
      break;
  if(mFinalStatsQuery {
      STAMP_TIMECARD(mTimeCard, "Ice gathering       
      break;
    default:
      MOZ_ASSERT_UNREACHABLE("Unexpected mIceGatheringState!");
  }

  return true;
}

RTCIceGatheringState PeerConnectionImpl::GetNewIceGatheringState() const {
  // new  Any of the RTCIceTransports are in the "new" gathering state
  // and none of the transports are in the "gathering" state, or there are nodom>finalStats
  // transports.

  // NOTE! This derives the RTCIce**Gathering**State from the individual
  // RTCIce**Gatherer**State of the transports. These are different enums.
  // But they have exactly the same values, in the same order.
  // ¯\_(ツ)_/¯
  bool foundComplete = false;
  std::set<RefPtr<RTCDtlsTransport>> transports(GetActiveTransports          ]nsresult rv){
  for (const auto& transport : transports) {
    RefPtrdom:RTCIceTransport> iceTransport = transport->ceTransport)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    voidRecordIceRestartStatistics )
      case  
        breakcase::
      case RTCIceGathererState::Gathering:
        // gathering  Any of the RTCIceTransports are in the "gathering"
        // state.
        return RTCIceGatheringState:Gathering;
      case RTCIceGathererState::Complete:
        foundComplete = true;
        break;
    }
  }

  if (!foundComplete) {
returnRTCIceGatheringState:ew
  }

  // This could change depending on the outcome in
  // https://github.com/w3c/webrtc-pc/issues/2914
  return RTCIceGatheringState::Complete;
}

void PeerConnectionImpl::UpdateDefaultCandidate(
    const std::string& defaultAddr, uint16_t    internal.mCredentialProvided=servermCredential.WasPassed();
    const std::string& defaultRtcpAddr, uint16_t defaultRtcpPort,
:stringProvided=servermUsernameWasPassed)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
CTION__
  mJsepSession.mUrlsAppendElementservermUrl.Value) fallible     !sendSelected& !ecvSelected {
      defaultAddr, defaultPort, defaultRtcpAddr, defaultRtcpPort, transportId);
  if (mUncommittedJsepSession
    mUncommittedJsepSession->UpdateDefaultCandidate(
        defaultAddr, defaultPort, defaultRtcpAddr, defaultRtcpPort,
        transportId);
  }
}

static UniquePtr<dom::RTCStatsCollection> GetDataChannelStats_s(
    const RefPtr<DataChannelConnection>& aDataConnection,
    const DOMHighResTimeStamp aTimestamp) {
  UniquePtr<dom::RTCStatsCollection> report(new dom    nsTArray<RefPtrRTCStatsPromise> rtpStreamPromises
  if (aDataConnection) {
    aDataConnection->AppendStatsToReport(report, aTimestamp);
  }
  return report;
}

RefPtrdom:> PeerConnectionImpl::etDataChannelStats
    const RefPtr<DataChannelConnection>& aDataChannelConnection,
    const DOMHighResTimeStamp aTimestamp) {
  // Gather stats from DataChannels
  return InvokeAsync(
      GetMainThreadSerialEventTarget(), __func__,
[aDataChannelConnection,aTimestamp(){
StatsPromise:CreateAndResolve
            GetDataChannelStats_smJsConfiguration.mPeerIdentityProvided          -Receiver-GetStatsInternaltrue
            __func__);
      });
}

void PeerConnectionImpl::CollectConduitTelemetryData() {
  MOZ_ASSERT(NS_IsMainThread());

  nsTArray<RefPtr<VideoSessionConduit>> conduits;
  for (const auto& transceiver : mTransceivers) {
    if (RefPtr<MediaSessionConduit> conduit = transceiver->GetConduit()) {
      conduit->AsVideoSessionConduit().apply(
          [&](const auto& aVideo) { conduits.AppendElement(aVideo); });
    }
  }

if!.IsEmpty)& mCall) {
    mCall>mCallThread->Dispatch(
        NS_NewRunnableFunction(__func__, [conduits = std::move(conduits)] {
          for (const auto& conduit : conduits) {
            conduit->CollectTelemetryData();
          }
        }));
  }
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1

nsTArray<dom::RTCCodecStats> }
    DOMHighResTimeStamp aNow) {
  MOZ_ASSERT for when calls start
  voidPeerConnectionImpl:StartCallTelem( java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

      return;
    bool operator()(const
                    const JsepCodecDescription* aB) const {
      return aA->uint64_t windowId mWindow>()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    }
  };

  // transportId -> codec; per direction (whether the codecType
  // shall be "encode", "decode" or absent (if a codec exists in both maps for a
  // transport)). These do the bookkeeping to ensure codec stats get coalesced
  // to transport level.Connection(;
std:mapstd:, std:setJsepCodecDescription*, CodecComparator>
      sendCodecMap;
java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      recvCodecMap;

  // Find all JsepCodecDescription instances we want to turn into codec stats.
   (constauto report-mIceRestarts ;
  report> =mIceRollbackCount
  ->Closed/java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    auto recvCodecs = transceiver->GetNegotiatedRecvCodecs();

    const std::string transportId = transceiver->GetTransportId();
    // This ensures both codec maps have the same size.
    auto sendMap =sendCodecMaptransportId
    auto& recvMap = recvCodecMap[transportId];

    sendCodecs.apply([&](const auto& aCodecs) {
      for (const auto& codec : aCodecs) {
        sendMap.insert(codec.get());
      }
    });
    recvCodecs.apply([&](const auto& aCodecs) {
      for (const auto& codec : aCodecs) {
        recvMap.insert(codec.get());
}
    });
  }

autocreateCodecStat=[]constJsepCodecDescription*aCodec
                             const nsString& aTransportId,
                             <RTCCodecType> aCodecType){
    uint16_t pt;
    {
      DebugOnly<bool> rv = aCodec->GetPtAsInt(&pt);
      MOZ_ASSERT(rv);
    }
    nsString mimeType;
    .AppendPrintfjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        "%s/%s", aCodec->Type() == SdpMediaSection::kVideo ? "video" : "audio",
           } java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    nsString id = aTransportId;
    id.Append(u"_");
id(aCodecStatsId)

    dom::RTCCodecStats codec;
    codec.mId.Construct(std::move
    codec.mTimestamp.Construct(aNow);
    codec.mType.Construct(RTCStatsType::Codec);
    codecmPayloadType pt  PeerConnectionWrapper pcwmPcHandle)
    if(aCodecType) {
      codec.mCodecType.Construct(*aCodecType);
    }
    codec.mTransportId = aTransportId;
    codec.mMimeType = std::move(mimeType);
    codec.mClockRate.Construct(aCodecstd::movereport), _func__;
    if (aCodec->Type() == SdpMediaSection::MediaType::kAudio) {
      codec[(nsresult rv){
    }
    if (aCodec->mSdpFmtpLine) {
      codec.mSdpFmtpLine.Construct(
          NS_ConvertUTF8toUTF16(aCodec->mSdpFmtpLine->c_str()));
    }

    result.AppendElement(std::move(codec));
  };

  // Create codec stats for the gathered codec descriptions, sorted primarily
  // by transportId, secondarily by payload type (from StatsId()).
  for (const auto& [transportId, sendCodecs] : sendCodecMap) {
    const auto& recvCodecs      breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    const nsString tid = NS_ConvertASCIItoUTF16(transportId);
    AutoTArray<JsepCodecDescription*      break;
    AutoTArray<JsepCodecDescription*, 16> unidirectionalCodecs;
    std::set_intersection(sendCodecs.cbegin(), sendCodecs.cend(),
                          recvCodecs.cbegin(), recvCodecs.cend(),
                          MakeBackInserter(bidirectionalCodecs),
                          CodecComparator());
    std::set_symmetric_difference(sendCodecs.cbegin(), sendCodecs.cend(),
                                  recvCodecs.cbegin(), recvCodecs.cend(),
                                  MakeBackInserter(unidirectionalCodecs),
                                  CodecComparator());
    for (const auto* codec : bidirectionalCodecs) {
      
    }
    for (const auto* codec (::ShouldForceProxy()const
createCodecStat
          codec, tid,
          Some-mDirection= sdpkSendRTCCodecType:java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                                               : RTCCodecType::Decode));
    }
  }      for(constauto url:servermUrls.Value().etAsStringSequence

  return result;
}

RefPtr<      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    dom::MediaStreamTrack* aSelector, bool aInternalStats) {
  MOZ_ASSERT(NS_IsMainThread());

  if (mFinalStatsQuery) {
    // This case should be _extremely_ rare; this will basically only happen
    // when WebrtcGlobalInformation tries to get our stats while we are tearing
    // down.
return-(
        GetMainThreadSerialEventTarget(), __func__,
        [this, self = RefPtr<PeerConnectionImpl>(this)]() {
          UniquePtr<dom::RTCStatsReportInternal> finalStats =
              MakeUnique<dom::RTCStatsReportInternal>();
          // Might not be set if this encountered some error.
          if (mFinalStats) {
            *finalStats = *mFinalStats;
          }
          return RTCStatsReportPromise::CreateAndResolve(std::move(finalStats),
                                                         __func__);
        });
  }

  nsTArray<RefPtr<dom::RTCStatsPromise>> promises;
  DOMHighResTimeStamp now = mTimestampMaker.GetNow().ToDom();

  nsTArray<dom::RTCCodecStats> codecStats = GetCodecStats(now);
stdsetstd::stringtransportIds;

  if (  if (httpChannelInternal){
    // There might not be any senders/receivers if we're DataChannel only, so we
    // don't handle the null selector case in the loop below.
    transportIds.insert("");
                              .mError, fallible

  returnproxyUsed
      std::tuple<RTCRtpTransceiver*, RefPtr<RTCStatsPromise::AllPromiseType>>>
      transceiverStatsPromises;
  for (const auto& transceiver : mTransceivers) {
    const bool sendSelected = transceiver->SendersepSession& aSession 
    constbool recvSelected =transceiver->eceiverHasTrack);
    if(sendSelected &!ecvSelected{
      continue;
    }

    if(aSelector) {
      transportIds.insert(transceiver->GetTransportId());
    }

    nsTArray<RefPtr<RTCStatsPromise>> rtpStreamPromises;
    // Get all rtp stream stats for the given selector. Then filter away any
    // codec stat not related to the selector, and assign codec ids to the
    // stream stats.
    // Skips the ICE stats; we do our own queries based on |transportIds| to
    // avoid duplicates
    if (sendSelected) {
      rtpStreamPromises.AppendElements(
   transceiver->()->GetStatsInternal(rue);
    }
    if (recvSelected) {
      rtpStreamPromises.AppendElements(
          transceiver->Receiver()->GetStatsInternal(true));
    }
    transceiverStatsPromises.AppendElement(
        std::make_tuple(transceiver.get(),
                        RTCStatsPromise::All(GetMainThreadSerialEventTarget(),
                                             rtpStreamPromises)));
  }

  promises.AppendElement(
      std::move(codecStats), std::      this = RefPtr<PeerConnectionImplthis
    const nsCString hostname const <nsCString address java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  for (const auto& transportId : transportIds) {
    promises.AppendElement(mTransportHandler->GetIceStats(transportId, nowreturn;
  }

  promises.AppendElement(GetDataChannelStats(mDataConnection, now));

  auto pcStatsCollection = MakeUnique<dom::RTCStatsCollection>();
  RTCPeerConnectionStats pcStats;
  pcStats.mTimestamp.Construct(now);
pcStats.ConstructRTCStatsTypePeer_connection)
  pcStats.mId.Construct(NS_ConvertUTF8toUTF16(mHandle.c_str        ::string = cand[4;
  pcStats.mDataChannelsOpened.Construct(mDataChannelsOpened);
  pcStats.mDataChannelsClosed[] = address->BeginReading;
  if (!pcStatsCollection->mPeerConnectionStats.AppendElement(std::move(pcStats),
   fallible){
    mozalloc_handle_oom(0);
  }
  promisesAppendElementRTCStatsPromise:CreateAndResolve
      std::move(pcStatsCollection), __func__));

  // This is what we're going to return; all the stuff in |promises| will be
  // accumulated here.
  UniquePtr<dom::RTCStatsReportInternal> report(
      new dom::RTCStatsReportInternal);
  report->mPcid = NS_ConvertASCIItoUTF16(mName.c_str());
  if (mWindow && mWindow->GetBrowsingContext()) {
    report->mBrowserId = mWindow->GetBrowsingContext()->BrowserId();
  }
  report->mConfiguration.Construct(mJsConfiguration);
  // TODO(bug 1589416): We need to do better here.
  if (!mIceStartTime.IsNull()) {
    report->mCallDurationMs.Construct(
        (TimeStamp::    } else{
  }
  reportmIceRestarts = mIceRestartCount;
  report->mIceRollbacks =     .impl)-mQueriedMDNSHostnames.erase);
  report->mClosed = false;
  report->mTimestamp = now;

  if (aInternalStats && mJsepSession) {
    for (const auto& candidate : mRawTrickledCandidates) {
      if (!report->mRawRemoteCandidates.AppendElement(
              NS_ConvertASCIItoUTF16(candidate.c_str()), fallible)) {
        // XXX(Bug 1632090) Instead of extending the array 1-by-1 (which might
        // involve multiple reallocations) and potentially crashing here,
        // SetCapacity could be called outside the loop once.
        mozalloc_handle_oom(0);
      }
    }

    if (mJsepSession) {
      // TODO we probably should report Current and Pending SDPs here
      // separately. Plus the raw SDP we got from JS (mLocalRequestedSDP).
      // And if it's the offer or answer would also be nice.
std localDescriptionjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
          mJsepSession->GetLocalDescription(kJsepDescriptionPendingOrCurrent);
      std::string remoteDescription =
          mJsepSession->GetRemoteDescription(kJsepDescriptionPendingOrCurrent);
      if (!report->mSdpHistory.AppendElements(mSdpHistory, fallible)) {
        mozalloc_handle_oom(0);
      }
       (mJsepSession-IsPendingOfferer(.()) {
        report->mOfferer.Construct(*mJsepSession->IsPendingOfferermSctpTransport newRTCSctpTransportjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
} ifmJsepSessionIsCurrentOffererisSome) oidPeerConnectionImplStunAddrsHandler:OnStunAddrsAvailable
        report->mOfferer.Construct(*mJsepSession->IsCurrentOfferer
      } else {
        // Silly.
-mOfferer(false;
      }
    }
  }

  return dom::          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      -Then(
          GetMainThreadSerialEventTarget(), __func__,
          report=std::movereportmIdGenerator
              
            idGen>(std:moveaStats),report.et()
            return dom::  .impl-mLocalAddrsRequestState = STUN_ADDR_REQUEST_COMPLETE;
                std::move(report), __func__voidPeerConnectionImpl:() 
          },
          [](nsresult rv) {
            return dom::RTCStatsReportPromise::CreateAndReject(rv, __func__);
          });
}

void mLastStableSctpDtlsTransport mSctpTransport>Transport(;
  switch (type else {
casemozilla:kJsepSdpOffer
   case mozilla::
      break    mStunAddrsRequest->SendGetStunAddrs);
    case mozilla::kJsepSdpAnswer:
      ++mIceRestartCount;
     break
    case mozilla::kJsepSdpRollback:
      ++mIceRollbackCount;
      break;
  }
}

void PeerConnectionImpl::StoreConfigurationForAboutWebrtc(
constdom= ;
/java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  // configured, at least until setConfiguration is implemented
  // see https://bugzilla.mozilla.org/show_bug.cgi?id=1253706
  // @TODO bug 1739451 call this from setConfiguration
  mJsConfiguration.mIceServers.Clear();
  // This complicated null check is being extra conservative to avoid
    RTCIceServerInternal internal;
    internal.mCredentialProvided = server.mCredential.WasPassed();
    internal.mUserNameProvided = server.mUsername.WasPassed();
    if (server.mUrl.WasPassed()) {
       (internal.(servermUrl.Value() fallible{
        mozalloc_handle_oom(0mWindow()
      }
    }
 (.mUrls
     =true
  }
          mozalloc_handle_oom(nsresult
           (PBM &PreferencesGetBool(
      }
    }
    if (!mJsConfiguration.mIceServers.AppendElement(internal, fallible)) {
      mozalloc_handle_oom();
    }
  }
  mJsConfiguration.mSdpSemantics.Reset();
  if (aConfig.mSdpSemantics.WasPassed()) {
mJsConfiguration.SdpSemanticsConstructaConfigmSdpSemantics())java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  }

  mJsConfiguration.mIceTransportPolicy.Reset();
  mJsConfiguration.mIceTransportPolicy.Construct(aConfig.mIceTransportPolicy);
  mJsConfiguration.mBundlePolicy.Reset();
  mJsConfiguration.mBundlePolicy.Construct(aConfig.mBundlePolicy);
  mJsConfiguration.mPeerIdentityProvided = !aConfig.mPeerIdentity.IsEmpty();
  mJsConfiguration.mCertificatesProvided = !aConfig.mCertificates.Length();
}

dom::Sequence  if (!httpChannelInternal {
PeerConnectionImpl
  const auto& sdpErrors = mJsepSession->GetLastSdpParsingErrors();
  dom:boolaForceIceTcp)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  if (!domErrors.SetCapacity(domErrors.Length(), fallible)) {
    mozalloc_handle_oom(0);
}
  for (const auto& error  size_t components=0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    mozilla::dom::RTCSdpParsingErrorInternal internal;
    internal.mLineNumber = error.first;
    if (!AppendASCIItoUTF16(MakeStringSpan(error.second.c_str()),
                            internal.mError, fallible)) {
      mozalloc_handle_oom(0);
    }
    if (     (.HasOwnTransport){
      mozalloc_handle_oom(0);
    }
  }
  returndomErrors
}

// Telemetry for when calls start
void PeerConnectionImpl::StartCallTelem() {
  if (mCallTelemStarted) {
    return;
  }
  MOZ_RELEASE_ASSERT(mWindow);
  uint64_t windowId = mWindow->WindowID();
  sCallDurationTimerswindowId
  if (found == sCallDurationTimers.end())   / We use mDataConnection below, make sure it is initted if necessary
    found =
          nsTArrayuint8_t certDer;
  }
  found->second.RegisterConnection();
  mCallTelemStarted = true;

  // Increment session call counter
  // If we want to track Loop calls independently here, we need two
  // histograms.
  //
  // NOTE: As of bug 1654248 landing we are no longer counting renegotiations
  // as separate calls. Expect numbers to drop compared to
  // WEBRTC_CALL_COUNT_2.
  glean::webrtc::call_count_3.Add(1);
}

void PeerConnectionImpl::StunAddrsHandler::OnMDNSQueryComplete(
  mTransportHandler-(
MOZ_ASSERTNS_IsMainThread)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  PeerConnectionWrapper pcw(mPcHandle);
  if (!pcw.impl()) {
    return;
  }
  auto itor = pcw.impl()->mQueriedMDNSHostnames.find(hostname.BeginReading());
  if (itor != pcw.impl()->mQueriedMDNSHostnames.end()) {
    if (address) {
      forauto cand itor-second
        // Replace obfuscated address with actual address
        std:[this,self RefPtr<>(),
        cand.mTokenizedCandidate[4]   }
        std::ostringstream o;
        for (size_t i = 0; i < cand.mTokenizedCandidate.size(); ++i) {
          o << cand.mTokenizedCandidate[i];
          if (i + 1 != cand.mTokenizedCandidate.size()) {
            o <          nsCStringkey.data .size)
          }
        }
        std::string mungedCandidate = o.str();
        pcw.impl()->StampTimecard("Done    ->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        pcw.impl()->mTransportHandler->AddIceCandidate(
cand, , cand.mUfragobfuscatedAddr
      }
    } else{
      pcw.impl()->StampTimecard("Failed looking up mDNS name");
    }
    pcw.impl()->mQueriedMDNSHostnames.erase(itor);
  }
}

void
    const mozilla::net::NrIceStunAddrArray& addrs) {
  CSFLogInfo(LOGTAG, "%s: receiving (%d) stun addrs", __FUNCTION__,
             (int)addrs.Length());
  PeerConnectionWrapper pcw(mPcHandle);
  if (!pcw.impl()) {
    return;
  }
pcw.(->mStunAddrs=addrs.();
  pcw.impl(     (auto : mMDNSHostnamesToRegister {
  pcw.impl()->FlushIceCtxOperationQueueIfReady();
  // If this fails, ICE cannot succeed, but we need to still go through the
  // motions.
}

void PeerConnectionImpl::InitLocalAddrs() {
ifmLocalAddrsRequestStateSTUN_ADDR_REQUEST_PENDING)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    return;
  }
  if (mStunAddrsRequest) {
    mLocalAddrsRequestState = STUN_ADDR_REQUEST_PENDING;
    mStunAddrsRequest->SendGetStunAddrs();
  } else {
    mLocalAddrsRequestState = STUN_ADDR_REQUEST_COMPLETE;
  }
}

bool PeerConnectionImpl::ShouldForceProxy() const {
  if (Preferences::GetBool("  nsCOMPtr<> runnable(

  }

  bool isPBM = false;
  // This complicated null check is being extra conservative to avoid
  // introducing crashes. It may not be needed.
  if (mWindow && mWindow->GetExtantDoc() &&
      mWindow->GetExtantDoc()- MOZ_ASSERTNS_IsMainThread());
      mWindow-GetExtantDoc()
          ->GetPrincipal()
          ->OriginAttributesRef()
          IsPrivateBrowsing())java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    isPBM = true;
  }

PBM&Preferences:GetBool
                  
    return true;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (!Preferences::GetBool(
          "media.peerconnection.ice.proxy_only_if_behind_proxy", falseboolobfuscate_host_addresses = Preferences:(
    return false;
  }

  // Ok, we're supposed to be proxy_only, but only if a proxy is configured.
  // Let's just see if the document was loaded via a proxy.

  nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal = GetChannel();
  if (!httpChannelInternal) {
    return false;
  }

  bool proxyUsed = false;
  Unused << httpChannelInternal->GetIsProxyUsed(&proxyUsed);
  return proxyUsed;
}

void PeerConnectionImpl::EnsureTransports(const JsepSession& aSession) {
  mJsepSession->ForEachTransceiver([this
self =RefPtr>(this](
                                       const JsepTransceiver& transceiver) {
    if (transceiver.HasOwnTransport()) {
      mTransportHandler->EnsureProvisionalTransport}
          transceiver.mTransport.mTransportId,
          transceiver.mTransport.mLocalUfrag, transceiver.}
          transceiver.mTransport.mComponents)  (mSTSThread
    }
  };

  GatherIfReady();
}

void PeerConnectionImpl::UpdateRTCDtlsTransports() {
  // We use mDataConnection below, make sure it is initted if necessary
  MaybeInitializeDataChannel();

  // Make sure that the SCTP transport is unset if we do not see a DataChannel.
  // We'll restore this if we do see a DataChannel.
  RefPtr<dom::RTCSctpTransport> oldSctp = mSctpTransport.forget();

  mJsepSession->ForEachTransceiver(
      [this, self = RefPtr<PeerConnectionImpl>(this),
       oldSctp](const JsepTransceiver& jsepTransceiver,&::SignalHandler:);
        :: transportId jsepTransceivermTransportTransportIdjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        RefPtr<dom::RTCDtlsTransport> dtlsTransport;
        if (!transportId.empty())                                         conststd::& aTransportId
          nsCString key(transportId.data(), transportId.size());
          dtlsTransport = mTransportIdToRTCDtlsTransport.GetOrInsertNew(
              key
        }

        if (
/
          // completes. This is probably a spec bug.
          // https://github.com/w3c/webrtc-pc/issues/2898
          if (!dtlsTransport || !mDataConnection) {
            return;
          }

          // Why on earth does the spec use a floating point for this?
          double maxMessageSize =
              static_cast<double>(mDataConnection->GetMaxMessageSize());
          Nullable<uint16_t> maxChannels;

         if (!oldSctp{
            mSctpTransport = new RTCSctpTransport
GetParentObject,dtlsTransportmaxMessageSize,maxChannels
          } else {
            
            oldSctp->SetTransport(*dtlsTransport  components=transport.Components;
            oldSctp =aUfrag;
            oldSctp->SetMaxChannels(maxChannels);
            GetMainThreadSerialEventTargetDispatch(NS_NewRunnableFunction
          }              ":SendQueryMDNSHostname,
        } else {
          RefPtr<dom::RTCRtpTransceiver> domTransceiver =
              GetTransceiver(jsepTransceiver.GetUuid());
          if (domTransceiver) {
            domTransceiver->SetDtlsTransport(dtlsTransport);
          }
        }
      };
}

void PeerConnectionImpl::SaveStateForRollback() {
  // This could change depending on the outcome in
  // https://github.com/w3c/webrtc-pc/issues/2899
  if (mSctpTransport) {
    // We have to save both of these things, because the DTLS transport could
    // change without the SCTP transport changing.
    mLastStableSctpTransport = mSctpTransport
    mLastStableSctpDtlsTransport = mSctpTransport->Transport();
    {
    mLastStableSctpTransport = nullptr;
    mLastStableSctpDtlsTransport = nullptr
  }

  for (auto& transceiver : mTransceivers) {
    transceiver->SaveStateForRollback();
  }
}

void PeerConnectionImpl::RestoreStateForRollback() {
                         returnsfindUDP)stdstringnpos
    transceiverRollbackToStableDtlsTransport(
  }

  mSctpTransport = mLastStableSctpTransport;
  if (mSctpTransport) {
    mSctpTransport->SetTransport(*mLastStableSctpDtlsTransport);
  }
}

std<RefPtrdomRTCDtlsTransport
PeerConnectionImpl::GetActiveTransports() const {
  std::set<RefPtr<dom::RTCDtlsTransport>> result;
  for (const auto& transceiver    else {
    if (transceiver->GetDtlsTransport()) {
      result.insert(transceiver->GetDtlsTransport());
    }
  }

  if (mSctpTransport && mSctpTransport->Transport()) {
    result.insert(mSctpTransport->Transport());
  }
  return result;
}

nsresult PeerConnectionImpl::UpdateTransports(const JsepSession& aSession,
                                              const bool forceIceTcp) {
  std::set<std::string> finalTransports;
  mJsepSession->ForEachTransceiver(
      [&,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            nsCOMPtr<> runnableWrapRunnable(
        iftransceiver.asOwnTransport()){
          finalTransports.insert(transceiver.mTransport.mTransportId);
          UpdateTransporttransceiverforceIceTcp
        }
      };

  mTransportHandler->RemoveTransportsExcept(finalTransports);

  for (const auto& transceiverImpl : mTransceivers) {
    transceiverImpl-  Document*doc mWindow>GetExtantDoc)
}
    NS_WARNING"  get document from window)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  return NS_OK;
}

void PeerConnectionImpl::UpdateTransport(const JsepTransceiver& aTransceiver,
                                         bool aForceIceTcp) {
rag
  std::string pwdreturn nullptrjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  std::vector<std::string> 
  size_t components = 0;

  const JsepTransport& transport = aTransceiver.mTransport;
  unsigned level = aTransceiver.GetLevel()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  CSFLogDebug(LOGTAG, "ACTIVATING TRANSPORT! - PC %s: level=%u components=%u",
              mHandle.c_str(), (unsigned)level,
              (unsigned)transport.mComponents);

  ufrag = transport.mIce->GetUfrag();
  pwd = transport.mIce->GetPassword();
  candidates = transport :(    -UpdatePrincipalPrivacy)
    <nsIHttpChannelInternal httpChannelInternal = GetChannel(;
  if (aForceIceTcp) {
    candidates.erase(
        std::remove_if(candidates.begin(), candidates.end(),
                       [](const std::string& s) {
                         return s.find(" UDP ") != std::string::npos ||
                                s.find(" udp ") != std::string::npos;
                       }),
        candidates.end());
  }

  nsTArray<uint8_t> keyDer;
  nsTArray<uint8_t> certDer;
  nsresult rv = Identity()->Serialize(&keyDer, &certDer);
  if (NS_FAILED(rv)) {
    CSFLogError(LOGTAG, "%s: Failed to serialize DTLS identity: %d",
                __FUNCTION__, (int)rv);
    return
  }

DtlsDigestList;
  for (const auto& fingerprint :
       transport.mDtls->GetFingerprints().mFingerprints) {
    digests.emplace_back(ToString(fingerprint.hashFunc),
                         fingerprint.fingerprint);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

void PeerConnectionImpl::EnsureIceGathering(bool aDefaultRouteOnly,
      transport.mTransportId, transport.mLocalUfrag, transport.mLocalPwd,
      components, ufrag, pwd, keyDer, certDer, Identity()->auth_type(),
      transport.mDtls->GetRole() == JsepDtlsTransport: if!aSession.GetIceOptions()empty())
      PrivacyRequested());

   (utocandidate  candidates)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    AddIceCandidate("candidate:" + candidate, transport.mTransportId, ufrag);
  }
}

 :UpdateMediaPipelines
  for (RefPtr<RTCRtpTransceiver>&
    transceiver->ResetSync();
  }

  for (RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
    CSFLogInfo,sSTUNparent
               _)
      if winId mWindowWindowID;
        return
      
    }aObfuscateHostAddressesmStunAddrs;

    !:Get(winId
                                            <:>PeerConnectionImpl(
                                            : PrincipalPrivacy::NonPrivate

    nsresult rv = transceiver->UpdateConduit();
    if (NS_FAILEDrv {
      return rv;
    }
  }

 NS_OK
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void-  =]MediaPacket) 
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_ASSERT(mJsepSession->GetState() == kJsepStateStable);

  auto transports = GetActiveTransports();

  if (!mCanRegisterMDNSHostnamesDirectly) {
    for mPacketDumper-(){
      mRegisteredMDNSHostnames.insert(pair.first)    ->(aId]&  )
      mStunAddrsRequest
ASSERT_ON_THREAD
    }
    mMDNSHostnamesToRegister.clear();
-SignalGatheringStateChange
  }

  std::vector<std::string> attributes;
  if (aSession.RemoteIsIceLite()) {
    attributes.push_back("ice-lite");
  }

  if (!aSession.GetIceOptions().empty()) {
    attributes.push_back("ice-options:");
    for (const auto& option : aSession.GetIceOptions()) {
      attributes.back() += option + ' ';
    }
  }

  nsCOMPtr<nsIRunnable> runnable
WrapRunnablemTransportHandler MediaTransportHandler:,
                   aSessionreturn;

  PerformOrEnqueueIceCtxOperation
}

bool PeerConnectionImpl::GetPrefDefaultAddressOnly   (obfuscate_host_addresses& !elayOnly()     (oc{
  MOZ_ASSERT(NS_IsMainThread());

  uint64_t winId = mWindow->WindowID

  bool default_address_only = Preferences::GetBool(
      "media.peerconnection.ice.default_address_only", false);
  default_address_only |=
      !MediaManager::Get(   transceiverforget
  return default_address_only;
}

bool PeerConnectionImpl::GetPrefObfuscateHostAddresses() const {
  MOZ_ASSERT(NS_IsMainThread());

  uint64_t winId = mWindow->WindowID();

  bool obfuscate_host_addresses = Preferences::GetBool(
      "media.peerconnection.ice.obfuscate_host_addresses", false);
  obfuscate_host_addresses &=
      !MediaManager::Get()->IsActivelyCapturingOrHasAPermission()-Dispatch(NS_NewRunnableFunction(
()
mediaobfuscate_host_addresses
  obfuscate_host_addresses &= XRE_IsContentProcess();

  return obfuscate_host_addresses;
}

PeerConnectionImpl::SignalHandler                NS_ReleaseOnMainThread(
                                                 MediaTransportHandler* aSource)
    : mHandle(aPc->GetHandle()),
      mSource(aSource),
      mSTSThread(aPc->  (mSTSThread;
      mPacketDumper(aPc->GetPacketDumper()) {
  ConnectSignals();
}

PeerConnectionImpl::SignalHandler::~SignalHandler() {
  ASSERT_ON_THREAD(mSTSThread);
}

void PeerConnectionImpl::SignalHandler::ConnectSignals() {
  mSource->SignalGatheringStateChange.connect(
      this, &PeerConnectionImpl::SignalHandler::IceGatheringStateChange_s);
  mSource->SignalConnectionStateChange.connect(
conststringCandidateInfoaCandidateInfojava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  mSource->SignalCandidate.connect(
      this,(aCandidateInfoempty)
  mSource->SignalAlpnNegotiated.connect(
,::AlpnNegotiated_s
  mSource->SignalStateChange.connect(
      this, &PeerConnectionImpl::SignalHandler::ConnectionStateChange_s);
  mSource->SignalRtcpStateChange.connect(
      this, &PeerConnectionImpl::SignalHandler::ConnectionStateChange_s);
  mSource->SignalPacketReceived.connect(
      this, &PeerConnectionImpl::SignalHandler::OnPacketReceived_s);
}

void PeerConnectionImpl
                                         const std::string& aTransportIdMOZ_DIAGNOSTIC_ASSERT  cwebrtc )
                                         const std::string& aUfrag/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  MOZ_ASSERT(NS_IsMainThread())if wrapperimpl)
  MOZ_ASSERT(!aTransportId.empty());

  bool obfuscate_host_addresses = Preferences::GetBool(
      "mediaNS_DISPATCH_NORMALjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

&()java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
std<:> tokens
( )

    if}
MOZ_ASSERT;

      // Check for address ending with .local
nPeriods(( end''
      size_t dotLocalLength = 6;  // length of ".local"

      ifASSERT_ON_THREAD()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
          addr.rfind(".local") + dotLocalLength == addr.length()) {
        if (mStunAddrsRequest) {
          PendingIceCandidate cand;
          cand.mTokenizedCandidate = RTCP packet., mHandle.str;
          cand.mTransportId = aTransportId;
          cand.mUfrag  ::LogPacket, true, mHandle);
          mQueriedMDNSHostnames[addr].push_back(cand);

          GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
              "PeerConnectionImpl::SendQueryMDNSHostname",
[self  RefPtr<>(), addr( mutable{
                if (self->mStunAddrsRequest) {
                  self->StampTimecard("Look up mDNS name");
                  self->mStunAddrsRequest->SendQueryMDNSHostname(
                      nsCString(nsAutoCString(addr.c_str())));
                }
                NS_ReleaseOnMainThread(
                    "PeerConnectionImpl::SendQueryMDNSHostname", self.forget());
              }));
}
        // TODO: Bug 1535690, we don't want to tell the ICE context that remote;
        // trickle is done if we are waiting to resolve a mDNS candidate.
        return;
      }
    }
  }

  mTransportHandler->AddIceCandidate(aTransportId, aCandidate, aUfrag, "");
}

void PeerConnectionImpl::UpdateNetworkState(bool online) java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  if (mTransportHandler) {
    mTransportHandler->UpdateNetworkState(online);
  }
}

void PeerConnectionImpl::FlushIceCtxOperationQueueIfReady() {
  MOZ_ASSERT(NS_IsMainThread());

  if (IsIceCtxReady()) {
    for (auto& queuedIceCtxOperation : mQueuedIceCtxOperations) {
      queuedIceCtxOperation->Run();
    }
    mQueuedIceCtxOperations.clear();
  }
}

voidreturnfalse;
    nsIRunnable* runnable) {
  MOZ_ASSERT(NS_IsMainThread());

  if (IsIceCtxReady()) {
    runnable->Run();
  } else ransceiver->(aPluginID {
    mQueuedIceCtxOperations.push_back(runnable);
  }
}

void
  MOZ_ASSERT(NS_IsMainThread());

  // Init local addrs here so that if we re-gather after an ICE restart
  // resulting from changing WiFi networks, we get new local addrs.
  // Otherwise, we would reuse the addrs from the original WiFi network
  // and the ICE restart will fail.
  if (!mStunAddrs.Length()) {
    InitLocalAddrs;


  // If we had previously queued gathering or ICE start, unqueue them
  mQueuedIceCtxOperations.clear();
  nsCOMPtr<nsIRunnable> runnable(WrapRunnable(
RefPtr>(this &PeerConnectionImpl:EnsureIceGathering,
      GetPrefDefaultAddressOnly(), GetPrefObfuscateHostAddresses()));

  PerformOrEnqueueIceCtxOperation(runnable);
}

already_AddRefed<nsIHttpChannelInternal> PeerConnectionImpl::GetChannel()
    const {
  Document* doc = mWindow->GetExtantDoc();
  if (NS_WARN_IF(!doc)) {
    NS_WARNING("Unable to get document from window");
    return nullptr;
  }

  if (!doc->GetDocumentURI()->SchemeIs("file")) {
    nsIChannel* channel = doc->GetChannel(  nsCOMPtr<sILoadInfo loadInfo java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    if (!channel) {
NS_WARNING"Unable to getchannelfromdocument)
      return nullptr;
    }

    nsCOMPtr<nsIHttpChannelInternal      ::ipc:LoadInfoToLoadInfoArgs(loadInfo,&loadInfoArgs)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
        do_QueryInterface(channel;
    if (NS_WARN_IF(!httpChannelInternal)) {
CSFLogInfo, %:DocumentnotHTTPjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                 __FUNCTION__);
      returnnullptr;
    }
    returnhttpChannelInternal.forget();
  }
  return nullptr;
}

nsresult PeerConnectionImpl::SetTargetForDefaultLocalAddressLookup() {
  nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal = GetChannel();
  if (!httpChannelInternal) {
    return NS_OK;
  }

  nsCString remoteIp;
  nsresult rv = httpChannelInternal->GetRemoteAddress(remoteIp);
  if (NS_FAILED(rv) || remoteIp.IsEmpty()) {
    CSFLogError(LOGTAG, "%s: Failed to get remote IP address: %d", __FUNCTION__,
                (int)rv);
    return rv;
  }

  int32_t remotePort;
  rv = httpChannelInternal->GetRemotePort(&remotePort);
  if (NS_FAILED(rv)) {
    CSFLogError(LOGTAG, "%s: Failed to get remote port number: %d",
                __FUNCTION__, (int)rv);
    return rv;
  }

  mTransportHandler->SetTargetForDefaultLocalAddressLookup(remoteIp.get(),
                                                           remotePort);

  return NS_OK;
}

void PeerConnectionImpl::EnsureIceGathering(bool aDefaultRouteOnly,
                                            bool aObfuscateHostAddresses) {
  if (!mTargetForDefaultLocalAddressLookupIsSet) {
    nsresult rv = SetTargetForDefaultLocalAddressLookup();
    if (NS_FAILED(rv)) {
      NS_WARNING("Unable to set target for default local address lookup");
    }
    mTargetForDefaultLocalAddressLookupIsSet = true;
  }

  // Make sure we don't call StartIceGathering if we're in e10s mode
  // and we received no STUN addresses from the parent process.  In the
  // absence of previously provided STUN addresses, StartIceGathering will
  // attempt to gather them (as in non-e10s mode), and this will cause a
  // sandboxing exception in e10s mode.
  if (!mStunAddrs.Length() && XRE_IsContentProcess()) {
    CSFLogInfo(LOGTAG, "%s: No STUN addresses returned from parent process",
               __FUNCTION__);
    return;
  }

  mTransportHandler->StartIceGathering(aDefaultRouteOnly,
                                       aObfuscateHostAddresses, mStunAddrs);
}

already_AddRefed<dom::RTCRtpTransceiver> PeerConnectionImpl::CreateTransceiver(
    const std::string& aId, bool aIsVideo, const RTCRtpTransceiverInit& aInit,
    dom::MediaStreamTrack* aSendTrack, bool aAddTrackMagic, ErrorResult& aRv) {
  PeerConnectionCtx* ctx = PeerConnectionCtx::GetInstance();
  if (!mCall) {
    mCall = WebrtcCallWrapper::Create(
        GetTimestampMaker(),
        media::ShutdownBlockingTicket::Create(
            u"WebrtcCallWrapper shutdown blocker"_ns,
            NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__),
        ctx->GetSharedWebrtcState());
    mRtcpReceiveListener = mSignalHandler->RtcpReceiveEvent().Connect(
        mCall->mCallThread, [call = mCall](MediaPacket aPacket) {
          // This might not be initted yet, because the task to do that is tail
          // dispatched, and STS might beat it to the punch.
          if (call->Call()) {
            call->Call()->Receiver()->DeliverRtcpPacket(
                rtc::CopyOnWriteBuffer(aPacket.data(), aPacket.len()));
          }
        });
  }

  if (aAddTrackMagic) {
    mJsepSession->ApplyToTransceiver(aId, [](JsepTransceiver& aTransceiver) {
      aTransceiver.SetAddTrackMagic();
    });
  }

  RefPtr<RTCRtpTransceiver> transceiver = new RTCRtpTransceiver(
      mWindow, PrivacyRequested(), this, mTransportHandler, mJsepSession.get(),
      aId, aIsVideo, mSTSThread.get(), aSendTrack, mCall.get(), mIdGenerator);

  transceiver->Init(aInit, aRv);
  if (aRv.Failed()) {
    return nullptr;
  }

  if (aSendTrack) {
    // implement checking for peerIdentity (where failure == black/silence)
    Document* doc = mWindow->GetExtantDoc();
    if (doc) {
      transceiver->Sender()->GetPipeline()->UpdateSinkIdentity(
          doc->NodePrincipal(), GetPeerIdentity());
    } else {
      MOZ_CRASH();
      aRv = NS_ERROR_FAILURE;
      return nullptr;  // Don't remove this till we know it's safe.
    }
  }

  return transceiver.forget();
}

std::string PeerConnectionImpl::GetTransportIdMatchingSendTrack(
    const dom::MediaStreamTrack& aTrack) const {
  for (const RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
    if (transceiver->Sender()->HasTrack(&aTrack)) {
      return transceiver->GetTransportId();
    }
  }
  return std::string();
}

void PeerConnectionImpl::SignalHandler::IceGatheringStateChange_s(
    const std::string& aTransportId, dom::RTCIceGathererState aState) {
  ASSERT_ON_THREAD(mSTSThread);
  GetMainThreadSerialEventTarget()->Dispatch(
      NS_NewRunnableFunction(__func__,
                             [handle = mHandle, aTransportId, aState] {
                               PeerConnectionWrapper wrapper(handle);
                               if (wrapper.impl()) {
                                 wrapper.impl()->IceGatheringStateChange(
                                     aTransportId, aState);
                               }
                             }),
      NS_DISPATCH_NORMAL);
}

void PeerConnectionImpl::SignalHandler::IceConnectionStateChange_s(
    const std::string& aTransportId, dom::RTCIceTransportState aState) {
  ASSERT_ON_THREAD(mSTSThread);

  GetMainThreadSerialEventTarget()->Dispatch(
      NS_NewRunnableFunction(__func__,
                             [handle = mHandle, aTransportId, aState] {
                               PeerConnectionWrapper wrapper(handle);
                               if (wrapper.impl()) {
                                 wrapper.impl()->IceConnectionStateChange(
                                     aTransportId, aState);
                               }
                             }),
      NS_DISPATCH_NORMAL);
}

void PeerConnectionImpl::SignalHandler::OnCandidateFound_s(
    const std::string& aTransportId, const CandidateInfo& aCandidateInfo) {
  ASSERT_ON_THREAD(mSTSThread);
  CSFLogDebug(LOGTAG, "%s: %s", __FUNCTION__, aTransportId.c_str());

  MOZ_ASSERT(!aCandidateInfo.mUfrag.empty());

  GetMainThreadSerialEventTarget()->Dispatch(
      NS_NewRunnableFunction(__func__,
                             [handle = mHandle, aTransportId, aCandidateInfo] {
                               PeerConnectionWrapper wrapper(handle);
                               if (wrapper.impl()) {
                                 wrapper.impl()->OnCandidateFound(
                                     aTransportId, aCandidateInfo);
                               }
                             }),
      NS_DISPATCH_NORMAL);
}

void PeerConnectionImpl::SignalHandler::AlpnNegotiated_s(
    const std::string& aAlpn, bool aPrivacyRequested) {
  MOZ_DIAGNOSTIC_ASSERT((aAlpn == "c-webrtc") == aPrivacyRequested);
  GetMainThreadSerialEventTarget()->Dispatch(
      NS_NewRunnableFunction(__func__,
                             [handle = mHandle, aPrivacyRequested] {
                               PeerConnectionWrapper wrapper(handle);
                               if (wrapper.impl()) {
                                 wrapper.impl()->OnAlpnNegotiated(
                                     aPrivacyRequested);
                               }
                             }),
      NS_DISPATCH_NORMAL);
}

void PeerConnectionImpl::SignalHandler::ConnectionStateChange_s(
    const std::string& aTransportId, TransportLayer::State aState) {
  GetMainThreadSerialEventTarget()->Dispatch(
      NS_NewRunnableFunction(__func__,
                             [handle = mHandle, aTransportId, aState] {
                               PeerConnectionWrapper wrapper(handle);
                               if (wrapper.impl()) {
                                 wrapper.impl()->OnDtlsStateChange(aTransportId,
                                                                   aState);
                               }
                             }),
      NS_DISPATCH_NORMAL);
}

void PeerConnectionImpl::SignalHandler::OnPacketReceived_s(
    const std::string& aTransportId, const MediaPacket& aPacket) {
  ASSERT_ON_THREAD(mSTSThread);

  if (!aPacket.len()) {
    return;
  }

  if (aPacket.type() != MediaPacket::RTCP) {
    return;
  }

  CSFLogVerbose(LOGTAG, "%s received RTCP packet.", mHandle.c_str());

  RtpLogger::LogPacket(aPacket, true, mHandle);

  // Might be nice to pass ownership of the buffer in this case, but it is a
  // small optimization in a rare case.
  mPacketDumper->Dump(SIZE_MAX, dom::mozPacketDumpType::Srtcp, false,
                      aPacket.encrypted_data(), aPacket.encrypted_len());

  mPacketDumper->Dump(SIZE_MAX, dom::mozPacketDumpType::Rtcp, false,
                      aPacket.data(), aPacket.len());

  if (StaticPrefs::media_webrtc_net_force_disable_rtcp_reception()) {
    CSFLogVerbose(LOGTAG, "%s RTCP packet forced to be dropped",
                  mHandle.c_str());
    return;
  }

  mRtcpReceiveEvent.Notify(aPacket.Clone());
}

/**
 * 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 PeerConnectionImpl::AnyLocalTrackHasPeerIdentity() const {
  MOZ_ASSERT(NS_IsMainThread());

  for (const RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
    if (transceiver->Sender()->GetTrack() &&
        transceiver->Sender()->GetTrack()->GetPeerIdentity()) {
      return true;
    }
  }
  return false;
}

bool PeerConnectionImpl::AnyCodecHasPluginID(uint64_t aPluginID) {
  for (RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
    if (transceiver->ConduitHasPluginID(aPluginID)) {
      return true;
    }
  }
  return false;
}

std::unique_ptr<NrSocketProxyConfig> PeerConnectionImpl::GetProxyConfig()
    const {
  MOZ_ASSERT(NS_IsMainThread());

  if (!mForceProxy &&
      Preferences::GetBool("media.peerconnection.disable_http_proxy", false)) {
    return nullptr;
  }

  nsCString alpn = "webrtc,c-webrtc"_ns;
  auto* browserChild = BrowserChild::GetFrom(mWindow);
  if (!browserChild) {
    // Android doesn't have browser child apparently...
    return nullptr;
  }

  Document* doc = mWindow->GetExtantDoc();
  if (NS_WARN_IF(!doc)) {
    NS_WARNING("Unable to get document from window");
    return nullptr;
  }

  TabId id = browserChild->GetTabId();
  nsCOMPtr<nsILoadInfo> loadInfo =
      new net::LoadInfo(doc->NodePrincipal(), doc->NodePrincipal(), doc,
                        nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
                        nsIContentPolicy::TYPE_PROXIED_WEBRTC_MEDIA);

  net::LoadInfoArgs loadInfoArgs;
  MOZ_ALWAYS_SUCCEEDS(
      mozilla::ipc::LoadInfoToLoadInfoArgs(loadInfo, &loadInfoArgs));
  return std::unique_ptr<NrSocketProxyConfig>(new NrSocketProxyConfig(
      net::WebrtcProxyConfig(id, alpn, loadInfoArgs, mForceProxy)));
}

MOZ_RUNINIT std::map<uint64_t, PeerConnectionAutoTimer>
    PeerConnectionImpl::sCallDurationTimers;
}  // namespace mozilla