Renaming AudioEncoder::SetTargetBitrate and SetProjectedPacketLossRate.

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc

 /*
  *  Copyright (c) 2015 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 125 matching lines @@
 TEST(AudioEncoderOpusTest, ToggleDtx) {
   auto states = CreateCodec(2);
   // Enable DTX
   EXPECT_TRUE(states.encoder->SetDtx(true));
   // Verify that the mode is still kAudio.
   EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application());
   // Turn off DTX.
   EXPECT_TRUE(states.encoder->SetDtx(false));
 }
 
-TEST(AudioEncoderOpusTest, SetBitrate) {
+TEST(AudioEncoderOpusTest,
+     OnReceivedTargetAudioBitrateWithoutAudioNetworkAdaptor) {
   auto states = CreateCodec(1);
   // Constants are replicated from audio_states.encoderopus.cc.
   const int kMinBitrateBps = 500;
   const int kMaxBitrateBps = 512000;
   // Set a too low bitrate.
-  states.encoder->SetTargetBitrate(kMinBitrateBps - 1);
+  states.encoder->OnReceivedTargetAudioBitrate(kMinBitrateBps - 1);
   EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
   // Set a too high bitrate.
-  states.encoder->SetTargetBitrate(kMaxBitrateBps + 1);
+  states.encoder->OnReceivedTargetAudioBitrate(kMaxBitrateBps + 1);
   EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
   // Set the minimum rate.
-  states.encoder->SetTargetBitrate(kMinBitrateBps);
+  states.encoder->OnReceivedTargetAudioBitrate(kMinBitrateBps);
   EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
   // Set the maximum rate.
-  states.encoder->SetTargetBitrate(kMaxBitrateBps);
+  states.encoder->OnReceivedTargetAudioBitrate(kMaxBitrateBps);
   EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
   // Set rates from 1000 up to 32000 bps.
   for (int rate = 1000; rate <= 32000; rate += 1000) {
-    states.encoder->SetTargetBitrate(rate);
+    states.encoder->OnReceivedTargetAudioBitrate(rate);
     EXPECT_EQ(rate, states.encoder->GetTargetBitrate());
   }
 }
 
 namespace {
 
 // Returns a vector with the n evenly-spaced numbers a, a + (b - a)/(n - 1),
 // ..., b.
 std::vector<double> IntervalSteps(double a, double b, size_t n) {
   RTC_DCHECK_GT(n, 1u);
   const double step = (b - a) / (n - 1);
   std::vector<double> points;
   for (size_t i = 0; i < n; ++i)
     points.push_back(a + i * step);
   return points;
 }
 
 // Sets the packet loss rate to each number in the vector in turn, and verifies
 // that the loss rate as reported by the encoder is |expected_return| for all
 // of them.
 void TestSetPacketLossRate(AudioEncoderOpus* encoder,
                            const std::vector<double>& losses,
                            double expected_return) {
   for (double loss : losses) {
-    encoder->SetProjectedPacketLossRate(loss);
+    encoder->OnReceivedUplinkPacketLossFraction(loss);
     EXPECT_DOUBLE_EQ(expected_return, encoder->packet_loss_rate());
   }
 }
 
 }  // namespace
 
 TEST(AudioEncoderOpusTest, PacketLossRateOptimized) {
   auto states = CreateCodec(1);
   auto I = [](double a, double b) { return IntervalSteps(a, b, 10); };
   const double eps = 1e-15;
@@ skipping 96 matching lines @@
   constexpr int kMinFrameLength = 10;
   constexpr int kMaxFrameLength = 60;
   EXPECT_CALL(**states.mock_audio_network_adaptor,
               SetReceiverFrameLengthRange(kMinFrameLength, kMaxFrameLength));
   states.encoder->SetReceiverFrameLengthRange(kMinFrameLength, kMaxFrameLength);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 }  // namespace webrtc