Switch to standard integer types in media/.

media/audio/alsa/alsa_output_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 "base/strings/stringprintf.h"
 #include "media/audio/alsa/alsa_output.h"
 #include "media/audio/alsa/alsa_wrapper.h"
 #include "media/audio/alsa/audio_manager_alsa.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/mock_audio_source_callback.h"
@@ skipping 96 matching lines @@
   }
 
   virtual ~AlsaPcmOutputStreamTest() {
   }
 
   AlsaPcmOutputStream* CreateStream(ChannelLayout layout) {
     return CreateStream(layout, kTestFramesPerPacket);
   }
 
   AlsaPcmOutputStream* CreateStream(ChannelLayout layout,
-                                    int32 samples_per_packet) {
+                                    int32_t samples_per_packet) {
     AudioParameters params(kTestFormat, layout, kTestSampleRate,
                            kTestBitsPerSample, samples_per_packet);
     return new AlsaPcmOutputStream(kTestDeviceName,
                                    params,
                                    &mock_alsa_wrapper_,
                                    mock_manager_.get());
   }
 
   // Helper function to malloc the string returned by DeviceNameHint for NAME.
   static char* EchoHint(const void* name, Unused) {
@@ skipping 15 matching lines @@
     test_stream->buffer_->Append(packet_.get());
   }
 
   static const ChannelLayout kTestChannelLayout;
   static const int kTestSampleRate;
   static const int kTestBitsPerSample;
   static const int kTestBytesPerFrame;
   static const AudioParameters::Format kTestFormat;
   static const char kTestDeviceName[];
   static const char kDummyMessage[];
-  static const uint32 kTestFramesPerPacket;
+  static const uint32_t kTestFramesPerPacket;
   static const int kTestPacketSize;
   static const int kTestFailedErrno;
   static snd_pcm_t* const kFakeHandle;
 
   // Used to simulate DeviceNameHint.
   static char kSurround40[];
   static char kSurround41[];
   static char kSurround50[];
   static char kSurround51[];
   static char kSurround70[];
@@ skipping 15 matching lines @@
 const int AlsaPcmOutputStreamTest::kTestSampleRate =
     AudioParameters::kAudioCDSampleRate;
 const int AlsaPcmOutputStreamTest::kTestBitsPerSample = 8;
 const int AlsaPcmOutputStreamTest::kTestBytesPerFrame =
     AlsaPcmOutputStreamTest::kTestBitsPerSample / 8 *
     ChannelLayoutToChannelCount(AlsaPcmOutputStreamTest::kTestChannelLayout);
 const AudioParameters::Format AlsaPcmOutputStreamTest::kTestFormat =
     AudioParameters::AUDIO_PCM_LINEAR;
 const char AlsaPcmOutputStreamTest::kTestDeviceName[] = "TestDevice";
 const char AlsaPcmOutputStreamTest::kDummyMessage[] = "dummy";
-const uint32 AlsaPcmOutputStreamTest::kTestFramesPerPacket = 1000;
+const uint32_t AlsaPcmOutputStreamTest::kTestFramesPerPacket = 1000;
 const int AlsaPcmOutputStreamTest::kTestPacketSize =
     AlsaPcmOutputStreamTest::kTestFramesPerPacket *
     AlsaPcmOutputStreamTest::kTestBytesPerFrame;
 const int AlsaPcmOutputStreamTest::kTestFailedErrno = -EACCES;
 snd_pcm_t* const AlsaPcmOutputStreamTest::kFakeHandle =
     reinterpret_cast<snd_pcm_t*>(1);
 
 char AlsaPcmOutputStreamTest::kSurround40[] = "surround40:CARD=foo,DEV=0";
 char AlsaPcmOutputStreamTest::kSurround41[] = "surround41:CARD=foo,DEV=0";
 char AlsaPcmOutputStreamTest::kSurround50[] = "surround50:CARD=foo,DEV=0";
@@ skipping 66 matching lines @@
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle)).WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   test_stream->Close();
 
   Mock::VerifyAndClear(&mock_alsa_wrapper_);
   Mock::VerifyAndClear(mock_manager_.get());
 
   // Test that having more packets ends up with a latency based on packet size.
   const int kOverMinLatencyPacketSize = kPacketFramesInMinLatency + 1;
-  int64 expected_micros = AlsaPcmOutputStream::FramesToTimeDelta(
-      kOverMinLatencyPacketSize * 2, kTestSampleRate).InMicroseconds();
+  int64_t expected_micros = AlsaPcmOutputStream::FramesToTimeDelta(
+                                kOverMinLatencyPacketSize * 2, kTestSampleRate)
+                                .InMicroseconds();
 
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
       .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmSetParams(_, _, _, _, _, _, expected_micros))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
                       SetArgumentPointee<2>(kTestFramesPerPacket / 2),
                       Return(0)));
 
   test_stream = CreateStream(kTestChannelLayout,
                              kOverMinLatencyPacketSize);
   ASSERT_TRUE(test_stream->Open());
 
   // Now close it and test that everything was released.
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   test_stream->Close();
 
   Mock::VerifyAndClear(&mock_alsa_wrapper_);
   Mock::VerifyAndClear(mock_manager_.get());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, OpenClose) {
-  int64 expected_micros = AlsaPcmOutputStream::FramesToTimeDelta(
-      2 * kTestFramesPerPacket, kTestSampleRate).InMicroseconds();
+  int64_t expected_micros = AlsaPcmOutputStream::FramesToTimeDelta(
+                                2 * kTestFramesPerPacket, kTestSampleRate)
+                                .InMicroseconds();
 
   // Open() call opens the playback device, sets the parameters, posts a task
   // with the resulting configuration data, and transitions the object state to
   // kIsOpened.
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmOpen(_, StrEq(kTestDeviceName),
                       SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK))
       .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
                       Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
@@ skipping 531 matching lines @@
 
   // TODO(ajwong): Find a way to test whether or not another task has been
   // posted so we can verify that the Alsa code will indeed break the task
   // posting loop.
 
   test_stream->TransitionTo(AlsaPcmOutputStream::kIsClosed);
   test_stream->Close();
 }
 
 }  // namespace media