Switch to standard integer types in media/.

media/audio/cras/cras_input_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 <string>
 
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "media/audio/cras/audio_manager_cras.h"
@@ skipping 11 matching lines @@
 using testing::AtLeast;
 using testing::Ge;
 using testing::InvokeWithoutArgs;
 using testing::StrictMock;
 
 namespace media {
 
 class MockAudioInputCallback : public AudioInputStream::AudioInputCallback {
  public:
   MOCK_METHOD4(OnData,
-               void(AudioInputStream*, const AudioBus*, uint32, double));
+               void(AudioInputStream*, const AudioBus*, uint32_t, double));
   MOCK_METHOD1(OnError, void(AudioInputStream*));
 };
 
 class MockAudioManagerCrasInput : public AudioManagerCras {
  public:
   MockAudioManagerCrasInput() : AudioManagerCras(&fake_audio_log_factory_) {}
 
   // We need to override this function in order to skip checking the number
   // of active output streams. It is because the number of active streams
   // is managed inside MakeAudioInputStream, and we don't use
@@ skipping 14 matching lines @@
   }
 
   virtual ~CrasInputStreamTest() {
   }
 
   CrasInputStream* CreateStream(ChannelLayout layout) {
     return CreateStream(layout, kTestFramesPerPacket);
   }
 
   CrasInputStream* CreateStream(ChannelLayout layout,
-                                int32 samples_per_packet) {
+                                int32_t samples_per_packet) {
     return CreateStream(layout, samples_per_packet,
                         AudioManagerBase::kDefaultDeviceId);
   }
 
   CrasInputStream* CreateStream(ChannelLayout layout,
-                                int32 samples_per_packet,
+                                int32_t samples_per_packet,
                                 const std::string& device_id) {
     AudioParameters params(kTestFormat,
                            layout,
                            kTestSampleRate,
                            kTestBitsPerSample,
                            samples_per_packet);
     return new CrasInputStream(params, mock_manager_.get(), device_id);
   }
 
   void CaptureSomeFrames(const AudioParameters &params,
@@ skipping 18 matching lines @@
     EXPECT_TRUE(event.TimedWait(TestTimeouts::action_timeout()));
 
     test_stream->Stop();
     test_stream->Close();
   }
 
   static const unsigned int kTestBitsPerSample;
   static const unsigned int kTestCaptureDurationMs;
   static const ChannelLayout kTestChannelLayout;
   static const AudioParameters::Format kTestFormat;
-  static const uint32 kTestFramesPerPacket;
+  static const uint32_t kTestFramesPerPacket;
   static const int kTestSampleRate;
 
   scoped_ptr<StrictMock<MockAudioManagerCrasInput> > mock_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CrasInputStreamTest);
 };
 
 const unsigned int CrasInputStreamTest::kTestBitsPerSample = 16;
 const unsigned int CrasInputStreamTest::kTestCaptureDurationMs = 250;
 const ChannelLayout CrasInputStreamTest::kTestChannelLayout =
     CHANNEL_LAYOUT_STEREO;
 const AudioParameters::Format CrasInputStreamTest::kTestFormat =
     AudioParameters::AUDIO_PCM_LINEAR;
-const uint32 CrasInputStreamTest::kTestFramesPerPacket = 1000;
+const uint32_t CrasInputStreamTest::kTestFramesPerPacket = 1000;
 const int CrasInputStreamTest::kTestSampleRate = 44100;
 
 TEST_F(CrasInputStreamTest, OpenMono) {
   CrasInputStream* test_stream = CreateStream(CHANNEL_LAYOUT_MONO);
   EXPECT_TRUE(test_stream->Open());
   test_stream->Close();
 }
 
 TEST_F(CrasInputStreamTest, OpenStereo) {
   CrasInputStream* test_stream = CreateStream(CHANNEL_LAYOUT_STEREO);
@@ skipping 70 matching lines @@
 TEST_F(CrasInputStreamTest, CaptureLoopback) {
   CrasInputStream* test_stream = CreateStream(
       CHANNEL_LAYOUT_STEREO,
       kTestFramesPerPacket,
       AudioManagerBase::kLoopbackInputDeviceId);
   EXPECT_TRUE(test_stream->Open());
   test_stream->Close();
 }
 
 }  // namespace media