Switch to standard integer types in media/.

media/cast/receiver/audio_decoder_unittest.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
@@ skipping 40 matching lines @@
     audio_bus_factory_.reset(
         new TestAudioBusFactory(GetParam().num_channels,
                                 GetParam().sampling_rate,
                                 TestAudioBusFactory::kMiddleANoteFreq,
                                 0.5f));
     last_frame_id_ = 0;
     seen_a_decoded_frame_ = false;
 
     if (GetParam().codec == CODEC_AUDIO_OPUS) {
       opus_encoder_memory_.reset(
-          new uint8[opus_encoder_get_size(GetParam().num_channels)]);
+          new uint8_t[opus_encoder_get_size(GetParam().num_channels)]);
       OpusEncoder* const opus_encoder =
           reinterpret_cast<OpusEncoder*>(opus_encoder_memory_.get());
       CHECK_EQ(OPUS_OK, opus_encoder_init(opus_encoder,
                                           GetParam().sampling_rate,
                                           GetParam().num_channels,
                                           OPUS_APPLICATION_AUDIO));
       CHECK_EQ(OPUS_OK,
                opus_encoder_ctl(opus_encoder, OPUS_SET_BITRATE(OPUS_AUTO)));
     }
 
@@ skipping 11 matching lines @@
     encoded_frame->dependency = EncodedFrame::KEY;
     encoded_frame->frame_id = last_frame_id_ + 1 + num_dropped_frames;
     encoded_frame->referenced_frame_id = encoded_frame->frame_id;
     last_frame_id_ = encoded_frame->frame_id;
 
     const scoped_ptr<AudioBus> audio_bus(
         audio_bus_factory_->NextAudioBus(duration).Pass());
 
     // Encode |audio_bus| into |encoded_frame->data|.
     const int num_elements = audio_bus->channels() * audio_bus->frames();
-    std::vector<int16> interleaved(num_elements);
-    audio_bus->ToInterleaved(
-        audio_bus->frames(), sizeof(int16), &interleaved.front());
+    std::vector<int16_t> interleaved(num_elements);
+    audio_bus->ToInterleaved(audio_bus->frames(), sizeof(int16_t),
+                             &interleaved.front());
     if (GetParam().codec == CODEC_AUDIO_PCM16) {
-      encoded_frame->data.resize(num_elements * sizeof(int16));
-      int16* const pcm_data =
-          reinterpret_cast<int16*>(encoded_frame->mutable_bytes());
+      encoded_frame->data.resize(num_elements * sizeof(int16_t));
+      int16_t* const pcm_data =
+          reinterpret_cast<int16_t*>(encoded_frame->mutable_bytes());
       for (size_t i = 0; i < interleaved.size(); ++i)
-        pcm_data[i] = static_cast<int16>(base::HostToNet16(interleaved[i]));
+        pcm_data[i] = static_cast<int16_t>(base::HostToNet16(interleaved[i]));
     } else if (GetParam().codec == CODEC_AUDIO_OPUS) {
       OpusEncoder* const opus_encoder =
           reinterpret_cast<OpusEncoder*>(opus_encoder_memory_.get());
       const int kOpusEncodeBufferSize = 4000;
       encoded_frame->data.resize(kOpusEncodeBufferSize);
       const int payload_size =
           opus_encode(opus_encoder,
                       &interleaved.front(),
                       audio_bus->frames(),
                       encoded_frame->mutable_bytes(),
@@ skipping 64 matching lines @@
     // Signal the main test thread that more audio was decoded.
     base::AutoLock auto_lock(lock_);
     total_audio_decoded_ += base::TimeDelta::FromSeconds(1) *
         audio_bus->frames() / GetParam().sampling_rate;
     cond_.Signal();
   }
 
   const scoped_refptr<StandaloneCastEnvironment> cast_environment_;
   scoped_ptr<AudioDecoder> audio_decoder_;
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
-  uint32 last_frame_id_;
+  uint32_t last_frame_id_;
   bool seen_a_decoded_frame_;
-  scoped_ptr<uint8[]> opus_encoder_memory_;
+  scoped_ptr<uint8_t[]> opus_encoder_memory_;
 
   base::Lock lock_;
   base::ConditionVariable cond_;
   base::TimeDelta total_audio_feed_in_;
   base::TimeDelta total_audio_decoded_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDecoderTest);
 };
 
 TEST_P(AudioDecoderTest, DecodesFramesWithSameDuration) {
@@ skipping 39 matching lines @@
     AudioDecoderTestScenarios,
     AudioDecoderTest,
     ::testing::Values(
          TestScenario(CODEC_AUDIO_PCM16, 1, 8000),
          TestScenario(CODEC_AUDIO_PCM16, 2, 48000),
          TestScenario(CODEC_AUDIO_OPUS, 1, 8000),
          TestScenario(CODEC_AUDIO_OPUS, 2, 48000)));
 
 }  // namespace cast
 }  // namespace media