Refactor: simplify interface of SenderRtcpSession and CastTransport.

media/cast/sender/video_sender.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/sender/video_sender.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/performance_metrics_overlay.h"
 #include "media/cast/sender/video_encoder.h"
 
 namespace media {
 namespace cast {
 
 namespace {
@@ skipping 20 matching lines @@
 // request to the encoder on receiving Pli messages. This is used to prevent
 // sending multiple requests while the sender is waiting for an encoded key
 // frame or receiving multiple Pli messages in a short period.
 const int64_t kMinKeyFrameRequestOnPliIntervalMs = 500;
 
 // Extract capture begin/end timestamps from |video_frame|'s metadata and log
 // it.
 void LogVideoCaptureTimestamps(CastEnvironment* cast_environment,
                                const media::VideoFrame& video_frame,
                                RtpTimeTicks rtp_timestamp) {
-  scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
+  std::unique_ptr<FrameEvent> capture_begin_event(new FrameEvent());
   capture_begin_event->type = FRAME_CAPTURE_BEGIN;
   capture_begin_event->media_type = VIDEO_EVENT;
   capture_begin_event->rtp_timestamp = rtp_timestamp;
 
-  scoped_ptr<FrameEvent> capture_end_event(new FrameEvent());
+  std::unique_ptr<FrameEvent> capture_end_event(new FrameEvent());
   capture_end_event->type = FRAME_CAPTURE_END;
   capture_end_event->media_type = VIDEO_EVENT;
   capture_end_event->rtp_timestamp = rtp_timestamp;
   capture_end_event->width = video_frame.visible_rect().width();
   capture_end_event->height = video_frame.visible_rect().height();
 
   if (!video_frame.metadata()->GetTimeTicks(
           media::VideoFrameMetadata::CAPTURE_BEGIN_TIME,
           &capture_begin_event->timestamp) ||
       !video_frame.metadata()->GetTimeTicks(
           media::VideoFrameMetadata::CAPTURE_END_TIME,
           &capture_end_event->timestamp)) {
     // The frame capture timestamps were not provided by the video capture
     // source.  Simply log the events as happening right now.
     capture_begin_event->timestamp = capture_end_event->timestamp =
         cast_environment->Clock()->NowTicks();
   }
 
   cast_environment->logger()->DispatchFrameEvent(
       std::move(capture_begin_event));
   cast_environment->logger()->DispatchFrameEvent(std::move(capture_end_event));
 }
 
+class VideoSenderRtcpClient : public RtpSenderRtcpClient {
+ public:
+  explicit VideoSenderRtcpClient(base::WeakPtr<VideoSender> video_sender)
+      : video_sender_(video_sender) {}
+
+  void OnCastMessageReceived(const RtcpCastMessage& cast_message) override {
+    if (video_sender_)
+      video_sender_->OnReceivedCastFeedback(cast_message);
+  }
+
+  void OnRttReceived(base::TimeDelta round_trip_time) override {
+    if (video_sender_)
+      video_sender_->OnMeasuredRoundTripTime(round_trip_time);
+  }
+
+  void OnPliReceived() override {
+    if (video_sender_)
+      video_sender_->OnReceivedPli();
+  }
+
+ private:
+  base::WeakPtr<VideoSender> video_sender_;
+
+  DISALLOW_COPY_AND_ASSIGN(VideoSenderRtcpClient);
+};
+
 }  // namespace
 
 // Note, we use a fixed bitrate value when external video encoder is used.
 // Some hardware encoder shows bad behavior if we set the bitrate too
 // frequently, e.g. quality drop, not abiding by target bitrate, etc.
 // See details: crbug.com/392086.
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb,
@@ skipping 39 matching lines @@
   }
 
   media::cast::CastTransportRtpConfig transport_config;
   transport_config.ssrc = video_config.ssrc;
   transport_config.feedback_ssrc = video_config.receiver_ssrc;
   transport_config.rtp_payload_type = video_config.rtp_payload_type;
   transport_config.aes_key = video_config.aes_key;
   transport_config.aes_iv_mask = video_config.aes_iv_mask;
 
   transport_sender->InitializeVideo(
-      transport_config, base::Bind(&VideoSender::OnReceivedCastFeedback,
-                                   weak_factory_.GetWeakPtr()),
-      base::Bind(&VideoSender::OnMeasuredRoundTripTime,
-                 weak_factory_.GetWeakPtr()),
-      base::Bind(&VideoSender::OnReceivedPli, weak_factory_.GetWeakPtr()));
+      transport_config,
+      base::WrapUnique(new VideoSenderRtcpClient(weak_factory_.GetWeakPtr())));
 }
 
 VideoSender::~VideoSender() {
 }
 
 void VideoSender::InsertRawVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& reference_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
@@ skipping 135 matching lines @@
     last_enqueued_frame_rtp_timestamp_ = rtp_timestamp;
     last_enqueued_frame_reference_time_ = reference_time;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
     TRACE_EVENT_INSTANT1("cast.stream", "Video Encode Reject",
                          TRACE_EVENT_SCOPE_THREAD,
                          "rtp_timestamp", rtp_timestamp.lower_32_bits());
   }
 }
 
-scoped_ptr<VideoFrameFactory> VideoSender::CreateVideoFrameFactory() {
+std::unique_ptr<VideoFrameFactory> VideoSender::CreateVideoFrameFactory() {
   return video_encoder_ ? video_encoder_->CreateVideoFrameFactory() : nullptr;
 }
 
 int VideoSender::GetNumberOfFramesInEncoder() const {
   return frames_in_encoder_;
 }
 
 base::TimeDelta VideoSender::GetInFlightMediaDuration() const {
   if (GetUnacknowledgedFrameCount() > 0) {
     const uint32_t oldest_unacked_frame_id = latest_acked_frame_id_ + 1;
     return last_enqueued_frame_reference_time_ -
         GetRecordedReferenceTime(oldest_unacked_frame_id);
   } else {
     return duration_in_encoder_;
   }
 }
 
 void VideoSender::OnEncodedVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     int encoder_bitrate,
-    scoped_ptr<SenderEncodedFrame> encoded_frame) {
+    std::unique_ptr<SenderEncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   frames_in_encoder_--;
   DCHECK_GE(frames_in_encoder_, 0);
 
   duration_in_encoder_ =
       last_enqueued_frame_reference_time_ - encoded_frame->reference_time;
 
   last_reported_deadline_utilization_ = encoded_frame->deadline_utilization;
   last_reported_lossy_utilization_ = encoded_frame->lossy_utilization;
@@ skipping 17 matching lines @@
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, std::move(encoded_frame));
 }
 
 }  // namespace cast
 }  // namespace media