Cast: Deduplicate event types in cast library.

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/receiver_rtcp_event_subscriber.h"
 #include "media/cast/rtcp/rtcp_sender.h"
@@ skipping 237 matching lines @@
   cast_message.ack_frame_id_ = kAckFrameId;
   PacketIdSet missing_packets;
   cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets;
 
   missing_packets.insert(kLostPacketId1);
   missing_packets.insert(kLostPacketId2);
   missing_packets.insert(kLostPacketId3);
   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
       missing_packets;
 
-  ReceiverRtcpEventSubscriber event_subscriber(
-      500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
+  ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 
   rtcp_sender_->SendRtcpFromRtpReceiver(
       transport::kRtcpRr | transport::kRtcpRrtr | transport::kRtcpCast |
           transport::kRtcpReceiverLog,
       &report_block,
       &rrtr,
       &cast_message,
       &rtcp_events,
       kDefaultDelay);
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
   p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs);
-  p.AddReceiverEventLog(0, kVideoAckSent, 0);
-  p.AddReceiverEventLog(kLostPacketId1, kVideoPacketReceived, kTimeDelayMs);
+  p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
+  p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
 
   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
   FrameEvent frame_event;
   frame_event.rtp_timestamp = kRtpTimestamp;
-  frame_event.type = kVideoAckSent;
+  frame_event.type = FRAME_ACK_SENT;
+  frame_event.media_type = VIDEO_EVENT;
   frame_event.timestamp = testing_clock.NowTicks();
   event_subscriber.OnReceiveFrameEvent(frame_event);
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 
   PacketEvent packet_event;
   packet_event.rtp_timestamp = kRtpTimestamp;
-  packet_event.type = kVideoPacketReceived;
+  packet_event.type = PACKET_RECEIVED;
+  packet_event.media_type = VIDEO_EVENT;
   packet_event.timestamp = testing_clock.NowTicks();
   packet_event.packet_id = kLostPacketId1;
   event_subscriber.OnReceivePacketEvent(packet_event);
   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
   EXPECT_EQ(2u, rtcp_events.size());
 
   rtcp_sender_->SendRtcpFromRtpReceiver(
       transport::kRtcpRr | transport::kRtcpRrtr | transport::kRtcpCast |
           transport::kRtcpReceiverLog,
       &report_block,
@@ skipping 27 matching lines @@
   remaining_bytes -= kRtcpReceiverFrameLogSize;
   int num_events = remaining_bytes / kRtcpReceiverEventLogSize;
   EXPECT_LE(num_events, static_cast<int>(kRtcpMaxReceiverLogMessages));
   // Only the last |num_events| events are sent due to receiver log size cap.
   p.AddReceiverFrameLog(
       kRtpTimestamp + 2345,
       num_events,
       kTimeBaseMs + (kRtcpMaxReceiverLogMessages - num_events) * kTimeDelayMs);
   for (int i = 0; i < num_events; i++) {
     p.AddReceiverEventLog(
-        kLostPacketId1, kVideoPacketReceived,
+        kLostPacketId1, PACKET_RECEIVED,
         static_cast<uint16>(kTimeDelayMs * i));
   }
 
   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
-  ReceiverRtcpEventSubscriber event_subscriber(
-      500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
+  ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   FrameEvent frame_event;
   frame_event.rtp_timestamp = kRtpTimestamp;
-  frame_event.type = media::cast::kVideoAckSent;
+  frame_event.type = FRAME_ACK_SENT;
+  frame_event.media_type = VIDEO_EVENT;
   frame_event.timestamp = testing_clock.NowTicks();
   event_subscriber.OnReceiveFrameEvent(frame_event);
 
   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
     PacketEvent packet_event;
     packet_event.rtp_timestamp = kRtpTimestamp + 2345;
-    packet_event.type = kVideoPacketReceived;
+    packet_event.type = PACKET_RECEIVED;
+    packet_event.media_type = VIDEO_EVENT;
     packet_event.timestamp = testing_clock.NowTicks();
     packet_event.packet_id = kLostPacketId1;
     event_subscriber.OnReceivePacketEvent(packet_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 
   rtcp_sender_->SendRtcpFromRtpReceiver(
@@ skipping 27 matching lines @@
   remaining_bytes -= kRtcpCastLogHeaderSize;
 
   int num_events =
       remaining_bytes / (kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize);
 
   // The last |num_events| events are sent due to receiver log size cap.
   for (size_t i = kRtcpMaxReceiverLogMessages - num_events;
        i < kRtcpMaxReceiverLogMessages;
        ++i) {
     p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs);
-    p.AddReceiverEventLog(0, kVideoAckSent, 0);
+    p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
   }
   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
-  ReceiverRtcpEventSubscriber event_subscriber(
-      500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
+  ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 
   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
     FrameEvent frame_event;
     frame_event.rtp_timestamp = kRtpTimestamp + static_cast<int>(i);
-    frame_event.type = media::cast::kVideoAckSent;
+    frame_event.type = FRAME_ACK_SENT;
+    frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 
   rtcp_sender_->SendRtcpFromRtpReceiver(
       transport::kRtcpRr | transport::kRtcpReceiverLog,
@@ skipping 20 matching lines @@
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   // Log 11 events for a single frame, each |kTimeBetweenEventsMs| apart.
   // Only last 10 events will be sent because the first event is more than
   // 4095 milliseconds away from latest event.
   const int kTimeBetweenEventsMs = 410;
   p.AddReceiverFrameLog(kRtpTimestamp, 10, kTimeBaseMs + kTimeBetweenEventsMs);
   for (int i = 0; i < 10; ++i) {
-    p.AddReceiverEventLog(0, kVideoAckSent, i * kTimeBetweenEventsMs);
+    p.AddReceiverEventLog(0, FRAME_ACK_SENT, i * kTimeBetweenEventsMs);
   }
   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
-  ReceiverRtcpEventSubscriber event_subscriber(
-      500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
+  ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   for (int i = 0; i < 11; ++i) {
     FrameEvent frame_event;
     frame_event.rtp_timestamp = kRtpTimestamp;
-    frame_event.type = media::cast::kVideoAckSent;
+    frame_event.type = FRAME_ACK_SENT;
+    frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
     testing_clock.Advance(
         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 
   rtcp_sender_->SendRtcpFromRtpReceiver(
       transport::kRtcpRr | transport::kRtcpReceiverLog,
       &report_block,
       NULL,
       NULL,
       &rtcp_events,
       kDefaultDelay);
 
   EXPECT_EQ(1, test_transport_.packet_count());
 }
 
 TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
   uint32 time_base_ms = 12345678;
   int kTimeBetweenEventsMs = 10;
 
   transport::RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms));
 
-  ReceiverRtcpEventSubscriber event_subscriber(
-      500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
+  ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   size_t packet_count = kReceiveLogMessageHistorySize + 10;
   for (size_t i = 0; i < packet_count; i++) {
     TestRtcpPacketBuilder p;
     p.AddRr(kSendingSsrc, 1);
     p.AddRb(kMediaSsrc);
     p.AddSdesCname(kSendingSsrc, kCName);
 
     p.AddReceiverLog(kSendingSsrc);
 
     if (i >= kSecondRedundancyOffset) {
       p.AddReceiverFrameLog(
           kRtpTimestamp,
           1,
           time_base_ms - kSecondRedundancyOffset * kTimeBetweenEventsMs);
-      p.AddReceiverEventLog(0, kVideoAckSent, 0);
+      p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
     }
     if (i >= kFirstRedundancyOffset) {
       p.AddReceiverFrameLog(
           kRtpTimestamp,
           1,
           time_base_ms - kFirstRedundancyOffset * kTimeBetweenEventsMs);
-      p.AddReceiverEventLog(0, kVideoAckSent, 0);
+      p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
     }
     p.AddReceiverFrameLog(kRtpTimestamp, 1, time_base_ms);
-    p.AddReceiverEventLog(0, kVideoAckSent, 0);
+    p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
 
     test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 
     FrameEvent frame_event;
     frame_event.rtp_timestamp = kRtpTimestamp;
-    frame_event.type = media::cast::kVideoAckSent;
+    frame_event.type = FRAME_ACK_SENT;
+    frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
 
     ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
     event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 
     rtcp_sender_->SendRtcpFromRtpReceiver(
         transport::kRtcpRr | transport::kRtcpReceiverLog,
         &report_block,
         NULL,
         NULL,
         &rtcp_events,
         kDefaultDelay);
 
     testing_clock.Advance(
         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
     time_base_ms += kTimeBetweenEventsMs;
   }
 
   EXPECT_EQ(static_cast<int>(packet_count), test_transport_.packet_count());
 }
 
 }  // namespace cast
 }  // namespace media