cast: Split Rtcp into two for sender and receiver

media/cast/receiver/frame_receiver.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.
 
 #include "media/cast/receiver/frame_receiver.h"
 
 #include <algorithm>
+#include <string>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/constants.h"
+#include "media/cast/net/rtcp/rtcp_utility.h"
 
 namespace {
+
 const int kMinSchedulingDelayMs = 1;
+
+media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) {
+  media::cast::RtcpTimeData ret;
+  ret.timestamp = now;
+  media::cast::ConvertTimeTicksToNtp(now, &ret.ntp_seconds, &ret.ntp_fraction);
+  return ret;
+}
+
 }  // namespace
 
 namespace media {
 namespace cast {
 
 FrameReceiver::FrameReceiver(
     const scoped_refptr<CastEnvironment>& cast_environment,
     const FrameReceiverConfig& config,
     EventMediaType event_media_type,
     CastTransportSender* const transport)
     : cast_environment_(cast_environment),
       transport_(transport),
       packet_parser_(config.sender_ssrc, config.rtp_payload_type),
       stats_(cast_environment->Clock()),
       event_media_type_(event_media_type),
       event_subscriber_(kReceiverRtcpEventHistorySize, event_media_type),
       rtp_timebase_(config.rtp_timebase),
       target_playout_delay_(
           base::TimeDelta::FromMilliseconds(config.rtp_max_delay_ms)),
-      expected_frame_duration_(
-          base::TimeDelta::FromSeconds(1) / config.target_frame_rate),
+      expected_frame_duration_(base::TimeDelta::FromSeconds(1) /
+                               config.target_frame_rate),
       reports_are_scheduled_(false),
       framer_(cast_environment->Clock(),
               this,
               config.sender_ssrc,
               true,
               config.rtp_max_delay_ms * config.target_frame_rate / 1000),
-      rtcp_(RtcpCastMessageCallback(),
-            RtcpRttCallback(),
-            RtcpLogMessageCallback(),
-            cast_environment_->Clock(),
+      rtcp_(cast_environment_->Clock(),
             NULL,
             config.receiver_ssrc,
             config.sender_ssrc),
       is_waiting_for_consecutive_frame_(false),
       lip_sync_drift_(ClockDriftSmoother::GetDefaultTimeConstant()),
       weak_factory_(this) {
   transport_->AddValidSsrc(config.sender_ssrc);
   DCHECK_GT(config.rtp_max_delay_ms, 0);
   DCHECK_GT(config.target_frame_rate, 0);
   decryptor_.Initialize(config.aes_key, config.aes_iv_mask);
   cast_environment_->logger()->Subscribe(&event_subscriber_);
 }
 
 FrameReceiver::~FrameReceiver() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   cast_environment_->logger()->Unsubscribe(&event_subscriber_);
 }
 
 void FrameReceiver::RequestEncodedFrame(
     const ReceiveEncodedFrameCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   frame_request_queue_.push_back(callback);
   EmitAvailableEncodedFrames();
 }
 
 bool FrameReceiver::ProcessPacket(scoped_ptr<Packet> packet) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
-  if (Rtcp::IsRtcpPacket(&packet->front(), packet->size())) {
+  if (IsRtcpPacket(&packet->front(), packet->size())) {
     rtcp_.IncomingRtcpPacket(&packet->front(), packet->size());
   } else {
     RtpCastHeader rtp_header;
     const uint8* payload_data;
     size_t payload_size;
     if (!packet_parser_.ParsePacket(&packet->front(),
                                     packet->size(),
                                     &rtp_header,
                                     &payload_data,
                                     &payload_size)) {
@@ skipping 89 matching lines @@
   scoped_ptr<FrameEvent> ack_sent_event(new FrameEvent());
   ack_sent_event->timestamp = now;
   ack_sent_event->type = FRAME_ACK_SENT;
   ack_sent_event->media_type = event_media_type_;
   ack_sent_event->rtp_timestamp = rtp_timestamp;
   ack_sent_event->frame_id = cast_message.ack_frame_id;
   cast_environment_->logger()->DispatchFrameEvent(ack_sent_event.Pass());
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber_.GetRtcpEventsWithRedundancy(&rtcp_events);
-  transport_->SendRtcpFromRtpReceiver(rtcp_.GetLocalSsrc(),
-                                      rtcp_.GetRemoteSsrc(),
-                                      rtcp_.ConvertToNTPAndSave(now),
-                                      &cast_message,
-                                      target_playout_delay_,
-                                      &rtcp_events,
-                                      NULL);
+  transport_->SendRtcpFromRtpReceiver(
+      rtcp_.local_ssrc(), rtcp_.remote_ssrc(), CreateRtcpTimeData(now),
+      &cast_message, target_playout_delay_, &rtcp_events, NULL);
 }
 
 void FrameReceiver::EmitAvailableEncodedFrames() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   while (!frame_request_queue_.empty()) {
     // Attempt to peek at the next completed frame from the |framer_|.
     // TODO(miu): We should only be peeking at the metadata, and not copying the
     // payload yet!  Or, at least, peek using a StringPiece instead of a copy.
     scoped_ptr<EncodedFrame> encoded_frame(
@@ skipping 131 matching lines @@
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&FrameReceiver::SendNextRtcpReport,
                  weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kRtcpReportIntervalMs));
 }
 
 void FrameReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   RtpReceiverStatistics stats = stats_.GetStatistics();
-  transport_->SendRtcpFromRtpReceiver(rtcp_.GetLocalSsrc(),
-                                      rtcp_.GetRemoteSsrc(),
-                                      rtcp_.ConvertToNTPAndSave(now),
-                                      NULL,
-                                      base::TimeDelta(),
-                                      NULL,
-                                      &stats);
+  transport_->SendRtcpFromRtpReceiver(rtcp_.local_ssrc(), rtcp_.remote_ssrc(),
+                                      CreateRtcpTimeData(now), NULL,
+                                      base::TimeDelta(), NULL, &stats);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media