Change SimulcastEncoderAdapter to allow a 0 for SetRates.

webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc

 /*
  *  Copyright (c) 2014 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 115 matching lines @@
 
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) /* override */ {
     callback_ = callback;
     return 0;
   }
 
   int32_t Release() /* override */ { return 0; }
 
   int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) /* override */ {
+    last_set_bitrate_ = static_cast<int32_t>(newBitRate);
     return 0;
   }
 
   MOCK_METHOD2(SetChannelParameters, int32_t(uint32_t packetLoss, int64_t rtt));
 
   bool SupportsNativeHandle() const /* override */ {
     return supports_native_handle_;
   }
 
   virtual ~MockVideoEncoder() {}
 
   const VideoCodec& codec() const { return codec_; }
 
   void SendEncodedImage(int width, int height) {
     // Sends a fake image of the given width/height.
     EncodedImage image;
     image._encodedWidth = width;
     image._encodedHeight = height;
     CodecSpecificInfo codecSpecificInfo;
     memset(&codecSpecificInfo, 0, sizeof(codecSpecificInfo));
     callback_->Encoded(image, &codecSpecificInfo, NULL);
   }
 
   void set_supports_native_handle(bool enabled) {
     supports_native_handle_ = enabled;
   }
+  int32_t last_set_bitrate() const { return last_set_bitrate_; }
 
   MOCK_CONST_METHOD0(ImplementationName, const char*());
 
  private:
   bool supports_native_handle_ = false;
+  int32_t last_set_bitrate_ = -1;
+
   VideoCodec codec_;
   EncodedImageCallback* callback_;
 };
 
 class MockVideoEncoderFactory : public VideoEncoderFactory {
  public:
   VideoEncoder* Create() override {
     MockVideoEncoder* encoder = new
         ::testing::NiceMock<MockVideoEncoder>();
     const char* encoder_name = encoder_names_.empty()
@@ skipping 240 matching lines @@
   codec_.numberOfSimulcastStreams = 1;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(1u, helper_->factory()->encoders().size());
   helper_->factory()->encoders()[0]->set_supports_native_handle(true);
   EXPECT_TRUE(adapter_->SupportsNativeHandle());
   helper_->factory()->encoders()[0]->set_supports_native_handle(false);
   EXPECT_FALSE(adapter_->SupportsNativeHandle());
 }
 
+TEST_F(TestSimulcastEncoderAdapterFake, SetRatesUnderMinBitrate) {
+  TestVp8Simulcast::DefaultSettings(
+      &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.minBitrate = 50;
+  codec_.numberOfSimulcastStreams = 1;
+  EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
+
+  // Above min should be respected.
+  adapter_->SetRates(100, 30);
+  EXPECT_EQ(100, helper_->factory()->encoders()[0]->last_set_bitrate());
+
+  // Below min but non-zero should be replaced with the min bitrate.
+  adapter_->SetRates(15, 30);
+  EXPECT_EQ(50, helper_->factory()->encoders()[0]->last_set_bitrate());
+
+  // Zero should be passed on as is, since it means "pause".
+  adapter_->SetRates(0, 30);
+  EXPECT_EQ(0, helper_->factory()->encoders()[0]->last_set_bitrate());
+}
+
 TEST_F(TestSimulcastEncoderAdapterFake, SupportsImplementationName) {
   EXPECT_STREQ("SimulcastEncoderAdapter", adapter_->ImplementationName());
   TestVp8Simulcast::DefaultSettings(
       &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
   std::vector<const char*> encoder_names;
   encoder_names.push_back("codec1");
   encoder_names.push_back("codec2");
   encoder_names.push_back("codec3");
   helper_->factory()->SetEncoderNames(encoder_names);
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
@@ skipping 85 matching lines @@
   memset(input_frame.video_frame_buffer()->MutableDataV(), 0,
          input_frame.allocated_size(kVPlane));
 
   std::vector<FrameType> frame_types(3, kVideoFrameKey);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE,
             adapter_->Encode(input_frame, nullptr, &frame_types));
 }
 
 }  // namespace testing
 }  // namespace webrtc