Switch to standard integer types in media/.

media/audio/audio_low_latency_input_output_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 "base/basictypes.h"
 #include "base/environment.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/synchronization/lock.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager_base.h"
@@ skipping 161 matching lines @@
               state.output_delay_ms);
       ++elements_written;
     }
 
     base::CloseFile(text_file);
   }
 
   // AudioInputStream::AudioInputCallback.
   void OnData(AudioInputStream* stream,
               const AudioBus* src,
-              uint32 hardware_delay_bytes,
+              uint32_t hardware_delay_bytes,
               double volume) override {
     base::AutoLock lock(lock_);
 
     // Update three components in the AudioDelayState for this recorded
     // audio packet.
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_write_time_).InMilliseconds();
     previous_write_time_ = now_time;
     if (input_elements_to_write_ < kMaxDelayMeasurements) {
       delay_states_[input_elements_to_write_].delta_time_ms = diff;
@@ skipping 25 matching lines @@
 
     // Update one component in the AudioDelayState for the packet
     // which is about to be played out.
     if (output_elements_to_write_ < kMaxDelayMeasurements) {
       delay_states_[output_elements_to_write_].output_delay_ms =
           BytesToMilliseconds(total_bytes_delay);
       ++output_elements_to_write_;
     }
 
     int size;
-    const uint8* source;
+    const uint8_t* source;
     // Read the data from the seekable media buffer which contains
     // captured data at the same size and sample rate as the output side.
     if (buffer_->GetCurrentChunk(&source, &size) && size > 0) {
       EXPECT_EQ(channels_, audio_bus->channels());
       size = std::min(audio_bus->frames() * frame_size_, size);
       EXPECT_EQ(static_cast<size_t>(size) % sizeof(*audio_bus->channel(0)), 0U);
       audio_bus->FromInterleaved(
           source, size / frame_size_, frame_size_ / channels_);
       buffer_->Seek(size);
       return size / frame_size_;
     }
 
     return 0;
   }
 
   void OnError(AudioOutputStream* stream) override {}
 
  protected:
   // Converts from bytes to milliseconds taking the sample rate and size
   // of an audio frame into account.
-  int BytesToMilliseconds(uint32 delay_bytes) const {
+  int BytesToMilliseconds(uint32_t delay_bytes) const {
     return static_cast<int>((delay_bytes / frame_size_) * frames_to_ms_ + 0.5);
   }
 
  private:
   base::Lock lock_;
   scoped_ptr<media::SeekableBuffer> buffer_;
   int sample_rate_;
   int samples_per_packet_;
   int channels_;
   int frame_size_;
@@ skipping 165 matching lines @@
 
   // All Close() operations that run on the mocked audio thread,
   // should be synchronous and not post additional close tasks to
   // mocked the audio thread. Hence, there is no need to call
   // message_loop()->RunUntilIdle() after the Close() methods.
   aos->Close();
   ais->Close();
 }
 
 }  // namespace media