Cast: Refactor RTCP handling

media/cast/test/cast_benchmarks.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.
 //
 // This program benchmarks the theoretical throughput of the cast library.
 // It runs using a fake clock, simulated network and fake codecs. This allows
 // tests to run much faster than real time.
 // To run the program, run:
 // $ ./out/Release/cast_benchmarks | tee benchmarkoutput.asc
 // This may take a while, when it is done, you can view the data with
@@ skipping 71 matching lines @@
 }
 
 void AudioInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_AUDIO_INITIALIZED, status);
 }
 
 void VideoInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status);
 }
 
-void IgnoreRawEvents(const std::vector<PacketEvent>& packet_events) {
+void IgnoreRawEvents(const std::vector<PacketEvent>& packet_events,
+                     const std::vector<FrameEvent>& frame_events) {
 }
 
 }  // namespace
 
 // Wraps a CastTransportSender and records some statistics about
 // the data that goes through it.
 class CastTransportSenderWrapper : public CastTransportSender {
  public:
   // Takes ownership of |transport|.
   void Init(CastTransportSender* transport,
             uint64* encoded_video_bytes,
             uint64* encoded_audio_bytes) {
     transport_.reset(transport);
     encoded_video_bytes_ = encoded_video_bytes;
     encoded_audio_bytes_ = encoded_audio_bytes;
   }
 
   virtual void InitializeAudio(
-      const CastTransportRtpConfig& config) OVERRIDE {
-    transport_->InitializeAudio(config);
+      const CastTransportRtpConfig& config,
+      const RtcpCastMessageCallback& cast_message_cb,
+      const RtcpRttCallback& rtt_cb) OVERRIDE {
+    transport_->InitializeAudio(config, cast_message_cb, rtt_cb);
   }
 
   virtual void InitializeVideo(
-      const CastTransportRtpConfig& config) OVERRIDE {
-    transport_->InitializeVideo(config);
-  }
-
-  virtual void SetPacketReceiver(
-      const PacketReceiverCallback& packet_receiver) OVERRIDE {
-    transport_->SetPacketReceiver(packet_receiver);
+      const CastTransportRtpConfig& config,
+      const RtcpCastMessageCallback& cast_message_cb,
+      const RtcpRttCallback& rtt_cb) OVERRIDE {
+    transport_->InitializeVideo(config, cast_message_cb, rtt_cb);
   }
 
   virtual void InsertCodedAudioFrame(
       const EncodedFrame& audio_frame) OVERRIDE {
     *encoded_audio_bytes_ += audio_frame.data.size();
     transport_->InsertCodedAudioFrame(audio_frame);
   }
 
   virtual void InsertCodedVideoFrame(
       const EncodedFrame& video_frame) OVERRIDE {
     *encoded_video_bytes_ += video_frame.data.size();
     transport_->InsertCodedVideoFrame(video_frame);
   }
 
-  virtual void SendRtcpFromRtpSender(uint32 packet_type_flags,
-                                     uint32 ntp_seconds,
-                                     uint32 ntp_fraction,
-                                     uint32 rtp_timestamp,
-                                     const RtcpDlrrReportBlock& dlrr,
-                                     uint32 sending_ssrc,
-                                     const std::string& c_name) OVERRIDE {
-    transport_->SendRtcpFromRtpSender(packet_type_flags,
-                                      ntp_seconds,
-                                      ntp_fraction,
-                                      rtp_timestamp,
-                                      dlrr,
-                                      sending_ssrc,
-                                      c_name);
+  virtual void SendSenderReport(
+      uint32 ssrc,
+      base::TimeTicks current_time,
+      uint32 current_time_as_rtp_timestamp) OVERRIDE {
+    transport_->SendSenderReport(ssrc,
+                                 current_time,
+                                 current_time_as_rtp_timestamp);
   }
 
   // Retransmission request.
   virtual void ResendPackets(
       bool is_audio,
       const MissingFramesAndPacketsMap& missing_packets,
       bool cancel_rtx_if_not_in_list,
       base::TimeDelta dedupe_window) OVERRIDE {
     transport_->ResendPackets(
         is_audio, missing_packets, cancel_rtx_if_not_in_list, dedupe_window);
   }
 
+  virtual PacketReceiverCallback PacketReceiverForTesting() OVERRIDE {
+    return transport_->PacketReceiverForTesting();
+  }
+
  private:
   scoped_ptr<CastTransportSender> transport_;
   uint64* encoded_video_bytes_;
   uint64* encoded_audio_bytes_;
 };
 
 struct MeasuringPoint {
   MeasuringPoint(double bitrate_, double latency_, double percent_packet_drop_)
       : bitrate(bitrate_),
         latency(latency_),
@@ skipping 118 matching lines @@
     testing_clock_receiver_->SetSkew(skew, offset);
     task_runner_receiver_->SetSkew(1.0 / skew);
   }
 
   void Create(const MeasuringPoint& p) {
     cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
                                           audio_receiver_config_,
                                           video_receiver_config_,
                                           &receiver_to_sender_);
     net::IPEndPoint dummy_endpoint;
-    transport_sender_.Init(new CastTransportSenderImpl(
-                               NULL,
-                               testing_clock_sender_,
-                               dummy_endpoint,
-                               base::Bind(&UpdateCastTransportStatus),
-                               base::Bind(&IgnoreRawEvents),
-                               base::TimeDelta::FromSeconds(1),
-                               task_runner_sender_,
-                               &sender_to_receiver_),
-                           &video_bytes_encoded_,
-                           &audio_bytes_encoded_);
+    transport_sender_.Init(
+        new CastTransportSenderImpl(
+            NULL,
+            testing_clock_sender_,
+            dummy_endpoint,
+            base::Bind(&UpdateCastTransportStatus),
+            base::Bind(&IgnoreRawEvents),
+            base::TimeDelta::FromSeconds(1),
+            task_runner_sender_,
+            &sender_to_receiver_),
+        &video_bytes_encoded_,
+        &audio_bytes_encoded_);
 
     cast_sender_ =
         CastSender::Create(cast_environment_sender_, &transport_sender_);
 
     // 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_.Initialize(
-        CreateSimplePipe(p).Pass(), cast_sender_->packet_receiver(),
+        CreateSimplePipe(p).Pass(),
+        transport_sender_.PacketReceiverForTesting(),
         task_runner_, &testing_clock_);
     sender_to_receiver_.Initialize(
         CreateSimplePipe(p).Pass(), cast_receiver_->packet_receiver(),
         task_runner_, &testing_clock_);
   }
 
   virtual ~RunOneBenchmark() {
     cast_sender_.reset();
     cast_receiver_.reset();
     task_runner_->RunTasks();
@@ skipping 371 matching lines @@
   media::cast::CastBenchmark benchmark;
   if (getenv("PROFILE_FILE")) {
     std::string profile_file(getenv("PROFILE_FILE"));
     base::debug::StartProfiling(profile_file);
     benchmark.Run();
     base::debug::StopProfiling();
   } else {
     benchmark.Run();
   }
 }