Frame continuity is now tested as soon as a frame is inserted into the FrameBuffer.

webrtc/modules/video_coding/frame_buffer2_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 111 matching lines @@
 
     std::unique_ptr<FrameObjectFake> frame(new FrameObjectFake());
     frame->picture_id = picture_id;
     frame->spatial_layer = spatial_layer;
     frame->timestamp = ts_ms * 90;
     frame->num_references = references.size();
     frame->inter_layer_predicted = inter_layer_predicted;
     for (size_t r = 0; r < references.size(); ++r)
       frame->references[r] = references[r];
 
-    buffer_.InsertFrame(std::move(frame));
+    last_continuous_frames_.push_back(buffer_.InsertFrame(std::move(frame)));
   }
 
   void ExtractFrame(int64_t max_wait_time = 0) {
     crit_.Enter();
     if (max_wait_time == 0) {
       std::unique_ptr<FrameObject> frame;
       FrameBuffer::ReturnReason res = buffer_.NextFrame(0, &frame);
       if (res != FrameBuffer::ReturnReason::kStopped)
         frames_.emplace_back(std::move(frame));
       crit_.Leave();
     } else {
       max_wait_time_ = max_wait_time;
       trigger_extract_event_.Set();
       crit_.Leave();
       // Make sure |crit_| is aquired by |extract_thread_| before returning.
       crit_acquired_event_.Wait(rtc::Event::kForever);
     }
   }
 
   void CheckFrame(size_t index, int picture_id, int spatial_layer) {
     rtc::CritScope lock(&crit_);
     ASSERT_LT(index, frames_.size());
     ASSERT_TRUE(frames_[index]);
     ASSERT_EQ(picture_id, frames_[index]->picture_id);
     ASSERT_EQ(spatial_layer, frames_[index]->spatial_layer);
   }
 
+  void CheckLastContinuousFrame(size_t index, int picture_id) {
+    rtc::CritScope lock(&crit_);
+    ASSERT_LT(index, last_continuous_frames_.size());
+    ASSERT_EQ(picture_id, last_continuous_frames_[index]);
+  }
+
   void CheckNoFrame(size_t index) {
     rtc::CritScope lock(&crit_);
     ASSERT_LT(index, frames_.size());
     ASSERT_FALSE(frames_[index]);
   }
 
   static bool ExtractLoop(void* obj) {
     TestFrameBuffer2* tfb = static_cast<TestFrameBuffer2*>(obj);
     while (true) {
       tfb->trigger_extract_event_.Wait(rtc::Event::kForever);
@@ skipping 12 matching lines @@
     }
   }
 
   uint32_t Rand() { return rand_.Rand<uint32_t>(); }
 
   SimulatedClock clock_;
   VCMTimingFake timing_;
   ::testing::NiceMock<VCMJitterEstimatorMock> jitter_estimator_;
   FrameBuffer buffer_;
   std::vector<std::unique_ptr<FrameObject>> frames_;
+  std::vector<int> last_continuous_frames_;
   Random rand_;
 
   int64_t max_wait_time_;
   bool tear_down_;
   rtc::PlatformThread extract_thread_;
   rtc::Event trigger_extract_event_;
   rtc::Event crit_acquired_event_;
   rtc::CriticalSection crit_;
 };
 
@@ skipping 149 matching lines @@
   EXPECT_CALL(jitter_estimator_, GetJitterEstimate(1.0));
   InsertFrame(pid, 0, ts, false);
   ExtractFrame();
 
   buffer_.SetProtectionMode(kProtectionNackFEC);
   EXPECT_CALL(jitter_estimator_, GetJitterEstimate(0.0));
   InsertFrame(pid + 1, 0, ts, false);
   ExtractFrame();
 }
 
+TEST_F(TestFrameBuffer2, LastContinuousFrameSingleStream) {

[danilchap, 2016/09/12 12:20:14]

It helps when test name describes both scenario and expected result.
If you have several scenarios (look like you do) - make several smaller tests.

+  uint16_t pid = Rand();
+  uint32_t ts = Rand();
+
+  InsertFrame(pid, 0, ts, false);
+  InsertFrame(pid + 2, 0, ts, false, pid + 1);
+  InsertFrame(pid + 1, 0, ts, false, pid);
+  InsertFrame(pid + 4, 0, ts, false, pid + 3);
+  InsertFrame(pid + 5, 0, ts, false);
+
+  CheckLastContinuousFrame(0, pid);

[danilchap, 2016/09/12 12:20:14]

May be make InsertFrame return the result of buffer_.InsertFrame and merge
InsertFrame & CheckLastContinuousFrame calls. Less fixture state should make
more clear what this 5 calls refer to:
EXPECT_EQ(static_cast<int>(pid), InsertFrame(pid, 0, ts, false));
EXPECT_EQ(static_cast<int>(pid), InsertFrame(pid + 2, 0, ts, false, pid + 1);
...

[philipel, 2016/09/16 14:01:20]

Done.

+  CheckLastContinuousFrame(1, pid);
+  CheckLastContinuousFrame(2, pid + 2);
+  CheckLastContinuousFrame(3, pid + 2);
+  CheckLastContinuousFrame(4, pid + 5);
+}

[danilchap, 2016/09/12 12:20:14]

May be add a test case where InsertFrame return -1

[philipel, 2016/09/16 14:01:20]

Done.

+
 }  // namespace video_coding
 }  // namespace webrtc