Cast:Adding cast_transport_config and cleaning up

media/cast/transport/pacing/paced_sender.cc

Index: media/cast/transport/pacing/paced_sender.cc
diff --git a/media/cast/transport/pacing/paced_sender.cc b/media/cast/transport/pacing/paced_sender.cc
index 3a342b59f34b42e41254db1f0ba87f8c81a7cdcb..5ecbc4f00145e854637cad851e71d79b8986b497 100644
--- a/media/cast/transport/pacing/paced_sender.cc
+++ b/media/cast/transport/pacing/paced_sender.cc
@@ -16,10 +16,12 @@ static const int64 kPacingIntervalMs = 10;
 // bursts of packets.
 static const size_t kPacingMaxBurstsPerFrame = 3;
 
-PacedSender::PacedSender(scoped_refptr<CastEnvironment> cast_environment,
-                         PacketSender* transport)
-    : cast_environment_(cast_environment),
+PacedSender::PacedSender(base::TickClock* clock,
+                         PacketSender* transport,
+                         scoped_refptr<base::TaskRunner> transport_thread)
+    : clock_(clock),
       transport_(transport),
+      transport_thread_(transport_thread),
       burst_size_(1),
       packets_sent_in_burst_(0),
       weak_factory_(this) {
@@ -29,24 +31,15 @@ PacedSender::PacedSender(scoped_refptr<CastEnvironment> cast_environment,
 PacedSender::~PacedSender() {}
 
 bool PacedSender::SendPackets(const PacketList& packets) {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  cast_environment_->Logging()->InsertPacketListEvent(now, kPacketSentToPacer,
-                                                      packets);
   return SendPacketsToTransport(packets, &packet_list_);
 }
 
 bool PacedSender::ResendPackets(const PacketList& packets) {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  cast_environment_->Logging()->InsertPacketListEvent(now, kPacketRetransmited,
-                                                      packets);
   return SendPacketsToTransport(packets, &resend_packet_list_);
 }
 
 bool PacedSender::SendPacketsToTransport(const PacketList& packets,
                                          PacketList* packets_not_sent) {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   UpdateBurstSize(packets.size());
 
   if (!packets_not_sent->empty()) {
@@ -71,39 +64,32 @@ bool PacedSender::SendPacketsToTransport(const PacketList& packets,
   packets_sent_in_burst_ += packets_to_send.size();
   if (packets_to_send.empty()) return true;
 
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  cast_environment_->Logging()->InsertPacketListEvent(now, kPacketSentToNetwork,
-                                                      packets);
   return transport_->SendPackets(packets_to_send);
 }
 
 bool PacedSender::SendRtcpPacket(const Packet& packet) {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // We pass the RTCP packets straight through.
   return transport_->SendPacket(packet);
 }
 
 void PacedSender::ScheduleNextSend() {
   base::TimeDelta time_to_next = time_last_process_ -
-      cast_environment_->Clock()->NowTicks() +
-      base::TimeDelta::FromMilliseconds(kPacingIntervalMs);
+      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(kPacingIntervalMs);
 
   time_to_next = std::max(time_to_next, base::TimeDelta());
 
-  cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
+  transport_thread_->PostDelayedTask(FROM_HERE,
       base::Bind(&PacedSender::SendNextPacketBurst, weak_factory_.GetWeakPtr()),
-                 time_to_next);
+      time_to_next);
 }
 
 void PacedSender::SendNextPacketBurst() {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   SendStoredPackets();
-  time_last_process_ = cast_environment_->Clock()->NowTicks();
+  time_last_process_ = clock_->NowTicks();
   ScheduleNextSend();
 }
 
 void PacedSender::SendStoredPackets() {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (packet_list_.empty() && resend_packet_list_.empty()) return;
 
   size_t packets_to_send = burst_size_;
@@ -139,7 +125,6 @@ void PacedSender::SendStoredPackets() {
 }
 
 void PacedSender::UpdateBurstSize(size_t packets_to_send) {
-  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   packets_to_send = std::max(packets_to_send,
       resend_packet_list_.size() + packet_list_.size());