cast: Wire upp logging to be sent over RTCP between receiver and sender.

media/cast/logging/logging_unittest.cc

 // Copyright 2013 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 <gtest/gtest.h>
 
 #include "base/rand_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "media/cast/logging/logging_impl.h"
 #include "media/cast/test/fake_task_runner.h"
 
 namespace media {
 namespace cast {
 
 // Insert frame duration- one second.
 const int64 kIntervalTime1S = 1;
 // Test frame rate goal - 30fps.
 const int kFrameIntervalMs = 33;
 
 static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
 
 class TestLogging : public ::testing::Test {
  protected:
-  TestLogging() {
+  TestLogging() : config_(false) {
     // Enable all logging types.
     config_.enable_raw_data_collection = true;
     config_.enable_stats_data_collection = true;
     config_.enable_uma_stats = true;
     config_.enable_tracing = true;
 
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     logging_.reset(new LoggingImpl(task_runner_, config_));
@@ skipping 216 matching lines @@
   EXPECT_EQ(kNumRuns / 4, rit->second.timestamp.size());
   // Stats - one value per event.
   GenericStatsMap::const_iterator sit = stats_map->find(kRttMs);
   EXPECT_NEAR(kBaseValue, sit->second, 2.5);
   sit = stats_map->find(kPacketLoss);
   EXPECT_NEAR(kBaseValue, sit->second, 2.5);
   sit = stats_map->find(kJitterMs);
   EXPECT_NEAR(kBaseValue, sit->second, 2.5);
 }
 
+TEST_F(TestLogging, RtcpMultipleEventFrameLogging) {
+  base::TimeTicks start_time = testing_clock_.NowTicks();
+  base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
+  uint32 rtp_timestamp = 0;
+  uint32 frame_id = 0;
+  do {
+    logging_->InsertFrameEvent(testing_clock_.NowTicks(), kAudioFrameCaptured,
+                               rtp_timestamp, frame_id);
+    if (frame_id % 2) {
+      logging_->InsertFrameEventWithSize(testing_clock_.NowTicks(),
+          kAudioFrameEncoded, rtp_timestamp, frame_id, 1500);
+    } else if (frame_id % 3) {
+      logging_->InsertFrameEvent(testing_clock_.NowTicks(), kVideoFrameDecoded,
+                                 rtp_timestamp, frame_id);
+    } else {
+      logging_->InsertFrameEventWithDelay(testing_clock_.NowTicks(),
+          kVideoRenderDelay, rtp_timestamp, frame_id,
+          base::TimeDelta::FromMilliseconds(20));
+    }
+    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.
+  FrameRawMap frame_map = logging_->GetFrameRawData();
+  // Size of map should be equal to the number of frames logged.
+  EXPECT_EQ(frame_id, frame_map.size());
+  // Multiple events captured per frame.
+
+  AudioRtcpRawMap audio_rtcp = logging_->GetAudioRtcpRawData();
+  EXPECT_EQ(0u, audio_rtcp.size());
+
+  VideoRtcpRawMap video_rtcp = logging_->GetVideoRtcpRawData();
+  EXPECT_EQ((frame_id + 1) / 2, video_rtcp.size());
+}
+
 }  // namespace cast
 }  // namespace media