Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/codecs/opus/opus_fec_test.cc

 /*
  *  Copyright (c) 2014 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 27 matching lines @@
 
   virtual void SetUp();
   virtual void TearDown();
 
   virtual void EncodeABlock();
 
   virtual void DecodeABlock(bool lost_previous, bool lost_current);
 
   int block_duration_ms_;
   int sampling_khz_;
-  int block_length_sample_;
+  size_t block_length_sample_;
 
   int channels_;
   int bit_rate_;
 
   size_t data_pointer_;
   size_t loop_length_samples_;
-  int max_bytes_;
-  int encoded_bytes_;
+  size_t max_bytes_;
+  size_t encoded_bytes_;
 
   WebRtcOpusEncInst* opus_encoder_;
   WebRtcOpusDecInst* opus_decoder_;
 
   string in_filename_;
 
   rtc::scoped_ptr<int16_t[]> in_data_;
   rtc::scoped_ptr<int16_t[]> out_data_;
   rtc::scoped_ptr<uint8_t[]> bit_stream_;
 };
@@ skipping 48 matching lines @@
 
 void OpusFecTest::TearDown() {
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
 OpusFecTest::OpusFecTest()
     : block_duration_ms_(kOpusBlockDurationMs),
       sampling_khz_(kOpusSamplingKhz),
-      block_length_sample_(block_duration_ms_ * sampling_khz_),
+      block_length_sample_(
+          static_cast<size_t>(block_duration_ms_ * sampling_khz_)),
       data_pointer_(0),
       max_bytes_(0),
       encoded_bytes_(0),
       opus_encoder_(NULL),
       opus_decoder_(NULL) {
 }
 
 void OpusFecTest::EncodeABlock() {
   int value = WebRtcOpus_Encode(opus_encoder_,
                                 &in_data_[data_pointer_],
                                 block_length_sample_,
                                 max_bytes_, &bit_stream_[0]);
   EXPECT_GT(value, 0);
 
-  encoded_bytes_ = value;
+  encoded_bytes_ = static_cast<size_t>(value);
 }
 
 void OpusFecTest::DecodeABlock(bool lost_previous, bool lost_current) {
   int16_t audio_type;
   int value_1 = 0, value_2 = 0;
 
   if (lost_previous) {
     // Decode previous frame.
     if (!lost_current &&
         WebRtcOpus_PacketHasFec(&bit_stream_[0], encoded_bytes_) == 1) {
       value_1 = WebRtcOpus_DecodeFec(opus_decoder_, &bit_stream_[0],
                                      encoded_bytes_, &out_data_[0],
                                      &audio_type);
     } else {
       value_1 = WebRtcOpus_DecodePlc(opus_decoder_, &out_data_[0], 1);
     }
-    EXPECT_EQ(block_length_sample_, value_1);
+    EXPECT_EQ(static_cast<int>(block_length_sample_), value_1);
   }
 
   if (!lost_current) {
     // Decode current frame.
     value_2 = WebRtcOpus_Decode(opus_decoder_, &bit_stream_[0], encoded_bytes_,
                                 &out_data_[value_1 * channels_], &audio_type);
-    EXPECT_EQ(block_length_sample_, value_2);
+    EXPECT_EQ(static_cast<int>(block_length_sample_), value_2);
   }
 }
 
 TEST_P(OpusFecTest, RandomPacketLossTest) {
   const int kDurationMs = 200000;
   int time_now_ms, fec_frames;
   int actual_packet_loss_rate;
   bool lost_current, lost_previous;
   mode mode_set[3] = {{true, 0},
                       {false, 0},
@@ skipping 55 matching lines @@
      ::std::tr1::make_tuple(1, 32000, string("audio_coding/testfile32kHz"),
                             string("pcm")),
      ::std::tr1::make_tuple(2, 64000, string("audio_coding/teststereo32kHz"),
                             string("pcm"))};
 
 // 64 kbps, stereo
 INSTANTIATE_TEST_CASE_P(AllTest, OpusFecTest,
                         ::testing::ValuesIn(param_set));
 
 }  // namespace webrtc