Switch to standard integer types in media/.

media/filters/ffmpeg_demuxer_unittest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 24 matching lines @@
 using ::testing::WithArgs;
 using ::testing::_;
 
 namespace media {
 
 MATCHER(IsEndOfStreamBuffer,
         std::string(negation ? "isn't" : "is") + " end of stream") {
   return arg->end_of_stream();
 }
 
-const uint8 kEncryptedMediaInitData[] = {
-  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
-  0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+const uint8_t kEncryptedMediaInitData[] = {
+    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+    0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
 };
 
 static void EosOnReadDone(bool* got_eos_buffer,
                           DemuxerStream::Status status,
                           const scoped_refptr<DecoderBuffer>& buffer) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 
   EXPECT_EQ(status, DemuxerStream::kOk);
   if (buffer->end_of_stream()) {
@@ skipping 45 matching lines @@
   }
 
   void InitializeDemuxerText(bool enable_text) {
     InitializeDemuxerWithTimelineOffset(enable_text, base::Time());
   }
 
   void InitializeDemuxer() {
     InitializeDemuxerText(false);
   }
 
-  MOCK_METHOD2(OnReadDoneCalled, void(int, int64));
+  MOCK_METHOD2(OnReadDoneCalled, void(int, int64_t));
 
   struct ReadExpectation {
     ReadExpectation(int size,
-                    int64 timestamp_us,
+                    int64_t timestamp_us,
                     const base::TimeDelta& discard_front_padding,
                     bool is_key_frame)
         : size(size),
           timestamp_us(timestamp_us),
           discard_front_padding(discard_front_padding),
-          is_key_frame(is_key_frame) {
-    }
+          is_key_frame(is_key_frame) {}
 
     int size;
-    int64 timestamp_us;
+    int64_t timestamp_us;
     base::TimeDelta discard_front_padding;
     bool is_key_frame;
   };
 
   // Verifies that |buffer| has a specific |size| and |timestamp|.
   // |location| simply indicates where the call to this function was made.
   // This makes it easier to track down where test failures occur.
   void OnReadDone(const tracked_objects::Location& location,
                   const ReadExpectation& read_expectation,
                   DemuxerStream::Status status,
@@ skipping 10 matching lines @@
     EXPECT_EQ(read_expectation.discard_front_padding,
               buffer->discard_padding().first);
     EXPECT_EQ(read_expectation.is_key_frame, buffer->is_key_frame());
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     OnReadDoneCalled(read_expectation.size, read_expectation.timestamp_us);
     message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   DemuxerStream::ReadCB NewReadCB(const tracked_objects::Location& location,
                                   int size,
-                                  int64 timestamp_us,
+                                  int64_t timestamp_us,
                                   bool is_key_frame) {
     return NewReadCBWithCheckedDiscard(location,
                                        size,
                                        timestamp_us,
                                        base::TimeDelta(),
                                        is_key_frame);
   }
 
   DemuxerStream::ReadCB NewReadCBWithCheckedDiscard(
       const tracked_objects::Location& location,
       int size,
-      int64 timestamp_us,
+      int64_t timestamp_us,
       base::TimeDelta discard_front_padding,
       bool is_key_frame) {
     EXPECT_CALL(*this, OnReadDoneCalled(size, timestamp_us));
 
     struct ReadExpectation read_expectation(size,
                                             timestamp_us,
                                             discard_front_padding,
                                             is_key_frame);
 
     return base::Bind(&FFmpegDemuxerTest::OnReadDone,
                       base::Unretained(this),
                       location,
                       read_expectation);
   }
 
   MOCK_METHOD2(OnEncryptedMediaInitData,
                void(EmeInitDataType init_data_type,
-                    const std::vector<uint8>& init_data));
+                    const std::vector<uint8_t>& init_data));
 
   // Accessor to demuxer internals.
   void set_duration_known(bool duration_known) {
     demuxer_->duration_known_ = duration_known;
   }
 
   bool IsStreamStopped(DemuxerStream::Type type) {
     DemuxerStream* stream = demuxer_->GetStream(type);
     CHECK(stream);
     return !static_cast<FFmpegDemuxerStream*>(stream)->demuxer_;
@@ skipping 171 matching lines @@
   EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
 
   // Unknown stream should never be present.
   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Encrypted) {
   EXPECT_CALL(*this,
               OnEncryptedMediaInitData(
                   EmeInitDataType::WEBM,
-                  std::vector<uint8>(kEncryptedMediaInitData,
-                                     kEncryptedMediaInitData +
-                                         arraysize(kEncryptedMediaInitData))))
+                  std::vector<uint8_t>(kEncryptedMediaInitData,
+                                       kEncryptedMediaInitData +
+                                           arraysize(kEncryptedMediaInitData))))
       .Times(Exactly(2));
 
   CreateDemuxer("bear-320x240-av_enc-av.webm");
   InitializeDemuxer();
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Audio) {
   // We test that on a successful audio packet read.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
@@ skipping 44 matching lines @@
   message_loop_.Run();
 }
 
 TEST_F(FFmpegDemuxerTest, SeekInitialized_NoVideoStartTime) {
   CreateDemuxer("audio-start-time-only.webm");
   InitializeDemuxer();
   EXPECT_EQ(0, preferred_seeking_stream_index());
 }
 
 TEST_F(FFmpegDemuxerTest, Read_VideoPositiveStartTime) {
-  const int64 kTimelineOffsetMs = 1352550896000LL;
+  const int64_t kTimelineOffsetMs = 1352550896000LL;
 
   // Test the start time is the first timestamp of the video and audio stream.
   CreateDemuxer("nonzero-start-time.webm");
   InitializeDemuxerWithTimelineOffset(
       false, base::Time::FromJsTime(kTimelineOffsetMs));
 
   // Attempt a read from the video stream and run the message loop until done.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
@@ skipping 518 matching lines @@
   ASSERT_TRUE(audio);
 
   // Seek to near the end of the file
   WaitableMessageLoopEvent event;
   demuxer_->Seek(.9 * audio->duration(), event.GetPipelineStatusCB());
   event.RunAndWaitForStatus(PIPELINE_OK);
 
   // Verify that seeking to the end read only a small portion of the file.
   // Slow seeks that read sequentially up to the seek point will read too many
   // bytes and fail this check.
-  int64 file_size = 0;
+  int64_t file_size = 0;
   ASSERT_TRUE(data_source_->GetSize(&file_size));
   EXPECT_LT(data_source_->bytes_read_for_testing(), (file_size * .25));
 }
 
 // MP3s should seek quickly without sequentially reading up to the seek point.
 // VBR vs CBR and the presence/absence of TOC influence the seeking algorithm.
 // See http://crbug.com/530043 and FFmpeg flag AVFMT_FLAG_FAST_SEEK.
 INSTANTIATE_TEST_CASE_P(, Mp3SeekFFmpegDemuxerTest,
                         ::testing::Values("bear-audio-10s-CBR-has-TOC.mp3",
                                           "bear-audio-10s-CBR-no-TOC.mp3",
@@ skipping 126 matching lines @@
 
   video->Read(NewReadCB(FROM_HERE, 3569, 66733, true));
   message_loop_.Run();
 
   video->Read(NewReadCB(FROM_HERE, 1042, 200200, false));
   message_loop_.Run();
 }
 #endif
 
 }  // namespace media