Cast: Restructure RTCP interface to better fit our usage.

media/cast/video_receiver/video_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/video_receiver/video_receiver.h"
 
 #include <algorithm>
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 90 matching lines @@
 
  private:
   RtpReceiver* rtp_receiver_;
 };
 
 VideoReceiver::VideoReceiver(scoped_refptr<CastEnvironment> cast_environment,
                              const VideoReceiverConfig& video_config,
                              PacedPacketSender* const packet_sender)
       : cast_environment_(cast_environment),
         codec_(video_config.codec),
-        incoming_ssrc_(video_config.incoming_ssrc),
         target_delay_delta_(
             base::TimeDelta::FromMilliseconds(video_config.rtp_max_delay_ms)),
         frame_delay_(base::TimeDelta::FromMilliseconds(
             1000 / video_config.max_frame_rate)),
         incoming_payload_callback_(
             new LocalRtpVideoData(cast_environment_->Clock(), this)),
         incoming_payload_feedback_(new LocalRtpVideoFeedback(this)),
         rtp_receiver_(cast_environment_->Clock(), NULL, &video_config,
                       incoming_payload_callback_.get()),
         rtp_video_receiver_statistics_(
@@ skipping 13 matching lines @@
   }
 
   rtcp_.reset(
       new Rtcp(cast_environment_->Clock(),
                NULL,
                packet_sender,
                NULL,
                rtp_video_receiver_statistics_.get(),
                video_config.rtcp_mode,
                base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
-               false,
                video_config.feedback_ssrc,
+               video_config.incoming_ssrc,
                video_config.rtcp_c_name));
-
-  rtcp_->SetRemoteSSRC(video_config.incoming_ssrc);
   ScheduleNextRtcpReport();
   ScheduleNextCastMessage();
 }
 
 VideoReceiver::~VideoReceiver() {}
 
 void VideoReceiver::GetRawVideoFrame(
     const VideoFrameDecodedCallback& callback) {
   GetEncodedVideoFrame(base::Bind(&VideoReceiver::DecodeVideoFrame,
                                   weak_factory_.GetWeakPtr(),
@@ skipping 199 matching lines @@
   VideoFrameEncodedCallback callback = queued_encoded_callbacks_.front();
   queued_encoded_callbacks_.pop_front();
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&VideoReceiver::GetEncodedVideoFrame,
           weak_factory_.GetWeakPtr(), callback));
 }
 
 // Send a cast feedback message. Actual message created in the framer (cast
 // message builder).
 void VideoReceiver::CastFeedback(const RtcpCastMessage& cast_message) {
-  rtcp_->SendRtcpCast(cast_message);
+  // TODO(pwestin): wire up log messages.
+  rtcp_->SendRtcpFromRtpReceiver(&cast_message, NULL);
   time_last_sent_cast_message_= cast_environment_->Clock()->NowTicks();
 }
 
 // Cast messages should be sent within a maximum interval. Schedule a call
 // if not triggered elsewhere, e.g. by the cast message_builder.
 void VideoReceiver::ScheduleNextCastMessage() {
   base::TimeTicks send_time;
   framer_->TimeToSendNextCastMessage(&send_time);
 
   base::TimeDelta time_to_send = send_time -
@@ skipping 17 matching lines @@
 
   time_to_next = std::max(time_to_next,
       base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
   cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&VideoReceiver::SendNextRtcpReport,
                 weak_factory_.GetWeakPtr()), time_to_next);
 }
 
 void VideoReceiver::SendNextRtcpReport() {
-  rtcp_->SendRtcpReport(incoming_ssrc_);
+  rtcp_->SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media