1 files changed, 215 insertions, 0 deletions
diff --git a/dom/media/webrtc/jsapi/RTCRtpReceiver.h b/dom/media/webrtc/jsapi/RTCRtpReceiver.h
new file mode 100644
index 0000000000..af074ee0f1
--- /dev/null
+++ b/dom/media/webrtc/jsapi/RTCRtpReceiver.h
@@ -0,0 +1,215 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _RTCRtpReceiver_h_
+#define _RTCRtpReceiver_h_
+
+#include "nsISupports.h"
+#include "nsWrapperCache.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/StateMirroring.h"
+#include "mozilla/Maybe.h"
+#include "js/RootingAPI.h"
+#include "libwebrtcglue/RtpRtcpConfig.h"
+#include "nsTArray.h"
+#include "mozilla/dom/RTCRtpCapabilitiesBinding.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "PerformanceRecorder.h"
+#include "RTCStatsReport.h"
+#include "transportbridge/MediaPipeline.h"
+#include <vector>
+
+class nsPIDOMWindowInner;
+
+namespace mozilla {
+class MediaSessionConduit;
+class MediaTransportHandler;
+class JsepTransceiver;
+class PeerConnectionImpl;
+enum class PrincipalPrivacy : uint8_t;
+class RemoteTrackSource;
+
+namespace dom {
+class MediaStreamTrack;
+class Promise;
+class RTCDtlsTransport;
+struct RTCRtpCapabilities;
+struct RTCRtpContributingSource;
+struct RTCRtpSynchronizationSource;
+class RTCRtpTransceiver;
+class RTCRtpScriptTransform;
+
+class RTCRtpReceiver : public nsISupports,
+                       public nsWrapperCache,
+                       public MediaPipelineReceiveControlInterface {
+ public:
+  RTCRtpReceiver(nsPIDOMWindowInner* aWindow, PrincipalPrivacy aPrivacy,
+                 PeerConnectionImpl* aPc,
+                 MediaTransportHandler* aTransportHandler,
+                 AbstractThread* aCallThread, nsISerialEventTarget* aStsThread,
+                 MediaSessionConduit* aConduit, RTCRtpTransceiver* aTransceiver,
+                 const TrackingId& aTrackingId);
+
+  // nsISupports
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpReceiver)
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+  // webidl
+  MediaStreamTrack* Track() const { return mTrack; }
+  RTCDtlsTransport* GetTransport() const;
+  static void GetCapabilities(const GlobalObject&, const nsAString& aKind,
+                              Nullable<dom::RTCRtpCapabilities>& aResult);
+  already_AddRefed<Promise> GetStats(ErrorResult& aError);
+  void GetContributingSources(
+      nsTArray<dom::RTCRtpContributingSource>& aSources);
+  void GetSynchronizationSources(
+      nsTArray<dom::RTCRtpSynchronizationSource>& aSources);
+  // test-only: insert fake CSRCs and audio levels for testing
+  void MozInsertAudioLevelForContributingSource(
+      const uint32_t aSource, const DOMHighResTimeStamp aTimestamp,
+      const uint32_t aRtpTimestamp, const bool aHasLevel, const uint8_t aLevel);
+
+  RTCRtpScriptTransform* GetTransform() const { return mTransform; }
+
+  void SetTransform(RTCRtpScriptTransform* aTransform, ErrorResult& aError);
+
+  nsPIDOMWindowInner* GetParentObject() const;
+  nsTArray<RefPtr<RTCStatsPromise>> GetStatsInternal(
+      bool aSkipIceStats = false);
+  Nullable<DOMHighResTimeStamp> GetJitterBufferTarget(
+      ErrorResult& aError) const {
+    return mJitterBufferTarget.isSome() ? Nullable(mJitterBufferTarget.value())
+                                        : Nullable<DOMHighResTimeStamp>();
+  }
+  void SetJitterBufferTarget(const Nullable<DOMHighResTimeStamp>& aTargetMs,
+                             ErrorResult& aError);
+
+  void Shutdown();
+  void BreakCycles();
+  void Unlink();
+  // Terminal state, reached through stopping RTCRtpTransceiver.
+  void Stop();
+  bool HasTrack(const dom::MediaStreamTrack* aTrack) const;
+  void SyncToJsep(JsepTransceiver& aJsepTransceiver) const;
+  void SyncFromJsep(const JsepTransceiver& aJsepTransceiver);
+  const std::vector<std::string>& GetStreamIds() const { return mStreamIds; }
+
+  struct StreamAssociation {
+    RefPtr<MediaStreamTrack> mTrack;
+    std::string mStreamId;
+  };
+
+  struct TrackEventInfo {
+    RefPtr<RTCRtpReceiver> mReceiver;
+    std::vector<std::string> mStreamIds;
+  };
+
+  struct StreamAssociationChanges {
+    std::vector<RefPtr<RTCRtpReceiver>> mReceiversToMute;
+    std::vector<StreamAssociation> mStreamAssociationsRemoved;
+    std::vector<StreamAssociation> mStreamAssociationsAdded;
+    std::vector<TrackEventInfo> mTrackEvents;
+  };
+
+  // This is called when we set an answer (ie; when the transport is finalized).
+  void UpdateTransport();
+  void UpdateConduit();
+
+  // This is called when we set a remote description; may be an offer or answer.
+  void UpdateStreams(StreamAssociationChanges* aChanges);
+
+  // Called when the privacy-needed state changes on the fly, as a result of
+  // ALPN negotiation.
+  void UpdatePrincipalPrivacy(PrincipalPrivacy aPrivacy);
+
+  // Called by FrameTransformerProxy
+  void RequestKeyFrame();
+
+  void OnRtcpBye();
+  void OnRtcpTimeout();
+
+  void SetTrackMuteFromRemoteSdp();
+  void OnRtpPacket();
+  void UpdateUnmuteBlockingState();
+  void UpdateReceiveTrackMute();
+
+  Canonical<Ssrc>& CanonicalSsrc() { return mSsrc; }
+  Canonical<Ssrc>& CanonicalVideoRtxSsrc() { return mVideoRtxSsrc; }
+  Canonical<RtpExtList>& CanonicalLocalRtpExtensions() {
+    return mLocalRtpExtensions;
+  }
+
+  Canonical<std::vector<AudioCodecConfig>>& CanonicalAudioCodecs() {
+    return mAudioCodecs;
+  }
+
+  Canonical<std::vector<VideoCodecConfig>>& CanonicalVideoCodecs() {
+    return mVideoCodecs;
+  }
+
+  Canonical<Maybe<RtpRtcpConfig>>& CanonicalVideoRtpRtcpConfig() {
+    return mVideoRtpRtcpConfig;
+  }
+
+  Canonical<bool>& CanonicalReceiving() override { return mReceiving; }
+
+  Canonical<RefPtr<FrameTransformerProxy>>& CanonicalFrameTransformerProxy() {
+    return mFrameTransformerProxy;
+  }
+
+ private:
+  virtual ~RTCRtpReceiver();
+
+  void UpdateVideoConduit();
+  void UpdateAudioConduit();
+
+  std::string GetMid() const;
+  JsepTransceiver& GetJsepTransceiver();
+  const JsepTransceiver& GetJsepTransceiver() const;
+
+  WatchManager<RTCRtpReceiver> mWatchManager;
+  nsCOMPtr<nsPIDOMWindowInner> mWindow;
+  RefPtr<PeerConnectionImpl> mPc;
+  bool mHaveStartedReceiving = false;
+  bool mHaveSetupTransport = false;
+  RefPtr<AbstractThread> mCallThread;
+  nsCOMPtr<nsISerialEventTarget> mStsThread;
+  RefPtr<dom::MediaStreamTrack> mTrack;
+  RefPtr<RemoteTrackSource> mTrackSource;
+  RefPtr<MediaPipelineReceive> mPipeline;
+  RefPtr<MediaTransportHandler> mTransportHandler;
+  RefPtr<RTCRtpTransceiver> mTransceiver;
+  RefPtr<RTCRtpScriptTransform> mTransform;
+  // This is [[AssociatedRemoteMediaStreams]], basically. We do not keep the
+  // streams themselves here, because that would require this object to know
+  // where the stream list for the whole RTCPeerConnection lives..
+  std::vector<std::string> mStreamIds;
+  bool mRemoteSetSendBit = false;
+  Watchable<bool> mReceiveTrackMute{true, "RTCRtpReceiver::mReceiveTrackMute"};
+  // This corresponds to the [[Receptive]] slot on RTCRtpTransceiver.
+  // Its only purpose is suppressing unmute events if true.
+  bool mReceptive = false;
+  // This is the [[JitterBufferTarget]] internal slot.
+  Maybe<DOMHighResTimeStamp> mJitterBufferTarget;
+
+  MediaEventListener mRtcpByeListener;
+  MediaEventListener mRtcpTimeoutListener;
+  MediaEventListener mUnmuteListener;
+
+  Canonical<Ssrc> mSsrc;
+  Canonical<Ssrc> mVideoRtxSsrc;
+  Canonical<RtpExtList> mLocalRtpExtensions;
+  Canonical<std::vector<AudioCodecConfig>> mAudioCodecs;
+  Canonical<std::vector<VideoCodecConfig>> mVideoCodecs;
+  Canonical<Maybe<RtpRtcpConfig>> mVideoRtpRtcpConfig;
+  Canonical<bool> mReceiving;
+  Canonical<RefPtr<FrameTransformerProxy>> mFrameTransformerProxy;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+#endif  // _RTCRtpReceiver_h_