Dont request keyframes if the stream is inactive or if we are currently receiving a keyframe.

webrtc/modules/video_coding/video_packet_buffer_unittest.cc

 /*
  *  Copyright (c) 2016 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 40 matching lines @@
 
   bool Insert(uint16_t seq_num,           // packet sequence number
               IsKeyFrame keyframe,        // is keyframe
               IsFirst first,              // is first packet of frame
               IsLast last,                // is last packet of frame
               int data_size = 0,          // size of data
               uint8_t* data = nullptr) {  // data pointer
     VCMPacket packet;
     packet.codec = kVideoCodecGeneric;
     packet.seqNum = seq_num;
-    packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta;
+    packet.frameType =
+        keyframe == kKeyFrame ? kVideoFrameKey : kVideoFrameDelta;
     packet.is_first_packet_in_frame = first == kFirst;
     packet.markerBit = last == kLast;
     packet.sizeBytes = data_size;
     packet.dataPtr = data;
 
     return packet_buffer_->InsertPacket(&packet);
   }
 
   void CheckFrame(uint16_t first_seq_num) {
     auto frame_it = frames_from_callback_.find(first_seq_num);
     ASSERT_FALSE(frame_it == frames_from_callback_.end())
         << "Could not find frame with first sequence number " << first_seq_num
         << ".";
   }
 
   const int kStartSize = 16;
   const int kMaxSize = 64;
 
   Random rand_;
-  std::unique_ptr<Clock> clock_;
+  std::unique_ptr<SimulatedClock> clock_;
   rtc::scoped_refptr<PacketBuffer> packet_buffer_;
   std::map<uint16_t, std::unique_ptr<RtpFrameObject>> frames_from_callback_;
 };
 
 TEST_F(TestPacketBuffer, InsertOnePacket) {
   const uint16_t seq_num = Rand();
   EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
 }
 
 TEST_F(TestPacketBuffer, InsertMultiplePackets) {
@@ skipping 378 matching lines @@
 
 TEST_F(TestPacketBuffer, ContinuousSeqNumDoubleMarkerBit) {
   Insert(2, kKeyFrame, kNotFirst, kNotLast);
   Insert(1, kKeyFrame, kFirst, kLast);
   frames_from_callback_.clear();
   Insert(3, kKeyFrame, kNotFirst, kLast);
 
   EXPECT_EQ(0UL, frames_from_callback_.size());
 }
 
+TEST_F(TestPacketBuffer, PacketTimestamps) {
+  rtc::Optional<int64_t> packet_ms;
+  rtc::Optional<int64_t> packet_keyframe_ms;
+
+  packet_ms = packet_buffer_->LastReceivedPacketMs();
+  packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
+  EXPECT_FALSE(packet_ms);
+  EXPECT_FALSE(packet_keyframe_ms);
+
+  int64_t keyframe_ms = clock_->TimeInMilliseconds();
+  EXPECT_TRUE(Insert(100, kKeyFrame, kFirst, kLast));
+  packet_ms = packet_buffer_->LastReceivedPacketMs();
+  packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
+  EXPECT_TRUE(packet_ms);
+  EXPECT_TRUE(packet_keyframe_ms);
+  EXPECT_EQ(keyframe_ms, *packet_ms);
+  EXPECT_EQ(keyframe_ms, *packet_keyframe_ms);
+
+  clock_->AdvanceTimeMilliseconds(100);
+  int64_t delta_ms = clock_->TimeInMilliseconds();
+  EXPECT_TRUE(Insert(101, kDeltaFrame, kFirst, kLast));
+  packet_ms = packet_buffer_->LastReceivedPacketMs();
+  packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
+  EXPECT_TRUE(packet_ms);
+  EXPECT_TRUE(packet_keyframe_ms);
+  EXPECT_EQ(delta_ms, *packet_ms);
+  EXPECT_EQ(keyframe_ms, *packet_keyframe_ms);
+
+  packet_buffer_->Clear();
+  packet_ms = packet_buffer_->LastReceivedPacketMs();
+  packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
+  EXPECT_FALSE(packet_ms);
+  EXPECT_FALSE(packet_keyframe_ms);
+}
+
 }  // namespace video_coding
 }  // namespace webrtc