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

media/cast/rtcp/rtcp_sender_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 "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/rtcp/rtcp_sender.h"
 #include "media/cast/rtcp/rtcp_utility.h"
@@ skipping 46 matching lines @@
   size_t expected_packet_length_;
   int packet_count_;
 };
 
 class RtcpSenderTest : public ::testing::Test {
  protected:
   RtcpSenderTest()
       : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
         cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
             task_runner_, task_runner_, task_runner_, task_runner_,
-            task_runner_, GetDefaultCastLoggingConfig())),
+            task_runner_, GetDefaultCastSenderLoggingConfig())),
         rtcp_sender_(new RtcpSender(cast_environment_,
                                     &test_transport_,
                                     kSendingSsrc,
                                     kCName)) {
   }
 
   base::SimpleTestTickClock testing_clock_;
   TestRtcpTransport test_transport_;
   scoped_refptr<test::FakeTaskRunner> task_runner_;
   scoped_refptr<CastEnvironment> cast_environment_;
@@ skipping 194 matching lines @@
 
   missing_packets.insert(kLostPacketId1);
   missing_packets.insert(kLostPacketId2);
   missing_packets.insert(kLostPacketId3);
   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
       missing_packets;
 
   // Test empty Log message.
   RtcpReceiverLogMessage receiver_log;
 
-  VLOG(0) << " Test empty Log  " ;
   rtcp_sender_->SendRtcpFromRtpReceiver(
       RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr | RtcpSender::kRtcpCast |
       RtcpSender::kRtcpReceiverLog,
       &report_block,
       &rrtr,
       &cast_message,
       &receiver_log);
 
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
   p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs);
-  p.AddReceiverEventLog(kDelayDeltaMs, 1, 0);
-  p.AddReceiverEventLog(kLostPacketId1, 6, kTimeDelayMs);
+  p.AddReceiverEventLog(kDelayDeltaMs, 5, 0);
+  p.AddReceiverEventLog(kLostPacketId1, 8, kTimeDelayMs);
 
   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 
   RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp);
   RtcpReceiverEventLogMessage event_log;
 
-  event_log.type = kAckSent;
+  event_log.type = kVideoAckSent;
   event_log.event_timestamp = testing_clock.NowTicks();
   event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
   frame_log.event_log_messages_.push_back(event_log);
 
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
-  event_log.type = kPacketReceived;
+  event_log.type = kVideoPacketReceived;
   event_log.event_timestamp = testing_clock.NowTicks();
   event_log.packet_id = kLostPacketId1;
   frame_log.event_log_messages_.push_back(event_log);
 
   receiver_log.push_back(frame_log);
 
-  VLOG(0) << " Test  Log  " ;
   rtcp_sender_->SendRtcpFromRtpReceiver(
       RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr | RtcpSender::kRtcpCast |
       RtcpSender::kRtcpReceiverLog,
       &report_block,
       &rrtr,
       &cast_message,
       &receiver_log);
 
   EXPECT_TRUE(receiver_log.empty());
   EXPECT_EQ(2, test_transport_.packet_count());
@@ skipping 19 matching lines @@
   report_block.jitter = kTestJitter;
   report_block.last_sr = kLastSr;
   report_block.delay_since_last_sr = kDelayLastSr;
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs);
-  p.AddReceiverEventLog(kDelayDeltaMs, 1, 0);
+  p.AddReceiverEventLog(kDelayDeltaMs, 5, 0);
   p.AddReceiverFrameLog(kRtpTimestamp + 2345,
       kRtcpMaxReceiverLogMessages, kTimeBaseMs);
 
   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
     p.AddReceiverEventLog(
-        kLostPacketId1, 6, static_cast<uint16>(kTimeDelayMs * i));
+        kLostPacketId1, 8, static_cast<uint16>(kTimeDelayMs * i));
   }
 
   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 
   RtcpReceiverFrameLogMessage frame_1_log(kRtpTimestamp);
   RtcpReceiverEventLogMessage event_log;
 
-  event_log.type = kAckSent;
+  event_log.type = kVideoAckSent;
   event_log.event_timestamp = testing_clock.NowTicks();
   event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
   frame_1_log.event_log_messages_.push_back(event_log);
 
   RtcpReceiverLogMessage receiver_log;
   receiver_log.push_back(frame_1_log);
 
   RtcpReceiverFrameLogMessage frame_2_log(kRtpTimestamp + 2345);
 
   for (int j = 0; j < 300; ++j) {
-    event_log.type = kPacketReceived;
+    event_log.type = kVideoPacketReceived;
     event_log.event_timestamp = testing_clock.NowTicks();
     event_log.packet_id = kLostPacketId1;
     frame_2_log.event_log_messages_.push_back(event_log);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
   receiver_log.push_back(frame_2_log);
 
   rtcp_sender_->SendRtcpFromRtpReceiver(
       RtcpSender::kRtcpRr | RtcpSender::kRtcpReceiverLog,
       &report_block,
@@ skipping 28 matching lines @@
   report_block.last_sr = kLastSr;
   report_block.delay_since_last_sr = kDelayLastSr;
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   for (int i = 0; i < 119; ++i) {
     p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs +  i * kTimeDelayMs);
-    p.AddReceiverEventLog(kDelayDeltaMs, 1, 0);
+    p.AddReceiverEventLog(kDelayDeltaMs, 5, 0);
   }
   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 
   RtcpReceiverLogMessage receiver_log;
 
   for (int j = 0; j < 200; ++j) {
     RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp);
     RtcpReceiverEventLogMessage event_log;
 
-    event_log.type = kAckSent;
+    event_log.type = kVideoAckSent;
     event_log.event_timestamp = testing_clock.NowTicks();
     event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
     frame_log.event_log_messages_.push_back(event_log);
     receiver_log.push_back(frame_log);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
   rtcp_sender_->SendRtcpFromRtpReceiver(
       RtcpSender::kRtcpRr | RtcpSender::kRtcpReceiverLog,
       &report_block,
       NULL,
       NULL,
       &receiver_log);
 
   EXPECT_EQ(1, test_transport_.packet_count());
   EXPECT_EQ(81u, receiver_log.size());
 }
 
 }  // namespace cast
 }  // namespace media