--- a/dom/media/webrtc/WebrtcGlobal.h
+++ b/dom/media/webrtc/WebrtcGlobal.h
@@ -196,30 +196,30 @@ struct ParamTraits<mozilla::dom::RTCCode
 
 template<>
 struct ParamTraits<mozilla::dom::RTCIceCandidatePairStats>
 {
   typedef mozilla::dom::RTCIceCandidatePairStats paramType;
 
   static void Write(Message* aMsg, const paramType& aParam)
   {
-    WriteParam(aMsg, aParam.mComponentId);
+    WriteParam(aMsg, aParam.mTransportId);
     WriteParam(aMsg, aParam.mLocalCandidateId);
     WriteParam(aMsg, aParam.mPriority);
     WriteParam(aMsg, aParam.mNominated);
     WriteParam(aMsg, aParam.mReadable);
     WriteParam(aMsg, aParam.mRemoteCandidateId);
     WriteParam(aMsg, aParam.mSelected);
     WriteParam(aMsg, aParam.mState);
     WriteRTCStats(aMsg, aParam);
   }
 
   static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
   {
-    if (!ReadParam(aMsg, aIter, &(aResult->mComponentId)) ||
+    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->mReadable)) ||
         !ReadParam(aMsg, aIter, &(aResult->mRemoteCandidateId)) ||
         !ReadParam(aMsg, aIter, &(aResult->mSelected)) ||
         !ReadParam(aMsg, aIter, &(aResult->mState)) ||
         !ReadRTCStats(aMsg, aIter, aResult)) {
@@ -234,33 +234,33 @@ template<>
 struct ParamTraits<mozilla::dom::RTCIceCandidateStats>
 {
   typedef mozilla::dom::RTCIceCandidateStats paramType;
 
   static void Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.mCandidateId);
     WriteParam(aMsg, aParam.mCandidateType);
-    WriteParam(aMsg, aParam.mComponentId);
-    WriteParam(aMsg, aParam.mIpAddress);
+    WriteParam(aMsg, aParam.mTransportId);
+    WriteParam(aMsg, aParam.mIp);
+    WriteParam(aMsg, aParam.mPort);
+    WriteParam(aMsg, aParam.mProtocol);
     WriteParam(aMsg, aParam.mMozLocalTransport);
-    WriteParam(aMsg, aParam.mPortNumber);
-    WriteParam(aMsg, aParam.mTransport);
     WriteRTCStats(aMsg, aParam);
   }
 
   static bool Read(const Message* aMsg, PickleIterator* aIter, 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->mTransportId)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mIp)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mPort)) ||
+        !ReadParam(aMsg, aIter, &(aResult->mProtocol)) ||
         !ReadParam(aMsg, aIter, &(aResult->mMozLocalTransport)) ||
-        !ReadParam(aMsg, aIter, &(aResult->mPortNumber)) ||
-        !ReadParam(aMsg, aIter, &(aResult->mTransport)) ||
         !ReadRTCStats(aMsg, aIter, aResult)) {
       return false;
     }
 
     return true;
  }
 };
 

--- a/dom/webidl/RTCStatsReport.webidl
+++ b/dom/webidl/RTCStatsReport.webidl
@@ -106,41 +106,62 @@ enum RTCStatsIceCandidatePairState {
   "waiting",
   "inprogress",
   "failed",
   "succeeded",
   "cancelled"
 };
 
 dictionary RTCIceCandidatePairStats : RTCStats {
-  DOMString componentId;
+  DOMString transportId;
   DOMString localCandidateId;
   DOMString remoteCandidateId;
   RTCStatsIceCandidatePairState state;
   unsigned long long priority;
+  boolean nominated;
+  boolean writable;
   boolean readable;
-  boolean nominated;
-  boolean selected;
+  boolean selected;  // not in the spec any more (?)
+  unsigned long long bytesSent;
+  unsigned long long bytesReceived;
+  double totalRoundTripTime;
+  double currentRountTripTime;
+  double availableOutgoingBitrate;
+  double availableIncomingBitrate;
+  unsigned long long requestsReceived;
+  unsigned long long requestsSent;
+  unsigned long long responsesReceived;
+  unsigned long long responsesSent;
+  unsigned long long retransmissionsReceived;
+  unsigned long long retransmissionsSent;
+  unsigned long long consentRequestsReceived;
+  unsigned long long consentRequestsSent;
+  unsigned long long consentResponsesReceived;
+  unsigned long long consentResponsesSent;
 };
 
 enum RTCStatsIceCandidateType {
   "host",
   "serverreflexive",
   "peerreflexive",
   "relayed"
 };
 
 dictionary RTCIceCandidateStats : RTCStats {
-  DOMString componentId;
-  DOMString candidateId;
-  DOMString ipAddress;
-  DOMString transport;
+  DOMString transportId;
+  DOMString candidateId; // no longer in the spec
+  boolean isRemote;
+  DOMString ip;
+  long port;
+  DOMString protocol;
   DOMString mozLocalTransport; // needs standardization
-  long portNumber;
   RTCStatsIceCandidateType candidateType;
+  long priority;
+  DOMString url;
+  boolean deleted;
 };
 
 dictionary RTCCodecStats : RTCStats {
   unsigned long payloadType;       // As used in RTP encoding.
   DOMString codec;                 // video/vp8 or equivalent
   unsigned long clockRate;
   unsigned long channels;          // 2=stereo, missing for most other cases.
   DOMString parameters;            // From SDP description line

--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
@@ -3682,41 +3682,41 @@ static void ToRTCIceCandidateStats(
     DOMHighResTimeStamp now,
     RTCStatsReportInternal* report) {
 
   MOZ_ASSERT(report);
   for (const auto& candidate : candidates) {
     RTCIceCandidateStats cand;
     cand.mType.Construct(candidateType);
     NS_ConvertASCIItoUTF16 codeword(candidate.codeword.c_str());
-    cand.mComponentId.Construct(componentId);
+    cand.mTransportId.Construct(componentId);
     cand.mId.Construct(codeword);
     cand.mTimestamp.Construct(now);
     cand.mCandidateType.Construct(
         RTCStatsIceCandidateType(candidate.type));
-    cand.mIpAddress.Construct(
+    cand.mIp.Construct(
         NS_ConvertASCIItoUTF16(candidate.cand_addr.host.c_str()));
-    cand.mPortNumber.Construct(candidate.cand_addr.port);
-    cand.mTransport.Construct(
+    cand.mPort.Construct(candidate.cand_addr.port);
+    cand.mProtocol.Construct(
         NS_ConvertASCIItoUTF16(candidate.cand_addr.transport.c_str()));
     if (candidateType == RTCStatsType::Local_candidate) {
       cand.mMozLocalTransport.Construct(
           NS_ConvertASCIItoUTF16(candidate.local_addr.transport.c_str()));
     }
     report->mIceCandidateStats.Value().AppendElement(cand, fallible);
   }
 }
 
 static void RecordIceStats_s(
     NrIceMediaStream& mediaStream,
     bool internalStats,
     DOMHighResTimeStamp now,
     RTCStatsReportInternal* report) {
 
-  NS_ConvertASCIItoUTF16 componentId(mediaStream.name().c_str());
+  NS_ConvertASCIItoUTF16 transportId(mediaStream.name().c_str());
 
   std::vector<NrIceCandidatePair> candPairs;
   nsresult res = mediaStream.GetCandidatePairs(&candPairs);
   if (NS_FAILED(res)) {
     CSFLogError(logTag, "%s: Error getting candidate pairs", __FUNCTION__);
     return;
   }
 
@@ -3724,42 +3724,42 @@ static void RecordIceStats_s(
     NS_ConvertASCIItoUTF16 codeword(candPair.codeword.c_str());
     NS_ConvertASCIItoUTF16 localCodeword(candPair.local.codeword.c_str());
     NS_ConvertASCIItoUTF16 remoteCodeword(candPair.remote.codeword.c_str());
     // Only expose candidate-pair statistics to chrome, until we've thought
     // through the implications of exposing it to content.
 
     RTCIceCandidatePairStats s;
     s.mId.Construct(codeword);
-    s.mComponentId.Construct(componentId);
+    s.mTransportId.Construct(transportId);
     s.mTimestamp.Construct(now);
     s.mType.Construct(RTCStatsType::Candidate_pair);
     s.mLocalCandidateId.Construct(localCodeword);
     s.mRemoteCandidateId.Construct(remoteCodeword);
     s.mNominated.Construct(candPair.nominated);
     s.mPriority.Construct(candPair.priority);
     s.mSelected.Construct(candPair.selected);
     s.mState.Construct(RTCStatsIceCandidatePairState(candPair.state));
     report->mIceCandidatePairStats.Value().AppendElement(s, fallible);
   }
 
   std::vector<NrIceCandidate> candidates;
   if (NS_SUCCEEDED(mediaStream.GetLocalCandidates(&candidates))) {
     ToRTCIceCandidateStats(candidates,
                            RTCStatsType::Local_candidate,
-                           componentId,
+                           transportId,
                            now,
                            report);
   }
   candidates.clear();
 
   if (NS_SUCCEEDED(mediaStream.GetRemoteCandidates(&candidates))) {
     ToRTCIceCandidateStats(candidates,
                            RTCStatsType::Remote_candidate,
-                           componentId,
+                           transportId,
                            now,
                            report);
   }
 }
 
 nsresult
 PeerConnectionImpl::ExecuteStatsQuery_s(RTCStatsQuery *query) {
 

--- a/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp
+++ b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp
@@ -965,25 +965,25 @@ static uint32_t GetCandidateIpAndTranspo
 
   uint32_t res = 0;
 
   nsAutoCString transport;
   // prefer local transport for local relay candidates
   if (cand->mMozLocalTransport.WasPassed()) {
     transport.Assign(NS_ConvertUTF16toUTF8(cand->mMozLocalTransport.Value()));
   } else {
-    transport.Assign(NS_ConvertUTF16toUTF8(cand->mTransport.Value()));
+    transport.Assign(NS_ConvertUTF16toUTF8(cand->mProtocol.Value()));
   }
   if (transport == kNrIceTransportUdp) {
     res |= CANDIDATE_BITMASK_UDP;
   } else if (transport == kNrIceTransportTcp) {
     res |= CANDIDATE_BITMASK_TCP;
   }
 
-  if (cand->mIpAddress.Value().FindChar(':') != -1) {
+  if (cand->mIp.Value().FindChar(':') != -1) {
     res |= CANDIDATE_BITMASK_IPV6;
   }
 
   return res;
 };
 
 static void StoreLongTermICEStatisticsImpl_m(
     nsresult result,
@@ -1009,42 +1009,39 @@ static void StoreLongTermICEStatisticsIm
 
   // Build list of streams, and whether or not they failed.
   for (size_t i = 0;
        i < query->report->mIceCandidatePairStats.Value().Length();
        ++i) {
     const RTCIceCandidatePairStats &pair =
       query->report->mIceCandidatePairStats.Value()[i];
 
-    if (!pair.mState.WasPassed() || !pair.mComponentId.WasPassed()) {
+    if (!pair.mState.WasPassed() || !pair.mTransportId.WasPassed()) {
       MOZ_CRASH();
       continue;
     }
 
-    // Note: this is not a "component" in the ICE definition, this is really a
-    // stream ID. This is just the way the stats API is standardized right now.
-    // Very confusing.
     std::string streamId(
-      NS_ConvertUTF16toUTF8(pair.mComponentId.Value()).get());
+      NS_ConvertUTF16toUTF8(pair.mTransportId.Value()).get());
 
     streamResults[streamId].streamSucceeded |=
       pair.mState.Value() == RTCStatsIceCandidatePairState::Succeeded;
   }
 
   for (size_t i = 0;
        i < query->report->mIceCandidateStats.Value().Length();
        ++i) {
     const RTCIceCandidateStats &cand =
       query->report->mIceCandidateStats.Value()[i];
 
     if (!cand.mType.WasPassed() ||
         !cand.mCandidateType.WasPassed() ||
-        !cand.mTransport.WasPassed() ||
-        !cand.mIpAddress.WasPassed() ||
-        !cand.mComponentId.WasPassed()) {
+        !cand.mProtocol.WasPassed() ||
+        !cand.mIp.WasPassed() ||
+        !cand.mTransportId.WasPassed()) {
       // Crash on debug, ignore this candidate otherwise.
       MOZ_CRASH();
       continue;
     }
 
     /* The bitmask after examaning a candidate should look like this:
      * REMOTE_GATHERED_HOST_UDP = 1,
      * REMOTE_GATHERED_HOST_TCP = 1 << 1,
@@ -1092,17 +1089,17 @@ static void StoreLongTermICEStatisticsIm
     } else if (cand.mCandidateType.Value() == RTCStatsIceCandidateType::Peerreflexive) {
       candBitmask <<= kPrflxShift;
     }
 
     // Note: this is not a "component" in the ICE definition, this is really a
     // stream ID. This is just the way the stats API is standardized right now.
     // Very confusing.
     std::string streamId(
-      NS_ConvertUTF16toUTF8(cand.mComponentId.Value()).get());
+      NS_ConvertUTF16toUTF8(cand.mTransportId.Value()).get());
 
     streamResults[streamId].candidateTypeBitpattern |= candBitmask;
   }
 
   for (auto& streamResult : streamResults) {
     Telemetry::RecordWebrtcIceCandidates(streamResult.second.candidateTypeBitpattern,
                                          streamResult.second.streamSucceeded);
   }