Update a ton of audio code to use size_t more correctly and in general reduce

webrtc/modules/audio_coding/neteq/packet_buffer.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 163 matching lines @@
   return kNotFound;
 }
 
 const RTPHeader* PacketBuffer::NextRtpHeader() const {
   if (Empty()) {
     return NULL;
   }
   return const_cast<const RTPHeader*>(&(buffer_.front()->header));
 }
 
-Packet* PacketBuffer::GetNextPacket(int* discard_count) {
+Packet* PacketBuffer::GetNextPacket(size_t* discard_count) {
   if (Empty()) {
     // Buffer is empty.
     return NULL;
   }
 
   Packet* packet = buffer_.front();
   // Assert that the packet sanity checks in InsertPacket method works.
   assert(packet && packet->payload);
   buffer_.pop_front();
 
   // Discard other packets with the same timestamp. These are duplicates or
   // redundant payloads that should not be used.
-  int discards = 0;
+  size_t discards = 0;
 
   while (!Empty() &&
       buffer_.front()->header.timestamp == packet->header.timestamp) {
     if (DiscardNextPacket() != kOK) {
       assert(false);  // Must be ok by design.
     }
     ++discards;
   }
   // The way of inserting packet should not cause any packet discarding here.
   // TODO(minyue): remove |discard_count|.
@@ skipping 25 matching lines @@
       assert(false);  // Must be ok by design.
     }
   }
   return 0;
 }
 
 int PacketBuffer::DiscardAllOldPackets(uint32_t timestamp_limit) {
   return DiscardOldPackets(timestamp_limit, 0);
 }
 
-int PacketBuffer::NumPacketsInBuffer() const {
-  return static_cast<int>(buffer_.size());
+size_t PacketBuffer::NumPacketsInBuffer() const {
+  return buffer_.size();
 }
 
-int PacketBuffer::NumSamplesInBuffer(DecoderDatabase* decoder_database,
-                                     int last_decoded_length) const {
+size_t PacketBuffer::NumSamplesInBuffer(DecoderDatabase* decoder_database,
+                                        size_t last_decoded_length) const {
   PacketList::const_iterator it;
-  int num_samples = 0;
-  int last_duration = last_decoded_length;
+  size_t num_samples = 0;
+  size_t last_duration = last_decoded_length;
   for (it = buffer_.begin(); it != buffer_.end(); ++it) {
     Packet* packet = (*it);
     AudioDecoder* decoder =
         decoder_database->GetDecoder(packet->header.payloadType);
     if (decoder && !packet->sync_packet) {
       if (!packet->primary) {
         continue;
       }
       int duration =
           decoder->PacketDuration(packet->payload, packet->payload_length);
@@ skipping 29 matching lines @@
     // Continue while the list is not empty.
   }
 }
 
 void PacketBuffer::BufferStat(int* num_packets, int* max_num_packets) const {
   *num_packets = static_cast<int>(buffer_.size());
   *max_num_packets = static_cast<int>(max_number_of_packets_);
 }
 
 }  // namespace webrtc