Cast: end2end bug fixes

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 {
@@ skipping 49 matching lines @@
   if (max_packets_to_send_now > 0) {
     size_t packets_to_send_now =
         std::min(max_packets_to_send_now, packets.size());
 
     std::advance(first_to_store_it, packets_to_send_now);
     packets_to_send.insert(
         packets_to_send.begin(), packets.begin(), first_to_store_it);
   }
   packets_not_sent->insert(
       packets_not_sent->end(), first_to_store_it, packets.end());
-  packets_sent_in_burst_ += packets_to_send.size();
+  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) {
   // We pass the RTCP packets straight through.
   return transport_->SendPacket(packet);
 }
@@ skipping 39 matching lines @@
     PacketList::iterator it = packet_list_.begin();
     size_t packets_to_send_now = std::min(packets_to_send, packet_list_.size());
 
     std::advance(it, packets_to_send_now);
     packets_to_resend.insert(packets_to_resend.end(), packet_list_.begin(), it);
     packet_list_.erase(packet_list_.begin(), it);
 
     if (packet_list_.empty()) {
       burst_size_ = 1;  // Reset burst size after we sent the last stored packet
       packets_sent_in_burst_ = 0;
+    } else {
+      packets_sent_in_burst_ = packets_to_resend.size();
     }
   }
   TransmitPackets(packets_to_resend);
 }
 
 bool PacedSender::TransmitPackets(const PacketList& packets) {
   bool ret = true;
   for (size_t i = 0; i < packets.size(); 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_);
 }
 
 }  // namespace transport
 }  // namespace cast
 }  // namespace media