Cast: Refactor RTCP handling

media/cast/test/simulator.cc

 // Copyright 2014 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.
 
 // Simulate end to end streaming.
 //
 // Input:
 // --source=
 //   WebM used as the source of video and audio frames.
 // --output=
@@ skipping 67 matching lines @@
 
 void AudioInitializationStatus(CastInitializationStatus status) {
   LOG(INFO) << "Audio status: " << status;
 }
 
 void VideoInitializationStatus(CastInitializationStatus status) {
   LOG(INFO) << "Video status: " << status;
 }
 
 void LogTransportEvents(const scoped_refptr<CastEnvironment>& env,
-                        const std::vector<PacketEvent>& packet_events) {
+                        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) {
     env->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) {
+    env->Logging()->InsertFrameEvent(it->timestamp,
+                                     it->type,
+                                     it->media_type,
+                                     it->rtp_timestamp,
+                                     it->frame_id);
+  }
 }
 
 void GotVideoFrame(
     int* counter,
     CastReceiver* cast_receiver,
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& render_time,
     bool continuous) {
   ++*counter;
   cast_receiver->RequestDecodedVideoFrame(
@@ skipping 146 matching lines @@
   const IPPModel& ipp_model = model.ipp();
 
   std::vector<double> average_rates(ipp_model.average_rate_size());
   std::copy(ipp_model.average_rate().begin(), ipp_model.average_rate().end(),
       average_rates.begin());
   test::InterruptedPoissonProcess ipp(average_rates,
       ipp_model.coef_burstiness(), ipp_model.coef_variance(), 0);
 
   // Connect sender to receiver. This initializes the pipe.
   receiver_to_sender.Initialize(
-      ipp.NewBuffer(128 * 1024), cast_sender->packet_receiver(), task_runner,
-      &testing_clock);
+      ipp.NewBuffer(128 * 1024), transport_sender->PacketReceiverForTesting(),
+      task_runner, &testing_clock);
   sender_to_receiver.Initialize(
       ipp.NewBuffer(128 * 1024), cast_receiver->packet_receiver(), task_runner,
       &testing_clock);
 
   // Start receiver.
   int audio_frame_count = 0;
   int video_frame_count = 0;
   cast_receiver->RequestDecodedVideoFrame(
       base::Bind(&GotVideoFrame, &video_frame_count, cast_receiver.get()));
   cast_receiver->RequestDecodedAudioFrame(
@@ skipping 156 matching lines @@
   values.SetBoolean("sim", true);
   values.SetString("sim-id", sim_id);
 
   std::string extra_data;
   base::JSONWriter::Write(&values, &extra_data);
 
   // Run.
   media::cast::RunSimulation(source_path, output_path, extra_data, model);
   return 0;
 }