Cast: Add GetStats() extensions API.

media/cast/logging/logging_impl_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/rand_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
@@ skipping 59 matching lines @@
   }  while (time_interval.InSeconds() < kIntervalTime1S);
   base::TimeTicks end_time = now;
 
   // Get logging data.
   std::vector<FrameEvent> frame_events;
   event_subscriber_.GetFrameEventsAndReset(&frame_events);
   // Size of vector should be equal to the number of events logged,
   // which equals to number of frames in this case.
   EXPECT_EQ(frame_id, frame_events.size());
   // Verify stats.
-  FrameStatsMap frame_stats = logging_->GetFrameStatsData();
+  FrameStatsMap frame_stats = logging_->GetFrameStatsData(AUDIO_EVENT);
   // Size of stats equals the number of events.
   EXPECT_EQ(1u, frame_stats.size());
   FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
   EXPECT_TRUE(it != frame_stats.end());
   EXPECT_EQ(0, it->second.max_delay.InMilliseconds());
   EXPECT_EQ(0, it->second.min_delay.InMilliseconds());
   EXPECT_EQ(start_time, it->second.first_event_time);
   EXPECT_EQ(end_time, it->second.last_event_time);
   EXPECT_EQ(0u, it->second.sum_size);
   // Number of events is equal to the number of frames.
@@ skipping 21 matching lines @@
     ++frame_id;
     time_interval = testing_clock_.NowTicks() - start_time;
   } while (time_interval.InSeconds() < kIntervalTime1S);
   // Get logging data.
   std::vector<FrameEvent> frame_events;
   event_subscriber_.GetFrameEventsAndReset(&frame_events);
   // Size of vector should be equal to the number of events logged, which
   // equals to number of frames in this case.
   EXPECT_EQ(frame_id, frame_events.size());
   // Verify stats.
-  FrameStatsMap frame_stats = logging_->GetFrameStatsData();
+  FrameStatsMap frame_stats = logging_->GetFrameStatsData(AUDIO_EVENT);
   // Size of stats equals the number of events.
   EXPECT_EQ(1u, frame_stats.size());
   FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
   EXPECT_TRUE(it != frame_stats.end());
   EXPECT_EQ(0, it->second.max_delay.InMilliseconds());
   EXPECT_EQ(0, it->second.min_delay.InMilliseconds());
   EXPECT_EQ(0, it->second.sum_delay.InMilliseconds());
   EXPECT_EQ(sum_size, it->second.sum_size);
 }
 
@@ skipping 15 matching lines @@
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
     time_interval = testing_clock_.NowTicks() - start_time;
   } while (time_interval.InSeconds() < kIntervalTime1S);
   // Get logging data.
   std::vector<FrameEvent> frame_events;
   event_subscriber_.GetFrameEventsAndReset(&frame_events);
   // Size of vector should be equal to the number of frames logged.
   EXPECT_EQ(frame_id, frame_events.size());
   // Verify stats.
-  FrameStatsMap frame_stats = logging_->GetFrameStatsData();
+  FrameStatsMap frame_stats = logging_->GetFrameStatsData(AUDIO_EVENT);
   // Size of stats equals the number of events.
   EXPECT_EQ(1u, frame_stats.size());
   FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
   EXPECT_TRUE(it != frame_stats.end());
   EXPECT_GE(kPlayoutDelayMs + kRandomSizeInterval,
       it->second.max_delay.InMilliseconds());
   EXPECT_LE(kPlayoutDelayMs - kRandomSizeInterval,
       it->second.min_delay.InMilliseconds());
 }
 
@@ skipping 32 matching lines @@
   // Size of vector should be equal to the number of frames logged.
   EXPECT_EQ(num_events, frame_events.size());
   // Multiple events captured per frame.
 }
 
 TEST_F(LoggingImplTest, PacketLogging) {
   const int kNumPacketsPerFrame = 10;
   const int kBaseSize = 2500;
   const int kSizeInterval = 100;
   base::TimeTicks start_time = testing_clock_.NowTicks();
+  base::TimeTicks latest_time;
   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
-  uint32 rtp_timestamp = 0;
-  uint32 frame_id = 0;
+  RtpTimestamp rtp_timestamp = 0;
+  int frame_id = 0;
+  int num_packets = 0;
+  int sum_size = 0u;
   do {
     for (int i = 0; i < kNumPacketsPerFrame; ++i) {
       int size = kBaseSize + base::RandInt(-kSizeInterval, kSizeInterval);
-      logging_->InsertPacketEvent(testing_clock_.NowTicks(), kPacketSentToPacer,
-                                  rtp_timestamp, frame_id, i,
-                                  kNumPacketsPerFrame, size);
+      sum_size += size;
+      latest_time = testing_clock_.NowTicks();
+      ++num_packets;
+      logging_->InsertPacketEvent(latest_time,
+                                  kDuplicateVideoPacketReceived,
+                                  rtp_timestamp,
+                                  frame_id,
+                                  i,
+                                  kNumPacketsPerFrame,
+                                  size);
     }
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
     time_interval = testing_clock_.NowTicks() - start_time;
   } while (time_interval.InSeconds() < kIntervalTime1S);
   // Get logging data.
   std::vector<PacketEvent> packet_events;
   event_subscriber_.GetPacketEventsAndReset(&packet_events);
   // Size of vector should be equal to the number of packets logged.
-  EXPECT_EQ(frame_id * kNumPacketsPerFrame, packet_events.size());
+  EXPECT_EQ(num_packets, static_cast<int>(packet_events.size()));
   // Verify stats.
-  PacketStatsMap stats_map = logging_->GetPacketStatsData();
-  // Size of stats equals the number of events.
+  PacketStatsMap stats_map = logging_->GetPacketStatsData(VIDEO_EVENT);
+  // Size of stats equals the number of event types.
   EXPECT_EQ(1u, stats_map.size());
-  PacketStatsMap::const_iterator it = stats_map.find(kPacketSentToPacer);
-  EXPECT_TRUE(it != stats_map.end());
+  PacketStatsMap::const_iterator it =
+      stats_map.find(kDuplicateVideoPacketReceived);
+  ASSERT_NE(stats_map.end(), it);
+  EXPECT_EQ(start_time, it->second.first_event_time);
+  EXPECT_EQ(latest_time, it->second.last_event_time);
+  EXPECT_EQ(num_packets, it->second.event_counter);
+  EXPECT_EQ(sum_size, static_cast<int>(it->second.sum_size));
 }
 
 TEST_F(LoggingImplTest, GenericLogging) {
   // Insert multiple generic types.
   const size_t kNumRuns = 20;//1000;
   const int kBaseValue = 20;
   int sum_value_rtt = 0;
   int sum_value_pl = 0;
   int sum_value_jitter = 0;
   uint64 sumsq_value_rtt = 0;
@@ skipping 92 matching lines @@
   EXPECT_EQ(1u, frame_events.size());
   frame_events.clear();
   event_subscriber_2.GetFrameEventsAndReset(&frame_events);
   EXPECT_EQ(1u, frame_events.size());
 
   logging_->RemoveRawEventSubscriber(&event_subscriber_2);
 }
 
 }  // namespace cast
 }  // namespace media