Switch to standard integer types in media/.

media/audio/win/audio_low_latency_input_win.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/audio/win/audio_low_latency_input_win.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 273 matching lines @@
 
   // Allocate a buffer with a size that enables us to take care of cases like:
   // 1) The recorded buffer size is smaller, or does not match exactly with,
   //    the selected packet size used in each callback.
   // 2) The selected buffer size is larger than the recorded buffer size in
   //    each event.
   size_t buffer_frame_index = 0;
   size_t capture_buffer_size = std::max(
       2 * endpoint_buffer_size_frames_ * frame_size_,
       2 * packet_size_frames_ * frame_size_);
-  scoped_ptr<uint8[]> capture_buffer(new uint8[capture_buffer_size]);
+  scoped_ptr<uint8_t[]> capture_buffer(new uint8_t[capture_buffer_size]);
 
   LARGE_INTEGER now_count = {};
   bool recording = true;
   bool error = false;
   double volume = GetVolume();
   HANDLE wait_array[2] =
       { stop_capture_event_.Get(), audio_samples_ready_event_.Get() };
 
   base::win::ScopedComPtr<IAudioClock> audio_clock;
   audio_client_->GetService(__uuidof(IAudioClock), audio_clock.ReceiveVoid());
@@ skipping 75 matching lines @@
                 first_audio_frame_timestamp) / 10000.0) * ms_to_frame_count_ +
                 buffer_frame_index - num_frames_to_read;
 
           // Get a cached AGC volume level which is updated once every second
           // on the audio manager thread. Note that, |volume| is also updated
           // each time SetVolume() is called through IPC by the render-side AGC.
           GetAgcVolume(&volume);
 
           // Deliver captured data to the registered consumer using a packet
           // size which was specified at construction.
-          uint32 delay_frames = static_cast<uint32>(audio_delay_frames + 0.5);
+          uint32_t delay_frames =
+              static_cast<uint32_t>(audio_delay_frames + 0.5);
           while (buffer_frame_index >= packet_size_frames_) {
             // Copy data to audio bus to match the OnData interface.
-            uint8* audio_data = reinterpret_cast<uint8*>(capture_buffer.get());
+            uint8_t* audio_data =
+                reinterpret_cast<uint8_t*>(capture_buffer.get());
             audio_bus_->FromInterleaved(
                 audio_data, audio_bus_->frames(), format_.wBitsPerSample / 8);
 
             // Deliver data packet, delay estimation and volume level to
             // the user.
             sink_->OnData(
                 this, audio_bus_.get(), delay_frames * frame_size_, volume);
 
             // Store parts of the recorded data which can't be delivered
             // using the current packet size. The stored section will be used
@@ skipping 271 matching lines @@
     return hr;
 
   // Obtain a reference to the ISimpleAudioVolume interface which enables
   // us to control the master volume level of an audio session.
   hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
                                  simple_audio_volume_.ReceiveVoid());
   return hr;
 }
 
 }  // namespace media