Initial rate allocation should not use fps = 0

webrtc/modules/video_coding/video_sender_unittest.cc

 /*
  *  Copyright (c) 2013 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 111 matching lines @@
     Vp8StreamInfo info;
     for (int tl = 0; tl < 3; ++tl) {
       info.framerate_fps[tl] = FramerateFpsWithinTemporalLayer(tl);
       info.bitrate_kbps[tl] = BitrateKbpsWithinTemporalLayer(tl);
     }
     return info;
   }
 
  private:
   struct FrameData {
-    FrameData() {}
+    FrameData() : payload_size(0) {}
 
     FrameData(size_t payload_size, const CodecSpecificInfo& codec_specific_info)
         : payload_size(payload_size),
           codec_specific_info(codec_specific_info) {}
 
     size_t payload_size;
     CodecSpecificInfo codec_specific_info;
   };
 
   int64_t interval_ms() {
@@ skipping 149 matching lines @@
   AddFrame();
   ExpectIntraRequest(-1);
   AddFrame();
 
   EXPECT_EQ(-1, sender_->IntraFrameRequest(3));
   ExpectIntraRequest(-1);
   AddFrame();
 }
 
 TEST_F(TestVideoSenderWithMockEncoder, TestSetRate) {
+  // Let actual fps be half of max, so it can be distinguished from default.
+  const int64_t kActualFrameRate = settings_.maxFramerate / 2;

[danilchap, 2016/11/21 13:14:49]

since it is not a time variable, may be revert to generic int (some number).

(checked some framerate variables, look like there is no consistency there:
unsigned char, uint32_t, float)

[sprang_webrtc, 2016/11/21 13:21:50]

Sure. And no, little consistency :(
I'd like to clean this up generally. I think uint32_t is the most common.

+  const int64_t kFrameIntervalMs = 1000 / kActualFrameRate;
   const uint32_t new_bitrate_kbps = settings_.startBitrate + 300;
+
+  // Initial frame rate is taken from config, as we have no data yet.
   BitrateAllocation new_rate_allocation = rate_allocator_->GetAllocation(
       new_bitrate_kbps * 1000, settings_.maxFramerate);
-  EXPECT_CALL(encoder_, SetRateAllocation(new_rate_allocation, _))
+  EXPECT_CALL(encoder_,
+              SetRateAllocation(new_rate_allocation, settings_.maxFramerate))
       .Times(1)
       .WillOnce(Return(0));
   sender_->SetChannelParameters(new_bitrate_kbps * 1000, 0, 200,
                                 rate_allocator_.get());
   AddFrame();
+  clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
+
+  // Add enough frames so that input frame rate will be updated.
+  const int kFramesToSend =
+      (VCMProcessTimer::kDefaultProcessIntervalMs / kFrameIntervalMs) + 1;
+  for (int i = 0; i < kFramesToSend; ++i) {
+    AddFrame();
+    clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
+  }
+
+  EXPECT_CALL(encoder_,
+              SetRateAllocation(new_rate_allocation, kActualFrameRate))
+      .Times(1)
+      .WillOnce(Return(0));
+
+  sender_->Process();
+  AddFrame();
 
   // Expect no call to encoder_.SetRates if the new bitrate is zero.
   EXPECT_CALL(encoder_, SetRateAllocation(_, _)).Times(0);
   sender_->SetChannelParameters(0, 0, 200, rate_allocator_.get());
   AddFrame();
 }
 
 TEST_F(TestVideoSenderWithMockEncoder, TestIntraRequestsInternalCapture) {
   // De-register current external encoder.
   sender_->RegisterExternalEncoder(nullptr, kUnusedPayloadType, false);
@@ skipping 223 matching lines @@
   }
   {
     // TODO(andresp): Find out why this fails with framerate = 7.5
     Vp8StreamInfo expected = {{7.0, 7.0, 7.0}, {high_b, high_b, high_b}};
     EXPECT_THAT(SimulateWithFramerate(7.0), MatchesVp8StreamInfo(expected));
   }
 }
 }  // namespace
 }  // namespace vcm
 }  // namespace webrtc