Remove kint8min, kint8max, and kint16min.

media/base/audio_bus.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 "media/base/audio_bus.h"
 
+#include <stdint.h>
+
+#include <limits>
+
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/limits.h"
 #include "media/base/vector_math.h"
 
 namespace media {
 
-static const uint8 kUint8Bias = 128;
+static const uint8_t kUint8Bias = 128;
 
 static bool IsAligned(void* ptr) {
   return (reinterpret_cast<uintptr_t>(ptr) &
           (AudioBus::kChannelAlignment - 1)) == 0U;
 }
 
 // Calculates the required size for an AudioBus with the given params, sets
 // |aligned_frames| to the actual frame length of each channel array.
 static int CalculateMemorySizeInternal(int channels, int frames,
                                        int* out_aligned_frames) {
@@ skipping 219 matching lines @@
   for (int i = 0; i < channels; ++i)
     channel_data_.push_back(data + i * aligned_frames);
 }
 
 // TODO(dalecurtis): See if intrinsic optimizations help any here.
 void AudioBus::FromInterleavedPartial(const void* source, int start_frame,
                                       int frames, int bytes_per_sample) {
   CheckOverflow(start_frame, frames, frames_);
   switch (bytes_per_sample) {
     case 1:
-      FromInterleavedInternal<uint8, int16, kUint8Bias>(
+      FromInterleavedInternal<uint8_t, int16_t, kUint8Bias>(
           source, start_frame, frames, this,
-          1.0f / kint8min, 1.0f / kint8max);
+          1.0f / std::numeric_limits<int8_t>::min(),
+          1.0f / std::numeric_limits<int8_t>::max());
       break;
     case 2:
-      FromInterleavedInternal<int16, int16, 0>(
+      FromInterleavedInternal<int16_t, int16_t, 0>(
           source, start_frame, frames, this,
-          1.0f / kint16min, 1.0f / kint16max);
+          1.0f / std::numeric_limits<int16_t>::min(),
+          1.0f / std::numeric_limits<int16_t>::max());
       break;
     case 4:
-      FromInterleavedInternal<int32, int32, 0>(
+      FromInterleavedInternal<int32_t, int32_t, 0>(
           source, start_frame, frames, this,
-          1.0f / kint32min, 1.0f / kint32max);
+          1.0f / std::numeric_limits<int32_t>::min(),
+          1.0f / std::numeric_limits<int32_t>::max());
       break;
     default:
       NOTREACHED() << "Unsupported bytes per sample encountered.";
       ZeroFramesPartial(start_frame, frames);
       return;
   }
 
   // Don't clear remaining frames if this is a partial deinterleave.
   if (!start_frame) {
     // Zero any remaining frames.
@@ skipping 10 matching lines @@
                              void* dest) const {
   ToInterleavedPartial(0, frames, bytes_per_sample, dest);
 }
 
 // TODO(dalecurtis): See if intrinsic optimizations help any here.
 void AudioBus::ToInterleavedPartial(int start_frame, int frames,
                                     int bytes_per_sample, void* dest) const {
   CheckOverflow(start_frame, frames, frames_);
   switch (bytes_per_sample) {
     case 1:
-      ToInterleavedInternal<uint8, int16, kUint8Bias>(
-          this, start_frame, frames, dest, kint8min, kint8max);
+      ToInterleavedInternal<uint8_t, int16_t, kUint8Bias>(
+          this, start_frame, frames, dest, std::numeric_limits<int8_t>::min(),
+          std::numeric_limits<int8_t>::max());
       break;
     case 2:
-      ToInterleavedInternal<int16, int16, 0>(
-          this, start_frame, frames, dest, kint16min, kint16max);
+      ToInterleavedInternal<int16_t, int16_t, 0>(
+          this, start_frame, frames, dest, std::numeric_limits<int16_t>::min(),
+          std::numeric_limits<int16_t>::max());
       break;
     case 4:
-      ToInterleavedInternal<int32, int32, 0>(
-          this, start_frame, frames, dest, kint32min, kint32max);
+      ToInterleavedInternal<int32_t, int32_t, 0>(
+          this, start_frame, frames, dest, std::numeric_limits<int32_t>::min(),
+          std::numeric_limits<int32_t>::max());
       break;
     default:
       NOTREACHED() << "Unsupported bytes per sample encountered.";
       memset(dest, 0, frames * bytes_per_sample);
       return;
   }
 }
 
 void AudioBus::CopyTo(AudioBus* dest) const {
   CopyPartialFramesTo(0, frames(), 0, dest);
@@ skipping 37 matching lines @@
   return scoped_refptr<AudioBusRefCounted>(
       new AudioBusRefCounted(channels, frames));
 }
 
 AudioBusRefCounted::AudioBusRefCounted(int channels, int frames)
     : AudioBus(channels, frames) {}
 
 AudioBusRefCounted::~AudioBusRefCounted() {}
 
 }  // namespace media