Refactor and clean-up relating to RTCCodecStats.

webrtc/pc/rtcstatscollector.cc

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 18 matching lines @@
 namespace webrtc {
 
 namespace {
 
 std::string RTCCertificateIDFromFingerprint(const std::string& fingerprint) {
   return "RTCCertificate_" + fingerprint;
 }
 
 std::string RTCCodecStatsIDFromDirectionMediaAndPayload(
     bool inbound, bool audio, uint32_t payload_type) {
-  // TODO(hbos): When we are able to handle multiple m= lines of the same media
-  // type (and multiple BaseChannels for the same type is possible?) this needs
-  // to be updated to differentiate the transport being used, and stats need to
-  // be collected for all of them. crbug.com/659117
+  // TODO(hbos): The present codec ID assignment is not sufficient to support
+  // Unified Plan or unbundled connections in all cases. When we are able to
+  // handle multiple m= lines of the same media type (and multiple BaseChannels
+  // for the same type is possible?) this needs to be updated to differentiate
+  // the transport being used, and stats need to be collected for all of them.
   if (inbound) {
     return audio ? "RTCCodec_InboundAudio_" + rtc::ToString<>(payload_type)
                  : "RTCCodec_InboundVideo_" + rtc::ToString<>(payload_type);
   }
   return audio ? "RTCCodec_OutboundAudio_" + rtc::ToString<>(payload_type)
                : "RTCCodec_OutboundVideo_" + rtc::ToString<>(payload_type);
 }
 
 std::string RTCIceCandidatePairStatsIDFromConnectionInfo(
     const cricket::ConnectionInfo& info) {
@@ skipping 135 matching lines @@
 }
 
 // Provides the media independent counters (both audio and video).
 void SetInboundRTPStreamStatsFromMediaReceiverInfo(
     const cricket::MediaReceiverInfo& media_receiver_info,
     RTCInboundRTPStreamStats* inbound_stats) {
   RTC_DCHECK(inbound_stats);
   inbound_stats->ssrc = rtc::ToString<>(media_receiver_info.ssrc());
   // TODO(hbos): Support the remote case. crbug.com/657855
   inbound_stats->is_remote = false;
-  // TODO(hbos): Set |codec_id| when we have |RTCCodecStats|. Maybe relevant:
-  // |media_receiver_info.codec_name|. crbug.com/657854, 657855, 659117

[hbos, 2017/02/03 15:18:32]

This is an old TODO that has already been resolved. The referenced bugs are
closed as duplicate bugs on bugs that replaced them.

   inbound_stats->packets_received =
       static_cast<uint32_t>(media_receiver_info.packets_rcvd);
   inbound_stats->bytes_received =
       static_cast<uint64_t>(media_receiver_info.bytes_rcvd);
   inbound_stats->packets_lost =
       static_cast<uint32_t>(media_receiver_info.packets_lost);
   inbound_stats->fraction_lost =
       static_cast<double>(media_receiver_info.fraction_lost);
 }
 
 void SetInboundRTPStreamStatsFromVoiceReceiverInfo(
     const cricket::VoiceReceiverInfo& voice_receiver_info,
     RTCInboundRTPStreamStats* inbound_audio) {
   SetInboundRTPStreamStatsFromMediaReceiverInfo(
       voice_receiver_info, inbound_audio);
   inbound_audio->media_type = "audio";
+  if (voice_receiver_info.codec_payload_type) {
+    inbound_audio->codec_id =
+        RTCCodecStatsIDFromDirectionMediaAndPayload(
+            true, true, *voice_receiver_info.codec_payload_type);
+  }

[hbos, 2017/02/03 15:18:32]

The refactoring was to move this to here. Previously it was placed in all the
calling places to the
Set[In/Out]boundRTPStreamStatsFrom[Voice/Video][Sender/Receiver]Info.

   inbound_audio->jitter =
       static_cast<double>(voice_receiver_info.jitter_ms) /
           rtc::kNumMillisecsPerSec;
   // |fir_count|, |pli_count| and |sli_count| are only valid for video and are
   // purposefully left undefined for audio.
 }
 
 void SetInboundRTPStreamStatsFromVideoReceiverInfo(
     const cricket::VideoReceiverInfo& video_receiver_info,
     RTCInboundRTPStreamStats* inbound_video) {
   SetInboundRTPStreamStatsFromMediaReceiverInfo(
       video_receiver_info, inbound_video);
   inbound_video->media_type = "video";
+  if (video_receiver_info.codec_payload_type) {
+    inbound_video->codec_id =
+        RTCCodecStatsIDFromDirectionMediaAndPayload(
+            true, false, *video_receiver_info.codec_payload_type);
+  }
   inbound_video->fir_count =
       static_cast<uint32_t>(video_receiver_info.firs_sent);
   inbound_video->pli_count =
       static_cast<uint32_t>(video_receiver_info.plis_sent);
   inbound_video->nack_count =
       static_cast<uint32_t>(video_receiver_info.nacks_sent);
   inbound_video->frames_decoded = video_receiver_info.frames_decoded;
 }
 
 // Provides the media independent counters (both audio and video).
 void SetOutboundRTPStreamStatsFromMediaSenderInfo(
     const cricket::MediaSenderInfo& media_sender_info,
     RTCOutboundRTPStreamStats* outbound_stats) {
   RTC_DCHECK(outbound_stats);
   outbound_stats->ssrc = rtc::ToString<>(media_sender_info.ssrc());
   // TODO(hbos): Support the remote case. crbug.com/657856
   outbound_stats->is_remote = false;
-  // TODO(hbos): Set |codec_id| when we have |RTCCodecStats|. Maybe relevant:
-  // |media_sender_info.codec_name|. crbug.com/657854, 657856, 659117
   outbound_stats->packets_sent =
       static_cast<uint32_t>(media_sender_info.packets_sent);
   outbound_stats->bytes_sent =
       static_cast<uint64_t>(media_sender_info.bytes_sent);
   if (media_sender_info.rtt_ms >= 0) {
     outbound_stats->round_trip_time = static_cast<double>(
         media_sender_info.rtt_ms) / rtc::kNumMillisecsPerSec;
   }
 }
 
 void SetOutboundRTPStreamStatsFromVoiceSenderInfo(
     const cricket::VoiceSenderInfo& voice_sender_info,
     RTCOutboundRTPStreamStats* outbound_audio) {
   SetOutboundRTPStreamStatsFromMediaSenderInfo(
       voice_sender_info, outbound_audio);
   outbound_audio->media_type = "audio";
+  if (voice_sender_info.codec_payload_type) {
+    outbound_audio->codec_id =
+        RTCCodecStatsIDFromDirectionMediaAndPayload(
+            false, true, *voice_sender_info.codec_payload_type);
+  }
   // |fir_count|, |pli_count| and |sli_count| are only valid for video and are
   // purposefully left undefined for audio.
 }
 
 void SetOutboundRTPStreamStatsFromVideoSenderInfo(
     const cricket::VideoSenderInfo& video_sender_info,
     RTCOutboundRTPStreamStats* outbound_video) {
   SetOutboundRTPStreamStatsFromMediaSenderInfo(
       video_sender_info, outbound_video);
   outbound_video->media_type = "video";
+  if (video_sender_info.codec_payload_type) {
+    outbound_video->codec_id =
+        RTCCodecStatsIDFromDirectionMediaAndPayload(
+            false, false, *video_sender_info.codec_payload_type);
+  }
   outbound_video->fir_count =
       static_cast<uint32_t>(video_sender_info.firs_rcvd);
   outbound_video->pli_count =
       static_cast<uint32_t>(video_sender_info.plis_rcvd);
   outbound_video->nack_count =
       static_cast<uint32_t>(video_sender_info.nacks_rcvd);
   if (video_sender_info.qp_sum)
     outbound_video->qp_sum = *video_sender_info.qp_sum;
   outbound_video->frames_encoded = video_sender_info.frames_encoded;
 }
@@ skipping 647 matching lines @@
       if (audio_track) {
         RTC_DCHECK(track_to_id_.find(audio_track.get()) != track_to_id_.end());
         inbound_audio->track_id =
             RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
                 false,
                 MediaStreamTrackInterface::kAudioKind,
                 track_to_id_.find(audio_track.get())->second,
                 voice_receiver_info.ssrc());
       }
       inbound_audio->transport_id = transport_id;
-      if (voice_receiver_info.codec_payload_type) {
-        inbound_audio->codec_id =
-            RTCCodecStatsIDFromDirectionMediaAndPayload(
-                true, true, *voice_receiver_info.codec_payload_type);
-      }
       report->AddStats(std::move(inbound_audio));
     }
     // Outbound
     for (const cricket::VoiceSenderInfo& voice_sender_info :
          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)
         continue;
       std::unique_ptr<RTCOutboundRTPStreamStats> outbound_audio(
           new RTCOutboundRTPStreamStats(
               RTCOutboundRTPStreamStatsIDFromSSRC(
                   true, voice_sender_info.ssrc()),
               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) {
         RTC_DCHECK(track_to_id_.find(audio_track.get()) != track_to_id_.end());
         outbound_audio->track_id =
             RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
                 true,
                 MediaStreamTrackInterface::kAudioKind,
                 track_to_id_.find(audio_track.get())->second,
                 voice_sender_info.ssrc());
       }
       outbound_audio->transport_id = transport_id;
-      if (voice_sender_info.codec_payload_type) {
-        outbound_audio->codec_id =
-            RTCCodecStatsIDFromDirectionMediaAndPayload(
-                false, true, *voice_sender_info.codec_payload_type);
-      }
       report->AddStats(std::move(outbound_audio));
     }
   }
   // 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 :
@@ skipping 14 matching lines @@
       if (video_track) {
         RTC_DCHECK(track_to_id_.find(video_track.get()) != track_to_id_.end());
         inbound_video->track_id =
             RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
                 false,
                 MediaStreamTrackInterface::kVideoKind,
                 track_to_id_.find(video_track.get())->second,
                 video_receiver_info.ssrc());
       }
       inbound_video->transport_id = transport_id;
-      if (video_receiver_info.codec_payload_type) {
-        inbound_video->codec_id =
-            RTCCodecStatsIDFromDirectionMediaAndPayload(
-                true, false, *video_receiver_info.codec_payload_type);
-      }
       report->AddStats(std::move(inbound_video));
     }
     // Outbound
     for (const cricket::VideoSenderInfo& video_sender_info :
          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)
         continue;
       std::unique_ptr<RTCOutboundRTPStreamStats> outbound_video(
           new RTCOutboundRTPStreamStats(
               RTCOutboundRTPStreamStatsIDFromSSRC(
                   false, video_sender_info.ssrc()),
               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) {
         RTC_DCHECK(track_to_id_.find(video_track.get()) != track_to_id_.end());
         outbound_video->track_id =
             RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
                 true,
                 MediaStreamTrackInterface::kVideoKind,
                 track_to_id_.find(video_track.get())->second,
                 video_sender_info.ssrc());
       }
       outbound_video->transport_id = transport_id;
-      if (video_sender_info.codec_payload_type) {
-        outbound_video->codec_id =
-            RTCCodecStatsIDFromDirectionMediaAndPayload(
-                false, false, *video_sender_info.codec_payload_type);
-      }
       report->AddStats(std::move(outbound_video));
     }
   }
 }
 
 void RTCStatsCollector::ProduceTransportStats_n(
     int64_t timestamp_us, const SessionStats& session_stats,
     const std::map<std::string, CertificateStatsPair>& transport_cert_stats,
     RTCStatsReport* report) const {
   RTC_DCHECK(network_thread_->IsCurrent());
@@ skipping 161 matching lines @@
     const std::string& type) {
   return CandidateTypeToRTCIceCandidateType(type);
 }
 
 const char* DataStateToRTCDataChannelStateForTesting(
     DataChannelInterface::DataState state) {
   return DataStateToRTCDataChannelState(state);
 }
 
 }  // namespace webrtc