Switch to standard integer types in media/.

media/base/audio_bus_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 <stdint.h>
 
 #include <limits>
 
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ skipping 262 matching lines @@
 TEST_F(AudioBusTest, FromInterleaved) {
   scoped_ptr<AudioBus> bus = AudioBus::Create(
       kTestVectorChannels, kTestVectorFrames);
   scoped_ptr<AudioBus> expected = AudioBus::Create(
       kTestVectorChannels, kTestVectorFrames);
   for (int ch = 0; ch < kTestVectorChannels; ++ch) {
     memcpy(expected->channel(ch), kTestVectorResult[ch],
            kTestVectorFrames * sizeof(*expected->channel(ch)));
   }
   {
-    SCOPED_TRACE("uint8");
+    SCOPED_TRACE("uint8_t");
     bus->Zero();
     bus->FromInterleaved(
         kTestVectorUint8, kTestVectorFrames, sizeof(*kTestVectorUint8));
     // Biased uint8_t calculations have poor precision, so the epsilon here is
     // slightly more permissive than int16_t and int32_t calculations.
     VerifyBusWithEpsilon(bus.get(), expected.get(),
                          1.0f / (std::numeric_limits<uint8_t>::max() - 1));
   }
   {
-    SCOPED_TRACE("int16");
+    SCOPED_TRACE("int16_t");
     bus->Zero();
     bus->FromInterleaved(
         kTestVectorInt16, kTestVectorFrames, sizeof(*kTestVectorInt16));
     VerifyBusWithEpsilon(bus.get(), expected.get(),
                          1.0f / (std::numeric_limits<uint16_t>::max() + 1.0f));
   }
   {
-    SCOPED_TRACE("int32");
+    SCOPED_TRACE("int32_t");
     bus->Zero();
     bus->FromInterleaved(
         kTestVectorInt32, kTestVectorFrames, sizeof(*kTestVectorInt32));
     VerifyBusWithEpsilon(bus.get(), expected.get(),
                          1.0f / (std::numeric_limits<uint32_t>::max() + 1.0f));
   }
 }
 
 // Verify FromInterleavedPartial() deinterleaves audio correctly.
 TEST_F(AudioBusTest, FromInterleavedPartial) {
@@ skipping 23 matching lines @@
 // Verify ToInterleaved() interleaves audio in suported formats correctly.
 TEST_F(AudioBusTest, ToInterleaved) {
   scoped_ptr<AudioBus> bus = AudioBus::Create(
       kTestVectorChannels, kTestVectorFrames);
   // Fill the bus with our test vector.
   for (int ch = 0; ch < bus->channels(); ++ch) {
     memcpy(bus->channel(ch), kTestVectorResult[ch],
            kTestVectorFrames * sizeof(*bus->channel(ch)));
   }
   {
-    SCOPED_TRACE("uint8");
+    SCOPED_TRACE("uint8_t");
     uint8_t test_array[arraysize(kTestVectorUint8)];
     bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorUint8), test_array);
     ASSERT_EQ(memcmp(
         test_array, kTestVectorUint8, sizeof(kTestVectorUint8)), 0);
   }
   {
-    SCOPED_TRACE("int16");
+    SCOPED_TRACE("int16_t");
     int16_t test_array[arraysize(kTestVectorInt16)];
     bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorInt16), test_array);
     ASSERT_EQ(memcmp(
         test_array, kTestVectorInt16, sizeof(kTestVectorInt16)), 0);
   }
   {
-    SCOPED_TRACE("int32");
+    SCOPED_TRACE("int32_t");
     int32_t test_array[arraysize(kTestVectorInt32)];
     bus->ToInterleaved(bus->frames(), sizeof(*kTestVectorInt32), test_array);
 
     // Some compilers get better precision than others on the half-max test, so
     // let the test pass with an off by one check on the half-max.
     int32_t fixed_test_array[arraysize(kTestVectorInt32)];
     memcpy(fixed_test_array, kTestVectorInt32, sizeof(kTestVectorInt32));
     ASSERT_EQ(fixed_test_array[4], std::numeric_limits<int32_t>::max() / 2);
     fixed_test_array[4]++;
 
@@ skipping 50 matching lines @@
 
   // Verify zero volume case.
   bus->Scale(0);
   for (int i = 0; i < bus->channels(); ++i) {
     SCOPED_TRACE("Zero Scale");
     VerifyValue(bus->channel(i), bus->frames(), 0);
   }
 }
 
 }  // namespace media