Rename AudioMixer factory method.

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.
  */
 
@@ skipping 357 matching lines @@
   }
 }
 
 // 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, &AudioMixerImpl::Create);
+      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));
   MockMixerAudioSource participant;
 
   ResetFrame(participant.fake_frame());
 
   participant_thread->Start();
   EXPECT_TRUE(participant_thread->Invoke<int>(
       RTC_FROM_HERE,
       rtc::Bind(&AudioMixer::AddSource, mixer.get(), &participant)));
 
   EXPECT_CALL(participant, GetAudioFrameWithInfo(kDefaultSampleRateHz, _))
@@ skipping 74 matching lines @@
   std::fill(frames[0].data_, frames[0].data_ + kDefaultSampleRateHz / 100,
             std::numeric_limits<int16_t>::max());
   std::vector<bool> expected_status(kAudioSources, true);
   expected_status[0] = false;
 
   MixAndCompare(frames, frame_info, expected_status);
 }
 
 TEST(AudioMixer, MixingRateShouldBeDecidedByRateCalculator) {
   constexpr int kOutputRate = 22000;
-  const auto mixer = AudioMixerImpl::CreateWithOutputRateCalculatorAndLimiter(
-      std::unique_ptr<OutputRateCalculator>(
-          new CustomRateCalculator(kOutputRate)),
-      true);
+  const auto mixer =
+      AudioMixerImpl::Create(std::unique_ptr<OutputRateCalculator>(
+                                 new CustomRateCalculator(kOutputRate)),
+                             true);
   MockMixerAudioSource audio_source;
   mixer->AddSource(&audio_source);
   ResetFrame(audio_source.fake_frame());
 
   EXPECT_CALL(audio_source, GetAudioFrameWithInfo(kOutputRate, _))
       .Times(Exactly(1));
 
   mixer->Mix(1, &frame_for_mixing);
 }
 
 TEST(AudioMixer, ZeroSourceRateShouldBeDecidedByRateCalculator) {
   constexpr int kOutputRate = 8000;
-  const auto mixer = AudioMixerImpl::CreateWithOutputRateCalculatorAndLimiter(
-      std::unique_ptr<OutputRateCalculator>(
-          new CustomRateCalculator(kOutputRate)),
-      true);
+  const auto mixer =
+      AudioMixerImpl::Create(std::unique_ptr<OutputRateCalculator>(
+                                 new CustomRateCalculator(kOutputRate)),
+                             true);
 
   mixer->Mix(1, &frame_for_mixing);
 
   EXPECT_EQ(kOutputRate, frame_for_mixing.sample_rate_hz_);
 }
 
 TEST(AudioMixer, NoLimiterBasicApiCalls) {
-  const auto mixer = AudioMixerImpl::CreateWithOutputRateCalculatorAndLimiter(
+  const auto mixer = AudioMixerImpl::Create(
       std::unique_ptr<OutputRateCalculator>(new DefaultOutputRateCalculator()),
       false);
   mixer->Mix(1, &frame_for_mixing);
 }
 
 TEST(AudioMixer, AnyRateIsPossibleWithNoLimiter) {
   // No APM limiter means no AudioProcessing::NativeRate restriction
   // on mixing rate. The rate has to be divisible by 100 since we use
   // 10 ms frames, though.
   for (const auto rate : {8000, 20000, 24000, 32000, 44100}) {
     for (const size_t number_of_channels : {1, 2}) {
       for (const auto number_of_sources : {0, 1, 2, 3, 4}) {
         SCOPED_TRACE(
             ProduceDebugText(rate, number_of_sources, number_of_sources));
         const auto mixer =
-            AudioMixerImpl::CreateWithOutputRateCalculatorAndLimiter(
-                std::unique_ptr<OutputRateCalculator>(
-                    new CustomRateCalculator(rate)),
-                false);
+            AudioMixerImpl::Create(std::unique_ptr<OutputRateCalculator>(
+                                       new CustomRateCalculator(rate)),
+                                   false);
 
         std::vector<MockMixerAudioSource> sources(number_of_sources);
         for (auto& source : sources) {
           mixer->AddSource(&source);
         }
 
         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