Cast: Refactor RTCP handling

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 570 matching lines @@
                                           video_receiver_config_,
                                           &receiver_to_sender_);
 
     net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new CastTransportSenderImpl(
         NULL,
         testing_clock_sender_,
         dummy_endpoint,
         base::Bind(&UpdateCastTransportStatus),
         base::Bind(&End2EndTest::LogRawEvents, base::Unretained(this)),
-        base::TimeDelta::FromSeconds(1),
+        base::TimeDelta::FromMilliseconds(1),
         task_runner_sender_,
         &sender_to_receiver_));
 
     cast_sender_ =
         CastSender::Create(cast_environment_sender_, transport_sender_.get());
 
     // Initializing audio and video senders.
     cast_sender_->InitializeAudio(audio_sender_config_,
                                   base::Bind(&AudioInitializationStatus));
     cast_sender_->InitializeVideo(video_sender_config_,
                                   base::Bind(&VideoInitializationStatus),
                                   CreateDefaultVideoEncodeAcceleratorCallback(),
                                   CreateDefaultVideoEncodeMemoryCallback());
 
-    receiver_to_sender_.SetPacketReceiver(cast_sender_->packet_receiver(),
-                                          task_runner_,
-                                          &testing_clock_);
+    receiver_to_sender_.SetPacketReceiver(
+        transport_sender_->PacketReceiverForTesting(),
+        task_runner_,
+        &testing_clock_);
     sender_to_receiver_.SetPacketReceiver(cast_receiver_->packet_receiver(),
                                           task_runner_,
                                           &testing_clock_);
 
     audio_frame_input_ = cast_sender_->audio_frame_input();
     video_frame_input_ = cast_sender_->video_frame_input();
 
     audio_bus_factory_.reset(
         new TestAudioBusFactory(audio_sender_config_.channels,
                                 audio_sender_config_.frequency,
@@ skipping 89 matching lines @@
 
   void StartBasicPlayer() {
     cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&End2EndTest::BasicPlayerGotVideoFrame,
                    base::Unretained(this)));
     cast_receiver_->RequestDecodedAudioFrame(
         base::Bind(&End2EndTest::BasicPlayerGotAudioFrame,
                    base::Unretained(this)));
   }
 
-  void LogRawEvents(const std::vector<PacketEvent>& packet_events) {
-    EXPECT_FALSE(packet_events.empty());
+  void LogRawEvents(const std::vector<PacketEvent>& packet_events,
+                    const std::vector<FrameEvent>& frame_events) {
     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);
     }
+    for (std::vector<media::cast::FrameEvent>::const_iterator it =
+             frame_events.begin();
+         it != frame_events.end();
+         ++it) {
+      cast_environment_sender_->Logging()->InsertFrameEvent(it->timestamp,
+                                                            it->type,
+                                                            it->media_type,
+                                                            it->rtp_timestamp,
+                                                            it->frame_id);
+    }
   }
 
   FrameReceiverConfig audio_receiver_config_;
   FrameReceiverConfig video_receiver_config_;
   AudioSenderConfig audio_sender_config_;
   VideoSenderConfig video_sender_config_;
 
   base::TimeTicks start_time_;
 
   // These run in "test time"
@@ skipping 504 matching lines @@
   // 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) {
       total_event_count_for_packet += map_it->second.counter[i];
     }
 
-    int expected_event_count_for_packet = 0;
     EXPECT_GT(map_it->second.counter[PACKET_RECEIVED], 0);
-    expected_event_count_for_packet +=
-        map_it->second.counter[PACKET_RECEIVED];
+    int packets_received = map_it->second.counter[PACKET_RECEIVED];
+    int packets_sent = map_it->second.counter[PACKET_SENT_TO_NETWORK];
+    EXPECT_EQ(packets_sent, packets_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);
+    // packet. (i.e. Total event count = packets sent + packets received)
+    EXPECT_EQ(packets_received + packets_sent, total_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) {
   Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
   Create();
 
   int audio_diff = kFrameTimerMs;
@@ skipping 168 matching lines @@
   EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000);
 }
 
 // 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