Refactor: simplify interface of SenderRtcpSession and CastTransport.

chrome/renderer/media/cast_transport_ipc.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 "chrome/renderer/media/cast_transport_ipc.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/id_map.h"
 #include "chrome/common/cast_messages.h"
 #include "chrome/renderer/media/cast_ipc_dispatcher.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "media/cast/cast_sender.h"
 
-CastTransportIPC::ClientCallbacks::ClientCallbacks() {}
-CastTransportIPC::ClientCallbacks::ClientCallbacks(
-    const ClientCallbacks& other) = default;
-CastTransportIPC::ClientCallbacks::~ClientCallbacks() {}
-
 CastTransportIPC::CastTransportIPC(
     const net::IPEndPoint& local_end_point,
     const net::IPEndPoint& remote_end_point,
-    scoped_ptr<base::DictionaryValue> options,
+    std::unique_ptr<base::DictionaryValue> options,
     const media::cast::PacketReceiverCallback& packet_callback,
     const media::cast::CastTransportStatusCallback& status_cb,
     const media::cast::BulkRawEventsCallback& raw_events_cb)
     : packet_callback_(packet_callback),
       status_callback_(status_cb),
       raw_events_callback_(raw_events_cb) {
   if (CastIPCDispatcher::Get()) {
     channel_id_ = CastIPCDispatcher::Get()->AddSender(this);
   }
   Send(new CastHostMsg_New(channel_id_, local_end_point, remote_end_point,
                            *options));
 }
 
 CastTransportIPC::~CastTransportIPC() {
   Send(new CastHostMsg_Delete(channel_id_));
   if (CastIPCDispatcher::Get()) {
     CastIPCDispatcher::Get()->RemoveSender(channel_id_);
   }
 }
 
 void CastTransportIPC::InitializeAudio(
     const media::cast::CastTransportRtpConfig& config,
-    const media::cast::RtcpCastMessageCallback& cast_message_cb,
-    const media::cast::RtcpRttCallback& rtt_cb,
-    const media::cast::RtcpPliCallback& pli_cb) {
-  clients_[config.ssrc].cast_message_cb = cast_message_cb;
-  clients_[config.ssrc].rtt_cb = rtt_cb;
-  clients_[config.ssrc].pli_cb = pli_cb;
+    std::unique_ptr<media::cast::SenderRtcpObserver> rtcp_observer) {
+  DCHECK(clients_.find(config.ssrc) == clients_.end());
+  clients_[config.ssrc] = std::move(rtcp_observer);
   Send(new CastHostMsg_InitializeAudio(channel_id_, config));
 }
 
 void CastTransportIPC::InitializeVideo(
     const media::cast::CastTransportRtpConfig& config,
-    const media::cast::RtcpCastMessageCallback& cast_message_cb,
-    const media::cast::RtcpRttCallback& rtt_cb,
-    const media::cast::RtcpPliCallback& pli_cb) {
-  clients_[config.ssrc].cast_message_cb = cast_message_cb;
-  clients_[config.ssrc].rtt_cb = rtt_cb;
-  clients_[config.ssrc].pli_cb = pli_cb;
+    std::unique_ptr<media::cast::SenderRtcpObserver> rtcp_observer) {
+  DCHECK(clients_.find(config.ssrc) == clients_.end());
+  clients_[config.ssrc] = std::move(rtcp_observer);
   Send(new CastHostMsg_InitializeVideo(channel_id_, config));
 }
 
 void CastTransportIPC::InsertFrame(uint32_t ssrc,
                                    const media::cast::EncodedFrame& frame) {
   Send(new CastHostMsg_InsertFrame(channel_id_, ssrc, frame));
 }
 
 void CastTransportIPC::SendSenderReport(
     uint32_t ssrc,
@@ skipping 57 matching lines @@
     media::cast::CastTransportStatus status) {
   status_callback_.Run(status);
 }
 
 void CastTransportIPC::OnRawEvents(
     const std::vector<media::cast::PacketEvent>& packet_events,
     const std::vector<media::cast::FrameEvent>& frame_events) {
   // Note: Casting away const to avoid having to copy all the data elements.  As
   // the only consumer of this data in the IPC message, mutating the inputs
   // should be acceptable.  Just nod and blame the interface we were given here.
-  scoped_ptr<std::vector<media::cast::FrameEvent>> taken_frame_events(
+  std::unique_ptr<std::vector<media::cast::FrameEvent>> taken_frame_events(
       new std::vector<media::cast::FrameEvent>());
   taken_frame_events->swap(
       const_cast<std::vector<media::cast::FrameEvent>&>(frame_events));
-  scoped_ptr<std::vector<media::cast::PacketEvent>> taken_packet_events(
+  std::unique_ptr<std::vector<media::cast::PacketEvent>> taken_packet_events(
       new std::vector<media::cast::PacketEvent>());
   taken_packet_events->swap(
       const_cast<std::vector<media::cast::PacketEvent>&>(packet_events));
   raw_events_callback_.Run(std::move(taken_frame_events),
                            std::move(taken_packet_events));
 }
 
 void CastTransportIPC::OnRtt(uint32_t rtp_sender_ssrc, base::TimeDelta rtt) {
   ClientMap::iterator it = clients_.find(rtp_sender_ssrc);
   if (it == clients_.end()) {
     LOG(ERROR) << "Received RTT report for unknown SSRC: " << rtp_sender_ssrc;
     return;
   }
-  if (!it->second.rtt_cb.is_null())
-    it->second.rtt_cb.Run(rtt);
+  it->second->OnRttReceived(rtt);
 }
 
 void CastTransportIPC::OnRtcpCastMessage(
     uint32_t rtp_sender_ssrc,
     const media::cast::RtcpCastMessage& cast_message) {
   ClientMap::iterator it = clients_.find(rtp_sender_ssrc);
   if (it == clients_.end()) {
     LOG(ERROR) << "Received cast message for unknown SSRC: " << rtp_sender_ssrc;
     return;
   }
-  if (it->second.cast_message_cb.is_null())
-    return;
-  it->second.cast_message_cb.Run(cast_message);
+  it->second->OnCastMessageReceived(cast_message);
 }
 
 void CastTransportIPC::OnReceivedPli(uint32_t rtp_sender_ssrc) {
   ClientMap::iterator it = clients_.find(rtp_sender_ssrc);
   if (it == clients_.end()) {
     LOG(ERROR) << "Received picture loss indicator for unknown SSRC: "
                << rtp_sender_ssrc;
     return;
   }
-  if (!it->second.pli_cb.is_null())
-    it->second.pli_cb.Run();
+  it->second->OnPliReceived();
 }
 
 void CastTransportIPC::OnReceivedPacket(const media::cast::Packet& packet) {
   if (!packet_callback_.is_null()) {
     // TODO(hubbe): Perhaps an non-ownership-transferring cb here?
-    scoped_ptr<media::cast::Packet> packet_copy(
+    std::unique_ptr<media::cast::Packet> packet_copy(
         new media::cast::Packet(packet));
     packet_callback_.Run(std::move(packet_copy));
   } else {
     DVLOG(1) << "CastIPCDispatcher::OnReceivedPacket no packet callback yet.";
   }
 }
 
 void CastTransportIPC::Send(IPC::Message* message) {
   if (CastIPCDispatcher::Get()) {
     CastIPCDispatcher::Get()->Send(message);
   } else {
     delete message;
   }
 }