RTCMediaStreamTrackStats.framesDropped collected by RTCStatsCollector.

webrtc/pc/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 1524 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_received = 2468;
-  video_receiver_info_ssrc3.frames_decoded = 1234;
+  video_receiver_info_ssrc3.frames_received = 1000;
+  video_receiver_info_ssrc3.frames_decoded = 995;
+  video_receiver_info_ssrc3.frames_rendered = 990;
 
   // Remote video 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_received = 0;
   video_receiver_info_ssrc4.frames_decoded = 0;
+  video_receiver_info_ssrc4.frames_rendered = 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 54 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_received = 2468;
-  expected_remote_video_track_ssrc3.frames_decoded = 1234;
+  expected_remote_video_track_ssrc3.frames_received = 1000;
+  expected_remote_video_track_ssrc3.frames_decoded = 995;
+  expected_remote_video_track_ssrc3.frames_dropped = 1000 - 990;
   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_received = 0;
   expected_remote_video_track_ssrc4.frames_decoded = 0;
+  expected_remote_video_track_ssrc4.frames_dropped = 0;
   // 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