Cast: Deduplicate event types in cast library.

media/cast/test/end2end_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.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
@@ skipping 91 matching lines @@
 void AudioInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_AUDIO_INITIALIZED, status);
 }
 
 void VideoInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status);
 }
 
 // This is wrapped in a struct because it needs to be put into a std::map.
 typedef struct {
-  int counter[kNumOfLoggingEvents];
+  int counter[kNumOfLoggingEvents+1];
 } LoggingEventCounts;
 
 // Constructs a map from each frame (RTP timestamp) to counts of each event
 // type logged for that frame.
 std::map<RtpTimestamp, LoggingEventCounts> GetEventCountForFrameEvents(
     const std::vector<FrameEvent>& frame_events) {
   std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame;
   for (std::vector<FrameEvent>::const_iterator it = frame_events.begin();
        it != frame_events.end();
        ++it) {
@@ skipping 508 matching lines @@
   }
 
   void LogRawEvents(const std::vector<PacketEvent>& packet_events) {
     EXPECT_FALSE(packet_events.empty());
     for (std::vector<media::cast::PacketEvent>::const_iterator it =
              packet_events.begin();
          it != packet_events.end();
          ++it) {
       cast_environment_sender_->Logging()->InsertPacketEvent(it->timestamp,
                                                              it->type,
+                                                             it->media_type,
                                                              it->rtp_timestamp,
                                                              it->frame_id,
                                                              it->packet_id,
                                                              it->max_packet_id,
                                                              it->size);
     }
   }
 
   AudioReceiverConfig audio_receiver_config_;
   VideoReceiverConfig video_receiver_config_;
@@ skipping 427 matching lines @@
 
   // Verify that there are logs for expected number of frames.
   EXPECT_EQ(num_frames, static_cast<int>(event_counter_for_frame.size()));
 
   // Verify that each frame have the expected types of events logged.
   for (std::map<RtpTimestamp, LoggingEventCounts>::iterator map_it =
            event_counter_for_frame.begin();
        map_it != event_counter_for_frame.end();
        ++map_it) {
     int total_event_count_for_frame = 0;
-    for (int i = 0; i < kNumOfLoggingEvents; ++i) {
+    for (int i = 0; i <= kNumOfLoggingEvents; ++i) {
       total_event_count_for_frame += map_it->second.counter[i];
     }
 
     int expected_event_count_for_frame = 0;
 
-    EXPECT_EQ(1, map_it->second.counter[kVideoFrameCaptureBegin]);
+    EXPECT_EQ(1, map_it->second.counter[FRAME_CAPTURE_BEGIN]);
     expected_event_count_for_frame +=
-        map_it->second.counter[kVideoFrameCaptureBegin];
+        map_it->second.counter[FRAME_CAPTURE_BEGIN];
 
-    EXPECT_EQ(1, map_it->second.counter[kVideoFrameEncoded]);
+    EXPECT_EQ(1, map_it->second.counter[FRAME_CAPTURE_END]);
     expected_event_count_for_frame +=
-        map_it->second.counter[kVideoFrameEncoded];
+        map_it->second.counter[FRAME_CAPTURE_END];
 
-    EXPECT_EQ(1, map_it->second.counter[kVideoFrameCaptureEnd]);
+    EXPECT_EQ(1, map_it->second.counter[FRAME_ENCODED]);
     expected_event_count_for_frame +=
-        map_it->second.counter[kVideoFrameCaptureEnd];
+        map_it->second.counter[FRAME_ENCODED];
 
-    EXPECT_EQ(1, map_it->second.counter[kVideoRenderDelay]);
-    expected_event_count_for_frame += map_it->second.counter[kVideoRenderDelay];
+    EXPECT_EQ(1, map_it->second.counter[FRAME_DECODED]);
+    expected_event_count_for_frame +=
+        map_it->second.counter[FRAME_DECODED];
 
-    EXPECT_EQ(1, map_it->second.counter[kVideoFrameDecoded]);
+    EXPECT_EQ(1, map_it->second.counter[FRAME_PLAYOUT]);
+    expected_event_count_for_frame += map_it->second.counter[FRAME_PLAYOUT];
+
+
+    // There is no guarantee that FRAME_ACK_SENT is loggeed exactly once per
+    // frame.
+    EXPECT_GT(map_it->second.counter[FRAME_ACK_SENT], 0);
+    expected_event_count_for_frame += map_it->second.counter[FRAME_ACK_SENT];
+
+    // There is no guarantee that FRAME_ACK_RECEIVED is loggeed exactly once per
+    // frame.
+    EXPECT_GT(map_it->second.counter[FRAME_ACK_RECEIVED], 0);
     expected_event_count_for_frame +=
-        map_it->second.counter[kVideoFrameDecoded];
-
-    // There is no guarantee that kVideoAckSent is loggeed exactly once per
-    // frame.
-    EXPECT_GT(map_it->second.counter[kVideoAckSent], 0);
-    expected_event_count_for_frame += map_it->second.counter[kVideoAckSent];
-
-    // There is no guarantee that kVideoAckReceived is loggeed exactly once per
-    // frame.
-    EXPECT_GT(map_it->second.counter[kVideoAckReceived], 0);
-    expected_event_count_for_frame += map_it->second.counter[kVideoAckReceived];
+        map_it->second.counter[FRAME_ACK_RECEIVED];
 
     // Verify that there were no other events logged with respect to this
     // frame.
     // (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_frame, expected_event_count_for_frame);
   }
 
   // Packet logging.
   // Verify that all packet related events were logged.
   event_subscriber_sender_.GetPacketEventsAndReset(&packet_events_);
   std::map<uint16, LoggingEventCounts> event_count_for_packet =
       GetEventCountForPacketEvents(packet_events_);
 
   // Verify that each packet have the expected types of events logged.
   for (std::map<uint16, LoggingEventCounts>::iterator map_it =
            event_count_for_packet.begin();
        map_it != event_count_for_packet.end();
        ++map_it) {
     int total_event_count_for_packet = 0;
-    for (int i = 0; i < kNumOfLoggingEvents; ++i) {
+    for (int i = 0; i <= kNumOfLoggingEvents; ++i) {
       total_event_count_for_packet += map_it->second.counter[i];
     }
 
     int expected_event_count_for_packet = 0;
-    EXPECT_GT(map_it->second.counter[kVideoPacketReceived], 0);
+    EXPECT_GT(map_it->second.counter[PACKET_RECEIVED], 0);
     expected_event_count_for_packet +=
-        map_it->second.counter[kVideoPacketReceived];
+        map_it->second.counter[PACKET_RECEIVED];
 
     // Verify that there were no other events logged with respect to this
     // packet. (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_packet, expected_event_count_for_packet);
   }
 }
 
 // Audio test without packet loss - tests the logging aspects of the end2end,
 // but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, AudioLogging) {
@@ skipping 31 matching lines @@
   std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame =
       GetEventCountForFrameEvents(frame_events_);
 
   int encoded_count = 0;
 
   // Verify the right number of events were logged for each event type.
   for (std::map<RtpTimestamp, LoggingEventCounts>::iterator it =
            event_counter_for_frame.begin();
        it != event_counter_for_frame.end();
        ++it) {
-    encoded_count += it->second.counter[kAudioFrameEncoded];
+    encoded_count += it->second.counter[FRAME_ENCODED];
   }
 
   EXPECT_EQ(num_audio_frames_requested, encoded_count);
 
   // Verify that each frame have the expected types of events logged.
   for (std::map<RtpTimestamp, LoggingEventCounts>::const_iterator map_it =
            event_counter_for_frame.begin();
        map_it != event_counter_for_frame.end(); ++map_it) {
     int total_event_count_for_frame = 0;
-    for (int j = 0; j < kNumOfLoggingEvents; ++j)
+    for (int j = 0; j <= kNumOfLoggingEvents; ++j)
       total_event_count_for_frame += map_it->second.counter[j];
 
     int expected_event_count_for_frame = 0;
 
-    EXPECT_EQ(1, map_it->second.counter[kAudioFrameEncoded]);
+    EXPECT_EQ(1, map_it->second.counter[FRAME_ENCODED]);
     expected_event_count_for_frame +=
-        map_it->second.counter[kAudioFrameEncoded];
+        map_it->second.counter[FRAME_ENCODED];
 
-    EXPECT_EQ(1, map_it->second.counter[kAudioPlayoutDelay]);
+    EXPECT_EQ(1, map_it->second.counter[FRAME_PLAYOUT]);
     expected_event_count_for_frame +=
-        map_it->second.counter[kAudioPlayoutDelay];
+        map_it->second.counter[FRAME_PLAYOUT];
 
-    EXPECT_EQ(1, map_it->second.counter[kAudioFrameDecoded]);
+    EXPECT_EQ(1, map_it->second.counter[FRAME_DECODED]);
     expected_event_count_for_frame +=
-        map_it->second.counter[kAudioFrameDecoded];
+        map_it->second.counter[FRAME_DECODED];
 
-    EXPECT_GT(map_it->second.counter[kAudioAckSent], 0);
-    expected_event_count_for_frame += map_it->second.counter[kAudioAckSent];
+    EXPECT_GT(map_it->second.counter[FRAME_ACK_SENT], 0);
+    expected_event_count_for_frame += map_it->second.counter[FRAME_ACK_SENT];
 
     // Verify that there were no other events logged with respect to this frame.
     // (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_frame, expected_event_count_for_frame);
   }
 }
 
 TEST_F(End2EndTest, BasicFakeSoftwareVideo) {
   Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
   Create();
@@ skipping 10 matching lines @@
   EXPECT_EQ(1000, received_counter);
 }
 
 // TODO(pwestin): Add repeatable packet loss test.
 // TODO(pwestin): Add test for misaligned send get calls.
 // TODO(pwestin): Add more tests that does not resample.
 // TODO(pwestin): Add test when we have starvation for our RunTask.
 
 }  // namespace cast
 }  // namespace media