--- a/dom/media/webrtc/WebrtcGlobal.h
+++ b/dom/media/webrtc/WebrtcGlobal.h
@@ -198,32 +198,32 @@ 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);
     WriteParam(aMsg, aParam.mBytesSent);
     WriteParam(aMsg, aParam.mBytesReceived);
     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)) ||
         !ReadParam(aMsg, aIter, &(aResult->mBytesSent)) ||

--- a/dom/webidl/RTCStatsReport.webidl
+++ b/dom/webidl/RTCStatsReport.webidl
@@ -119,17 +119,17 @@ 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 readable;
   boolean nominated;
   unsigned long long bytesSent;
   unsigned long long bytesReceived;

--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
@@ -3564,17 +3564,17 @@ static void ToRTCIceCandidateStats(
 }
 
 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;
   }
 
@@ -3582,17 +3582,17 @@ 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.mBytesSent.Construct(candPair.bytes_sent);
@@ -3600,26 +3600,26 @@ static void RecordIceStats_s(
     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
@@ -1013,26 +1013,25 @@ 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.
+    // Note: we use NrIceMediaStream's name for the
+    // RTCIceCandidatePairStats tranportId
     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) {