Refactor: simplify interface of SenderRtcpSession and CastTransport.

media/cast/net/cast_transport_impl.cc

Index: media/cast/net/cast_transport_impl.cc
diff --git a/media/cast/net/cast_transport_impl.cc b/media/cast/net/cast_transport_impl.cc
index 739dc3f723626859729be02fe51ffc334ce8fe0d..5d0e5cc5aa5109e7a0b41de3a9639dcd03c53acc 100644
--- a/media/cast/net/cast_transport_impl.cc
+++ b/media/cast/net/cast_transport_impl.cc
@@ -9,6 +9,7 @@
 #include <string>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "media/cast/net/cast_transport_defines.h"
@@ -41,13 +42,13 @@ int LookupOptionWithDefault(const base::DictionaryValue& options,
 
 }  // namespace
 
-scoped_ptr<CastTransport> CastTransport::Create(
+std::unique_ptr<CastTransport> CastTransport::Create(
     base::TickClock* clock,  // Owned by the caller.
     base::TimeDelta logging_flush_interval,
-    scoped_ptr<Client> client,
-    scoped_ptr<PacketTransport> transport,
+    std::unique_ptr<Client> client,
+    std::unique_ptr<PacketTransport> transport,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) {
-  return scoped_ptr<CastTransport>(
+  return std::unique_ptr<CastTransport>(
       new CastTransportImpl(clock, logging_flush_interval, std::move(client),
                             std::move(transport), transport_task_runner.get()));
 }
@@ -56,11 +57,46 @@ PacketReceiverCallback CastTransport::PacketReceiverForTesting() {
   return PacketReceiverCallback();
 }
 
+class CastTransportImpl::RtcpObserver : public SenderRtcpObserver {
+ public:
+  RtcpObserver(std::unique_ptr<SenderRtcpObserver> observer,
+               uint32_t rtp_sender_ssrc,
+               EventMediaType media_type,
+               CastTransportImpl* cast_transport_impl)
+      : rtp_sender_ssrc_(rtp_sender_ssrc),
+        sender_rtcp_observer_(std::move(observer)),
+        media_type_(media_type),
+        cast_transport_impl_(cast_transport_impl) {}
+
+  void OnCastMessageReceived(const RtcpCastMessage& cast_message) override {
+    sender_rtcp_observer_->OnCastMessageReceived(cast_message);
+    cast_transport_impl_->OnReceivedCastMessage(rtp_sender_ssrc_, cast_message);

[miu, 2016/04/25 23:23:53]

naming nit: OnCastMessageReceived versus OnReceivedCastMessage.  Let's pick one,
to be consistent.  ;)

[xjz, 2016/04/29 19:15:49]

Done.

+  }
+
+  void OnRttReceived(base::TimeDelta round_trip_time) override {
+    sender_rtcp_observer_->OnRttReceived(round_trip_time);
+  }
+
+  void OnReceiverLogReceived(const RtcpReceiverLogMessage& log) override {
+    cast_transport_impl_->OnReceivedLogMessage(media_type_, log);
+  }
+
+  void OnPliReceived() override { sender_rtcp_observer_->OnPliReceived(); }
+
+ private:
+  const uint32_t rtp_sender_ssrc_;
+  const std::unique_ptr<SenderRtcpObserver> sender_rtcp_observer_;
+  const EventMediaType media_type_;
+  CastTransportImpl* const cast_transport_impl_;
+
+  DISALLOW_COPY_AND_ASSIGN(RtcpObserver);
+};
+
 CastTransportImpl::CastTransportImpl(
     base::TickClock* clock,
     base::TimeDelta logging_flush_interval,
-    scoped_ptr<Client> client,
-    scoped_ptr<PacketTransport> transport,
+    std::unique_ptr<Client> client,
+    std::unique_ptr<PacketTransport> transport,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner)
     : clock_(clock),
       logging_flush_interval_(logging_flush_interval),
@@ -96,9 +132,7 @@ CastTransportImpl::~CastTransportImpl() {
 
 void CastTransportImpl::InitializeAudio(
     const CastTransportRtpConfig& config,
-    const RtcpCastMessageCallback& cast_message_cb,
-    const RtcpRttCallback& rtt_cb,
-    const RtcpPliCallback& pli_cb) {
+    std::unique_ptr<SenderRtcpObserver> rtcp_observer) {
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send audio with encryption DISABLED.";
   if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
@@ -119,11 +153,9 @@ void CastTransportImpl::InitializeAudio(
   }
 
   audio_rtcp_session_.reset(new SenderRtcpSession(
-      base::Bind(&CastTransportImpl::OnReceivedCastMessage,
-                 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb),
-      rtt_cb, base::Bind(&CastTransportImpl::OnReceivedLogMessage,
-                         weak_factory_.GetWeakPtr(), AUDIO_EVENT),
-      pli_cb, clock_, &pacer_, config.ssrc, config.feedback_ssrc));
+      base::WrapUnique(new RtcpObserver(std::move(rtcp_observer), config.ssrc,
+                                        AUDIO_EVENT, this)),
+      clock_, &pacer_, config.ssrc, config.feedback_ssrc));
   pacer_.RegisterAudioSsrc(config.ssrc);
   valid_sender_ssrcs_.insert(config.feedback_ssrc);
   transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED);
@@ -131,9 +163,7 @@ void CastTransportImpl::InitializeAudio(
 
 void CastTransportImpl::InitializeVideo(
     const CastTransportRtpConfig& config,
-    const RtcpCastMessageCallback& cast_message_cb,
-    const RtcpRttCallback& rtt_cb,
-    const RtcpPliCallback& pli_cb) {
+    std::unique_ptr<SenderRtcpObserver> rtcp_observer) {
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send video with encryption DISABLED.";
   if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
@@ -149,11 +179,9 @@ void CastTransportImpl::InitializeVideo(
   }
 
   video_rtcp_session_.reset(new SenderRtcpSession(
-      base::Bind(&CastTransportImpl::OnReceivedCastMessage,
-                 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb),
-      rtt_cb, base::Bind(&CastTransportImpl::OnReceivedLogMessage,
-                         weak_factory_.GetWeakPtr(), VIDEO_EVENT),
-      pli_cb, clock_, &pacer_, config.ssrc, config.feedback_ssrc));
+      base::WrapUnique(new RtcpObserver(std::move(rtcp_observer), config.ssrc,
+                                        VIDEO_EVENT, this)),
+      clock_, &pacer_, config.ssrc, config.feedback_ssrc));
   pacer_.RegisterVideoSsrc(config.ssrc);
   valid_sender_ssrcs_.insert(config.feedback_ssrc);
   transport_client_->OnStatusChanged(TRANSPORT_VIDEO_INITIALIZED);
@@ -259,10 +287,10 @@ void CastTransportImpl::SendRawEvents() {
   DCHECK(logging_flush_interval_ > base::TimeDelta());
 
   if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) {
-    scoped_ptr<std::vector<FrameEvent>> frame_events(
+    std::unique_ptr<std::vector<FrameEvent>> frame_events(
         new std::vector<FrameEvent>());
     frame_events->swap(recent_frame_events_);
-    scoped_ptr<std::vector<PacketEvent>> packet_events(
+    std::unique_ptr<std::vector<PacketEvent>> packet_events(
         new std::vector<PacketEvent>());
     packet_events->swap(recent_packet_events_);
     transport_client_->OnLoggingEventsReceived(std::move(frame_events),
@@ -275,7 +303,7 @@ void CastTransportImpl::SendRawEvents() {
       logging_flush_interval_);
 }
 
-bool CastTransportImpl::OnReceivedPacket(scoped_ptr<Packet> packet) {
+bool CastTransportImpl::OnReceivedPacket(std::unique_ptr<Packet> packet) {
   const uint8_t* const data = &packet->front();
   const size_t length = packet->size();
   uint32_t ssrc;
@@ -347,10 +375,7 @@ void CastTransportImpl::OnReceivedLogMessage(
 
 void CastTransportImpl::OnReceivedCastMessage(
     uint32_t ssrc,
-    const RtcpCastMessageCallback& cast_message_cb,
     const RtcpCastMessage& cast_message) {
-  if (!cast_message_cb.is_null())
-    cast_message_cb.Run(cast_message);
 
   DedupInfo dedup_info;
   if (audio_sender_ && audio_sender_->ssrc() == ssrc) {