Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 438 insertions, 0 deletions

diff --git a/dom/media/webrtc/WebrtcGlobal.h b/dom/media/webrtc/WebrtcGlobal.h
new file mode 100644
index 0000000000..7e27ca9aaf
--- /dev/null
+++ b/dom/media/webrtc/WebrtcGlobal.h
@@ -0,0 +1,438 @@
+/* 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 _WEBRTC_GLOBAL_H_
+#define _WEBRTC_GLOBAL_H_
+
+#include "WebrtcIPCTraits.h"
+#include "ipc/EnumSerializer.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/RTCDataChannelBinding.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "mozilla/UniquePtr.h"
+
+typedef mozilla::dom::RTCStatsReportInternal StatsReport;
+typedef nsTArray<mozilla::UniquePtr<StatsReport>> RTCReports;
+typedef mozilla::dom::Sequence<nsString> WebrtcGlobalLog;
+
+namespace mozilla {
+namespace dom {
+// webidl dictionaries don't have move semantics, which is something that ipdl
+// needs for async returns. So, we create a "moveable" subclass that just
+// copies. _Really_ lame, but it gets the job done.
+struct NotReallyMovableButLetsPretendItIsRTCStatsCollection
+    : public RTCStatsCollection {
+  NotReallyMovableButLetsPretendItIsRTCStatsCollection() = default;
+  explicit NotReallyMovableButLetsPretendItIsRTCStatsCollection(
+      RTCStatsCollection&& aStats) {
+    RTCStatsCollection::operator=(aStats);
+  }
+  explicit NotReallyMovableButLetsPretendItIsRTCStatsCollection(
+      const RTCStatsCollection& aStats) {
+    RTCStatsCollection::operator=(aStats);
+  }
+};
+}  // namespace dom
+}  // namespace mozilla
+
+namespace IPC {
+
+template <typename T>
+struct ParamTraits<mozilla::dom::Sequence<T>> {
+  typedef mozilla::dom::Sequence<T> paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, static_cast<const FallibleTArray<T>&>(aParam));
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    return ReadParam(aMsg, aIter, static_cast<FallibleTArray<T>*>(aResult));
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::dom::RTCStatsType>
+    : public ContiguousEnumSerializer<mozilla::dom::RTCStatsType,
+                                      mozilla::dom::RTCStatsType::Inbound_rtp,
+                                      mozilla::dom::RTCStatsType::EndGuard_> {};
+
+template <>
+struct ParamTraits<mozilla::dom::RTCStatsIceCandidatePairState>
+    : public ContiguousEnumSerializer<
+          mozilla::dom::RTCStatsIceCandidatePairState,
+          mozilla::dom::RTCStatsIceCandidatePairState::Frozen,
+          mozilla::dom::RTCStatsIceCandidatePairState::EndGuard_> {};
+
+template <>
+struct ParamTraits<mozilla::dom::RTCIceCandidateType>
+    : public ContiguousEnumSerializer<
+          mozilla::dom::RTCIceCandidateType,
+          mozilla::dom::RTCIceCandidateType::Host,
+          mozilla::dom::RTCIceCandidateType::EndGuard_> {};
+
+template <>
+struct ParamTraits<
+    mozilla::dom::NotReallyMovableButLetsPretendItIsRTCStatsCollection> {
+  typedef mozilla::dom::NotReallyMovableButLetsPretendItIsRTCStatsCollection
+      paramType;
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg,
+               static_cast<const mozilla::dom::RTCStatsCollection&>(aParam));
+  }
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    return ReadParam(aMsg, aIter,
+                     static_cast<mozilla::dom::RTCStatsCollection*>(aResult));
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::dom::RTCBundlePolicy>
+    : public ContiguousEnumSerializer<
+          mozilla::dom::RTCBundlePolicy,
+          mozilla::dom::RTCBundlePolicy::Balanced,
+          mozilla::dom::RTCBundlePolicy::EndGuard_> {};
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::RTCIceServerInternal, mUrls,
+                                  mCredentialProvided, mUserNameProvided);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::RTCConfigurationInternal,
+                                  mBundlePolicy, mCertificatesProvided,
+                                  mIceServers, mIceTransportPolicy,
+                                  mPeerIdentityProvided, mSdpSemantics);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::RTCSdpParsingErrorInternal,
+                                  mLineNumber, mError);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::RTCSdpHistoryEntryInternal,
+                                  mTimestamp, mIsLocal, mSdp, mErrors);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(
+    mozilla::dom::RTCStatsCollection, mIceCandidatePairStats,
+    mIceCandidateStats, mInboundRtpStreamStats, mOutboundRtpStreamStats,
+    mRemoteInboundRtpStreamStats, mRemoteOutboundRtpStreamStats,
+    mRtpContributingSourceStats, mTrickledIceCandidateStats,
+    mRawLocalCandidates, mRawRemoteCandidates, mDataChannelStats,
+    mVideoFrameHistories, mBandwidthEstimations);
+
+DEFINE_IPC_SERIALIZER_WITH_SUPER_CLASS_AND_FIELDS(
+    mozilla::dom::RTCStatsReportInternal, mozilla::dom::RTCStatsCollection,
+    mClosed, mLocalSdp, mSdpHistory, mPcid, mBrowserId, mRemoteSdp, mTimestamp,
+    mCallDurationMs, mIceRestarts, mIceRollbacks, mOfferer, mConfiguration);
+
+typedef mozilla::dom::RTCStats RTCStats;
+
+static void WriteRTCStats(Message* aMsg, const RTCStats& aParam) {
+  // RTCStats base class
+  WriteParam(aMsg, aParam.mId);
+  WriteParam(aMsg, aParam.mTimestamp);
+  WriteParam(aMsg, aParam.mType);
+}
+
+static bool ReadRTCStats(const Message* aMsg, PickleIterator* aIter,
+                         RTCStats* aResult) {
+  // RTCStats base class
+  if (!ReadParam(aMsg, aIter, &(aResult->mId)) ||
+      !ReadParam(aMsg, aIter, &(aResult->mTimestamp)) ||
+      !ReadParam(aMsg, aIter, &(aResult->mType))) {
+    return false;
+  }
+
+  return true;
+}
+
+template <>
+struct ParamTraits<mozilla::dom::RTCIceCandidatePairStats> {
+  typedef mozilla::dom::RTCIceCandidatePairStats paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mTransportId);
+    WriteParam(aMsg, aParam.mLocalCandidateId);
+    WriteParam(aMsg, aParam.mPriority);
+    WriteParam(aMsg, aParam.mNominated);
+    WriteParam(aMsg, aParam.mWritable);
+    WriteParam(aMsg, aParam.mReadable);
+    WriteParam(aMsg, aParam.mRemoteCandidateId);
+    WriteParam(aMsg, aParam.mSelected);
+    WriteParam(aMsg, aParam.mComponentId);
+    WriteParam(aMsg, aParam.mState);
+    WriteParam(aMsg, aParam.mBytesSent);
+    WriteParam(aMsg, aParam.mBytesReceived);
+    WriteParam(aMsg, aParam.mLastPacketSentTimestamp);
+    WriteParam(aMsg, aParam.mLastPacketReceivedTimestamp);
+    WriteRTCStats(aMsg, aParam);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    if (!ReadParam(aMsg, aIter, &(aResult->mTransportId)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mLocalCandidateId)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mPriority)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mNominated)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mWritable)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mReadable)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mRemoteCandidateId)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mSelected)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mComponentId)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mState)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mBytesSent)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mBytesReceived)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mLastPacketSentTimestamp)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mLastPacketReceivedTimestamp)) ||
+        !ReadRTCStats(aMsg, aIter, aResult)) {
+      return false;
+    }
+
+    return true;
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::dom::RTCIceCandidateStats> {
+  typedef mozilla::dom::RTCIceCandidateStats paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mCandidateType);
+    WriteParam(aMsg, aParam.mPriority);
+    WriteParam(aMsg, aParam.mTransportId);
+    WriteParam(aMsg, aParam.mAddress);
+    WriteParam(aMsg, aParam.mRelayProtocol);
+    WriteParam(aMsg, aParam.mPort);
+    WriteParam(aMsg, aParam.mProtocol);
+    WriteParam(aMsg, aParam.mProxied);
+    WriteRTCStats(aMsg, aParam);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    if (!ReadParam(aMsg, aIter, &(aResult->mCandidateType)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mPriority)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mTransportId)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mAddress)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mRelayProtocol)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mPort)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mProtocol)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mProxied)) ||
+        !ReadRTCStats(aMsg, aIter, aResult)) {
+      return false;
+    }
+
+    return true;
+  }
+};
+
+static void WriteRTCRtpStreamStats(
+    Message* aMsg, const mozilla::dom::RTCRtpStreamStats& aParam) {
+  WriteParam(aMsg, aParam.mSsrc);
+  WriteParam(aMsg, aParam.mMediaType);
+  WriteParam(aMsg, aParam.mKind);
+  WriteParam(aMsg, aParam.mTransportId);
+  WriteRTCStats(aMsg, aParam);
+}
+
+static bool ReadRTCRtpStreamStats(const Message* aMsg, PickleIterator* aIter,
+                                  mozilla::dom::RTCRtpStreamStats* aResult) {
+  return ReadParam(aMsg, aIter, &(aResult->mSsrc)) &&
+         ReadParam(aMsg, aIter, &(aResult->mMediaType)) &&
+         ReadParam(aMsg, aIter, &(aResult->mKind)) &&
+         ReadParam(aMsg, aIter, &(aResult->mTransportId)) &&
+         ReadRTCStats(aMsg, aIter, aResult);
+}
+
+static void WriteRTCReceivedRtpStreamStats(
+    Message* aMsg, const mozilla::dom::RTCReceivedRtpStreamStats& aParam) {
+  WriteParam(aMsg, aParam.mPacketsReceived);
+  WriteParam(aMsg, aParam.mPacketsLost);
+  WriteParam(aMsg, aParam.mJitter);
+  WriteParam(aMsg, aParam.mDiscardedPackets);
+  WriteParam(aMsg, aParam.mPacketsDiscarded);
+  WriteRTCRtpStreamStats(aMsg, aParam);
+}
+
+static bool ReadRTCReceivedRtpStreamStats(
+    const Message* aMsg, PickleIterator* aIter,
+    mozilla::dom::RTCReceivedRtpStreamStats* aResult) {
+  return ReadParam(aMsg, aIter, &(aResult->mPacketsReceived)) &&
+         ReadParam(aMsg, aIter, &(aResult->mPacketsLost)) &&
+         ReadParam(aMsg, aIter, &(aResult->mJitter)) &&
+         ReadParam(aMsg, aIter, &(aResult->mDiscardedPackets)) &&
+         ReadParam(aMsg, aIter, &(aResult->mPacketsDiscarded)) &&
+         ReadRTCRtpStreamStats(aMsg, aIter, aResult);
+}
+
+template <>
+struct ParamTraits<mozilla::dom::RTCInboundRtpStreamStats> {
+  typedef mozilla::dom::RTCInboundRtpStreamStats paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mRemoteId);
+    WriteParam(aMsg, aParam.mFramesDecoded);
+    WriteParam(aMsg, aParam.mBytesReceived);
+    WriteParam(aMsg, aParam.mNackCount);
+    WriteParam(aMsg, aParam.mFirCount);
+    WriteParam(aMsg, aParam.mPliCount);
+    WriteParam(aMsg, aParam.mBitrateMean);
+    WriteParam(aMsg, aParam.mBitrateStdDev);
+    WriteParam(aMsg, aParam.mFramerateMean);
+    WriteParam(aMsg, aParam.mFramerateStdDev);
+    WriteRTCReceivedRtpStreamStats(aMsg, aParam);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    return ReadParam(aMsg, aIter, &(aResult->mRemoteId)) &&
+           ReadParam(aMsg, aIter, &(aResult->mFramesDecoded)) &&
+           ReadParam(aMsg, aIter, &(aResult->mBytesReceived)) &&
+           ReadParam(aMsg, aIter, &(aResult->mNackCount)) &&
+           ReadParam(aMsg, aIter, &(aResult->mFirCount)) &&
+           ReadParam(aMsg, aIter, &(aResult->mPliCount)) &&
+           ReadParam(aMsg, aIter, &(aResult->mBitrateMean)) &&
+           ReadParam(aMsg, aIter, &(aResult->mBitrateStdDev)) &&
+           ReadParam(aMsg, aIter, &(aResult->mFramerateMean)) &&
+           ReadParam(aMsg, aIter, &(aResult->mFramerateStdDev)) &&
+           ReadRTCReceivedRtpStreamStats(aMsg, aIter, aResult);
+  }
+};
+
+static void WriteRTCSentRtpStreamStats(
+    Message* aMsg, const mozilla::dom::RTCSentRtpStreamStats& aParam) {
+  WriteParam(aMsg, aParam.mPacketsSent);
+  WriteParam(aMsg, aParam.mBytesSent);
+  WriteRTCRtpStreamStats(aMsg, aParam);
+}
+
+static bool ReadRTCSentRtpStreamStats(
+    const Message* aMsg, PickleIterator* aIter,
+    mozilla::dom::RTCSentRtpStreamStats* aResult) {
+  return ReadParam(aMsg, aIter, &(aResult->mPacketsSent)) &&
+         ReadParam(aMsg, aIter, &(aResult->mBytesSent)) &&
+         ReadRTCRtpStreamStats(aMsg, aIter, aResult);
+}
+
+template <>
+struct ParamTraits<mozilla::dom::RTCOutboundRtpStreamStats> {
+  typedef mozilla::dom::RTCOutboundRtpStreamStats paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mRemoteId);
+    WriteParam(aMsg, aParam.mFramesEncoded);
+    WriteParam(aMsg, aParam.mQpSum);
+    WriteParam(aMsg, aParam.mNackCount);
+    WriteParam(aMsg, aParam.mFirCount);
+    WriteParam(aMsg, aParam.mPliCount);
+    WriteParam(aMsg, aParam.mBitrateMean);
+    WriteParam(aMsg, aParam.mBitrateStdDev);
+    WriteParam(aMsg, aParam.mFramerateMean);
+    WriteParam(aMsg, aParam.mFramerateStdDev);
+    WriteParam(aMsg, aParam.mDroppedFrames);
+    WriteRTCSentRtpStreamStats(aMsg, aParam);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    return ReadParam(aMsg, aIter, &(aResult->mRemoteId)) &&
+           ReadParam(aMsg, aIter, &(aResult->mFramesEncoded)) &&
+           ReadParam(aMsg, aIter, &(aResult->mQpSum)) &&
+           ReadParam(aMsg, aIter, &(aResult->mNackCount)) &&
+           ReadParam(aMsg, aIter, &(aResult->mFirCount)) &&
+           ReadParam(aMsg, aIter, &(aResult->mPliCount)) &&
+           ReadParam(aMsg, aIter, &(aResult->mBitrateMean)) &&
+           ReadParam(aMsg, aIter, &(aResult->mBitrateStdDev)) &&
+           ReadParam(aMsg, aIter, &(aResult->mFramerateMean)) &&
+           ReadParam(aMsg, aIter, &(aResult->mFramerateStdDev)) &&
+           ReadParam(aMsg, aIter, &(aResult->mDroppedFrames)) &&
+           ReadRTCSentRtpStreamStats(aMsg, aIter, aResult);
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::dom::RTCRemoteInboundRtpStreamStats> {
+  typedef mozilla::dom::RTCRemoteInboundRtpStreamStats paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mLocalId);
+    WriteParam(aMsg, aParam.mBytesReceived);  // To be removed in Bug 1529405
+    WriteParam(aMsg, aParam.mRoundTripTime);
+    WriteRTCReceivedRtpStreamStats(aMsg, aParam);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    return ReadParam(aMsg, aIter, &(aResult->mLocalId)) &&
+           ReadParam(
+               aMsg, aIter,
+               &(aResult->mBytesReceived)) &&  // To be removed in Bug 1529405
+           ReadParam(aMsg, aIter, &(aResult->mRoundTripTime)) &&
+           ReadRTCReceivedRtpStreamStats(aMsg, aIter, aResult);
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::dom::RTCRemoteOutboundRtpStreamStats> {
+  typedef mozilla::dom::RTCRemoteOutboundRtpStreamStats paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mLocalId);
+    WriteParam(aMsg, aParam.mRemoteTimestamp);
+    WriteRTCSentRtpStreamStats(aMsg, aParam);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    return ReadParam(aMsg, aIter, &(aResult->mLocalId)) &&
+           ReadParam(aMsg, aIter, &(aResult->mRemoteTimestamp)) &&
+           ReadRTCSentRtpStreamStats(aMsg, aIter, aResult);
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::dom::RTCRTPContributingSourceStats> {
+  typedef mozilla::dom::RTCRTPContributingSourceStats paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mContributorSsrc);
+    WriteParam(aMsg, aParam.mInboundRtpStreamId);
+    WriteRTCStats(aMsg, aParam);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    if (!ReadParam(aMsg, aIter, &(aResult->mContributorSsrc)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mInboundRtpStreamId)) ||
+        !ReadRTCStats(aMsg, aIter, aResult)) {
+      return false;
+    }
+    return true;
+  }
+};
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(
+    mozilla::dom::RTCVideoFrameHistoryEntryInternal, mWidth, mHeight,
+    mRotationAngle, mFirstFrameTimestamp, mLastFrameTimestamp,
+    mConsecutiveFrames, mLocalSsrc, mRemoteSsrc);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::RTCVideoFrameHistoryInternal,
+                                  mTrackIdentifier, mEntries);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::RTCBandwidthEstimationInternal,
+                                  mTrackIdentifier, mSendBandwidthBps,
+                                  mMaxPaddingBps, mReceiveBandwidthBps,
+                                  mPacerDelayMs, mRttMs);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::RTCDataChannelStats, mId,
+                                  mTimestamp, mType, mLabel, mProtocol,
+                                  mDataChannelIdentifier, mState, mMessagesSent,
+                                  mBytesSent, mMessagesReceived, mBytesReceived)
+
+template <>
+struct ParamTraits<mozilla::dom::RTCDataChannelState>
+    : public ContiguousEnumSerializer<
+          mozilla::dom::RTCDataChannelState,
+          mozilla::dom::RTCDataChannelState::Connecting,
+          mozilla::dom::RTCDataChannelState::EndGuard_> {};
+}  // namespace IPC
+
+#endif  // _WEBRTC_GLOBAL_H_