In PeerConnectionTestWrapper, put audio input on a separate thread.

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 11 matching lines @@
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "talk/app/webrtc/test/fakeaudiocapturemodule.h"
 
 #include <algorithm>
 
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/thread.h"
 
 using std::min;
 
 class FakeAdmTest : public testing::Test,
                     public webrtc::AudioTransport {
  protected:
   static const int kMsInSecond = 1000;
 
   FakeAdmTest()
       : push_iterations_(0),
         pull_iterations_(0),
         rec_buffer_bytes_(0) {
     memset(rec_buffer_, 0, sizeof(rec_buffer_));
   }
 
   virtual void SetUp() {
-    fake_audio_capture_module_ = FakeAudioCaptureModule::Create(
-        rtc::Thread::Current());
+    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 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,
                            const uint8_t nChannels,
                            const uint32_t samplesPerSec,
                            void* audioSamples,
                            uint32_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() ?
         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 { return push_iterations_; }
-  int pull_iterations() const { return pull_iterations_; }
+  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) {
     memset(audio_buffer, 0, audio_buffer_size);
     return audio_buffer_size;
   }
   int32_t CopyFromRecBuffer(void* audio_buffer, uint32_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_);
     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_;
 };
 
 TEST_F(FakeAdmTest, TestProccess) {
   // Next process call must be some time in the future (or now).
@@ skipping 66 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());
 }