Extract common simulcast logic from VP8 wrapper and simulcast adapter

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 114 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 */ {
-    return 0;
-  }
-
+  MOCK_METHOD2(SetRates, int32_t(uint32_t newBitRate, uint32_t frameRate));
   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_; }
 
@@ skipping 19 matching lines @@
   EncodedImageCallback* callback_;
 };
 
 class MockVideoEncoderFactory : public VideoEncoderFactory {
  public:
   VideoEncoder* Create() override {
     MockVideoEncoder* encoder = new MockVideoEncoder();
     const char* encoder_name = encoder_names_.empty()
                                    ? "codec_implementation_name"
                                    : encoder_names_[encoders_.size()];
-    ON_CALL(*encoder, ImplementationName()).WillByDefault(Return(encoder_name));
+    EXPECT_CALL(*encoder, ImplementationName())
+        .WillRepeatedly(Return(encoder_name));
     encoders_.push_back(encoder);
     return encoder;
   }
 
   void Destroy(VideoEncoder* encoder) override {
     for (size_t i = 0; i < encoders_.size(); ++i) {
       if (encoders_[i] == encoder) {
         encoders_.erase(encoders_.begin() + i);
         break;
       }
     }
     delete encoder;
   }
 
+  void ExpectRates(const std::vector<int>& expected_bitrates_kbps,
+                   int expected_framerate) {
+    ASSERT_EQ(encoders_.size(), expected_bitrates_kbps.size());
+    for (size_t i = 0; i < expected_bitrates_kbps.size(); ++i) {
+      EXPECT_CALL(*encoders_[i],
+                  SetRates(expected_bitrates_kbps[i], expected_framerate))
+          .WillOnce(Return(0));
+    }
+  }
+
   virtual ~MockVideoEncoderFactory() {}
 
   const std::vector<MockVideoEncoder*>& encoders() const { return encoders_; }
   void SetEncoderNames(const std::vector<const char*>& encoder_names) {
     encoder_names_ = encoder_names;
   }
 
  private:
   std::vector<MockVideoEncoder*> encoders_;
   std::vector<const char*> encoder_names_;
@@ skipping 170 matching lines @@
   const uint32_t packetLoss = 5;
   const int64_t rtt = 30;
   helper_->ExpectCallSetChannelParameters(packetLoss, rtt);
   adapter_->SetChannelParameters(packetLoss, rtt);
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake, EncodedCallbackForDifferentEncoders) {
   SetupCodec();
 
   // Set bitrates so that we send all layers.
-  adapter_->SetRates(1200, 30);
+  int total_bitrate_kbps = 0;
+  std::vector<int> expected_rates_kbps;
+  for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) {
+    expected_rates_kbps.push_back(codec_.simulcastStream[i].targetBitrate);
+    total_bitrate_kbps += codec_.simulcastStream[i].targetBitrate;
+  }
+
+  int kFrameRate = 30;
+  helper_->factory()->ExpectRates(expected_rates_kbps, kFrameRate);
+  adapter_->SetRates(total_bitrate_kbps, kFrameRate);
 
   // At this point, the simulcast encoder adapter should have 3 streams: HD,
   // quarter HD, and quarter quarter HD. We're going to mostly ignore the exact
   // resolutions, to test that the adapter forwards on the correct resolution
   // and simulcast index values, going only off the encoder that generates the
   // image.
   EXPECT_EQ(3u, helper_->factory()->encoders().size());
   helper_->factory()->encoders()[0]->SendEncodedImage(1152, 704);
   int width;
   int height;
@@ skipping 23 matching lines @@
   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, SupportsImplementationName) {
-  EXPECT_STREQ("SimulcastEncoderAdapter", adapter_->ImplementationName());
+  EXPECT_STREQ("SimulcastEncoderAdapter (uninitialized)",
+               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));
   EXPECT_STREQ("SimulcastEncoderAdapter (codec1, codec2, codec3)",
                adapter_->ImplementationName());
@@ skipping 17 matching lines @@
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(3u, helper_->factory()->encoders().size());
   for (MockVideoEncoder* encoder : helper_->factory()->encoders())
     encoder->set_supports_native_handle(true);
   EXPECT_FALSE(adapter_->SupportsNativeHandle());
 }
 
 }  // namespace testing
 }  // namespace webrtc