Switch to standard integer types in remoting/.

remoting/client/audio_player_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 "remoting/client/audio_player.h"
 
+#include <stdint.h>
+
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const int kAudioSamplesPerFrame = 25;
 const int kAudioSampleBytes = 4;
 const int kAudioFrameBytes = kAudioSamplesPerFrame * kAudioSampleBytes;
 const int kPaddingBytes = 16;
 
 // TODO(garykac): Generate random audio data in the tests rather than having
 // a single constant value.
-const uint8 kDefaultBufferData = 0x5A;
-const uint8 kDummyAudioData = 0x8B;
+const uint8_t kDefaultBufferData = 0x5A;
+const uint8_t kDummyAudioData = 0x8B;
 
 }  // namespace
 
 namespace remoting {
 
 class FakeAudioPlayer : public AudioPlayer {
  public:
   FakeAudioPlayer() {
   }
 
   bool ResetAudioPlayer(AudioPacket::SamplingRate) override { return true; }
 
-  uint32 GetSamplesPerFrame() override { return kAudioSamplesPerFrame; }
+  uint32_t GetSamplesPerFrame() override { return kAudioSamplesPerFrame; }
 };
 
 class AudioPlayerTest : public ::testing::Test {
  protected:
   void SetUp() override {
     audio_.reset(new FakeAudioPlayer());
     buffer_.reset(new char[kAudioFrameBytes + kPaddingBytes]);
   }
 
   void TearDown() override {}
 
   void ConsumeAudioFrame() {
-    uint8* buffer = reinterpret_cast<uint8*>(buffer_.get());
+    uint8_t* buffer = reinterpret_cast<uint8_t*>(buffer_.get());
     memset(buffer, kDefaultBufferData, kAudioFrameBytes + kPaddingBytes);
     AudioPlayer::AudioPlayerCallback(reinterpret_cast<void*>(buffer_.get()),
                                      kAudioFrameBytes,
                                      reinterpret_cast<void*>(audio_.get()));
     // Verify we haven't written beyond the end of the buffer.
     for (int i = 0; i < kPaddingBytes; i++)
       ASSERT_EQ(kDefaultBufferData, *(buffer + kAudioFrameBytes + i));
   }
 
   // Check that the first |num_bytes| bytes are filled with audio data and
   // the rest of the buffer is zero-filled.
   void CheckAudioFrameBytes(int num_bytes) {
-    uint8* buffer = reinterpret_cast<uint8*>(buffer_.get());
+    uint8_t* buffer = reinterpret_cast<uint8_t*>(buffer_.get());
     int i = 0;
     for (; i < num_bytes; i++) {
       ASSERT_EQ(kDummyAudioData, *(buffer + i));
     }
     // Rest of audio frame must be filled with '0's.
     for (; i < kAudioFrameBytes; i++) {
       ASSERT_EQ(0, *(buffer + i));
     }
   }
 
@@ skipping 230 matching lines @@
 
   // Attempt to consume a frame of 25 samples.
   ConsumeAudioFrame();
   ASSERT_EQ(0, GetNumQueuedSamples());
   ASSERT_EQ(0, GetNumQueuedPackets());
   ASSERT_EQ(0, GetBytesConsumed());
   CheckAudioFrameBytes(packet1_samples * kAudioSampleBytes);
 }
 
 }  // namespace remoting