Cast: Restructure RTCP interface to better fit our usage.

media/cast/audio_receiver/audio_receiver.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 "media/cast/audio_receiver/audio_receiver.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/audio_receiver/audio_decoder.h"
@@ skipping 62 matching lines @@
 
  private:
   RtpReceiver* rtp_receiver_;
 };
 
 AudioReceiver::AudioReceiver(scoped_refptr<CastEnvironment> cast_environment,
                              const AudioReceiverConfig& audio_config,
                              PacedPacketSender* const packet_sender)
     : cast_environment_(cast_environment),
       codec_(audio_config.codec),
-      incoming_ssrc_(audio_config.incoming_ssrc),
       frequency_(audio_config.frequency),
       audio_buffer_(),
       audio_decoder_(),
       time_offset_(),
       weak_factory_(this) {
   target_delay_delta_ =
       base::TimeDelta::FromMilliseconds(audio_config.rtp_max_delay_ms);
   incoming_payload_callback_.reset(new LocalRtpAudioData(this));
   incoming_payload_feedback_.reset(new LocalRtpAudioFeedback(this));
   if (audio_config.use_external_decoder) {
@@ skipping 13 matching lines @@
       new LocalRtpReceiverStatistics(rtp_receiver_.get()));
   base::TimeDelta rtcp_interval_delta =
       base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval);
   rtcp_.reset(new Rtcp(cast_environment->Clock(),
                        NULL,
                        packet_sender,
                        NULL,
                        rtp_audio_receiver_statistics_.get(),
                        audio_config.rtcp_mode,
                        rtcp_interval_delta,
-                       false,
                        audio_config.feedback_ssrc,
+                       audio_config.incoming_ssrc,
                        audio_config.rtcp_c_name));
-  rtcp_->SetRemoteSSRC(audio_config.incoming_ssrc);
   ScheduleNextRtcpReport();
   ScheduleNextCastMessage();
 }
 
 AudioReceiver::~AudioReceiver() {}
 
 void AudioReceiver::IncomingParsedRtpPacket(const uint8* payload_data,
                                             size_t payload_size,
                                             const RtpCastHeader& rtp_header) {
   // TODO(pwestin): update this as video to refresh over time.
@@ skipping 142 matching lines @@
   bool rtcp_packet = Rtcp::IsRtcpPacket(packet, length);
   if (!rtcp_packet) {
     rtp_receiver_->ReceivedPacket(packet, length);
   } else {
     rtcp_->IncomingRtcpPacket(packet, length);
   }
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, callback);
 }
 
 void AudioReceiver::CastFeedback(const RtcpCastMessage& cast_message) {
-  rtcp_->SendRtcpCast(cast_message);
+  // TODO(pwestin): add logging.
+  rtcp_->SendRtcpFromRtpReceiver(&cast_message, NULL);
 }
 
 base::TimeTicks AudioReceiver::GetPlayoutTime(base::TimeTicks now,
                                               uint32 rtp_timestamp) {
   // Senders time in ms when this frame was recorded.
   // Note: the senders clock and our local clock might not be synced.
   base::TimeTicks rtp_timestamp_in_ticks;
   if (time_offset_ == base::TimeDelta()) {
     if (rtcp_->RtpTimestampInSenderTime(frequency_,
                                         first_incoming_rtp_timestamp_,
@@ skipping 26 matching lines @@
 
   time_to_send = std::max(time_to_send,
       base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
   cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&AudioReceiver::SendNextRtcpReport,
       weak_factory_.GetWeakPtr()), time_to_send);
 }
 
 void AudioReceiver::SendNextRtcpReport() {
-  rtcp_->SendRtcpReport(incoming_ssrc_);
+  // TODO(pwestin): add logging.
+  rtcp_->SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 // Cast messages should be sent within a maximum interval. Schedule a call
 // if not triggered elsewhere, e.g. by the cast message_builder.
 void AudioReceiver::ScheduleNextCastMessage() {
   if (audio_buffer_) {
     base::TimeTicks send_time;
     audio_buffer_->TimeToSendNextCastMessage(&send_time);
 
     base::TimeDelta time_to_send = send_time -
         cast_environment_->Clock()->NowTicks();
     time_to_send = std::max(time_to_send,
         base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
     cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
         base::Bind(&AudioReceiver::SendNextCastMessage,
                    weak_factory_.GetWeakPtr()), time_to_send);
   }
 }
 
 void AudioReceiver::SendNextCastMessage() {
   DCHECK(audio_buffer_) << "Invalid function call in this configuration";
   audio_buffer_->SendCastMessage();  // Will only send a message if it is time.
   ScheduleNextCastMessage();
 }
 
 }  // namespace cast
 }  // namespace media