Switch to standard integer types in media/.

media/audio/cras/cras_unified.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/cras/cras_unified.h"
 
 #include "base/logging.h"
 #include "media/audio/cras/audio_manager_cras.h"
 
 namespace media {
@@ skipping 140 matching lines @@
       params_.sample_rate(),
       params_.channels());
   if (!audio_format) {
     LOG(WARNING) << "Error setting up audio parameters.";
     callback->OnError(this);
     return;
   }
 
   // Initialize channel layout to all -1 to indicate that none of
   // the channels is set in the layout.
-  int8 layout[CRAS_CH_MAX] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
+  int8_t layout[CRAS_CH_MAX] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
 
   // Converts to CRAS defined channels. ChannelOrder will return -1
   // for channels that does not present in params_.channel_layout().
   for (size_t i = 0; i < arraysize(kChannelMap); ++i)
     layout[kChannelMap[i]] = ChannelOrder(params_.channel_layout(),
                                           static_cast<Channels>(i));
 
   if (cras_audio_format_set_channel_layout(audio_format, layout)) {
     LOG(WARNING) << "Error setting channel layout.";
     callback->OnError(this);
@@ skipping 53 matching lines @@
   if (!client_)
     return;
   volume_ = static_cast<float>(volume);
   cras_client_set_stream_volume(client_, stream_id_, volume_);
 }
 
 void CrasUnifiedStream::GetVolume(double* volume) {
   *volume = volume_;
 }
 
-uint32 CrasUnifiedStream::GetBytesLatency(
-    const struct timespec& latency_ts) {
-  uint32 latency_usec;
+uint32_t CrasUnifiedStream::GetBytesLatency(const struct timespec& latency_ts) {
+  uint32_t latency_usec;
 
   // Treat negative latency (if we are too slow to render) as 0.
   if (latency_ts.tv_sec < 0 || latency_ts.tv_nsec < 0) {
     latency_usec = 0;
   } else {
     latency_usec = (latency_ts.tv_sec * base::Time::kMicrosecondsPerSecond) +
         latency_ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
   }
 
   double frames_latency =
       latency_usec * params_.sample_rate() / base::Time::kMicrosecondsPerSecond;
 
   return static_cast<unsigned int>(frames_latency * bytes_per_frame_);
 }
 
 // Static callback asking for samples.
 int CrasUnifiedStream::UnifiedCallback(cras_client* client,
                                        cras_stream_id_t stream_id,
-                                       uint8* input_samples,
-                                       uint8* output_samples,
+                                       uint8_t* input_samples,
+                                       uint8_t* output_samples,
                                        unsigned int frames,
                                        const timespec* input_ts,
                                        const timespec* output_ts,
                                        void* arg) {
   CrasUnifiedStream* me = static_cast<CrasUnifiedStream*>(arg);
   return me->DispatchCallback(frames,
                               input_samples,
                               output_samples,
                               input_ts,
                               output_ts);
 }
 
 // Static callback for stream errors.
 int CrasUnifiedStream::StreamError(cras_client* client,
                                    cras_stream_id_t stream_id,
                                    int err,
                                    void* arg) {
   CrasUnifiedStream* me = static_cast<CrasUnifiedStream*>(arg);
   me->NotifyStreamError(err);
   return 0;
 }
 
 // Calls the appropriate rendering function for this type of stream.
-uint32 CrasUnifiedStream::DispatchCallback(size_t frames,
-                                           uint8* input_samples,
-                                           uint8* output_samples,
-                                           const timespec* input_ts,
-                                           const timespec* output_ts) {
+uint32_t CrasUnifiedStream::DispatchCallback(size_t frames,
+                                             uint8_t* input_samples,
+                                             uint8_t* output_samples,
+                                             const timespec* input_ts,
+                                             const timespec* output_ts) {
   switch (stream_direction_) {
     case CRAS_STREAM_OUTPUT:
       return WriteAudio(frames, output_samples, output_ts);
     case CRAS_STREAM_INPUT:
       NOTREACHED() << "CrasUnifiedStream doesn't support input streams.";
       return 0;
     default:
       break;
   }
 
   return 0;
 }
 
-uint32 CrasUnifiedStream::WriteAudio(size_t frames,
-                                     uint8* buffer,
-                                     const timespec* sample_ts) {
+uint32_t CrasUnifiedStream::WriteAudio(size_t frames,
+                                       uint8_t* buffer,
+                                       const timespec* sample_ts) {
   DCHECK_EQ(frames, static_cast<size_t>(output_bus_->frames()));
 
   // Determine latency and pass that on to the source.
   timespec latency_ts  = {0, 0};
   cras_client_calc_playback_latency(sample_ts, &latency_ts);
 
   int frames_filled = source_callback_->OnMoreData(
       output_bus_.get(), GetBytesLatency(latency_ts), 0);
 
   // Note: If this ever changes to output raw float the data must be clipped and
   // sanitized since it may come from an untrusted source such as NaCl.
   output_bus_->ToInterleaved(
       frames_filled, bytes_per_frame_ / params_.channels(), buffer);
 
   return frames_filled;
 }
 
 void CrasUnifiedStream::NotifyStreamError(int err) {
   // This will remove the stream from the client.
   if (source_callback_)
     source_callback_->OnError(this);
 }
 
 }  // namespace media