Revert of Drop frames until specified bitrate is achieved.

webrtc/media/engine/webrtcvideoengine2_unittest.cc

 /*
  *  Copyright (c) 2004 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 84 matching lines @@
   it = rtx_types.find(config.encoder_settings.payload_type);
   EXPECT_TRUE(it != rtx_types.end() &&
               it->second == config.rtp.rtx.payload_type);
 
   if (config.rtp.ulpfec.red_rtx_payload_type != -1) {
     it = rtx_types.find(config.rtp.ulpfec.red_payload_type);
     EXPECT_TRUE(it != rtx_types.end() &&
                 it->second == config.rtp.ulpfec.red_rtx_payload_type);
   }
 }
-
-cricket::MediaConfig GetMediaConfig() {
-  cricket::MediaConfig media_config;
-  media_config.video.enable_cpu_overuse_detection = false;
-  return media_config;
-}
 }  // namespace
 
 namespace cricket {
 class WebRtcVideoEngine2Test : public ::testing::Test {
  public:
   WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {}
   explicit WebRtcVideoEngine2Test(const char* field_trials)
       : override_field_trials_(field_trials),
         call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
         engine_() {
@@ skipping 208 matching lines @@
 
   // Verify removing header extension turns on applying rotation.
   parameters.extensions.clear();
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(capturer.apply_rotation());
 }
 
 TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
   engine_.Init();
   std::unique_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
+      engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
 
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
 
   EXPECT_FALSE(channel->SetSend(true))
       << "Channel should not start without codecs.";
   EXPECT_TRUE(channel->SetSend(false))
       << "Channel should be stoppable even without set codecs.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
   engine_.Init();
   std::unique_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
+      engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
   VideoMediaInfo info;
   channel->GetStats(&info);
 }
 
 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType("VP8");
 
   std::unique_ptr<VideoMediaChannel> channel(
@@ skipping 74 matching lines @@
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType("VP8");
   std::unique_ptr<VideoMediaChannel> channel;
   FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
   call_.reset(fake_call);
   if (use_external_encoder) {
     channel.reset(SetUpForExternalEncoderFactory(&encoder_factory));
   } else {
     engine_.Init();
     channel.reset(
-        engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
+        engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
   }
   ASSERT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(channel->SetSend(true));
   FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
 
   EXPECT_EQ(use_external_encoder,
@@ skipping 89 matching lines @@
   ADD_FAILURE() << "Unrecognized codec name: " << name;
   return cricket::VideoCodec();
 }
 
 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
     cricket::WebRtcVideoEncoderFactory* encoder_factory) {
   engine_.SetExternalEncoderFactory(encoder_factory);
   engine_.Init();
 
   VideoMediaChannel* channel =
-      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
+      engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
   cricket::VideoSendParameters parameters;
   // We need to look up the codec in the engine to get the correct payload type.
   for (const VideoCodec& codec : encoder_factory->supported_codecs())
     parameters.codecs.push_back(GetEngineCodec(codec.name));
 
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   return channel;
 }
 
 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
     cricket::WebRtcVideoDecoderFactory* decoder_factory,
     const std::vector<VideoCodec>& codecs) {
   engine_.SetExternalDecoderFactory(decoder_factory);
   engine_.Init();
 
   VideoMediaChannel* channel =
-      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
+      engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
   cricket::VideoRecvParameters parameters;
   parameters.codecs = codecs;
   EXPECT_TRUE(channel->SetRecvParameters(parameters));
 
   return channel;
 }
 
 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType("VP8");
@@ skipping 52 matching lines @@
 
 TEST_F(WebRtcVideoEngine2Test,
        DontUseExternalEncoderFactoryForUnsupportedCodecs) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType("H264");
 
   engine_.SetExternalEncoderFactory(&encoder_factory);
   engine_.Init();
 
   std::unique_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
+      engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   // Make sure DestroyVideoEncoder was called on the factory.
   ASSERT_EQ(0u, encoder_factory.encoders().size());
 }
 
 TEST_F(WebRtcVideoEngine2Test,
        UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType("VP8");
   encoder_factory.AddSupportedVideoCodecType("H264");
 
   engine_.SetExternalEncoderFactory(&encoder_factory);
   engine_.Init();
 
   std::unique_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
+      engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
 
   EXPECT_TRUE(
       channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
   EXPECT_TRUE(channel->SetSend(true));
 
@@ skipping 19 matching lines @@
 TEST_F(WebRtcVideoEngine2Test,
        DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType("VP8");
   encoder_factory.AddSupportedVideoCodecType("H264");
 
   engine_.SetExternalEncoderFactory(&encoder_factory);
   engine_.Init();
 
   std::unique_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
+      engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("H264"));
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   ASSERT_EQ(1u, encoder_factory.encoders().size());
 
   // Send a frame of 720p. This should trigger a "real" encoder initialization.
   cricket::VideoFormat format(
@@ skipping 242 matching lines @@
 }
 
 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
  public:
   WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {}
   explicit WebRtcVideoChannel2Test(const char* field_trials)
       : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {}
   void SetUp() override {
     fake_call_.reset(new FakeCall(webrtc::Call::Config(&event_log_)));
     engine_.Init();
-    channel_.reset(engine_.CreateChannel(fake_call_.get(), GetMediaConfig(),
-                                         VideoOptions()));
+    channel_.reset(
+        engine_.CreateChannel(fake_call_.get(), MediaConfig(), VideoOptions()));
     channel_->OnReadyToSend(true);
     last_ssrc_ = 123;
     send_parameters_.codecs = engine_.codecs();
     recv_parameters_.codecs = engine_.codecs();
     ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
   }
 
  protected:
   FakeVideoSendStream* AddSendStream() {
     return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
@@ skipping 790 matching lines @@
 
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
   FakeVideoSendStream* stream = AddSendStream();
   EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetMediaConfigSuspendBelowMinBitrate) {
-  MediaConfig media_config = GetMediaConfig();
+  MediaConfig media_config = MediaConfig();
   media_config.video.suspend_below_min_bitrate = true;
 
   channel_.reset(
       engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
   channel_->OnReadyToSend(true);
 
   channel_->SetSendParameters(send_parameters_);
 
   FakeVideoSendStream* stream = AddSendStream();
   EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
@@ skipping 276 matching lines @@
 
 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) {
   TestCpuAdaptation(true, true);
 }
 
 TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) {
   cricket::VideoCodec codec = GetEngineCodec("VP8");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
 
-  MediaConfig media_config = GetMediaConfig();
+  MediaConfig media_config = MediaConfig();
   channel_.reset(
       engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
   channel_->OnReadyToSend(true);
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   ASSERT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
   ASSERT_EQ(cricket::CS_RUNNING,
@@ skipping 54 matching lines @@
   EXPECT_EQ(724, send_stream->GetLastHeight());
 
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
 }
 
 TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) {
   cricket::VideoCodec codec = GetEngineCodec("VP8");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
 
-  MediaConfig media_config = GetMediaConfig();
-  media_config.video.enable_cpu_overuse_detection = true;
+  MediaConfig media_config = MediaConfig();
   channel_.reset(
       engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
   channel_->OnReadyToSend(true);
   ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   ASSERT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
@@ skipping 44 matching lines @@
 
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
 }
 
 void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
                                                 bool is_screenshare) {
   cricket::VideoCodec codec = GetEngineCodec("VP8");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
 
-  MediaConfig media_config = GetMediaConfig();
-  if (enable_overuse) {
-    media_config.video.enable_cpu_overuse_detection = true;
+  MediaConfig media_config = MediaConfig();
+  if (!enable_overuse) {
+    media_config.video.enable_cpu_overuse_detection = false;
   }
   channel_.reset(
       engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
   channel_->OnReadyToSend(true);
 
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
@@ skipping 1705 matching lines @@
 }
 
 class WebRtcVideoChannel2SimulcastTest : public testing::Test {
  public:
   WebRtcVideoChannel2SimulcastTest()
       : fake_call_(webrtc::Call::Config(&event_log_)), last_ssrc_(0) {}
 
   void SetUp() override {
     engine_.Init();
     channel_.reset(
-        engine_.CreateChannel(&fake_call_, GetMediaConfig(), VideoOptions()));
+        engine_.CreateChannel(&fake_call_, MediaConfig(), VideoOptions()));
     channel_->OnReadyToSend(true);
     last_ssrc_ = 123;
   }
 
  protected:
   void VerifySimulcastSettings(const VideoCodec& codec,
                                int capture_width,
                                int capture_height,
                                size_t num_configured_streams,
                                size_t expected_num_streams,
@@ skipping 165 matching lines @@
 }
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsForSimulcastScreenshare) {
   webrtc::test::ScopedFieldTrials override_field_trials_(
       "WebRTC-SimulcastScreenshare/Enabled/");
   VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 2, true,
                           true);
 }
 
 }  // namespace cricket