Switch to standard integer types in media/.

media/audio/alsa/alsa_input.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 "media/audio/alsa/alsa_input.h"
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/audio/alsa/alsa_output.h"
 #include "media/audio/alsa/alsa_util.h"
 #include "media/audio/alsa/alsa_wrapper.h"
 #include "media/audio/alsa/audio_manager_alsa.h"
 #include "media/audio/audio_manager.h"
 
 namespace media {
@@ skipping 35 matching lines @@
     return false;  // Already open.
 
   snd_pcm_format_t pcm_format = alsa_util::BitsToFormat(
       params_.bits_per_sample());
   if (pcm_format == SND_PCM_FORMAT_UNKNOWN) {
     LOG(WARNING) << "Unsupported bits per sample: "
                  << params_.bits_per_sample();
     return false;
   }
 
-  uint32 latency_us =
+  uint32_t latency_us =
       buffer_duration_.InMicroseconds() * kNumPacketsInRingBuffer;
 
   // Use the same minimum required latency as output.
   latency_us = std::max(latency_us, AlsaPcmOutputStream::kMinLatencyMicros);
 
   if (device_name_ == kAutoSelectDevice) {
     const char* device_names[] = { kDefaultDevice1, kDefaultDevice2 };
     for (size_t i = 0; i < arraysize(device_names); ++i) {
       device_handle_ = alsa_util::OpenCaptureDevice(
           wrapper_, device_names[i], params_.channels(),
           params_.sample_rate(), pcm_format, latency_us);
 
       if (device_handle_) {
         device_name_ = device_names[i];
         break;
       }
     }
   } else {
     device_handle_ = alsa_util::OpenCaptureDevice(wrapper_,
                                                   device_name_.c_str(),
                                                   params_.channels(),
                                                   params_.sample_rate(),
                                                   pcm_format, latency_us);
   }
 
   if (device_handle_) {
-    audio_buffer_.reset(new uint8[bytes_per_buffer_]);
+    audio_buffer_.reset(new uint8_t[bytes_per_buffer_]);
 
     // Open the microphone mixer.
     mixer_handle_ = alsa_util::OpenMixer(wrapper_, device_name_);
     if (mixer_handle_) {
       mixer_element_handle_ = alsa_util::LoadCaptureMixerElement(
           wrapper_, mixer_handle_);
     }
   }
 
   return device_handle_ != NULL;
@@ skipping 88 matching lines @@
 
     base::TimeDelta next_check_time = buffer_duration_ / 2;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
         next_check_time);
     return;
   }
 
   int num_buffers = frames / params_.frames_per_buffer();
-  uint32 hardware_delay_bytes =
-      static_cast<uint32>(GetCurrentDelay() * params_.GetBytesPerFrame());
+  uint32_t hardware_delay_bytes =
+      static_cast<uint32_t>(GetCurrentDelay() * params_.GetBytesPerFrame());
   double normalized_volume = 0.0;
 
   // Update the AGC volume level once every second. Note that, |volume| is
   // also updated each time SetVolume() is called through IPC by the
   // render-side AGC.
   GetAgcVolume(&normalized_volume);
 
   while (num_buffers--) {
     int frames_read = wrapper_->PcmReadi(device_handle_, audio_buffer_.get(),
                                          params_.frames_per_buffer());
@@ skipping 127 matching lines @@
 bool AlsaPcmInputStream::IsMuted() {
   return false;
 }
 
 void AlsaPcmInputStream::HandleError(const char* method, int error) {
   LOG(WARNING) << method << ": " << wrapper_->StrError(error);
   callback_->OnError(this);
 }
 
 }  // namespace media