Update a ton of audio code to use size_t more correctly and in general reduce

talk/app/webrtc/test/fakeaudiocapturemodule_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 38 matching lines @@
   }
 
   virtual void SetUp() {
     fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
     EXPECT_TRUE(fake_audio_capture_module_.get() != NULL);
   }
 
   // Callbacks inherited from webrtc::AudioTransport.
   // ADM is pushing data.
   int32_t RecordedDataIsAvailable(const void* audioSamples,
-                                  const uint32_t nSamples,
-                                  const uint8_t nBytesPerSample,
+                                  const size_t nSamples,
+                                  const size_t nBytesPerSample,
                                   const uint8_t nChannels,
                                   const uint32_t samplesPerSec,
                                   const uint32_t totalDelayMS,
                                   const int32_t clockDrift,
                                   const uint32_t currentMicLevel,
                                   const bool keyPressed,
                                   uint32_t& newMicLevel) override {
     rtc::CritScope cs(&crit_);
     rec_buffer_bytes_ = nSamples * nBytesPerSample;
     if ((rec_buffer_bytes_ == 0) ||
         (rec_buffer_bytes_ > FakeAudioCaptureModule::kNumberSamples *
          FakeAudioCaptureModule::kNumberBytesPerSample)) {
       ADD_FAILURE();
       return -1;
     }
     memcpy(rec_buffer_, audioSamples, rec_buffer_bytes_);
     ++push_iterations_;
     newMicLevel = currentMicLevel;
     return 0;
   }
 
   // ADM is pulling data.
-  int32_t NeedMorePlayData(const uint32_t nSamples,
-                           const uint8_t nBytesPerSample,
+  int32_t NeedMorePlayData(const size_t nSamples,
+                           const size_t nBytesPerSample,
                            const uint8_t nChannels,
                            const uint32_t samplesPerSec,
                            void* audioSamples,
-                           uint32_t& nSamplesOut,
+                           size_t& nSamplesOut,
                            int64_t* elapsed_time_ms,
                            int64_t* ntp_time_ms) override {
     rtc::CritScope cs(&crit_);
     ++pull_iterations_;
-    const uint32_t audio_buffer_size = nSamples * nBytesPerSample;
-    const uint32_t bytes_out = RecordedDataReceived() ?
+    const size_t audio_buffer_size = nSamples * nBytesPerSample;
+    const size_t bytes_out = RecordedDataReceived() ?
         CopyFromRecBuffer(audioSamples, audio_buffer_size):
         GenerateZeroBuffer(audioSamples, audio_buffer_size);
     nSamplesOut = bytes_out / nBytesPerSample;
     *elapsed_time_ms = 0;
     *ntp_time_ms = 0;
     return 0;
   }
 
   int push_iterations() const {
     rtc::CritScope cs(&crit_);
     return push_iterations_;
   }
   int pull_iterations() const {
     rtc::CritScope cs(&crit_);
     return pull_iterations_;
   }
 
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
 
  private:
   bool RecordedDataReceived() const {
     return rec_buffer_bytes_ != 0;
   }
-  int32_t GenerateZeroBuffer(void* audio_buffer, uint32_t audio_buffer_size) {
+  size_t GenerateZeroBuffer(void* audio_buffer, size_t audio_buffer_size) {
     memset(audio_buffer, 0, audio_buffer_size);
     return audio_buffer_size;
   }
-  int32_t CopyFromRecBuffer(void* audio_buffer, uint32_t audio_buffer_size) {
+  size_t CopyFromRecBuffer(void* audio_buffer, size_t audio_buffer_size) {
     EXPECT_EQ(audio_buffer_size, rec_buffer_bytes_);
-    const uint32_t min_buffer_size = min(audio_buffer_size, rec_buffer_bytes_);
+    const size_t min_buffer_size = min(audio_buffer_size, rec_buffer_bytes_);
     memcpy(audio_buffer, rec_buffer_, min_buffer_size);
     return min_buffer_size;
   }
 
   mutable rtc::CriticalSection crit_;
 
   int push_iterations_;
   int pull_iterations_;
 
   char rec_buffer_[FakeAudioCaptureModule::kNumberSamples *
                    FakeAudioCaptureModule::kNumberBytesPerSample];
-  uint32_t rec_buffer_bytes_;
+  size_t rec_buffer_bytes_;
 };
 
 TEST_F(FakeAdmTest, TestProccess) {
   // Next process call must be some time in the future (or now).
   EXPECT_LE(0, fake_audio_capture_module_->TimeUntilNextProcess());
   // Process call updates TimeUntilNextProcess() but there are no guarantees on
   // timing so just check that Process can ba called successfully.
   EXPECT_LE(0, fake_audio_capture_module_->Process());
 }
 
@@ skipping 60 matching lines @@
 
   EXPECT_EQ(0, fake_audio_capture_module_->InitRecording());
   EXPECT_EQ(0, fake_audio_capture_module_->StartRecording());
 
   EXPECT_TRUE_WAIT(push_iterations() > 0, kMsInSecond);
   EXPECT_TRUE_WAIT(pull_iterations() > 0, kMsInSecond);
 
   EXPECT_EQ(0, fake_audio_capture_module_->StopPlayout());
   EXPECT_EQ(0, fake_audio_capture_module_->StopRecording());
 }