--- a/dom/media/tests/mochitest/test_peerConnection_stats.html
+++ b/dom/media/tests/mochitest/test_peerConnection_stats.html
@@ -5,64 +5,170 @@
</head>
<body>
<pre id="test">
<script type="application/javascript">
createHTML({
bug: "1337525",
title: "webRtc Stats composition and sanity"
});
+
+
+//
+// Creates type definitions by extending other type definitions
+//
+function extendTypeWith(superTypeDefinition, ownTypeDefintion) {
+ let newType = {
+ name: ownTypeDefintion.name,
+ types: [ownTypeDefintion.name],
+ hasSuperType: function(type) {
+ return this.types.includes(type);
+ },
+ };
+ newType.types = [...newType.types, ...superTypeDefinition.types || []];
+ for (let i of ["expected", "optional", "unimplemented", "localVideoOnly",
+ "deprecated"]) {
+ newType[i] = superTypeDefinition[i] ? [...superTypeDefinition[i]] : [];
+ if (ownTypeDefintion[i]) {
+ newType[i] = [...newType[i], ...ownTypeDefintion[i]];
+ }
+ }
+ return newType;
+}
+
+//
+// Super types for tested types, these never appear as type in the reports
+// directly.
+//
+var rtcStats = extendTypeWith({}, {
+ name: "RTCStats",
+ expected: ["timestamp",
+ "type",
+ "id",],
+});
+
+var rtcRtpStreamStats = extendTypeWith(rtcStats, {
+ name: "RTCRtpStreamStats",
+ expected: ["ssrc",
+ "mediaType",],
+ optional: ["nackCount",],
+ unimplemented: ["mediaTrackId",
+ "transportId",
+ "codecId",
+ "sliCount",
+ "qpSum",],
+ localVideoOnly: ["firCount",
+ "pliCount",],
+});
+
+var rtcReceivedRtpStreamStats = extendTypeWith(rtcRtpStreamStats, {
+ name: "RTCReceivedRTPStreamStats",
+ expected: ["packetsReceived",
+ "bytesReceived",
+ "packetsLost",
+ "jitter",],
+ localVideoOnly: ["packetsDiscarded",],
+ unimplemented: ["fractionLost",
+ "packetsRepaired",
+ "burstPacketsLost",
+ "burstPacketsDiscarded",
+ "burstLossCount",
+ "burstDiscardCount",
+ "burstLossRate",
+ "burstDiscardRate",
+ "gapLossRate",
+ "gapDiscardRate",],
+});
+
+var rtcSentRtpStreamStats = extendTypeWith(rtcRtpStreamStats, {
+ name: "RTCSentRTPStreamStats",
+ expected: ["packetsSent",
+ "bytesSent",],
+ unimplemented: ["packetsDiscardedOnSend",
+ "bytesDiscardedOnSend",],
+});
+
var statsExpectedByType = {
- "inbound-rtp": {
- expected: ["id", "timestamp", "type", "ssrc", "isRemote", "mediaType",
- "packetsReceived", "packetsLost", "bytesReceived", "jitter",],
- optional: ["roundTripTime", "remoteId", "nackCount",],
- localVideoOnly: ["discardedPackets", "framerateStdDev", "framerateMean",
- "bitrateMean", "bitrateStdDev", "firCount", "pliCount", "framesDecoded",],
- unimplemented: ["mediaTrackId", "transportId", "codecId",
- "packetsDiscarded", "associateStatsId",
- "sliCount", "qpSum", "packetsRepaired", "fractionLost",
- "burstPacketsLost", "burstLossCount", "burstDiscardCount",
- "gapDiscardRate", "gapLossRate",],
- deprecated: ["mozRtt"],
- },
- "outbound-rtp": {
- expected: ["id", "timestamp", "type", "ssrc", "isRemote", "mediaType",
- "packetsSent", "bytesSent", "remoteId",],
- optional: ["remoteId", "nackCount",],
- localVideoOnly: ["droppedFrames", "bitrateMean", "bitrateStdDev",
- "framerateMean", "framerateStdDev", "framesEncoded", "firCount",
- "pliCount",],
- unimplemented: ["mediaTrackId", "transportId", "codecId",
- "sliCount", "qpSum", "targetBitrate",],
- deprecated: [],
- },
- "csrc": { skip: true },
- "codec": { skip: true },
- "peer-connection": { skip: true },
- "data-channel": { skip: true },
- "track": { skip: true },
- "transport": { skip: true },
- "candidate-pair": {
- expected: ["id", "timestamp", "type",
- "transportId", "localCandidateId", "remoteCandidateId", "state",
- "priority", "nominated", "writable", "readable",
- "bytesSent", "bytesReceived",
- "lastPacketSentTimestamp", "lastPacketReceivedTimestamp",],
- optional: ["selected",],
- unimplemented: ["totalRoundTripTime", "currentRoundTripTime",
- "availableOutgoingBitrate", "availableIncomingBitrate",
- "requestsReceived", "requestsSent", "responsesReceived",
- "responsesSent", "retransmissionsReceived", "retransmissionsSent",
- "consentRequestsSent",],
- deprecated: [],
- },
- "local-candidate": { skip: true },
+ "inbound-rtp": extendTypeWith(rtcReceivedRtpStreamStats, {
+ name: "inbound-rtp",
+ optional: ["remoteId",],
+ localVideoOnly: ["discardedPackets",
+ "framerateStdDev",
+ "framerateMean",
+ "bitrateMean",
+ "bitrateStdDev",
+ "framesDecoded",],
+ unimplemented: ["lastPacketReceivedTimestamp",],
+ deprecated: ["mozRtt",
+ "isRemote",],
+ }),
+ "remote-inbound-rtp": extendTypeWith(rtcReceivedRtpStreamStats, {
+ name: "remote-inbound-rtp",
+ expected: ["localId",
+ "roundTripTime",],
+ }),
+ "outbound-rtp": extendTypeWith(rtcSentRtpStreamStats, {
+ name: "outbound-rtp",
+ expected: ["packetsSent",
+ "bytesSent",],
+ optional: ["remoteId",
+ "nackCount",],
+ localVideoOnly: ["droppedFrames",
+ "bitrateMean",
+ "bitrateStdDev",
+ "framerateMean",
+ "framerateStdDev",
+ "framesEncoded",],
+ unimplemented: ["lastPacketSentTimeStamp",
+ "targetBitrate",
+ "totalEncodeTime",
+ "averageRTCPInterval",],
+ deprecated: ["isRemote",],
+ }),
+ "remote-outbound-rtp": extendTypeWith(rtcSentRtpStreamStats, {
+ name: "remote-outbound-rtp",
+ expected: ["localId",],
+ unimplemented: ["remoteTimeStamp",],
+ }),
+ "candidate-pair": extendTypeWith(rtcStats, {
+ name: "candidate-pair",
+ expected: ["transportId",
+ "localCandidateId",
+ "remoteCandidateId",
+ "state",
+ "priority",
+ "nominated",
+ "writable",
+ "readable",
+ "bytesSent",
+ "bytesReceived",
+ "lastPacketSentTimestamp",
+ "lastPacketReceivedTimestamp",],
+ optional: ["selected",],
+ unimplemented: ["totalRoundTripTime",
+ "currentRoundTripTime",
+ "availableOutgoingBitrate",
+ "availableIncomingBitrate",
+ "requestsReceived",
+ "requestsSent",
+ "responsesReceived",
+ "responsesSent",
+ "retransmissionsReceived",
+ "retransmissionsSent",
+ "consentRequestsSent",],
+ }),
+ "csrc": { skip: true },
+ "codec": { skip: true },
+ "peer-connection": { skip: true },
+ "data-channel": { skip: true },
+ "track": { skip: true },
+ "transport": { skip: true },
+ "local-candidate": { skip: true },
"remote-candidate": { skip: true },
- "certificate": { skip: true },
+ "certificate": { skip: true },
};
["in", "out"].forEach(pre => {
let s = statsExpectedByType[pre + "bound-rtp"];
s.optional = [...s.optional, ...s.localVideoOnly];
});
//
// Checks that the fields in a report conform to the expectations in
@@ -109,84 +215,95 @@ var checkExpectedFields = report => repo
var pedanticChecks = report => {
report.forEach((statObj, mapKey) => {
let tested = {};
// Record what fields get tested.
// To access a field foo without marking it as tested use stat.inner.foo
let stat = new Proxy(statObj, {
get(stat, key) {
+ if (key == "isRemote") return stat.type.startsWith("remote-");
if (key == "inner") return stat;
tested[key] = true;
return stat[key];
}
});
let expectations = statsExpectedByType[stat.type];
if (expectations.skip) {
return;
}
- // All stats share the following attributes inherited from RTCStats
- is(stat.id, mapKey, stat.type + ".id is the same as the report key.");
+ if (expectations.hasSuperType("RTCStats")) {
+ // All stats share the following attributes inherited from RTCStats
+ is(stat.id, mapKey, stat.type + ".id is the same as the report key.");
- // timestamp
- ok(stat.timestamp >= 0, stat.type + ".timestamp is not less than 0");
+ // timestamp
+ ok(stat.timestamp >= 0, stat.type + ".timestamp is not less than 0");
+ }
//
// RTCStreamStats attributes with common behavior
//
- // inbound-rtp and outbound-rtp inherit from RTCStreamStats
- if (["inbound-rtp", "outbound-rtp"].includes(stat.type)) {
+ if (expectations.hasSuperType("RTCRtpStreamStats")) {
//
// Common RTCStreamStats fields
//
// SSRC
ok(stat.ssrc, stat.type + ".ssrc has a value");
- // isRemote
- ok(stat.isRemote !== undefined, stat.type + ".isRemote exists.");
-
// mediaType
ok(["audio", "video"].includes(stat.mediaType),
stat.type + ".mediaType is 'audio' or 'video'");
// remote id
- if (stat.remoteId) {
+ if (stat.inner.remoteId) {
ok(report.has(stat.remoteId), "remoteId exists in report.");
is(report.get(stat.remoteId).ssrc, stat.ssrc,
"remote ssrc and local ssrc match.");
- is(report.get(stat.remoteId).remoteId, stat.id,
- "remote object has local object as it's own remote object.");
+ is(report.get(stat.remoteId).localId, stat.id,
+ "remote object has localId matching the id of the local object.");
+ }
+
+ // local id
+ if (stat.inner.localId) {
+ ok(report.has(stat.localId), "localId exists in report.");
+ is(report.get(stat.localId).ssrc, stat.ssrc,
+ "remote ssrc and local ssrc match.");
+ is(report.get(stat.localId).remoteId, stat.id,
+ "local object has remoteId matching the id of the remote object.");
}
// nackCount
- if (!stat.inner.isRemote) {
+ if (!stat.isRemote) {
ok(stat.nackCount >= 0, stat.type + ".nackCount is sane.");
} else {
is(stat.nackCount, undefined, stat.type
+ ".nackCount is only set when isRemote is false");
}
- if (!stat.inner.isRemote && stat.inner.mediaType == "video") {
+ if (!stat.isRemote && stat.inner.mediaType == "video") {
// firCount
ok(stat.firCount >= 0 && stat.firCount < 100,
stat.type + ".firCount is a sane number for a short test. value="
+ stat.firCount);
// pliCount
ok(stat.pliCount >= 0 && stat.pliCount < 100,
stat.type + ".pliCount is a sane number for a short test. value="
+ stat.pliCount);
}
}
- if (stat.type == "inbound-rtp") {
+ //
+ // Common RTCReceivedRTPStreamStats fields
+ //
+ if (expectations.hasSuperType("RTCReceivedRTPStreamStats")) {
//
// Required fields
//
// packetsReceived
ok(stat.packetsReceived >= 0
&& stat.packetsReceived < 10 ** 5,
stat.type + ".packetsReceived is a sane number for a short test. value="
@@ -205,174 +322,131 @@ var pedanticChecks = report => {
// This should be much lower for audio, TODO: Bug 1330575
let expectedJitter = stat.mediaType == "video" ? 0.5 : 1;
// jitter
ok(stat.jitter < expectedJitter,
stat.type + ".jitter is sane number for a local only test. value="
+ stat.jitter);
- // packetsDiscarded
- // special exception for, TODO: Bug 1335967
- // if (!stat.inner.isRemote && stat.discardedPackets !== undefined) {
- // ok(stat.packetsDiscarded < 100, stat.type
- // + ".packetsDiscarded is a sane number for a short test. value="
- // + stat.packetsDiscarded);
- // }
- // if (stat.packetsDiscarded !== undefined) {
- // ok(!stat.inner.isRemote,
- // stat.type + ".packetsDiscarded is only set when isRemote is "
- // + "false");
- // }
-
- //
- // Optional fields
- //
-
- // roundTripTime
- if (stat.inner.isRemote) {
- ok(stat.roundTripTime >= 0, stat.type + ".roundTripTime is sane with" +
- "value of:" + stat.roundTripTime);
- } else {
- is(stat.roundTripTime, undefined, stat.type
- + ".roundTripTime is only set when isRemote is true");
- }
-
- //
- // Local video only stats
- //
- if (stat.inner.isRemote || stat.inner.mediaType != "video") {
- expectations.localVideoOnly.forEach(field => {
- if (stat.inner.isRemote) {
- ok(stat[field] === undefined, stat.type + " does not have field "
- + field + " when isRemote is true");
- } else { // mediaType != video
- ok(stat[field] === undefined, stat.type + " does not have field "
- + field + " when mediaType is not 'video'");
- }
- });
+ // Bug 1386010, only available on local video for the time being
+ if (stat.mediaType == "video" && stat.type == "inbound-rtp") {
+ // packetsDiscarded
+ ok(stat.packetsDiscarded < 100 && stat.packetsDiscarded >= 0,
+ stat.type
+ + ".packetsDiscared is a sane number for a short test. value="
+ + stat.packetsDiscared);
+ // discardedPackets
+ is(stat.discardedPackets, stat.packetsDiscarded, stat.type
+ + ".discardedPackets is the same as packetsDiscarded. value="
+ + stat.discardedPackets);
} else {
- expectations.localVideoOnly.forEach(field => {
- ok(stat.inner[field] !== undefined, stat.type + " has field " + field
- + " when mediaType is video");
- });
- // discardedPackets
- ok(stat.discardedPackets < 100, stat.type
- + ".discardedPackets is a sane number for a short test. value="
- + stat.discardedPackets);
- // framesDecoded
- ok(stat.framesDecoded > 0 && stat.framesDecoded < 1000000, stat.type
- + ".framesDecoded is a sane number for a short test. value="
- + stat.framesDecoded);
- // bitrateMean
- // special exception, TODO: Bug 1341533
- if (stat.bitrateMean !== undefined) {
- // TODO: uncomment when Bug 1341533 lands
- // ok(stat.bitrateMean >= 0 && stat.bitrateMean < 2 ** 25,
- // stat.type + ".bitrateMean is sane. value="
- // + stat.bitrateMean);
- }
+ is(stat.packetsDiscarded, undefined);
+ is(stat.discardedPackets, undefined);
+ }
+ }
- // bitrateStdDev
- // special exception, TODO Bug 1341533
- if (stat.bitrateStdDev !== undefined) {
- // TODO: uncomment when Bug 1341533 lands
- // ok(stat.bitrateStdDev >= 0 && stat.bitrateStdDev < 2 ** 25,
- // stat.type + ".bitrateStdDev is sane. value="
- // + stat.bitrateStdDev);
- }
-
- // framerateMean
- // special exception, TODO: Bug 1341533
- if (stat.framerateMean !== undefined) {
- // TODO: uncomment when Bug 1341533 lands
- // ok(stat.framerateMean >= 0 && stat.framerateMean < 120,
- // stat.type + ".framerateMean is sane. value="
- // + stat.framerateMean);
- }
-
- // framerateStdDev
- // special exception, TODO: Bug 1341533
- if (stat.framerateStdDev !== undefined) {
- // TODO: uncomment when Bug 1341533 lands
- // ok(stat.framerateStdDev >= 0 && stat.framerateStdDev < 120,
- // stat.type + ".framerateStdDev is sane. value="
- // + stat.framerateStdDev);
- }
- }
- } else if (stat.type == "outbound-rtp") {
- //
- // Required fields
- //
-
+ //
+ // Common RTCSentRTPStreamStats
+ //
+ if (expectations.hasSuperType("RTCSentRTPStreamStats")) {
// packetsSent
ok(stat.packetsSent > 0 && stat.packetsSent < 10000,
stat.type + ".packetsSent is a sane number for a short test. value="
+ stat.packetsSent);
// bytesSent
ok(stat.bytesSent, stat.type + ".bytesSent has a value."
+ " Value not expected to be sane, bug 1339104. value="
+ stat.bytesSent);
+ }
+
+ // Common fields between inbound and outbound-rtp that are not common
+ // to remote-*-rtp. Note these are all non-spec and will be removed
+ if (stat.type == "inbound-rtp" || stat.type == "outbound-rtp" &&
+ stat.mediaType == "video") {
+ // bitrateMean
+ // special exception, TODO: Bug 1341533
+ if (stat.bitrateMean !== undefined) {
+ // TODO: uncomment when Bug 1341533 lands
+ // ok(stat.bitrateMean >= 0 && stat.bitrateMean < 2 ** 25,
+ // stat.type + ".bitrateMean is sane. value="
+ // + stat.bitrateMean);
+ }
+
+ // bitrateStdDev
+ // special exception, TODO Bug 1341533
+ if (stat.bitrateStdDev !== undefined) {
+ // TODO: uncomment when Bug 1341533 lands
+ // ok(stat.bitrateStdDev >= 0 && stat.bitrateStdDev < 2 ** 25,
+ // stat.type + ".bitrateStdDev is sane. value="
+ // + stat.bitrateStdDev);
+ }
+
+ // framerateMean
+ // special exception, TODO: Bug 1341533
+ if (stat.framerateMean !== undefined) {
+ // TODO: uncomment when Bug 1341533 lands
+ // ok(stat.framerateMean >= 0 && stat.framerateMean < 120,
+ // stat.type + ".framerateMean is sane. value="
+ // + stat.framerateMean);
+ }
+
+ // framerateStdDev
+ // special exception, TODO: Bug 1341533
+ if (stat.framerateStdDev !== undefined) {
+ // TODO: uncomment when Bug 1341533 lands
+ // ok(stat.framerateStdDev >= 0 && stat.framerateStdDev < 120,
+ // stat.type + ".framerateStdDev is sane. value="
+ // + stat.framerateStdDev);
+ }
+ }
+
+ if (stat.type == "inbound-rtp") {
+ //
+ // Local video only stats
+ //
+ if (stat.inner.mediaType != "video") {
+ expectations.localVideoOnly.forEach(field => {
+ ok(stat[field] === undefined, stat.type + " does not have field "
+ + field + " when mediaType is not 'video'");
+ });
+ } else {
+ expectations.localVideoOnly.forEach(field => {
+ ok(stat.inner[field] !== undefined, stat.type + " has field " + field
+ + " when mediaType is video");
+ });
+ // framesDecoded
+ ok(stat.framesDecoded > 0 && stat.framesDecoded < 1000000, stat.type
+ + ".framesDecoded is a sane number for a short test. value="
+ + stat.framesDecoded);
+ }
+ } else if (stat.type == "remote-inbound-rtp") {
+ ok(stat.roundTripTime >= 0, stat.type + ".roundTripTime is sane with" +
+ "value of:" + stat.roundTripTime);
+ } else if (stat.type == "outbound-rtp") {
//
// Optional fields
//
//
// Local video only stats
//
- if (stat.inner.isRemote || stat.inner.mediaType != "video") {
+ if (stat.inner.mediaType != "video") {
expectations.localVideoOnly.forEach(field => {
- if (stat.inner.isRemote) {
- ok(stat[field] === undefined, stat.type + " does not have field "
- + field + " when isRemote is true");
- } else { // mediaType != video
- ok(stat[field] === undefined, stat.type + " does not have field "
- + field + " when mediaType is not 'video'");
- }
+ ok(stat[field] === undefined, stat.type + " does not have field "
+ + field + " when mediaType is not 'video'");
});
} else {
expectations.localVideoOnly.forEach(field => {
ok(stat.inner[field] !== undefined, stat.type + " has field " + field
+ " when mediaType is video and isRemote is false");
});
- // bitrateMean
- if (stat.bitrateMean !== undefined) {
- // TODO: uncomment when Bug 1341533 lands
- // ok(stat.bitrateMean >= 0 && stat.bitrateMean < 2 ** 25,
- // stat.type + ".bitrateMean is sane. value="
- // + stat.bitrateMean);
- }
-
- // bitrateStdDev
- if (stat.bitrateStdDev !== undefined) {
- // TODO: uncomment when Bug 1341533 lands
- // ok(stat.bitrateStdDev >= 0 && stat.bitrateStdDev < 2 ** 25,
- // stat.type + ".bitrateStdDev is sane. value="
- // + stat.bitrateStdDev);
- }
-
- // framerateMean
- if (stat.framerateMean !== undefined) {
- // TODO: uncomment when Bug 1341533 lands
- // ok(stat.framerateMean >= 0 && stat.framerateMean < 120,
- // stat.type + ".framerateMean is sane. value="
- // + stat.framerateMean);
- }
-
- // framerateStdDev
- if (stat.framerateStdDev !== undefined) {
- // TODO: uncomment when Bug 1341533 lands
- // ok(stat.framerateStdDev >= 0 && stat.framerateStdDev < 120,
- // stat.type + ".framerateStdDev is sane. value="
- // + stat.framerateStdDev);
- }
-
// droppedFrames
ok(stat.droppedFrames >= 0,
stat.type + ".droppedFrames is not negative. value="
+ stat.droppedFrames);
// framesEncoded
ok(stat.framesEncoded >= 0 && stat.framesEncoded < 100000, stat.type
+ ".framesEncoded is a sane number for a short test. value="
@@ -490,21 +564,30 @@ var pedanticChecks = report => {
// This MUST be run after PC_*_WAIT_FOR_MEDIA_FLOW to ensure that we have RTP
// before checking for RTCP.
var waitForSyncedRtcp = async pc => {
// Ensures that RTCP is present
let ensureSyncedRtcp = async () => {
let stats = await pc.getStats();
for (let [k, v] of stats) {
- if (v.type.endsWith("bound-rtp") && !v.remoteId) {
- throw new Error(v.id + " is missing remoteId: "
- + JSON.stringify(v));
+ if (v.type.endsWith("bound-rtp")) {
+ if (v.type.startsWith("remote-")) {
+ if (!v.localId) {
+ throw new Error(v.id + "remote stat is missing localId: "
+ + JSON.stringify(v));
+ }
+ } else {
+ if (!v.remoteId) {
+ throw new Error(v.id + "local stat is missing remoteId: "
+ + JSON.stringify(v));
+ }
+ }
}
- if (v.type == "inbound-rtp" && v.isRemote == true
+ if (v.type == "remote-inbound-rtp"
&& v.roundTripTime === undefined) {
throw new Error(v.id + " is missing roundTripTime: "
+ JSON.stringify(v));
}
}
return stats;
}
const waitPeriod = 500;
--- a/dom/media/webrtc/WebrtcGlobal.h
+++ b/dom/media/webrtc/WebrtcGlobal.h
@@ -27,49 +27,49 @@ struct ParamTraits<mozilla::dom::Optiona
WriteParam(aMsg, true);
WriteParam(aMsg, aParam.Value());
return;
}
WriteParam(aMsg, false);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
bool was_passed = false;
- if (!ReadParam(aMsg, aIter, &was_passed)) {
+ if (!ReadParam(aMsg, aItr, &was_passed)) {
return false;
}
- aResult->Reset(); //XXX Optional_base seems to reach this point with isSome true.
+ //XXX Optional_base seems to reach this point with isSome true.
+ aResult->Reset();
if (was_passed) {
- if (!ReadParam(aMsg, aIter, &(aResult->Construct()))) {
- return false;
- }
+ return ReadParam(aMsg, aItr, &(aResult->Construct()));
}
return true;
}
};
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)
+ static bool Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- return ReadParam(aMsg, aIter, dynamic_cast<FallibleTArray<T>*>(aResult));
+ return ReadParam(aMsg, aItr, dynamic_cast<FallibleTArray<T>*>(aResult));
}
};
template<>
struct ParamTraits<mozilla::dom::RTCStatsType> :
public ContiguousEnumSerializer<
mozilla::dom::RTCStatsType,
mozilla::dom::RTCStatsType::Inbound_rtp,
@@ -100,105 +100,102 @@ struct ParamTraits<mozilla::dom::RTCStat
static void Write(Message* aMsg, const paramType& aParam)
{
WriteParam(aMsg, aParam.mClosed);
WriteParam(aMsg, aParam.mCodecStats);
WriteParam(aMsg, aParam.mIceCandidatePairStats);
WriteParam(aMsg, aParam.mIceCandidateStats);
WriteParam(aMsg, aParam.mIceComponentStats);
WriteParam(aMsg, aParam.mInboundRTPStreamStats);
+ WriteParam(aMsg, aParam.mRemoteInboundRTPStreamStats);
WriteParam(aMsg, aParam.mLocalSdp);
WriteParam(aMsg, aParam.mMediaStreamStats);
WriteParam(aMsg, aParam.mMediaStreamTrackStats);
WriteParam(aMsg, aParam.mOutboundRTPStreamStats);
+ WriteParam(aMsg, aParam.mRemoteOutboundRTPStreamStats);
WriteParam(aMsg, aParam.mPcid);
WriteParam(aMsg, aParam.mRemoteSdp);
WriteParam(aMsg, aParam.mTimestamp);
WriteParam(aMsg, aParam.mIceRestarts);
WriteParam(aMsg, aParam.mIceRollbacks);
WriteParam(aMsg, aParam.mTransportStats);
WriteParam(aMsg, aParam.mRtpContributingSourceStats);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mClosed)) ||
- !ReadParam(aMsg, aIter, &(aResult->mCodecStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mIceCandidatePairStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mIceCandidateStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mIceComponentStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mInboundRTPStreamStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mLocalSdp)) ||
- !ReadParam(aMsg, aIter, &(aResult->mMediaStreamStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mMediaStreamTrackStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mOutboundRTPStreamStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mPcid)) ||
- !ReadParam(aMsg, aIter, &(aResult->mRemoteSdp)) ||
- !ReadParam(aMsg, aIter, &(aResult->mTimestamp)) ||
- !ReadParam(aMsg, aIter, &(aResult->mIceRestarts)) ||
- !ReadParam(aMsg, aIter, &(aResult->mIceRollbacks)) ||
- !ReadParam(aMsg, aIter, &(aResult->mTransportStats)) ||
- !ReadParam(aMsg, aIter, &(aResult->mRtpContributingSourceStats))) {
- return false;
- }
-
- return true;
+ return ReadParam(aMsg, aItr, &(aResult->mClosed)) &&
+ ReadParam(aMsg, aItr, &(aResult->mCodecStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mIceCandidatePairStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mIceCandidateStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mIceComponentStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mInboundRTPStreamStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mRemoteInboundRTPStreamStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mLocalSdp)) &&
+ ReadParam(aMsg, aItr, &(aResult->mMediaStreamStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mMediaStreamTrackStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mOutboundRTPStreamStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mRemoteOutboundRTPStreamStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mPcid)) &&
+ ReadParam(aMsg, aItr, &(aResult->mRemoteSdp)) &&
+ ReadParam(aMsg, aItr, &(aResult->mTimestamp)) &&
+ ReadParam(aMsg, aItr, &(aResult->mIceRestarts)) &&
+ ReadParam(aMsg, aItr, &(aResult->mIceRollbacks)) &&
+ ReadParam(aMsg, aItr, &(aResult->mTransportStats)) &&
+ ReadParam(aMsg, aItr, &(aResult->mRtpContributingSourceStats));
}
};
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;
+template<>
+struct ParamTraits<mozilla::dom::RTCStats> {
+ static void Write(Message* aMsg, const RTCStats& aParam)
+ {
+ // RTCStats base class
+ WriteParam(aMsg, aParam.mId);
+ WriteParam(aMsg, aParam.mTimestamp);
+ WriteParam(aMsg, aParam.mType);
}
- return true;
-}
+ static bool Read(const Message* aMsg, PickleIterator* aItr, RTCStats* aResult)
+ {
+ // RTCStats base class
+ return ReadParam(aMsg, aItr, &(aResult->mId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mTimestamp)) &&
+ ReadParam(aMsg, aItr, &(aResult->mType));
+ }
+};
template<>
struct ParamTraits<mozilla::dom::RTCCodecStats>
{
typedef mozilla::dom::RTCCodecStats paramType;
static void Write(Message* aMsg, const paramType& aParam)
{
WriteParam(aMsg, aParam.mChannels);
WriteParam(aMsg, aParam.mClockRate);
WriteParam(aMsg, aParam.mCodec);
WriteParam(aMsg, aParam.mParameters);
WriteParam(aMsg, aParam.mPayloadType);
- WriteRTCStats(aMsg, aParam);
+ ParamTraits<mozilla::dom::RTCStats>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mChannels)) ||
- !ReadParam(aMsg, aIter, &(aResult->mClockRate)) ||
- !ReadParam(aMsg, aIter, &(aResult->mCodec)) ||
- !ReadParam(aMsg, aIter, &(aResult->mParameters)) ||
- !ReadParam(aMsg, aIter, &(aResult->mPayloadType)) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
-
- return true;
- }
+ return ReadParam(aMsg, aItr, &(aResult->mChannels)) &&
+ ReadParam(aMsg, aItr, &(aResult->mClockRate)) &&
+ ReadParam(aMsg, aItr, &(aResult->mCodec)) &&
+ ReadParam(aMsg, aItr, &(aResult->mParameters)) &&
+ ReadParam(aMsg, aItr, &(aResult->mPayloadType)) &&
+ ParamTraits<mozilla::dom::RTCStats>::Read(aMsg, aItr, aResult);
+ }
};
template<>
struct ParamTraits<mozilla::dom::RTCIceCandidatePairStats>
{
typedef mozilla::dom::RTCIceCandidatePairStats paramType;
static void Write(Message* aMsg, const paramType& aParam)
@@ -211,39 +208,36 @@ struct ParamTraits<mozilla::dom::RTCIceC
WriteParam(aMsg, aParam.mReadable);
WriteParam(aMsg, aParam.mRemoteCandidateId);
WriteParam(aMsg, aParam.mSelected);
WriteParam(aMsg, aParam.mState);
WriteParam(aMsg, aParam.mBytesSent);
WriteParam(aMsg, aParam.mBytesReceived);
WriteParam(aMsg, aParam.mLastPacketSentTimestamp);
WriteParam(aMsg, aParam.mLastPacketReceivedTimestamp);
- WriteRTCStats(aMsg, aParam);
+ ParamTraits<mozilla::dom::RTCStats>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, 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->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;
+ return ReadParam(aMsg, aItr, &(aResult->mTransportId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mLocalCandidateId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mPriority)) &&
+ ReadParam(aMsg, aItr, &(aResult->mNominated)) &&
+ ReadParam(aMsg, aItr, &(aResult->mWritable)) &&
+ ReadParam(aMsg, aItr, &(aResult->mReadable)) &&
+ ReadParam(aMsg, aItr, &(aResult->mRemoteCandidateId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mSelected)) &&
+ ReadParam(aMsg, aItr, &(aResult->mState)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBytesSent)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBytesReceived)) &&
+ ReadParam(aMsg, aItr, &(aResult->mLastPacketSentTimestamp)) &&
+ ReadParam(aMsg, aItr, &(aResult->mLastPacketReceivedTimestamp)) &&
+ ParamTraits<mozilla::dom::RTCStats>::Read(aMsg, aItr, aResult);
}
};
template<>
struct ParamTraits<mozilla::dom::RTCIceCandidateStats>
{
typedef mozilla::dom::RTCIceCandidateStats paramType;
@@ -251,227 +245,294 @@ struct ParamTraits<mozilla::dom::RTCIceC
{
WriteParam(aMsg, aParam.mCandidateId);
WriteParam(aMsg, aParam.mCandidateType);
WriteParam(aMsg, aParam.mComponentId);
WriteParam(aMsg, aParam.mIpAddress);
WriteParam(aMsg, aParam.mMozLocalTransport);
WriteParam(aMsg, aParam.mPortNumber);
WriteParam(aMsg, aParam.mTransport);
- WriteRTCStats(aMsg, aParam);
+ ParamTraits<mozilla::dom::RTCStats>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mCandidateId)) ||
- !ReadParam(aMsg, aIter, &(aResult->mCandidateType)) ||
- !ReadParam(aMsg, aIter, &(aResult->mComponentId)) ||
- !ReadParam(aMsg, aIter, &(aResult->mIpAddress)) ||
- !ReadParam(aMsg, aIter, &(aResult->mMozLocalTransport)) ||
- !ReadParam(aMsg, aIter, &(aResult->mPortNumber)) ||
- !ReadParam(aMsg, aIter, &(aResult->mTransport)) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
-
- return true;
- }
+ return ReadParam(aMsg, aItr, &(aResult->mCandidateId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mCandidateType)) &&
+ ReadParam(aMsg, aItr, &(aResult->mComponentId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mIpAddress)) &&
+ ReadParam(aMsg, aItr, &(aResult->mMozLocalTransport)) &&
+ ReadParam(aMsg, aItr, &(aResult->mPortNumber)) &&
+ ReadParam(aMsg, aItr, &(aResult->mTransport)) &&
+ ParamTraits<mozilla::dom::RTCStats>::Read(aMsg, aItr, aResult);
+ }
};
template<>
struct ParamTraits<mozilla::dom::RTCIceComponentStats>
{
typedef mozilla::dom::RTCIceComponentStats paramType;
static void Write(Message* aMsg, const paramType& aParam)
{
WriteParam(aMsg, aParam.mActiveConnection);
WriteParam(aMsg, aParam.mBytesReceived);
WriteParam(aMsg, aParam.mBytesSent);
WriteParam(aMsg, aParam.mComponent);
WriteParam(aMsg, aParam.mTransportId);
- WriteRTCStats(aMsg, aParam);
+ ParamTraits<mozilla::dom::RTCStats>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mActiveConnection)) ||
- !ReadParam(aMsg, aIter, &(aResult->mBytesReceived)) ||
- !ReadParam(aMsg, aIter, &(aResult->mBytesSent)) ||
- !ReadParam(aMsg, aIter, &(aResult->mComponent)) ||
- !ReadParam(aMsg, aIter, &(aResult->mTransportId)) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
-
- return true;
+ return ReadParam(aMsg, aItr, &(aResult->mActiveConnection)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBytesReceived)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBytesSent)) &&
+ ReadParam(aMsg, aItr, &(aResult->mComponent)) &&
+ ReadParam(aMsg, aItr, &(aResult->mTransportId)) &&
+ ParamTraits<mozilla::dom::RTCStats>::Read(aMsg, aItr, aResult);
}
};
-static void WriteRTCRTPStreamStats(
- Message* aMsg,
- const mozilla::dom::RTCRTPStreamStats& aParam)
+template<>
+struct ParamTraits<mozilla::dom::RTCRTPStreamStats>
{
- WriteParam(aMsg, aParam.mBitrateMean);
- WriteParam(aMsg, aParam.mBitrateStdDev);
- WriteParam(aMsg, aParam.mCodecId);
- WriteParam(aMsg, aParam.mFramerateMean);
- WriteParam(aMsg, aParam.mFramerateStdDev);
- WriteParam(aMsg, aParam.mIsRemote);
- WriteParam(aMsg, aParam.mMediaTrackId);
- WriteParam(aMsg, aParam.mMediaType);
- WriteParam(aMsg, aParam.mRemoteId);
- WriteParam(aMsg, aParam.mSsrc);
- WriteParam(aMsg, aParam.mTransportId);
-}
+ typedef mozilla::dom::RTCRTPStreamStats paramType;
+ typedef mozilla::dom::RTCStats superType;
-static bool ReadRTCRTPStreamStats(
- const Message* aMsg, PickleIterator* aIter,
- mozilla::dom::RTCRTPStreamStats* aResult)
-{
- if (!ReadParam(aMsg, aIter, &(aResult->mBitrateMean)) ||
- !ReadParam(aMsg, aIter, &(aResult->mBitrateStdDev)) ||
- !ReadParam(aMsg, aIter, &(aResult->mCodecId)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramerateMean)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramerateStdDev)) ||
- !ReadParam(aMsg, aIter, &(aResult->mIsRemote)) ||
- !ReadParam(aMsg, aIter, &(aResult->mMediaTrackId)) ||
- !ReadParam(aMsg, aIter, &(aResult->mMediaType)) ||
- !ReadParam(aMsg, aIter, &(aResult->mRemoteId)) ||
- !ReadParam(aMsg, aIter, &(aResult->mSsrc)) ||
- !ReadParam(aMsg, aIter, &(aResult->mTransportId))) {
- return false;
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mSsrc);
+ WriteParam(aMsg, aParam.mMediaType);
+ WriteParam(aMsg, aParam.mMediaTrackId);
+ WriteParam(aMsg, aParam.mTransportId);
+ WriteParam(aMsg, aParam.mCodecId);
+ WriteParam(aMsg, aParam.mFirCount);
+ WriteParam(aMsg, aParam.mNackCount);
+ WriteParam(aMsg, aParam.mPliCount);
+ ParamTraits<superType>::Write(aMsg, aParam);
}
- return true;
-}
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
+ {
+ return ReadParam(aMsg, aItr, &(aResult->mSsrc)) &&
+ ReadParam(aMsg, aItr, &(aResult->mMediaType)) &&
+ ReadParam(aMsg, aItr, &(aResult->mMediaTrackId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mTransportId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mCodecId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFirCount)) &&
+ ReadParam(aMsg, aItr, &(aResult->mNackCount)) &&
+ ReadParam(aMsg, aItr, &(aResult->mPliCount)) &&
+ ParamTraits<superType>::Read(aMsg, aItr, aResult);
+ }
+};
+
+template<>
+struct ParamTraits<mozilla::dom::RTCReceivedRTPStreamStats>
+{
+ typedef mozilla::dom::RTCReceivedRTPStreamStats paramType;
+ typedef mozilla::dom::RTCRTPStreamStats superType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mPacketsReceived);
+ WriteParam(aMsg, aParam.mBytesReceived);
+ WriteParam(aMsg, aParam.mPacketsLost);
+ WriteParam(aMsg, aParam.mJitter);
+ WriteParam(aMsg, aParam.mFractionLost);
+ WriteParam(aMsg, aParam.mPacketsDiscarded);
+ ParamTraits<superType>::Write(aMsg, aParam);
+ }
+
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
+ {
+ return ReadParam(aMsg, aItr, &(aResult->mPacketsReceived)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBytesReceived)) &&
+ ReadParam(aMsg, aItr, &(aResult->mPacketsLost)) &&
+ ReadParam(aMsg, aItr, &(aResult->mJitter)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFractionLost)) &&
+ ReadParam(aMsg, aItr, &(aResult->mPacketsDiscarded)) &&
+ ParamTraits<superType>::Read(aMsg, aItr, aResult);
+ }
+};
template<>
struct ParamTraits<mozilla::dom::RTCInboundRTPStreamStats>
{
typedef mozilla::dom::RTCInboundRTPStreamStats paramType;
+ typedef mozilla::dom::RTCReceivedRTPStreamStats superType;
static void Write(Message* aMsg, const paramType& aParam)
{
- WriteParam(aMsg, aParam.mBytesReceived);
- WriteParam(aMsg, aParam.mDiscardedPackets);
WriteParam(aMsg, aParam.mFramesDecoded);
- WriteParam(aMsg, aParam.mJitter);
WriteParam(aMsg, aParam.mMozAvSyncDelay);
WriteParam(aMsg, aParam.mMozJitterBufferDelay);
- WriteParam(aMsg, aParam.mRoundTripTime);
- WriteParam(aMsg, aParam.mPacketsLost);
- WriteParam(aMsg, aParam.mPacketsReceived);
- WriteRTCRTPStreamStats(aMsg, aParam);
- WriteRTCStats(aMsg, aParam);
+ WriteParam(aMsg, aParam.mBitrateMean);
+ WriteParam(aMsg, aParam.mBitrateStdDev);
+ WriteParam(aMsg, aParam.mFramerateMean);
+ WriteParam(aMsg, aParam.mFramerateStdDev);
+ ParamTraits<superType>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
+ {
+ return ReadParam(aMsg, aItr, &(aResult->mFramesDecoded)) &&
+ ReadParam(aMsg, aItr, &(aResult->mMozAvSyncDelay)) &&
+ ReadParam(aMsg, aItr, &(aResult->mMozJitterBufferDelay)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBitrateMean)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBitrateStdDev)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramerateMean)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramerateStdDev)) &&
+ ParamTraits<superType>::Read(aMsg, aItr, aResult);
+ }
+};
+
+template<>
+struct ParamTraits<mozilla::dom::RTCRemoteInboundRTPStreamStats>
+{
+ typedef mozilla::dom::RTCRemoteInboundRTPStreamStats paramType;
+ typedef mozilla::dom::RTCReceivedRTPStreamStats superType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mBytesReceived)) ||
- !ReadParam(aMsg, aIter, &(aResult->mDiscardedPackets)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramesDecoded)) ||
- !ReadParam(aMsg, aIter, &(aResult->mJitter)) ||
- !ReadParam(aMsg, aIter, &(aResult->mMozAvSyncDelay)) ||
- !ReadParam(aMsg, aIter, &(aResult->mMozJitterBufferDelay)) ||
- !ReadParam(aMsg, aIter, &(aResult->mRoundTripTime)) ||
- !ReadParam(aMsg, aIter, &(aResult->mPacketsLost)) ||
- !ReadParam(aMsg, aIter, &(aResult->mPacketsReceived)) ||
- !ReadRTCRTPStreamStats(aMsg, aIter, aResult) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
+ WriteParam(aMsg, aParam.mLocalId);
+ WriteParam(aMsg, aParam.mRoundTripTime);
+ ParamTraits<superType>::Write(aMsg, aParam);
+ }
+
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
+ {
+ return ReadParam(aMsg, aItr, &(aResult->mLocalId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mRoundTripTime)) &&
+ ParamTraits<superType>::Read(aMsg, aItr, aResult);
+ }
+};
- return true;
+template<>
+struct ParamTraits<mozilla::dom::RTCSentRTPStreamStats>
+{
+ typedef mozilla::dom::RTCSentRTPStreamStats paramType;
+ typedef mozilla::dom::RTCRTPStreamStats superType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mPacketsSent);
+ WriteParam(aMsg, aParam.mBytesSent);
+ ParamTraits<superType>::Write(aMsg, aParam);
+ }
+
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
+ {
+ return ReadParam(aMsg, aItr, &(aResult->mPacketsSent)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBytesSent)) &&
+ ParamTraits<superType>::Read(aMsg, aItr, aResult);
}
};
template<>
struct ParamTraits<mozilla::dom::RTCOutboundRTPStreamStats>
{
typedef mozilla::dom::RTCOutboundRTPStreamStats paramType;
+ typedef mozilla::dom::RTCSentRTPStreamStats superType;
static void Write(Message* aMsg, const paramType& aParam)
{
- WriteParam(aMsg, aParam.mBytesSent);
+ WriteParam(aMsg, aParam.mTargetBitrate);
WriteParam(aMsg, aParam.mDroppedFrames);
- WriteParam(aMsg, aParam.mPacketsSent);
- WriteParam(aMsg, aParam.mTargetBitrate);
WriteParam(aMsg, aParam.mFramesEncoded);
- WriteParam(aMsg, aParam.mFirCount);
- WriteParam(aMsg, aParam.mNackCount);
- WriteParam(aMsg, aParam.mPliCount);
- WriteRTCRTPStreamStats(aMsg, aParam);
- WriteRTCStats(aMsg, aParam);
+ WriteParam(aMsg, aParam.mBitrateMean);
+ WriteParam(aMsg, aParam.mBitrateStdDev);
+ WriteParam(aMsg, aParam.mFramerateMean);
+ WriteParam(aMsg, aParam.mFramerateStdDev);
+ ParamTraits<superType>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mBytesSent)) ||
- !ReadParam(aMsg, aIter, &(aResult->mDroppedFrames)) ||
- !ReadParam(aMsg, aIter, &(aResult->mPacketsSent)) ||
- !ReadParam(aMsg, aIter, &(aResult->mTargetBitrate)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramesEncoded)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFirCount)) ||
- !ReadParam(aMsg, aIter, &(aResult->mNackCount)) ||
- !ReadParam(aMsg, aIter, &(aResult->mPliCount)) ||
- !ReadRTCRTPStreamStats(aMsg, aIter, aResult) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
+ return ReadParam(aMsg, aItr, &(aResult->mTargetBitrate)) &&
+ ReadParam(aMsg, aItr, &(aResult->mDroppedFrames)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramesEncoded)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBitrateMean)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBitrateStdDev)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramerateMean)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramerateStdDev)) &&
+ ParamTraits<superType>::Read(aMsg, aItr, aResult);
+ }
+};
+
- return true;
+template<>
+struct ParamTraits<mozilla::dom::RTCRemoteOutboundRTPStreamStats>
+{
+ typedef mozilla::dom::RTCRemoteOutboundRTPStreamStats paramType;
+ typedef mozilla::dom::RTCSentRTPStreamStats superType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mLocalId);
+ WriteParam(aMsg, aParam.mRemoteTimestamp);
+ ParamTraits<superType>::Write(aMsg, aParam);
+ }
+
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
+ {
+ return ReadParam(aMsg, aItr, &(aResult->mLocalId)) &&
+ ReadParam(aMsg, aItr, &(aResult->mRemoteTimestamp)) &&
+ ParamTraits<superType>::Read(aMsg, aItr, aResult);
}
};
template<>
struct ParamTraits<mozilla::dom::RTCMediaStreamStats>
{
typedef mozilla::dom::RTCMediaStreamStats paramType;
static void Write(Message* aMsg, const paramType& aParam)
{
WriteParam(aMsg, aParam.mStreamIdentifier);
WriteParam(aMsg, aParam.mTrackIds);
- WriteRTCStats(aMsg, aParam);
+ ParamTraits<mozilla::dom::RTCStats>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mStreamIdentifier)) ||
- !ReadParam(aMsg, aIter, &(aResult->mTrackIds)) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
-
- return true;
+ return ReadParam(aMsg, aItr, &(aResult->mStreamIdentifier)) &&
+ ReadParam(aMsg, aItr, &(aResult->mTrackIds)) &&
+ ParamTraits<mozilla::dom::RTCStats>::Read(aMsg, aItr, aResult);
}
};
template<>
struct ParamTraits<mozilla::dom::RTCTransportStats>
{
typedef mozilla::dom::RTCTransportStats paramType;
static void Write(Message* aMsg, const paramType& aParam)
{
WriteParam(aMsg, aParam.mBytesReceived);
WriteParam(aMsg, aParam.mBytesSent);
- WriteRTCStats(aMsg, aParam);
+ ParamTraits<mozilla::dom::RTCStats>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mBytesReceived)) ||
- !ReadParam(aMsg, aIter, &(aResult->mBytesSent)) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
-
- return true;
+ return ReadParam(aMsg, aItr, &(aResult->mBytesReceived)) &&
+ ReadParam(aMsg, aItr, &(aResult->mBytesSent)) &&
+ ParamTraits<mozilla::dom::RTCStats>::Read(aMsg, aItr, aResult);
}
};
template<>
struct ParamTraits<mozilla::dom::RTCMediaStreamTrackStats>
{
typedef mozilla::dom::RTCMediaStreamTrackStats paramType;
@@ -486,61 +547,56 @@ struct ParamTraits<mozilla::dom::RTCMedi
WriteParam(aMsg, aParam.mFramesDecoded);
WriteParam(aMsg, aParam.mFramesDropped);
WriteParam(aMsg, aParam.mFramesPerSecond);
WriteParam(aMsg, aParam.mFramesReceived);
WriteParam(aMsg, aParam.mFramesSent);
WriteParam(aMsg, aParam.mRemoteSource);
WriteParam(aMsg, aParam.mSsrcIds);
WriteParam(aMsg, aParam.mTrackIdentifier);
- WriteRTCStats(aMsg, aParam);
+ ParamTraits<mozilla::dom::RTCStats>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mAudioLevel)) ||
- !ReadParam(aMsg, aIter, &(aResult->mEchoReturnLoss)) ||
- !ReadParam(aMsg, aIter, &(aResult->mEchoReturnLossEnhancement)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFrameHeight)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFrameWidth)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramesCorrupted)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramesDecoded)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramesDropped)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramesPerSecond)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramesReceived)) ||
- !ReadParam(aMsg, aIter, &(aResult->mFramesSent)) ||
- !ReadParam(aMsg, aIter, &(aResult->mRemoteSource)) ||
- !ReadParam(aMsg, aIter, &(aResult->mSsrcIds)) ||
- !ReadParam(aMsg, aIter, &(aResult->mTrackIdentifier)) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
-
- return true;
+ return ReadParam(aMsg, aItr, &(aResult->mAudioLevel)) &&
+ ReadParam(aMsg, aItr, &(aResult->mEchoReturnLoss)) &&
+ ReadParam(aMsg, aItr, &(aResult->mEchoReturnLossEnhancement)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFrameHeight)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFrameWidth)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramesCorrupted)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramesDecoded)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramesDropped)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramesPerSecond)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramesReceived)) &&
+ ReadParam(aMsg, aItr, &(aResult->mFramesSent)) &&
+ ReadParam(aMsg, aItr, &(aResult->mRemoteSource)) &&
+ ReadParam(aMsg, aItr, &(aResult->mSsrcIds)) &&
+ ReadParam(aMsg, aItr, &(aResult->mTrackIdentifier)) &&
+ ParamTraits<mozilla::dom::RTCStats>::Read(aMsg, aItr, 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);
+ ParamTraits<mozilla::dom::RTCStats>::Write(aMsg, aParam);
}
- static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ static bool
+ Read(const Message* aMsg, PickleIterator* aItr, paramType* aResult)
{
- if (!ReadParam(aMsg, aIter, &(aResult->mContributorSsrc)) ||
- !ReadParam(aMsg, aIter, &(aResult->mInboundRtpStreamId)) ||
- !ReadRTCStats(aMsg, aIter, aResult)) {
- return false;
- }
- return true;
+ return ReadParam(aMsg, aItr, &(aResult->mContributorSsrc)) &&
+ ReadParam(aMsg, aItr, &(aResult->mInboundRtpStreamId)) &&
+ ParamTraits<mozilla::dom::RTCStats>::Read(aMsg, aItr, aResult);
}
};
} // namespace ipc
#endif // _WEBRTC_GLOBAL_H_