Switch to standard integer types in media/.

media/base/android/media_source_player_unittest.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 <string>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/android/audio_decoder_job.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/android/media_drm_bridge.h"
 #include "media/base/android/media_player_manager.h"
 #include "media/base/android/media_source_player.h"
 #include "media/base/android/media_url_interceptor.h"
 #include "media/base/android/sdk_media_codec_bridge.h"
@@ skipping 222 matching lines @@
     DemuxerConfigs configs;
     configs.audio_codec = audio_codec;
     configs.audio_channels = 2;
     configs.is_audio_encrypted = false;
     configs.duration = kDefaultDuration;
 
     if (audio_codec == kCodecVorbis) {
       configs.audio_sampling_rate = use_low_sample_rate ? 11025 : 44100;
       scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(
           "vorbis-extradata");
-      configs.audio_extra_data = std::vector<uint8>(
-          buffer->data(),
-          buffer->data() + buffer->data_size());
+      configs.audio_extra_data = std::vector<uint8_t>(
+          buffer->data(), buffer->data() + buffer->data_size());
       return configs;
     }
 
     // Other codecs are not yet supported by this helper.
     EXPECT_EQ(audio_codec, kCodecAAC);
 
     configs.audio_sampling_rate = 48000;
-    uint8 aac_extra_data[] = { 0x13, 0x10 };
-    configs.audio_extra_data = std::vector<uint8>(
-        aac_extra_data,
-        aac_extra_data + 2);
+    uint8_t aac_extra_data[] = {0x13, 0x10};
+    configs.audio_extra_data =
+        std::vector<uint8_t>(aac_extra_data, aac_extra_data + 2);
     return configs;
   }
 
   DemuxerConfigs CreateVideoDemuxerConfigs(bool use_larger_size) {
     DemuxerConfigs configs;
     configs.video_codec = kCodecVP8;
     configs.video_size =
         use_larger_size ? gfx::Size(640, 240) : gfx::Size(320, 240);
     configs.is_video_encrypted = false;
     configs.duration = kDefaultDuration;
@@ skipping 94 matching lines @@
 
     unit.status = DemuxerStream::kOk;
     scoped_refptr<DecoderBuffer> buffer;
     if (is_audio) {
       buffer = ReadTestDataFile(
           base::StringPrintf("vorbis-packet-%d", audio_packet_id));
     } else {
       buffer = ReadTestDataFile(
           use_large_size_video ? "vp8-I-frame-640x240" : "vp8-I-frame-320x240");
     }
-    unit.data = std::vector<uint8>(
-        buffer->data(), buffer->data() + buffer->data_size());
+    unit.data = std::vector<uint8_t>(buffer->data(),
+                                     buffer->data() + buffer->data_size());
 
     if (is_audio) {
       // Vorbis needs 4 extra bytes padding on Android to decode properly. Check
       // NuMediaExtractor.cpp in Android source code.
-      uint8 padding[4] = { 0xff , 0xff , 0xff , 0xff };
+      uint8_t padding[4] = {0xff, 0xff, 0xff, 0xff};
       unit.data.insert(unit.data.end(), padding, padding + 4);
     }
 
     return unit;
   }
 
   DemuxerData CreateReadFromDemuxerAckForAudio(int packet_id) {
     DemuxerData data;
     data.type = DemuxerStream::AUDIO;
     data.access_units.resize(1);
@@ skipping 470 matching lines @@
   EXPECT_TRUE(GetMediaCodecBridge(true));
 }
 
 TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithInvalidConfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test audio decoder job will not be created when failed to start the codec.
   DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, false);
   // Replace with invalid |audio_extra_data|
   configs.audio_extra_data.clear();
-  uint8 invalid_codec_data[] = { 0x00, 0xff, 0xff, 0xff, 0xff };
+  uint8_t invalid_codec_data[] = {0x00, 0xff, 0xff, 0xff, 0xff};
   configs.audio_extra_data.insert(configs.audio_extra_data.begin(),
                                  invalid_codec_data, invalid_codec_data + 4);
   Start(configs);
 
   // Decoder is not created after data is received.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_FALSE(GetMediaCodecBridge(true));
 }
 
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithValidSurface) {
@@ skipping 1492 matching lines @@
 
   EXPECT_EQ(demuxer_->num_data_requests(), 0);
   player_.OnDemuxerConfigsAvailable(CreateDemuxerConfigs(true, true));
 
   manager_.set_allow_play(true);
   player_.Start();
   EXPECT_TRUE(player_.IsPlaying());
 }
 
 }  // namespace media