Cast: Clean up injection of transport into PacedPacketSender

media/cast/transport/pacing/paced_sender.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/transport/pacing/paced_sender.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 
 namespace media {
 namespace cast {
 namespace transport {
 
 namespace {
 static const int64 kPacingIntervalMs = 10;
 // Each frame will be split into no more than kPacingMaxBurstsPerFrame
 // bursts of packets.
 static const size_t kPacingMaxBurstsPerFrame = 3;
 
 }  // namespace
 
 PacedSender::PacedSender(
     base::TickClock* clock,
-    const CastTransportConfig* const config,
-    PacketSender* external_transport,
-    const scoped_refptr<base::TaskRunner>& transport_task_runner,
-    const CastTransportStatusCallback& status_callback)
+    PacketSender* transport,
+    const scoped_refptr<base::TaskRunner>& transport_task_runner)
     : clock_(clock),
-      external_transport_(external_transport),
-      config_(config),
+      transport_(transport),
       transport_task_runner_(transport_task_runner),
       burst_size_(1),
       packets_sent_in_burst_(0),
       weak_factory_(this) {
-  if (!external_transport) {
-    net::IPEndPoint local_end_point;
-    net::IPEndPoint receiver_end_point;
-    // Set up transport in the absence of an external transport.
-    transport_.reset(new UdpTransport(transport_task_runner,
-                                      config_->local_endpoint,
-                                      config_->receiver_endpoint,
-                                      status_callback));
-  }
   ScheduleNextSend();
 }
 
 PacedSender::~PacedSender() {}
 
-void PacedSender::SetPacketReceiver(
-    const PacketReceiverCallback& packet_receiver) {
-  DCHECK(!external_transport_);
-  transport_->StartReceiving(packet_receiver);
-}
-
 bool PacedSender::SendPackets(const PacketList& packets) {
   return SendPacketsToTransport(packets, &packet_list_);
 }
 
 bool PacedSender::ResendPackets(const PacketList& packets) {
   return SendPacketsToTransport(packets, &resend_packet_list_);
 }
 
 bool PacedSender::SendPacketsToTransport(const PacketList& packets,
                                          PacketList* packets_not_sent) {
@@ skipping 20 matching lines @@
   }
   packets_not_sent->insert(packets_not_sent->end(),
                          first_to_store_it, packets.end());
   packets_sent_in_burst_ += packets_to_send.size();
   if (packets_to_send.empty()) return true;
 
   return TransmitPackets(packets_to_send);
 }
 
 bool PacedSender::SendRtcpPacket(const Packet& packet) {
-  if (external_transport_) {
-    return external_transport_->SendPacket(packet);
-  }
   // We pass the RTCP packets straight through.
   return transport_->SendPacket(packet);
 }
 
 void PacedSender::ScheduleNextSend() {
   base::TimeDelta time_to_next = time_last_process_ -
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(kPacingIntervalMs);
 
   time_to_next = std::max(time_to_next, base::TimeDelta());
 
@@ skipping 39 matching lines @@
       burst_size_ = 1;  // Reset burst size after we sent the last stored packet
       packets_sent_in_burst_ = 0;
     }
   }
   TransmitPackets(packets_to_resend);
 }
 
 bool PacedSender::TransmitPackets(const PacketList& packets) {
   bool ret = true;
   for (size_t i = 0; i < packets.size(); i++) {
-    if (external_transport_) {
-      ret &= external_transport_->SendPacket(packets[i]);
-    } else {
-      ret &= transport_->SendPacket(packets[i]);
-    }
+    ret &= transport_->SendPacket(packets[i]);
   }
   return ret;
 }
 
 void PacedSender::UpdateBurstSize(size_t packets_to_send) {
   packets_to_send = std::max(packets_to_send,
       resend_packet_list_.size() + packet_list_.size());
 
   packets_to_send += (kPacingMaxBurstsPerFrame - 1);  // Round up.
   burst_size_ = std::max(packets_to_send / kPacingMaxBurstsPerFrame,
                          burst_size_);
 }
 
-void PacedSender::InsertFakeTransportForTesting(PacketSender* fake_transport) {
-  external_transport_ = fake_transport;
-}
-
 }  // namespace transport
 }  // namespace cast
 }  // namespace media