Switch to standard integer types in media/.

media/mojo/services/media_type_converters_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 "media/mojo/services/media_type_converters.h"
 
 #include <string.h>
 
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_util.h"
 #include "media/base/sample_format.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 namespace {
 
-void CompareBytes(uint8* original_data, uint8* result_data, size_t length) {
+void CompareBytes(uint8_t* original_data, uint8_t* result_data, size_t length) {
   EXPECT_GT(length, 0u);
   EXPECT_EQ(memcmp(original_data, result_data, length), 0);
 }
 
 void CompareAudioBuffers(SampleFormat sample_format,
                          const scoped_refptr<AudioBuffer>& original,
                          const scoped_refptr<AudioBuffer>& result) {
   EXPECT_EQ(original->frame_count(), result->frame_count());
   EXPECT_EQ(original->timestamp(), result->timestamp());
   EXPECT_EQ(original->duration(), result->duration());
@@ skipping 45 matching lines @@
   EXPECT_EQ(original->natural_size().width(), result->natural_size().width());
 
   CompareVideoPlane(media::VideoFrame::kYPlane, original, result);
   CompareVideoPlane(media::VideoFrame::kUPlane, original, result);
   CompareVideoPlane(media::VideoFrame::kVPlane, original, result);
 }
 
 }  // namespace
 
 TEST(MediaTypeConvertersTest, ConvertDecoderBuffer_Normal) {
-  const uint8 kData[] = "hello, world";
-  const uint8 kSideData[] = "sideshow bob";
+  const uint8_t kData[] = "hello, world";
+  const uint8_t kSideData[] = "sideshow bob";
   const int kDataSize = arraysize(kData);
   const int kSideDataSize = arraysize(kSideData);
 
   // Original.
   scoped_refptr<DecoderBuffer> buffer(DecoderBuffer::CopyFrom(
-      reinterpret_cast<const uint8*>(&kData), kDataSize,
-      reinterpret_cast<const uint8*>(&kSideData), kSideDataSize));
+      reinterpret_cast<const uint8_t*>(&kData), kDataSize,
+      reinterpret_cast<const uint8_t*>(&kSideData), kSideDataSize));
   buffer->set_timestamp(base::TimeDelta::FromMilliseconds(123));
   buffer->set_duration(base::TimeDelta::FromMilliseconds(456));
   buffer->set_splice_timestamp(base::TimeDelta::FromMilliseconds(200));
   buffer->set_discard_padding(
       DecoderBuffer::DiscardPadding(base::TimeDelta::FromMilliseconds(5),
                                     base::TimeDelta::FromMilliseconds(6)));
 
   // Convert from and back.
   interfaces::DecoderBufferPtr ptr(interfaces::DecoderBuffer::From(buffer));
   scoped_refptr<DecoderBuffer> result(ptr.To<scoped_refptr<DecoderBuffer>>());
@@ skipping 21 matching lines @@
 
   // Convert from and back.
   interfaces::DecoderBufferPtr ptr(interfaces::DecoderBuffer::From(buffer));
   scoped_refptr<DecoderBuffer> result(ptr.To<scoped_refptr<DecoderBuffer>>());
 
   // Compare.
   EXPECT_TRUE(result->end_of_stream());
 }
 
 TEST(MediaTypeConvertersTest, ConvertDecoderBuffer_KeyFrame) {
-  const uint8 kData[] = "hello, world";
+  const uint8_t kData[] = "hello, world";
   const int kDataSize = arraysize(kData);
 
   // Original.
   scoped_refptr<DecoderBuffer> buffer(DecoderBuffer::CopyFrom(
-      reinterpret_cast<const uint8*>(&kData), kDataSize));
+      reinterpret_cast<const uint8_t*>(&kData), kDataSize));
   buffer->set_is_key_frame(true);
   EXPECT_TRUE(buffer->is_key_frame());
 
   // Convert from and back.
   interfaces::DecoderBufferPtr ptr(interfaces::DecoderBuffer::From(buffer));
   scoped_refptr<DecoderBuffer> result(ptr.To<scoped_refptr<DecoderBuffer>>());
 
   // Compare.
   // Note: We intentionally do not serialize the data section of the
   // DecoderBuffer; no need to check the data here.
   EXPECT_EQ(kDataSize, result->data_size());
   EXPECT_TRUE(result->is_key_frame());
 }
 
 TEST(MediaTypeConvertersTest, ConvertDecoderBuffer_EncryptedBuffer) {
-  const uint8 kData[] = "hello, world";
+  const uint8_t kData[] = "hello, world";
   const int kDataSize = arraysize(kData);
   const char kKeyId[] = "00112233445566778899aabbccddeeff";
   const char kIv[] = "0123456789abcdef";
 
   std::vector<SubsampleEntry> subsamples;
   subsamples.push_back(SubsampleEntry(10, 20));
   subsamples.push_back(SubsampleEntry(30, 40));
   subsamples.push_back(SubsampleEntry(50, 60));
 
   // Original.
   scoped_refptr<DecoderBuffer> buffer(DecoderBuffer::CopyFrom(
-      reinterpret_cast<const uint8*>(&kData), kDataSize));
+      reinterpret_cast<const uint8_t*>(&kData), kDataSize));
   buffer->set_decrypt_config(
       make_scoped_ptr(new DecryptConfig(kKeyId, kIv, subsamples)));
 
   // Convert from and back.
   interfaces::DecoderBufferPtr ptr(interfaces::DecoderBuffer::From(buffer));
   scoped_refptr<DecoderBuffer> result(ptr.To<scoped_refptr<DecoderBuffer>>());
 
   // Compare.
   // Note: We intentionally do not serialize the data section of the
   // DecoderBuffer; no need to check the data here.
@@ skipping 71 matching lines @@
   scoped_refptr<AudioBuffer> result(ptr.To<scoped_refptr<AudioBuffer>>());
 
   // Compare.
   EXPECT_TRUE(result->end_of_stream());
 }
 
 TEST(MediaTypeConvertersTest, ConvertAudioBuffer_MONO) {
   // Original.
   const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_MONO;
   const int kSampleRate = 48000;
-  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<uint8>(
+  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<uint8_t>(
       kSampleFormatU8, kChannelLayout,
       ChannelLayoutToChannelCount(kChannelLayout), kSampleRate, 1, 1,
       kSampleRate / 100, base::TimeDelta());
 
   // Convert to and back.
   interfaces::AudioBufferPtr ptr(interfaces::AudioBuffer::From(buffer));
   scoped_refptr<AudioBuffer> result(ptr.To<scoped_refptr<AudioBuffer>>());
 
   // Compare.
   CompareAudioBuffers(kSampleFormatU8, buffer, result);
@@ skipping 48 matching lines @@
 
   // Convert to and back.
   interfaces::VideoFramePtr ptr(interfaces::VideoFrame::From(buffer));
   scoped_refptr<VideoFrame> result(ptr.To<scoped_refptr<VideoFrame>>());
 
   // Compare.
   CompareVideoFrames(buffer, result);
 }
 
 }  // namespace media