In PeerConnectionTestWrapper, put audio input on a separate thread.

talk/app/webrtc/test/fakeaudiocapturemodule.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 36 matching lines @@
 static const int kTimePerFrameMs = 10;
 static const uint8_t kNumberOfChannels = 1;
 static const int kSamplesPerSecond = 44000;
 static const int kTotalDelayMs = 0;
 static const int kClockDriftMs = 0;
 static const uint32_t kMaxVolume = 14392;
 
 enum {
   MSG_START_PROCESS,
   MSG_RUN_PROCESS,
-  MSG_STOP_PROCESS,
 };
 
 FakeAudioCaptureModule::FakeAudioCaptureModule(
     rtc::Thread* process_thread)
     : last_process_time_ms_(0),
       audio_callback_(NULL),
       recording_(false),
       playing_(false),
       play_is_initialized_(false),
       rec_is_initialized_(false),
       current_mic_level_(kMaxVolume),
       started_(false),
       next_frame_time_(0),
       process_thread_(process_thread),
       frames_received_(0) {
 }
 
 FakeAudioCaptureModule::~FakeAudioCaptureModule() {
   // Ensure that thread stops calling ProcessFrame().
-  process_thread_->Send(this, MSG_STOP_PROCESS);
+  process_thread_->Clear(this);
 }
 
 rtc::scoped_refptr<FakeAudioCaptureModule> FakeAudioCaptureModule::Create(
     rtc::Thread* process_thread) {
   if (process_thread == NULL) return NULL;
 
   rtc::scoped_refptr<FakeAudioCaptureModule> capture_module(
       new rtc::RefCountedObject<FakeAudioCaptureModule>(process_thread));
   if (!capture_module->Initialize()) {
     return NULL;
@@ skipping 506 matching lines @@
 }
 
 void FakeAudioCaptureModule::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_START_PROCESS:
       StartProcessP();
       break;
     case MSG_RUN_PROCESS:
       ProcessFrameP();
       break;
-    case MSG_STOP_PROCESS:
-      StopProcessP();
-      break;
     default:
       // All existing messages should be caught. Getting here should never
       // happen.
       ASSERT(false);
   }
 }
 
 bool FakeAudioCaptureModule::Initialize() {
   // Set the send buffer samples high enough that it would not occur on the
   // remote side unless a packet containing a sample of that magnitude has been
@@ skipping 28 matching lines @@
 }
 
 bool FakeAudioCaptureModule::ShouldStartProcessing() {
   return recording_ || playing_;
 }
 
 void FakeAudioCaptureModule::UpdateProcessing(bool start) {
   if (start) {
     process_thread_->Post(this, MSG_START_PROCESS);
   } else {
-    process_thread_->Send(this, MSG_STOP_PROCESS);
+    process_thread_->Clear(this);
+    started_ = false;
   }
 }
 
 void FakeAudioCaptureModule::StartProcessP() {
   ASSERT(rtc::Thread::Current() == process_thread_);
   if (started_) {
     // Already started.
     return;
   }
   ProcessFrameP();
@@ skipping 74 matching lines @@
                                               kNumberOfChannels,
                                               kSamplesPerSecond, kTotalDelayMs,
                                               kClockDriftMs, current_mic_level,
                                               key_pressed,
                                               current_mic_level) != 0) {
     ASSERT(false);
   }
   SetMicrophoneVolume(current_mic_level);
 }
 
-void FakeAudioCaptureModule::StopProcessP() {
-  ASSERT(rtc::Thread::Current() == process_thread_);
-  started_ = false;
-  process_thread_->Clear(this);
-}