Make sure temporal layered screenshare frames are sent in at least 2s.

webrtc/modules/video_coding/codecs/vp8/screenshare_layers_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 341 matching lines @@
           break;
         case 1:
           ++tl1_frames;
           break;
         default:
           abort();
       }
     }
   }
 
-  EXPECT_EQ(5, tl0_frames);
-  EXPECT_EQ(45, tl1_frames);
+  EXPECT_EQ(50, tl0_frames + tl1_frames);
   EXPECT_EQ(50, dropped_frames);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateCappedByTL0) {
   vpx_codec_enc_cfg_t cfg;
   layers_->ConfigureBitrates(100, 1000, 5, &cfg);
 
   EXPECT_EQ(static_cast<unsigned int>(
                 ScreenshareLayers::kMaxTL0FpsReduction * 100 + 0.5),
             cfg.rc_target_bitrate);
@@ skipping 60 matching lines @@
   layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
 
   layers_->EncodeFlags(timestamp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   EXPECT_EQ(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
 }
 
+TEST_F(ScreenshareLayerTest, RespectsMaxIntervalBetweenFrames) {
+  const int kLowBitrateKbps = 50;
+  const int kLargeFrameSizeBytes = 100000;
+  const uint32_t kStartTimestamp = 1234;
+
+  vpx_codec_enc_cfg_t cfg;
+  layers_->ConfigureBitrates(kLowBitrateKbps, kLowBitrateKbps, 5, &cfg);
+
+  EXPECT_EQ(ScreenshareLayers::kTl0Flags,
+            layers_->EncodeFlags(kStartTimestamp));
+  layers_->FrameEncoded(kLargeFrameSizeBytes, kStartTimestamp, kDefaultQp);
+
+  const uint32_t kTwoSecondsLater =
+      kStartTimestamp + (ScreenshareLayers::kMaxFrameIntervalMs * 90);
+
+  // Sanity check, repayment time should exceed kMaxFrameIntervalMs.
+  ASSERT_GT(kStartTimestamp + 90 * (kLargeFrameSizeBytes * 8) / kLowBitrateKbps,
+            kStartTimestamp + (ScreenshareLayers::kMaxFrameIntervalMs * 90));
+
+  EXPECT_EQ(-1, layers_->EncodeFlags(kTwoSecondsLater));
+  // More than two seconds has passed since last frame, one should be emitted
+  // even if bitrate target is then exceeded.
+  EXPECT_EQ(ScreenshareLayers::kTl0Flags,
+            layers_->EncodeFlags(kTwoSecondsLater + 90));
+}
+
 TEST_F(ScreenshareLayerTest, UpdatesHistograms) {
   ConfigureBitrates();
   vpx_codec_enc_cfg_t cfg;
   cfg.rc_max_quantizer = kDefaultQp;
   bool trigger_drop = false;
   bool dropped_frame = false;
   bool overshoot = false;
   const int kTl0Qp = 35;
   const int kTl1Qp = 30;
   for (int64_t timestamp = 0;
@@ skipping 66 matching lines @@
             test::LastHistogramSample("WebRTC.Video.Screenshare.Layer1.Qp"));
   EXPECT_EQ(kDefaultTl0BitrateKbps,
             test::LastHistogramSample(
                 "WebRTC.Video.Screenshare.Layer0.TargetBitrate"));
   EXPECT_EQ(kDefaultTl1BitrateKbps,
             test::LastHistogramSample(
                 "WebRTC.Video.Screenshare.Layer1.TargetBitrate"));
 }
 
 }  // namespace webrtc