Remove dependency on rtc::Thread and rtc_base from audio_mixer_unittests.

webrtc/modules/audio_mixer/audio_mixer_impl_unittest.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <string.h>
 
 #include <limits>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <utility>
 
 #include "webrtc/api/audio/audio_mixer.h"
 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h"
 #include "webrtc/modules/audio_mixer/default_output_rate_calculator.h"
 #include "webrtc/rtc_base/bind.h"
 #include "webrtc/rtc_base/checks.h"
-#include "webrtc/rtc_base/thread.h"
+#include "webrtc/rtc_base/event.h"
+#include "webrtc/rtc_base/task_queue.h"
 #include "webrtc/test/gmock.h"
 
 using testing::_;
 using testing::Exactly;
 using testing::Invoke;
 using testing::Return;
 
 namespace webrtc {
 
 namespace {
@@ skipping 331 matching lines @@
   for (int i = 1; i < kAudioSources; ++i) {
     EXPECT_EQ(true,
               mixer->GetAudioSourceMixabilityStatusForTest(&participants[i]))
         << "Mixed status of AudioSource #" << i << " wrong.";
   }
 }
 
 // This test checks that the initialization and participant addition
 // can be done on a different thread.
 TEST(AudioMixer, ConstructFromOtherThread) {
-  std::unique_ptr<rtc::Thread> init_thread = rtc::Thread::Create();
-  std::unique_ptr<rtc::Thread> participant_thread = rtc::Thread::Create();
-  init_thread->Start();
-  const auto mixer = init_thread->Invoke<rtc::scoped_refptr<AudioMixer>>(
-      RTC_FROM_HERE,
-      // Since AudioMixerImpl::Create is overloaded, we have to
-      // specify the type of which version we want.
-      static_cast<rtc::scoped_refptr<AudioMixerImpl>(*)()>(
-          &AudioMixerImpl::Create));
+  rtc::TaskQueue init_queue("init");
+  rtc::scoped_refptr<AudioMixer> mixer;
+  rtc::Event event(false, false);
+  init_queue.PostTask([&mixer, &event]() {
+    mixer = AudioMixerImpl::Create();
+    event.Set();
+  });
+  event.Wait(rtc::Event::kForever);
+
   MockMixerAudioSource participant;
+  EXPECT_CALL(participant, PreferredSampleRate())

[minyue-webrtc, 2017/07/11 11:16:20]

would you explain why this additional expected call?

[tommi, 2017/07/11 11:58:36]

This call is and should always be made so I'm setting the expectation and
avoiding polluting the log.  That wasn't done previously.

There's an ON_CALL() handler set above, but that one only sets the default
handling and prints an error when it's called - which because it always happens,
we get trained to ignore (which is not a good thing).

Take for example a look at the "GMOCK WARNING" lines for the AudioMixer tests in
these runs:

https://isolateserver.appspot.com/browse?namespace=default-gzip&digest=5961e2...

https://isolateserver.appspot.com/browse?namespace=default-gzip&digest=f88549...

(etc - same amount of noise from most of the AudioMixer tests)

Then look at the output from the ConstructFromOtherThread test when it runs
normally (with this patch):

https://isolateserver.appspot.com/browse?namespace=default-gzip&digest=799c70...

[minyue-webrtc, 2017/07/11 13:03:22]

Acknowledged.

I also advice using StrictMock<MockMixerAudioSource> if possible

[tommi, 2017/07/11 13:13:29]

Yes that would be an improvement.  This CL is about removing use of rtc::Thread
though so I think that's a separate goal.
Alex - could you take a look at that at some point?

+      .WillRepeatedly(Return(kDefaultSampleRateHz));
 
   ResetFrame(participant.fake_frame());
 
-  participant_thread->Start();
-  EXPECT_TRUE(participant_thread->Invoke<int>(
-      RTC_FROM_HERE,
-      rtc::Bind(&AudioMixer::AddSource, mixer.get(), &participant)));
+  rtc::TaskQueue participant_queue("participant");
+  participant_queue.PostTask([&mixer, &event, &participant]() {
+    mixer->AddSource(&participant);
+    event.Set();
+  });
+  event.Wait(rtc::Event::kForever);
 
   EXPECT_CALL(participant, GetAudioFrameWithInfo(kDefaultSampleRateHz, _))
       .Times(Exactly(1));
 
   // Do one mixer iteration
   mixer->Mix(1, &frame_for_mixing);
 }
 
 TEST(AudioMixer, MutedShouldMixAfterUnmuted) {
   constexpr int kAudioSources =
@@ skipping 128 matching lines @@
         }
 
         mixer->Mix(number_of_channels, &frame_for_mixing);
         EXPECT_EQ(rate, frame_for_mixing.sample_rate_hz_);
         EXPECT_EQ(number_of_channels, frame_for_mixing.num_channels_);
       }
     }
   }
 }
 }  // namespace webrtc