Switch to standard integer types in media/.

media/filters/ffmpeg_glue_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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_data_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/in_memory_url_protocol.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 
 namespace media {
 
 class MockProtocol : public FFmpegURLProtocol {
  public:
   MockProtocol() {}
 
-  MOCK_METHOD2(Read, int(int size, uint8* data));
-  MOCK_METHOD1(GetPosition, bool(int64* position_out));
-  MOCK_METHOD1(SetPosition, bool(int64 position));
-  MOCK_METHOD1(GetSize, bool(int64* size_out));
+  MOCK_METHOD2(Read, int(int size, uint8_t* data));
+  MOCK_METHOD1(GetPosition, bool(int64_t* position_out));
+  MOCK_METHOD1(SetPosition, bool(int64_t position));
+  MOCK_METHOD1(GetSize, bool(int64_t* size_out));
   MOCK_METHOD0(IsStreaming, bool());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockProtocol);
 };
 
 class FFmpegGlueTest : public ::testing::Test {
  public:
   FFmpegGlueTest()
       : protocol_(new StrictMock<MockProtocol>()) {
     // IsStreaming() is called when opening.
     EXPECT_CALL(*protocol_.get(), IsStreaming()).WillOnce(Return(true));
     glue_.reset(new FFmpegGlue(protocol_.get()));
     CHECK(glue_->format_context());
     CHECK(glue_->format_context()->pb);
   }
 
   ~FFmpegGlueTest() override {
     // Ensure |glue_| and |protocol_| are still alive.
     CHECK(glue_.get());
     CHECK(protocol_.get());
 
     // |protocol_| should outlive |glue_|, so ensure it's destructed first.
     glue_.reset();
   }
 
-  int ReadPacket(int size, uint8* data) {
+  int ReadPacket(int size, uint8_t* data) {
     return glue_->format_context()->pb->read_packet(
         protocol_.get(), data, size);
   }
 
-  int64 Seek(int64 offset, int whence) {
+  int64_t Seek(int64_t offset, int whence) {
     return glue_->format_context()->pb->seek(protocol_.get(), offset, whence);
   }
 
  protected:
   scoped_ptr<FFmpegGlue> glue_;
   scoped_ptr< StrictMock<MockProtocol> > protocol_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FFmpegGlueTest);
 };
@@ skipping 36 matching lines @@
 
 // Ensure writing has been disabled.
 TEST_F(FFmpegGlueTest, Write) {
   ASSERT_FALSE(glue_->format_context()->pb->write_packet);
   ASSERT_FALSE(glue_->format_context()->pb->write_flag);
 }
 
 // Test both successful and unsuccessful reads pass through correctly.
 TEST_F(FFmpegGlueTest, Read) {
   const int kBufferSize = 16;
-  uint8 buffer[kBufferSize];
+  uint8_t buffer[kBufferSize];
 
   // Reads are for the most part straight-through calls to Read().
   InSequence s;
   EXPECT_CALL(*protocol_, Read(0, buffer))
       .WillOnce(Return(0));
   EXPECT_CALL(*protocol_, Read(kBufferSize, buffer))
       .WillOnce(Return(kBufferSize));
   EXPECT_CALL(*protocol_, Read(kBufferSize, buffer))
       .WillOnce(Return(DataSource::kReadError));
 
@@ skipping 106 matching lines @@
   ASSERT_GT(glue_->format_context()->nb_streams, 0u);
 
   // Pick the audio stream (1) so this works when the ffmpeg video decoders are
   // disabled.
   AVCodecContext* context = glue_->format_context()->streams[1]->codec;
   ASSERT_EQ(0, avcodec_open2(
       context, avcodec_find_decoder(context->codec_id), NULL));
 }
 
 }  // namespace media