RTCMediaStreamTrackStats.framesDecoded collected.

webrtc/api/rtcstatscollector_unittest.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 1515 matching lines @@
       CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID3",
                       MediaStreamTrackInterface::kEnded);
   remote_stream->AddTrack(static_cast<VideoTrackInterface*>(
       remote_video_track_ssrc3.get()));
 
   cricket::VideoReceiverInfo video_receiver_info_ssrc3;
   video_receiver_info_ssrc3.local_stats.push_back(cricket::SsrcReceiverInfo());
   video_receiver_info_ssrc3.local_stats[0].ssrc = 3;
   video_receiver_info_ssrc3.frame_width = 6789;
   video_receiver_info_ssrc3.frame_height = 9876;
+  video_receiver_info_ssrc3.frames_decoded = 1234;
 
   // Remote audio track with undefined (default) values
   rtc::scoped_refptr<MediaStreamTrackInterface> remote_video_track_ssrc4 =
       CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID4",
                       MediaStreamTrackInterface::kLive);
   remote_stream->AddTrack(static_cast<VideoTrackInterface*>(
       remote_video_track_ssrc4.get()));
 
   cricket::VideoReceiverInfo video_receiver_info_ssrc4;
   video_receiver_info_ssrc4.local_stats.push_back(cricket::SsrcReceiverInfo());
   video_receiver_info_ssrc4.local_stats[0].ssrc = 4;
   video_receiver_info_ssrc4.frame_width = 0;
   video_receiver_info_ssrc4.frame_height = 0;
+  video_receiver_info_ssrc4.frames_decoded = 0;
 
   test_->CreateMockRtpSendersReceiversAndChannels(
       {}, {},
       { std::make_pair(local_video_track.get(), video_sender_info_ssrc1),
         std::make_pair(local_video_track.get(), video_sender_info_ssrc2) },
       { std::make_pair(remote_video_track_ssrc3.get(),
                        video_receiver_info_ssrc3),
         std::make_pair(remote_video_track_ssrc4.get(),
                        video_receiver_info_ssrc4) });
 
@@ skipping 52 matching lines @@
   RTCMediaStreamTrackStats expected_remote_video_track_ssrc3(
       "RTCMediaStreamTrack_remote_video_RemoteVideoTrackID3_3",
       report->timestamp_us(), RTCMediaStreamTrackKind::kVideo);
   expected_remote_video_track_ssrc3.track_identifier =
       remote_video_track_ssrc3->id();
   expected_remote_video_track_ssrc3.remote_source = true;
   expected_remote_video_track_ssrc3.ended = true;
   expected_remote_video_track_ssrc3.detached = false;
   expected_remote_video_track_ssrc3.frame_width = 6789;
   expected_remote_video_track_ssrc3.frame_height = 9876;
+  expected_remote_video_track_ssrc3.frames_decoded = 1234;
   ASSERT_TRUE(report->Get(expected_remote_video_track_ssrc3.id()));
   EXPECT_EQ(expected_remote_video_track_ssrc3,
             report->Get(expected_remote_video_track_ssrc3.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 
   RTCMediaStreamTrackStats expected_remote_video_track_ssrc4(
       "RTCMediaStreamTrack_remote_video_RemoteVideoTrackID4_4",
       report->timestamp_us(), RTCMediaStreamTrackKind::kVideo);
   expected_remote_video_track_ssrc4.track_identifier =
       remote_video_track_ssrc4->id();
   expected_remote_video_track_ssrc4.remote_source = true;
   expected_remote_video_track_ssrc4.ended = false;
   expected_remote_video_track_ssrc4.detached = false;
+  expected_remote_video_track_ssrc4.frames_decoded = 0;

[hta-webrtc, 2017/01/20 09:41:36]

If we expect in the future that two SSRCs may be associated with an incoming
track, we should maybe add a test for it now - see that it behaves as expected
(I don't care if it's a DCHECK, a sum or a number that is less than the max - as
long as it's the behavior you expect).

If we can't do it now, just leave it.

[hbos, 2017/01/20 14:45:48]

Can't do it now, the assumption about only having one receiver info per remote
track is DCHECKed, testing that would crash.

Unless you mean multiple SSRCs for the same receiver, that is possible, but only
the first one is used as an ID, the rest don't matter. (I don't fully understand
what multiple SSRCs in the same "group" like that means but it doesn't affect
this AFAIK.)

   // Should be undefined: |expected_remote_video_track_ssrc4.frame_width| and
   // |expected_remote_video_track_ssrc4.frame_height|.
   ASSERT_TRUE(report->Get(expected_remote_video_track_ssrc4.id()));
   EXPECT_EQ(expected_remote_video_track_ssrc4,
             report->Get(expected_remote_video_track_ssrc4.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
   MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
@@ skipping 590 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc