RTC[In/Out]boundRTPStreamStats.mediaTrackId collected.

webrtc/api/rtcstatscollector.cc

Index: webrtc/api/rtcstatscollector.cc
diff --git a/webrtc/api/rtcstatscollector.cc b/webrtc/api/rtcstatscollector.cc
index 3ab7ac94e1e12429a423d05d7180da4f84fdbef3..99d931bae89c62199a8e8d1a76aff81c92a9ebc0 100644
--- a/webrtc/api/rtcstatscollector.cc
+++ b/webrtc/api/rtcstatscollector.cc
@@ -54,8 +54,9 @@ std::string RTCIceCandidatePairStatsIDFromConnectionInfo(
 }
 
 std::string RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
-    const MediaStreamTrackInterface& track) {
-  return "RTCMediaStreamTrack_" + track.id();
+    const MediaStreamTrackInterface& track, bool is_local) {
+  return (is_local ? "RTCMediaStreamTrack_local_" + track.id()
+                   : "RTCMediaStreamTrack_remote_" + track.id());
 }
 
 std::string RTCTransportStatsIDFromTransportChannel(
@@ -328,7 +329,7 @@ void ProduceMediaStreamAndTrackStats(
     for (const rtc::scoped_refptr<AudioTrackInterface>& audio_track :
          stream->GetAudioTracks()) {
       std::string id = RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
-        *audio_track.get());
+          *audio_track.get(), is_local);
       if (report->Get(id)) {
         // Skip track, stats already exist for it.
         continue;
@@ -366,7 +367,7 @@ void ProduceMediaStreamAndTrackStats(
     for (const rtc::scoped_refptr<VideoTrackInterface>& video_track :
          stream->GetVideoTracks()) {
       std::string id = RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
-          *video_track.get());
+          *video_track.get(), is_local);
       if (report->Get(id)) {
         // Skip track, stats already exist for it.
         continue;
@@ -450,7 +451,7 @@ void RTCStatsCollector::GetStatsReport(
     num_pending_partial_reports_ = 2;
     partial_report_timestamp_us_ = cache_now_us;
 
-    // Prepare |channel_names_| and |media_info_| for use in
+    // Prepare |channel_name_pairs_| for use in
     // |ProducePartialResultsOnNetworkThread|.
     channel_name_pairs_.reset(new ChannelNamePairs());
     if (pc_->session()->voice_channel()) {
@@ -468,7 +469,10 @@ void RTCStatsCollector::GetStatsReport(
           ChannelNamePair(pc_->session()->data_channel()->content_name(),
                           pc_->session()->data_channel()->transport_name()));
     }
-    media_info_.reset(PrepareMediaInfo_s().release());
+    // Prepare |track_media_info_map_| for use in
+    // |ProducePartialResultsOnNetworkThread| and
+    // |ProducePartialResultsOnSignalingThread|.
+    track_media_info_map_.reset(PrepareTrackMediaInfoMap_s().release());
 
     invoker_.AsyncInvoke<void>(RTC_FROM_HERE, network_thread_,
         rtc::Bind(&RTCStatsCollector::ProducePartialResultsOnNetworkThread,
@@ -521,11 +525,11 @@ void RTCStatsCollector::ProducePartialResultsOnNetworkThread(
     ProduceCertificateStats_n(
         timestamp_us, transport_cert_stats, report.get());
     ProduceCodecStats_n(
-        timestamp_us, *media_info_, report.get());
+        timestamp_us, *track_media_info_map_, report.get());
     ProduceIceCandidateAndPairStats_n(
         timestamp_us, *session_stats, report.get());
     ProduceRTPStreamStats_n(
-        timestamp_us, *session_stats, *media_info_, report.get());
+        timestamp_us, *session_stats, *track_media_info_map_, report.get());
     ProduceTransportStats_n(
         timestamp_us, *session_stats, transport_cert_stats, report.get());
   }
@@ -558,6 +562,8 @@ void RTCStatsCollector::AddPartialResults_s(
     cache_timestamp_us_ = partial_report_timestamp_us_;
     cached_report_ = partial_report_;
     partial_report_ = nullptr;
+    channel_name_pairs_.reset();
+    track_media_info_map_.reset();
     DeliverCachedReport();
   }
 }
@@ -591,31 +597,35 @@ void RTCStatsCollector::ProduceCertificateStats_n(
 }
 
 void RTCStatsCollector::ProduceCodecStats_n(
-    int64_t timestamp_us, const MediaInfo& media_info,
+    int64_t timestamp_us, const TrackMediaInfoMap& track_media_info_map,
     RTCStatsReport* report) const {
   RTC_DCHECK(network_thread_->IsCurrent());
   // Audio
-  if (media_info.voice) {
+  if (track_media_info_map.voice_media_info()) {
     // Inbound
-    for (const auto& pair : media_info.voice->receive_codecs) {
+    for (const auto& pair :
+         track_media_info_map.voice_media_info()->receive_codecs) {
       report->AddStats(CodecStatsFromRtpCodecParameters(
           timestamp_us, true, true, pair.second));
     }
     // Outbound
-    for (const auto& pair : media_info.voice->send_codecs) {
+    for (const auto& pair :
+         track_media_info_map.voice_media_info()->send_codecs) {
       report->AddStats(CodecStatsFromRtpCodecParameters(
           timestamp_us, false, true, pair.second));
     }
   }
   // Video
-  if (media_info.video) {
+  if (track_media_info_map.video_media_info()) {
     // Inbound
-    for (const auto& pair : media_info.video->receive_codecs) {
+    for (const auto& pair :
+         track_media_info_map.video_media_info()->receive_codecs) {
       report->AddStats(CodecStatsFromRtpCodecParameters(
           timestamp_us, true, false, pair.second));
     }
     // Outbound
-    for (const auto& pair : media_info.video->send_codecs) {
+    for (const auto& pair :
+         track_media_info_map.video_media_info()->send_codecs) {
       report->AddStats(CodecStatsFromRtpCodecParameters(
           timestamp_us, false, false, pair.second));
     }
@@ -725,17 +735,18 @@ void RTCStatsCollector::ProducePeerConnectionStats_s(
 
 void RTCStatsCollector::ProduceRTPStreamStats_n(
     int64_t timestamp_us, const SessionStats& session_stats,
-    const MediaInfo& media_info, RTCStatsReport* report) const {
+    const TrackMediaInfoMap& track_media_info_map,
+    RTCStatsReport* report) const {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   // Audio
-  if (media_info.voice) {
+  if (track_media_info_map.voice_media_info()) {
     std::string transport_id = RTCTransportStatsIDFromBaseChannel(
         session_stats.proxy_to_transport, *pc_->session()->voice_channel());
     RTC_DCHECK(!transport_id.empty());
     // Inbound
     for (const cricket::VoiceReceiverInfo& voice_receiver_info :
-         media_info.voice->receivers) {
+         track_media_info_map.voice_media_info()->receivers) {
       // TODO(nisse): SSRC == 0 currently means none. Delete check when that
       // is fixed.
       if (voice_receiver_info.ssrc() == 0)
@@ -747,6 +758,12 @@ void RTCStatsCollector::ProduceRTPStreamStats_n(
               timestamp_us));
       SetInboundRTPStreamStatsFromVoiceReceiverInfo(
           voice_receiver_info, inbound_audio.get());
+      rtc::scoped_refptr<AudioTrackInterface> audio_track =
+          track_media_info_map_->GetAudioTrack(voice_receiver_info);
+      RTC_DCHECK(audio_track);
+      inbound_audio->media_track_id =
+          RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
+              *audio_track, false);
       inbound_audio->transport_id = transport_id;
       if (voice_receiver_info.codec_payload_type) {
         inbound_audio->codec_id =
@@ -757,7 +774,7 @@ void RTCStatsCollector::ProduceRTPStreamStats_n(
     }
     // Outbound
     for (const cricket::VoiceSenderInfo& voice_sender_info :
-         media_info.voice->senders) {
+         track_media_info_map.voice_media_info()->senders) {
       // TODO(nisse): SSRC == 0 currently means none. Delete check when that
       // is fixed.
       if (voice_sender_info.ssrc() == 0)
@@ -769,6 +786,13 @@ void RTCStatsCollector::ProduceRTPStreamStats_n(
               timestamp_us));
       SetOutboundRTPStreamStatsFromVoiceSenderInfo(
           voice_sender_info, outbound_audio.get());
+      rtc::scoped_refptr<AudioTrackInterface> audio_track =
+          track_media_info_map_->GetAudioTrack(voice_sender_info);
+      if (audio_track) {
+        outbound_audio->media_track_id =
+            RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
+                *audio_track, true);
+      }
       outbound_audio->transport_id = transport_id;
       if (voice_sender_info.codec_payload_type) {
         outbound_audio->codec_id =
@@ -779,13 +803,13 @@ void RTCStatsCollector::ProduceRTPStreamStats_n(
     }
   }
   // Video
-  if (media_info.video) {
+  if (track_media_info_map.video_media_info()) {
     std::string transport_id = RTCTransportStatsIDFromBaseChannel(
         session_stats.proxy_to_transport, *pc_->session()->video_channel());
     RTC_DCHECK(!transport_id.empty());
     // Inbound
     for (const cricket::VideoReceiverInfo& video_receiver_info :
-         media_info.video->receivers) {
+         track_media_info_map.video_media_info()->receivers) {
       // TODO(nisse): SSRC == 0 currently means none. Delete check when that
       // is fixed.
       if (video_receiver_info.ssrc() == 0)
@@ -797,6 +821,13 @@ void RTCStatsCollector::ProduceRTPStreamStats_n(
               timestamp_us));
       SetInboundRTPStreamStatsFromVideoReceiverInfo(
           video_receiver_info, inbound_video.get());
+      rtc::scoped_refptr<VideoTrackInterface> video_track =
+          track_media_info_map_->GetVideoTrack(video_receiver_info);

[Taylor Brandstetter, 2017/01/09 18:58:10]

nit: If you add a DCHECK for remote audio tracks' existence, should add one for
video as well for consistency.

[hbos, 2017/01/10 09:34:09]

Nice catch. Done.

+      if (video_track) {
+        inbound_video->media_track_id =
+            RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
+                *video_track, false);
+      }
       inbound_video->transport_id = transport_id;
       if (video_receiver_info.codec_payload_type) {
         inbound_video->codec_id =
@@ -807,7 +838,7 @@ void RTCStatsCollector::ProduceRTPStreamStats_n(
     }
     // Outbound
     for (const cricket::VideoSenderInfo& video_sender_info :
-         media_info.video->senders) {
+         track_media_info_map.video_media_info()->senders) {
       // TODO(nisse): SSRC == 0 currently means none. Delete check when that
       // is fixed.
       if (video_sender_info.ssrc() == 0)
@@ -819,6 +850,13 @@ void RTCStatsCollector::ProduceRTPStreamStats_n(
               timestamp_us));
       SetOutboundRTPStreamStatsFromVideoSenderInfo(
           video_sender_info, outbound_video.get());
+      rtc::scoped_refptr<VideoTrackInterface> video_track =
+          track_media_info_map_->GetVideoTrack(video_sender_info);
+      if (video_track) {
+        outbound_video->media_track_id =
+            RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
+                *video_track, true);
+      }
       outbound_video->transport_id = transport_id;
       if (video_sender_info.codec_payload_type) {
         outbound_video->codec_id =
@@ -922,25 +960,29 @@ RTCStatsCollector::PrepareTransportCertificateStats_n(
   return transport_cert_stats;
 }
 
-std::unique_ptr<RTCStatsCollector::MediaInfo>
-RTCStatsCollector::PrepareMediaInfo_s() const {
+std::unique_ptr<TrackMediaInfoMap>
+RTCStatsCollector::PrepareTrackMediaInfoMap_s() const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
-  std::unique_ptr<MediaInfo> media_info(new MediaInfo());
+  std::unique_ptr<cricket::VoiceMediaInfo> voice_media_info;
   if (pc_->session()->voice_channel()) {
-    cricket::VoiceMediaInfo voice_media_info;
-    if (pc_->session()->voice_channel()->GetStats(&voice_media_info)) {
-      media_info->voice = rtc::Optional<cricket::VoiceMediaInfo>(
-          std::move(voice_media_info));
+    voice_media_info.reset(new cricket::VoiceMediaInfo());
+    if (!pc_->session()->voice_channel()->GetStats(voice_media_info.get())) {
+      voice_media_info.reset();
     }
   }
+  std::unique_ptr<cricket::VideoMediaInfo> video_media_info;
   if (pc_->session()->video_channel()) {
-    cricket::VideoMediaInfo video_media_info;
-    if (pc_->session()->video_channel()->GetStats(&video_media_info)) {
-      media_info->video = rtc::Optional<cricket::VideoMediaInfo>(
-          std::move(video_media_info));
+    video_media_info.reset(new cricket::VideoMediaInfo());
+    if (!pc_->session()->video_channel()->GetStats(video_media_info.get())) {
+      video_media_info.reset();
     }
   }
-  return media_info;
+  std::unique_ptr<TrackMediaInfoMap> track_media_info_map(
+      new TrackMediaInfoMap(std::move(voice_media_info),
+                            std::move(video_media_info),
+                            pc_->GetSenders(),
+                            pc_->GetReceivers()));
+  return track_media_info_map;
 }
 
 void RTCStatsCollector::OnDataChannelCreated(DataChannel* channel) {