Cast streaming logging: Log additional stats for the GetStats() API.

media/cast/logging/stats_event_subscriber_unittest.cc

Index: media/cast/logging/stats_event_subscriber_unittest.cc
diff --git a/media/cast/logging/stats_event_subscriber_unittest.cc b/media/cast/logging/stats_event_subscriber_unittest.cc
index 09c418b4258dccc20b2c949b9f65483c51cf7ec1..fe03bc62473549f938b25fe30db32355db246dc1 100644
--- a/media/cast/logging/stats_event_subscriber_unittest.cc
+++ b/media/cast/logging/stats_event_subscriber_unittest.cc
@@ -65,20 +65,44 @@ class StatsEventSubscriberTest : public ::testing::Test {
   scoped_ptr<StatsEventSubscriber> subscriber_;
 };
 
-TEST_F(StatsEventSubscriberTest, Capture) {
+TEST_F(StatsEventSubscriberTest, CaptureEncode) {
   Init(VIDEO_EVENT);
 
   uint32 rtp_timestamp = 0;
   uint32 frame_id = 0;
-  int num_frames = 10;
+  int extra_frames = 50;
+  // Only the first |extra_frames| frames logged will be taken into account
+  // when computing dropped frames.
+  int num_frames = StatsEventSubscriber::kMaxFrameInfoMapSize + 50;
+  int dropped_frames = 0;
   base::TimeTicks start_time = sender_clock_->NowTicks();
+  // Drop half the frames during the encode step.
   for (int i = 0; i < num_frames; i++) {
     cast_environment_->Logging()->InsertFrameEvent(sender_clock_->NowTicks(),
                                                    FRAME_CAPTURE_BEGIN,
                                                    VIDEO_EVENT,
                                                    rtp_timestamp,
                                                    frame_id);
-
+    AdvanceClocks(base::TimeDelta::FromMicroseconds(10));
+    cast_environment_->Logging()->InsertFrameEvent(sender_clock_->NowTicks(),
+                                                   FRAME_CAPTURE_END,
+                                                   VIDEO_EVENT,
+                                                   rtp_timestamp,
+                                                   frame_id);
+    if (i % 2 == 0) {
+      AdvanceClocks(base::TimeDelta::FromMicroseconds(10));
+      cast_environment_->Logging()->InsertEncodedFrameEvent(
+          sender_clock_->NowTicks(),
+          FRAME_ENCODED,
+          VIDEO_EVENT,
+          rtp_timestamp,
+          frame_id,
+          1024,
+          true,
+          5678);
+    } else if (i < extra_frames) {
+      dropped_frames++;
+    }
     AdvanceClocks(base::TimeDelta::FromMicroseconds(34567));
     rtp_timestamp += 90;
     frame_id++;
@@ -97,6 +121,16 @@ TEST_F(StatsEventSubscriberTest, Capture) {
   EXPECT_DOUBLE_EQ(
       it->second,
       static_cast<double>(num_frames) / duration.InMillisecondsF() * 1000);
+
+  it = stats_map.find(StatsEventSubscriber::NUM_FRAMES_CAPTURED);
+  ASSERT_TRUE(it != stats_map.end());
+
+  EXPECT_DOUBLE_EQ(it->second, static_cast<double>(num_frames));
+
+  it = stats_map.find(StatsEventSubscriber::NUM_FRAMES_DROPPED_BY_ENCODER);
+  ASSERT_TRUE(it != stats_map.end());
+
+  EXPECT_DOUBLE_EQ(it->second, static_cast<double>(dropped_frames));
 }
 
 TEST_F(StatsEventSubscriberTest, Encode) {
@@ -185,10 +219,12 @@ TEST_F(StatsEventSubscriberTest, PlayoutDelay) {
   uint32 frame_id = 0;
   int num_frames = 10;
   int total_delay_ms = 0;
-  for (int i = 0; i < num_frames; i++) {
-    int delay_ms = base::RandInt(-50, 50);
+  int late_frames = 0;
+  for (int i = 0, delay_ms = -50; i < num_frames; i++, delay_ms += 10) {
     base::TimeDelta delay = base::TimeDelta::FromMilliseconds(delay_ms);
     total_delay_ms += delay_ms;
+    if (delay_ms <= 0)
+      late_frames++;
     cast_environment_->Logging()->InsertFrameEventWithDelay(
         receiver_clock_.NowTicks(),
         FRAME_PLAYOUT,
@@ -211,6 +247,11 @@ TEST_F(StatsEventSubscriberTest, PlayoutDelay) {
 
   EXPECT_DOUBLE_EQ(
       it->second, static_cast<double>(total_delay_ms) / num_frames);
+
+  it = stats_map.find(StatsEventSubscriber::NUM_FRAMES_LATE);
+  ASSERT_TRUE(it != stats_map.end());
+
+  EXPECT_DOUBLE_EQ(it->second, late_frames);
 }
 
 TEST_F(StatsEventSubscriberTest, E2ELatency) {
@@ -268,11 +309,12 @@ TEST_F(StatsEventSubscriberTest, Packets) {
   int total_size = 0;
   int retransmit_total_size = 0;
   base::TimeDelta total_latency;
-  int num_packets_sent = 0;
+  int num_packets_transmitted = 0;
   int num_packets_retransmitted = 0;
+  int num_packets_rtx_rejected = 0;
   // Every 2nd packet will be retransmitted once.
   // Every 4th packet will be retransmitted twice.
-  // Every 8th packet will be retransmitted 3 times.
+  // Every 8th packet will be retransmitted 3 times + 1 rejected retransmission.
   for (int i = 0; i < num_packets; i++) {
     int size = 1000 + base::RandInt(-100, 100);
     total_size += size;
@@ -285,7 +327,7 @@ TEST_F(StatsEventSubscriberTest, Packets) {
                                                     i,
                                                     num_packets - 1,
                                                     size);
-    num_packets_sent++;
+    num_packets_transmitted++;
 
     int latency_micros = 20000 + base::RandInt(-10000, 10000);
     base::TimeDelta latency = base::TimeDelta::FromMicroseconds(latency_micros);
@@ -312,7 +354,7 @@ TEST_F(StatsEventSubscriberTest, Packets) {
           num_packets - 1,
           size);
       retransmit_total_size += size;
-      num_packets_sent++;
+      num_packets_transmitted++;
       num_packets_retransmitted++;
     }
 
@@ -329,7 +371,7 @@ TEST_F(StatsEventSubscriberTest, Packets) {
           num_packets - 1,
           size);
       retransmit_total_size += size;
-      num_packets_sent++;
+      num_packets_transmitted++;
       num_packets_retransmitted++;
     }
 
@@ -345,9 +387,19 @@ TEST_F(StatsEventSubscriberTest, Packets) {
           i,
           num_packets - 1,
           size);
+      cast_environment_->Logging()->InsertPacketEvent(
+          receiver_clock_.NowTicks(),
+          PACKET_RTX_REJECTED,
+          VIDEO_EVENT,
+          rtp_timestamp,
+          0,
+          i,
+          num_packets - 1,
+          size);
       retransmit_total_size += size;
-      num_packets_sent++;
+      num_packets_transmitted++;
       num_packets_retransmitted++;
+      num_packets_rtx_rejected++;
     }
 
     cast_environment_->Logging()->InsertPacketEvent(received_time,
@@ -394,7 +446,22 @@ TEST_F(StatsEventSubscriberTest, Packets) {
 
   EXPECT_DOUBLE_EQ(
       it->second,
-      static_cast<double>(num_packets_retransmitted) / num_packets_sent);
+      static_cast<double>(num_packets_retransmitted) / num_packets_transmitted);
+
+  it = stats_map.find(StatsEventSubscriber::NUM_PACKETS_SENT);
+  ASSERT_TRUE(it != stats_map.end());
+
+  EXPECT_DOUBLE_EQ(it->second, static_cast<double>(num_packets));
+
+  it = stats_map.find(StatsEventSubscriber::NUM_PACKETS_RETRANSMITTED);
+  ASSERT_TRUE(it != stats_map.end());
+
+  EXPECT_DOUBLE_EQ(it->second, static_cast<double>(num_packets_retransmitted));
+
+  it = stats_map.find(StatsEventSubscriber::NUM_PACKETS_RTX_REJECTED);
+  ASSERT_TRUE(it != stats_map.end());
+
+  EXPECT_DOUBLE_EQ(it->second, static_cast<double>(num_packets_rtx_rejected));
 }
 
 }  // namespace cast