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

webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc

 /*
  *  Copyright (c) 2013 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 151 matching lines @@
 };
 
 // This test encodes a few packets of PCM16b 32 kHz data and inserts it into two
 // different NetEq instances. The first instance uses the internal version of
 // the decoder object, while the second one uses an externally created decoder
 // object (ExternalPcm16B wrapped in MockExternalPcm16B, both defined above).
 // The test verifies that the output from both instances match.
 class NetEqExternalVsInternalDecoderTest : public NetEqExternalDecoderUnitTest,
                                            public ::testing::Test {
  protected:
-  static const int kMaxBlockSize = 480;  // 10 ms @ 48 kHz.
+  static const size_t kMaxBlockSize = 480;  // 10 ms @ 48 kHz.
 
   NetEqExternalVsInternalDecoderTest()
       : NetEqExternalDecoderUnitTest(kDecoderPCM16Bswb32kHz,
                                      new MockExternalPcm16B),
         sample_rate_hz_(CodecSampleRateHz(kDecoderPCM16Bswb32kHz)) {
     NetEq::Config config;
     config.sample_rate_hz = CodecSampleRateHz(kDecoderPCM16Bswb32kHz);
     neteq_internal_.reset(NetEq::Create(config));
   }
 
   void SetUp() override {
     ASSERT_EQ(NetEq::kOK,
               neteq_internal_->RegisterPayloadType(kDecoderPCM16Bswb32kHz,
                                                    kPayloadType));
   }
 
   void GetAndVerifyOutput() override {
     NetEqOutputType output_type;
-    int samples_per_channel;
+    size_t samples_per_channel;
     int num_channels;
     // Get audio from internal decoder instance.
     EXPECT_EQ(NetEq::kOK,
               neteq_internal_->GetAudio(kMaxBlockSize,
                                         output_internal_,
                                         &samples_per_channel,
                                         &num_channels,
                                         &output_type));
     EXPECT_EQ(1, num_channels);
-    EXPECT_EQ(kOutputLengthMs * sample_rate_hz_ / 1000, samples_per_channel);
+    EXPECT_EQ(static_cast<size_t>(kOutputLengthMs * sample_rate_hz_ / 1000),
+              samples_per_channel);
 
     // Get audio from external decoder instance.
     samples_per_channel = GetOutputAudio(kMaxBlockSize, output_, &output_type);
 
-    for (int i = 0; i < samples_per_channel; ++i) {
+    for (size_t i = 0; i < samples_per_channel; ++i) {
       ASSERT_EQ(output_[i], output_internal_[i]) <<
           "Diff in sample " << i << ".";
     }
   }
 
   void InsertPacket(WebRtcRTPHeader rtp_header, const uint8_t* payload,
                     size_t payload_size_bytes,
                     uint32_t receive_timestamp) override {
     // Insert packet in internal decoder.
     ASSERT_EQ(
@@ skipping 16 matching lines @@
   int16_t output_[kMaxBlockSize];
 };
 
 TEST_F(NetEqExternalVsInternalDecoderTest, RunTest) {
   RunTest(100);  // Run 100 laps @ 10 ms each in the test loop.
 }
 
 class LargeTimestampJumpTest : public NetEqExternalDecoderUnitTest,
                                public ::testing::Test {
  protected:
-  static const int kMaxBlockSize = 480;  // 10 ms @ 48 kHz.
+  static const size_t kMaxBlockSize = 480;  // 10 ms @ 48 kHz.
 
   enum TestStates {
     kInitialPhase,
     kNormalPhase,
     kExpandPhase,
     kFadedExpandPhase,
     kRecovered
   };
 
   LargeTimestampJumpTest()
@@ skipping 32 matching lines @@
         }
         break;
       }
       case kRecovered: {
         break;
       }
     }
   }
 
   void GetAndVerifyOutput() override {
-    int num_samples;
+    size_t num_samples;
     NetEqOutputType output_type;
     num_samples = GetOutputAudio(kMaxBlockSize, output_, &output_type);
     UpdateState(output_type);
 
     if (test_state_ == kExpandPhase || test_state_ == kFadedExpandPhase) {
       // Don't verify the output in this phase of the test.
       return;
     }
 
-    for (int i = 0; i < num_samples; ++i) {
+    for (size_t i = 0; i < num_samples; ++i) {
       if (output_[i] != 0)
         return;
     }
     EXPECT_TRUE(false)
         << "Expected at least one non-zero sample in each output block.";
   }
 
   int NumExpectedDecodeCalls(int num_loops) override {
     // Some packets at the end of the stream won't be decoded. When the jump in
     // timestamp happens, NetEq will do Expand during one GetAudio call. In the
@@ skipping 136 matching lines @@
                                                         kStartSeqeunceNumber,
                                                         kStartTimestamp,
                                                         kJumpFromTimestamp,
                                                         kJumpToTimestamp));
 
   RunTest(130);  // Run 130 laps @ 10 ms each in the test loop.
   EXPECT_EQ(kRecovered, test_state_);
 }
 
 }  // namespace webrtc