Remove simulcast bitrate modes.

talk/media/webrtc/webrtcvideoengine2_unittest.cc

 /*
  * libjingle
  * Copyright 2004 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 2071 matching lines @@
   // Send a frame to make sure this scales up to >1 stream (simulcast).
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
 
   std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
   ASSERT_GT(streams.size(), 1u)
       << "Without simulcast this test doesn't make sense.";
-  int initial_max_bitrate_bps = 0;
-  for (auto& video_stream : streams)
-    initial_max_bitrate_bps += video_stream.max_bitrate_bps;
+  int initial_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
   EXPECT_GT(initial_max_bitrate_bps, 0);
 
   parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   streams = stream->GetVideoStreams();
-  int increased_max_bitrate_bps = 0;
-  for (auto& video_stream : streams)
-    increased_max_bitrate_bps += video_stream.max_bitrate_bps;
+  int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
   EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
 
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], nullptr));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
   static const char* kMaxQuantization = "21";
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(kVp8Codec);
   parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
@@ skipping 886 matching lines @@
   WebRtcVideoChannel2SimulcastTest() : fake_call_(webrtc::Call::Config()) {}
 
   void SetUp() override {
     engine_.Init();
     channel_.reset(engine_.CreateChannel(&fake_call_, VideoOptions()));
     last_ssrc_ = 123;
   }
 
  protected:
   void VerifySimulcastSettings(const VideoCodec& codec,
-                               VideoOptions::HighestBitrate bitrate_mode,
                                size_t num_configured_streams,
-                               size_t expected_num_streams,
-                               SimulcastBitrateMode simulcast_bitrate_mode) {
+                               size_t expected_num_streams) {
     cricket::VideoSendParameters parameters;
-    parameters.options.video_highest_bitrate.Set(bitrate_mode);
     parameters.codecs.push_back(codec);
     ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
     std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
     RTC_DCHECK(num_configured_streams <= ssrcs.size());
     ssrcs.resize(num_configured_streams);
 
     FakeVideoSendStream* stream =
         AddSendStream(CreateSimStreamParams("cname", ssrcs));
     // Send a full-size frame to trigger a stream reconfiguration to use all
     // expected simulcast layers.
     cricket::FakeVideoCapturer capturer;
     EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), &capturer));
     EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat(
                                        codec.width, codec.height,
                                        cricket::VideoFormat::FpsToInterval(30),
                                        cricket::FOURCC_I420)));
     channel_->SetSend(true);
     EXPECT_TRUE(capturer.CaptureFrame());
 
     std::vector<webrtc::VideoStream> video_streams = stream->GetVideoStreams();
     ASSERT_EQ(expected_num_streams, video_streams.size());
 
     std::vector<webrtc::VideoStream> expected_streams = GetSimulcastConfig(
-        num_configured_streams,
-        simulcast_bitrate_mode,
-        codec.width,
-        codec.height,
-        0,
-        kDefaultQpMax,
+        num_configured_streams, codec.width, codec.height, 0, kDefaultQpMax,
         codec.framerate != 0 ? codec.framerate : kDefaultFramerate);
 
     ASSERT_EQ(expected_streams.size(), video_streams.size());
 
     size_t num_streams = video_streams.size();
     int total_max_bitrate_bps = 0;
     for (size_t i = 0; i < num_streams; ++i) {
       EXPECT_EQ(expected_streams[i].width, video_streams[i].width);
       EXPECT_EQ(expected_streams[i].height, video_streams[i].height);
 
@@ skipping 66 matching lines @@
     return streams[streams.size() - 1];
   }
 
   FakeCall fake_call_;
   WebRtcVideoEngine2 engine_;
   rtc::scoped_ptr<VideoMediaChannel> channel_;
   uint32_t last_ssrc_;
 };
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
-  VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL);
+  VerifySimulcastSettings(kVp8Codec, 2, 2);
 }
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
-  VerifySimulcastSettings(
-      kVp8Codec720p, VideoOptions::NORMAL, 3, 3, SBM_NORMAL);
-}
-
-TEST_F(WebRtcVideoChannel2SimulcastTest,
-       SetSendCodecsWith2SimulcastStreamsHighBitrateMode) {
-  VerifySimulcastSettings(kVp8Codec, VideoOptions::HIGH, 2, 2, SBM_HIGH);
-}
-
-TEST_F(WebRtcVideoChannel2SimulcastTest,
-       SetSendCodecsWith3SimulcastStreamsHighBitrateMode) {
-  VerifySimulcastSettings(kVp8Codec720p, VideoOptions::HIGH, 3, 3, SBM_HIGH);
-}
-
-TEST_F(WebRtcVideoChannel2SimulcastTest,
-       SetSendCodecsWith2SimulcastStreamsVeryHighBitrateMode) {
-  VerifySimulcastSettings(
-      kVp8Codec, VideoOptions::VERY_HIGH, 2, 2, SBM_VERY_HIGH);
-}
-
-TEST_F(WebRtcVideoChannel2SimulcastTest,
-       SetSendCodecsWith3SimulcastStreamsVeryHighBitrateMode) {
-  VerifySimulcastSettings(
-      kVp8Codec720p, VideoOptions::VERY_HIGH, 3, 3, SBM_VERY_HIGH);
+  VerifySimulcastSettings(kVp8Codec720p, 3, 3);
 }
 
 // Test that we normalize send codec format size in simulcast.
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
   cricket::VideoCodec codec(kVp8Codec270p);
   codec.width += 1;
   codec.height += 1;
-  VerifySimulcastSettings(codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL);
+  VerifySimulcastSettings(codec, 2, 2);
 }
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x800) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, DISABLED_SimulcastSend_1280x720) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
@@ skipping 64 matching lines @@
 // Ensures that the correct settings are applied to the codec when two temporal
 // layer screencasting is enabled, and that the correct simulcast settings are
 // reapplied when disabling screencasting.
 TEST_F(WebRtcVideoChannel2SimulcastTest,
        DISABLED_TwoTemporalLayerScreencastSettings) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 }  // namespace cricket