Experiment for the nack module.

webrtc/modules/video_coding/jitter_buffer_unittest.cc

 /*
  *  Copyright (c) 2011 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.
  */
 
-#include <string.h>
+#include <string>
 
 #include <list>
 #include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "webrtc/modules/video_coding/frame_buffer.h"
 #include "webrtc/modules/video_coding/jitter_buffer.h"
 #include "webrtc/modules/video_coding/media_opt_util.h"
 #include "webrtc/modules/video_coding/packet.h"
 #include "webrtc/modules/video_coding/test/stream_generator.h"
 #include "webrtc/modules/video_coding/test/test_util.h"
 #include "webrtc/system_wrappers/include/clock.h"
+#include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/metrics.h"
+#include "webrtc/test/field_trial.h"
 #include "webrtc/test/histogram.h"
 
 namespace webrtc {
 
 namespace {
 const uint32_t kProcessIntervalSec = 60;
 }  // namespace
 
 class Vp9SsMapTest : public ::testing::Test {
  protected:
@@ skipping 143 matching lines @@
 
   packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = 3;
   EXPECT_TRUE(map_.UpdatePacket(&packet_));
   EXPECT_EQ(2, packet_.codecSpecificHeader.codecHeader.VP9.temporal_idx);
   EXPECT_FALSE(packet_.codecSpecificHeader.codecHeader.VP9.temporal_up_switch);
   EXPECT_EQ(2U, packet_.codecSpecificHeader.codecHeader.VP9.num_ref_pics);
   EXPECT_EQ(1, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[0]);
   EXPECT_EQ(2, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[1]);
 }
 
-class TestBasicJitterBuffer : public ::testing::Test {
+class ProcessThreadMock : public ProcessThread {
+ public:
+  MOCK_METHOD0(Start, void());
+  MOCK_METHOD0(Stop, void());
+  MOCK_METHOD1(WakeUp, void(Module* module));
+  MOCK_METHOD1(RegisterModule, void(Module* module));
+  MOCK_METHOD1(DeRegisterModule, void(Module* module));
+  void PostTask(rtc::scoped_ptr<ProcessTask> task) {}
+};
+
+class TestBasicJitterBuffer : public ::testing::TestWithParam<std::string>,
+                              public NackSender,
+                              public KeyFrameRequestSender {
+ public:
+  void SendNack(const std::vector<uint16_t>& sequence_numbers) override {
+    nack_sent_.insert(nack_sent_.end(), sequence_numbers.begin(),
+                      sequence_numbers.end());
+  }
+
+  void RequestKeyFrame() override { ++keyframe_requests_; }
+
+  ::testing::NiceMock<ProcessThreadMock> process_thread_mock_;
+  std::vector<uint16_t> nack_sent_;
+  int keyframe_requests_;
+
  protected:
+  TestBasicJitterBuffer() : scoped_field_trial_(GetParam()) {}
   virtual void SetUp() {
     clock_.reset(new SimulatedClock(0));
     jitter_buffer_.reset(new VCMJitterBuffer(
         clock_.get(),
-        std::unique_ptr<EventWrapper>(event_factory_.CreateEvent())));
+        std::unique_ptr<EventWrapper>(event_factory_.CreateEvent()),
+        &process_thread_mock_, this, this));
     jitter_buffer_->Start();
     seq_num_ = 1234;
     timestamp_ = 0;
     size_ = 1400;
     // Data vector -  0, 0, 0x80, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0x80, 3....
     data_[0] = 0;
     data_[1] = 0;
     data_[2] = 0x80;
     int count = 3;
     for (unsigned int i = 3; i < sizeof(data_) - 3; ++i) {
@@ skipping 66 matching lines @@
   }
 
   uint16_t seq_num_;
   uint32_t timestamp_;
   int size_;
   uint8_t data_[1500];
   std::unique_ptr<VCMPacket> packet_;
   std::unique_ptr<SimulatedClock> clock_;
   NullEventFactory event_factory_;
   std::unique_ptr<VCMJitterBuffer> jitter_buffer_;
+  test::ScopedFieldTrials scoped_field_trial_;
 };
 
-class TestRunningJitterBuffer : public ::testing::Test {
+INSTANTIATE_TEST_CASE_P(
+    TestWithNackModule,
+    TestBasicJitterBuffer,
+    ::testing::Values("WebRTC-NewVideoJitterBuffer/Enabled/",
+                      "WebRTC-NewVideoJitterBuffer/Disabled/"));
+
+class TestRunningJitterBuffer : public ::testing::TestWithParam<std::string>,
+                                public NackSender,
+                                public KeyFrameRequestSender {
+ public:
+  void SendNack(const std::vector<uint16_t>& sequence_numbers) {
+    nack_sent_.insert(nack_sent_.end(), sequence_numbers.begin(),
+                      sequence_numbers.end());
+  }
+
+  void RequestKeyFrame() { ++keyframe_requests_; }
+
+  ::testing::NiceMock<ProcessThreadMock> process_thread_mock_;
+  std::vector<uint16_t> nack_sent_;
+  int keyframe_requests_;
+
  protected:
   enum { kDataBufferSize = 10 };
 
   virtual void SetUp() {
     clock_.reset(new SimulatedClock(0));
     max_nack_list_size_ = 150;
     oldest_packet_to_nack_ = 250;
     jitter_buffer_ = new VCMJitterBuffer(
         clock_.get(),
-        std::unique_ptr<EventWrapper>(event_factory_.CreateEvent()));
+        std::unique_ptr<EventWrapper>(event_factory_.CreateEvent()),
+        &process_thread_mock_, this, this);
     stream_generator_ = new StreamGenerator(0, clock_->TimeInMilliseconds());
     jitter_buffer_->Start();
     jitter_buffer_->SetNackSettings(max_nack_list_size_, oldest_packet_to_nack_,
                                     0);
     memset(data_buffer_, 0, kDataBufferSize);
   }
 
   virtual void TearDown() {
     jitter_buffer_->Stop();
     delete stream_generator_;
@@ skipping 79 matching lines @@
   StreamGenerator* stream_generator_;
   std::unique_ptr<SimulatedClock> clock_;
   NullEventFactory event_factory_;
   size_t max_nack_list_size_;
   int oldest_packet_to_nack_;
   uint8_t data_buffer_[kDataBufferSize];
 };
 
 class TestJitterBufferNack : public TestRunningJitterBuffer {
  protected:
+  TestJitterBufferNack() : scoped_field_trial_(GetParam()) {}
   virtual void SetUp() {
     TestRunningJitterBuffer::SetUp();
     jitter_buffer_->SetNackMode(kNack, -1, -1);
   }
 
   virtual void TearDown() { TestRunningJitterBuffer::TearDown(); }
+
+  test::ScopedFieldTrials scoped_field_trial_;
 };
 
-TEST_F(TestBasicJitterBuffer, StopRunning) {
+INSTANTIATE_TEST_CASE_P(
+    TestWithNackModule,
+    TestJitterBufferNack,
+    ::testing::Values("WebRTC-NewVideoJitterBuffer/Enabled/",
+                      "WebRTC-NewVideoJitterBuffer/Disabled/"));
+
+TEST_P(TestBasicJitterBuffer, StopRunning) {
   jitter_buffer_->Stop();
   EXPECT_TRUE(NULL == DecodeCompleteFrame());
   EXPECT_TRUE(NULL == DecodeIncompleteFrame());
   jitter_buffer_->Start();
   // Allow selective errors.
   jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
 
   // No packets inserted.
   EXPECT_TRUE(NULL == DecodeCompleteFrame());
   EXPECT_TRUE(NULL == DecodeIncompleteFrame());
 
   // Allow decoding with errors.
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
 
   // No packets inserted.
   EXPECT_TRUE(NULL == DecodeCompleteFrame());
   EXPECT_TRUE(NULL == DecodeIncompleteFrame());
 }
 
-TEST_F(TestBasicJitterBuffer, SinglePacketFrame) {
+TEST_P(TestBasicJitterBuffer, SinglePacketFrame) {
   // Always start with a complete key frame when not allowing errors.
   jitter_buffer_->SetDecodeErrorMode(kNoErrors);
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->timestamp += 123 * 90;
 
   // Insert the packet to the jitter buffer and get a frame.
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, VerifyHistogramStats) {
+TEST_P(TestBasicJitterBuffer, VerifyHistogramStats) {
   test::ClearHistograms();
   // Always start with a complete key frame when not allowing errors.
   jitter_buffer_->SetDecodeErrorMode(kNoErrors);
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->timestamp += 123 * 90;
 
   // Insert single packet frame to the jitter buffer and get a frame.
   bool retransmitted = false;
@@ skipping 21 matching lines @@
   EXPECT_EQ(
       1, test::NumHistogramSamples("WebRTC.Video.DiscardedPacketsInPercent"));
   EXPECT_EQ(
       1, test::NumHistogramSamples("WebRTC.Video.DuplicatedPacketsInPercent"));
   EXPECT_EQ(1, test::NumHistogramSamples(
                    "WebRTC.Video.CompleteFramesReceivedPerSecond"));
   EXPECT_EQ(
       1, test::NumHistogramSamples("WebRTC.Video.KeyFramesReceivedInPermille"));
 }
 
-TEST_F(TestBasicJitterBuffer, DualPacketFrame) {
+TEST_P(TestBasicJitterBuffer, DualPacketFrame) {
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   // Should not be complete.
   EXPECT_TRUE(frame_out == NULL);
 
   ++seq_num_;
   packet_->isFirstPacket = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 2 * size_, false);
 
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, 100PacketKeyFrame) {
+TEST_P(TestBasicJitterBuffer, 100PacketKeyFrame) {
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
@@ skipping 22 matching lines @@
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
 
   CheckOutFrame(frame_out, 100 * size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) {
+TEST_P(TestBasicJitterBuffer, 100PacketDeltaFrame) {
   // Always start with a complete key frame.
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
 
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_FALSE(frame_out == NULL);
@@ skipping 35 matching lines @@
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
 
   CheckOutFrame(frame_out, 100 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
+TEST_P(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
   // Insert the "first" packet last.
   seq_num_ += 100;
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
@@ skipping 26 matching lines @@
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
 
   CheckOutFrame(frame_out, 100 * size_, false);
 
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
+TEST_P(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
@@ skipping 39 matching lines @@
   CheckOutFrame(frame_out, 2 * size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 2 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, TestReorderingWithPadding) {
+TEST_P(TestBasicJitterBuffer, TestReorderingWithPadding) {
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
 
   // Send in an initial good packet/frame (Frame A) to start things off.
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_TRUE(frame_out != NULL);
@@ skipping 36 matching lines @@
   empty_packet.seqNum += 1;
   EXPECT_EQ(kOldPacket,
             jitter_buffer_->InsertPacket(empty_packet, &retransmitted));
 
   // But now Frame C should be ready!
   frame_out = DecodeCompleteFrame();
   EXPECT_TRUE(frame_out != NULL);
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, DuplicatePackets) {
+TEST_P(TestBasicJitterBuffer, DuplicatePackets) {
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   EXPECT_EQ(0, jitter_buffer_->num_packets());
   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
@@ skipping 22 matching lines @@
   frame_out = DecodeCompleteFrame();
   ASSERT_TRUE(frame_out != NULL);
   CheckOutFrame(frame_out, 2 * size_, false);
 
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   EXPECT_EQ(3, jitter_buffer_->num_packets());
   EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, DuplicatePreviousDeltaFramePacket) {
+TEST_P(TestBasicJitterBuffer, DuplicatePreviousDeltaFramePacket) {
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   jitter_buffer_->SetDecodeErrorMode(kNoErrors);
   EXPECT_EQ(0, jitter_buffer_->num_packets());
   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
 
   bool retransmitted = false;
@@ skipping 31 matching lines @@
   // Should be able to decode 3 delta frames, key frame already decoded.
   for (size_t i = 0; i < 3; ++i) {
     frame_out = DecodeCompleteFrame();
     ASSERT_TRUE(frame_out != NULL);
     CheckOutFrame(frame_out, size_, false);
     EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
     jitter_buffer_->ReleaseFrame(frame_out);
   }
 }
 
-TEST_F(TestBasicJitterBuffer, TestSkipForwardVp9) {
+TEST_P(TestBasicJitterBuffer, TestSkipForwardVp9) {
   // Verify that JB skips forward to next base layer frame.
   //  -------------------------------------------------
   // | 65485 | 65486 | 65487 | 65488 | 65489 | ...
   // | pid:5 | pid:6 | pid:7 | pid:8 | pid:9 | ...
   // | tid:0 | tid:2 | tid:1 | tid:2 | tid:0 | ...
   // |  ss   |   x   |   x   |   x   |       |
   //  -------------------------------------------------
   // |<----------tl0idx:200--------->|<---tl0idx:201---
 
   bool re = false;
@@ skipping 32 matching lines @@
   EXPECT_EQ(1000U, frame_out->TimeStamp());
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   frame_out = DecodeCompleteFrame();
   EXPECT_EQ(13000U, frame_out->TimeStamp());
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) {
+TEST_P(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) {
   // Verify that frames are updated with SS data when SS packet is reordered.
   //  --------------------------------
   // | 65486 | 65487 | 65485 |...
   // | pid:6 | pid:7 | pid:5 |...
   // | tid:2 | tid:1 | tid:0 |...
   // |       |       |  ss   |
   //  --------------------------------
   // |<--------tl0idx:200--------->|
 
   bool re = false;
@@ skipping 53 matching lines @@
   jitter_buffer_->ReleaseFrame(frame_out);
 
   frame_out = DecodeCompleteFrame();
   EXPECT_EQ(9000U, frame_out->TimeStamp());
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   EXPECT_EQ(1, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
   EXPECT_TRUE(frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_2Tl2SLayers) {
+TEST_P(TestBasicJitterBuffer, ReorderedVp9SsData_2Tl2SLayers) {
   // Verify that frames are updated with SS data when SS packet is reordered.
   //  -----------------------------------------
   // | 65486  | 65487  | 65485  | 65484  |...
   // | pid:6  | pid:6  | pid:5  | pid:5  |...
   // | tid:1  | tid:1  | tid:0  | tid:0  |...
   // | sid:0  | sid:1  | sid:1  | sid:0  |...
   // | t:6000 | t:6000 | t:3000 | t:3000 |
   // |        |        |        |  ss    |
   //  -----------------------------------------
   // |<-----------tl0idx:200------------>|
@@ skipping 63 matching lines @@
   jitter_buffer_->ReleaseFrame(frame_out);
 
   frame_out = DecodeCompleteFrame();
   EXPECT_EQ(6000U, frame_out->TimeStamp());
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   EXPECT_EQ(1, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
   EXPECT_TRUE(frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, H264InsertStartCode) {
+TEST_P(TestBasicJitterBuffer, H264InsertStartCode) {
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->insertStartCode = true;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
@@ skipping 11 matching lines @@
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, size_ * 2 + 4 * 2, true);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 // Test threshold conditions of decodable state.
-TEST_F(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsThresholdCheck) {
+TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsThresholdCheck) {
   jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
   // Always start with a key frame. Use 10 packets to test Decodable State
   // boundaries.
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
@@ skipping 65 matching lines @@
   CheckOutFrame(frame_out, 9 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   packet_->markerBit = true;
   packet_->seqNum++;
   EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 }
 
 // Make sure first packet is present before a frame can be decoded.
-TEST_F(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsIncompleteKey) {
+TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsIncompleteKey) {
   jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
   // Always start with a key frame.
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
@@ skipping 43 matching lines @@
   packet_->seqNum++;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 6 * size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 // Make sure first packet is present before a frame can be decoded.
-TEST_F(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsMissingFirstPacket) {
+TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsMissingFirstPacket) {
   jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
   // Always start with a key frame.
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
@@ skipping 41 matching lines @@
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   frame_out = DecodeIncompleteFrame();
   CheckOutFrame(frame_out, 7 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, DiscontinuousStreamWhenDecodingWithErrors) {
+TEST_P(TestBasicJitterBuffer, DiscontinuousStreamWhenDecodingWithErrors) {
   // Will use one packet per frame.
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
@@ skipping 22 matching lines @@
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &next_timestamp));
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&next_timestamp));
   EXPECT_EQ(packet_->timestamp - 33 * 90, next_timestamp);
 }
 
-TEST_F(TestBasicJitterBuffer, PacketLoss) {
+TEST_P(TestBasicJitterBuffer, PacketLoss) {
   // Verify missing packets statistics and not decodable packets statistics.
   // Insert 10 frames consisting of 4 packets and remove one from all of them.
   // The last packet is an empty (non-media) packet.
 
   // Select a start seqNum which triggers a difficult wrap situation
   // The JB will only output (incomplete)frames if the next one has started
   // to arrive. Start by inserting one frame (key).
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   seq_num_ = 0xffff - 4;
   seq_num_++;
@@ skipping 80 matching lines @@
   EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   EXPECT_EQ(3, jitter_buffer_->num_discarded_packets());
 
   jitter_buffer_->Flush();
 
   // This statistic shouldn't be reset by a flush.
   EXPECT_EQ(3, jitter_buffer_->num_discarded_packets());
 }
 
-TEST_F(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
+TEST_P(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
   seq_num_ = 0xfff0;
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
@@ skipping 28 matching lines @@
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
 
   CheckOutFrame(frame_out, 100 * size_, false);
 
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
+TEST_P(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
   // Insert "first" packet last seqnum.
   seq_num_ = 10;
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
@@ skipping 28 matching lines @@
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 100 * size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, TestInsertOldFrame) {
+TEST_P(TestBasicJitterBuffer, TestInsertOldFrame) {
   //   -------      -------
   //  |   2   |    |   1   |
   //   -------      -------
   //  t = 3000     t = 2000
   seq_num_ = 2;
   timestamp_ = 3000;
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->timestamp = timestamp_;
@@ skipping 13 matching lines @@
   timestamp_ = 2000;
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 }
 
-TEST_F(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
+TEST_P(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
   //   -------      -------
   //  |   2   |    |   1   |
   //   -------      -------
   //  t = 3000     t = 0xffffff00
 
   seq_num_ = 2;
   timestamp_ = 3000;
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
@@ skipping 18 matching lines @@
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   // This timestamp is old.
   EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 }
 
-TEST_F(TestBasicJitterBuffer, TimestampWrap) {
+TEST_P(TestBasicJitterBuffer, TimestampWrap) {
   //  ---------------     ---------------
   // |   1   |   2   |   |   3   |   4   |
   //  ---------------     ---------------
   //  t = 0xffffff00        t = 33*90
 
   timestamp_ = 0xffffff00;
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
@@ skipping 39 matching lines @@
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 2 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
+TEST_P(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
   //   -------          -------
   //  |   1   |        |   2   |
   //   -------          -------
   // t = 0xffffff00    t = 2700
 
   timestamp_ = 0xffffff00;
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->timestamp = timestamp_;
@@ skipping 21 matching lines @@
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   VCMEncodedFrame* frame_out2 = DecodeCompleteFrame();
   EXPECT_EQ(2700u, frame_out2->TimeStamp());
   CheckOutFrame(frame_out2, size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out2->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out2);
 }
 
-TEST_F(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
+TEST_P(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
   //   -------          -------
   //  |   2   |        |   1   |
   //   -------          -------
   //  t = 2700        t = 0xffffff00
 
   seq_num_ = 2;
   timestamp_ = 2700;
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
@@ skipping 22 matching lines @@
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   VCMEncodedFrame* frame_out2 = DecodeCompleteFrame();
   EXPECT_EQ(2700u, frame_out2->TimeStamp());
   CheckOutFrame(frame_out2, size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out2->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out2);
 }
 
-TEST_F(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
+TEST_P(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
   int loop = 0;
   bool firstPacket = true;
   bool retransmitted = false;
   // Insert kMaxPacketsInJitterBuffer into frame.
   do {
     seq_num_++;
     packet_->isFirstPacket = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
@@ skipping 14 matching lines @@
   seq_num_++;
   packet_->isFirstPacket = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   // Insert the packet -> frame recycled.
   EXPECT_EQ(kSizeError, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_TRUE(NULL == DecodeCompleteFrame());
 }
 
-TEST_F(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
+TEST_P(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
   // TEST fill JB with more than max number of frame (50 delta frames +
   // 51 key frames) with wrap in seq_num_
   //
   //  --------------------------------------------------------------
   // | 65485 | 65486 | 65487 | .... | 65535 | 0 | 1 | 2 | .....| 50 |
   //  --------------------------------------------------------------
   // |<-----------delta frames------------->|<------key frames----->|
 
   // Make sure the jitter doesn't request a keyframe after too much non-
   // decodable frames.
@@ skipping 39 matching lines @@
   EXPECT_EQ(kFlushIndicator,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_EQ(first_key_frame_timestamp, frame_out->TimeStamp());
   CheckOutFrame(frame_out, size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, EmptyLastFrame) {
+TEST_P(TestBasicJitterBuffer, EmptyLastFrame) {
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   seq_num_ = 3;
   // Insert one empty packet per frame, should never return the last timestamp
   // inserted. Only return empty frames in the presence of subsequent frames.
   int maxSize = 1000;
   bool retransmitted = false;
   for (int i = 0; i < maxSize + 10; i++) {
     timestamp_ += 33 * 90;
     seq_num_++;
     packet_->isFirstPacket = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
     packet_->timestamp = timestamp_;
     packet_->frameType = kEmptyFrame;
 
     EXPECT_EQ(kNoError, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     VCMEncodedFrame* testFrame = DecodeIncompleteFrame();
     // Timestamp should never be the last TS inserted.
     if (testFrame != NULL) {
       EXPECT_TRUE(testFrame->TimeStamp() < timestamp_);
       jitter_buffer_->ReleaseFrame(testFrame);
     }
   }
 }
 
-TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
+TEST_P(TestBasicJitterBuffer, H264IncompleteNalu) {
   jitter_buffer_->SetNackMode(kNoNack, -1, -1);
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   ++seq_num_;
   timestamp_ += 33 * 90;
   int insertedLength = 0;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->completeNALU = kNaluStart;
@@ skipping 160 matching lines @@
   emptypacket.markerBit = true;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(emptypacket, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
   // Only last NALU is complete
   CheckOutFrame(frame_out, packet_->sizeBytes, false);
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
-TEST_F(TestBasicJitterBuffer, NextFrameWhenIncomplete) {
+TEST_P(TestBasicJitterBuffer, NextFrameWhenIncomplete) {
   // Test that a we cannot get incomplete frames from the JB if we haven't
   // received the marker bit, unless we have received a packet from a later
   // timestamp.
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   // Start with a complete key frame - insert and decode.
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   bool retransmitted = false;
 
@@ skipping 156 matching lines @@
   stream_generator_->GenerateFrame(kVideoFrameDelta, 2, 0,
                                    clock_->TimeInMilliseconds());
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(1));
   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(1));
   EXPECT_FALSE(DecodeCompleteFrame());
   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
   EXPECT_TRUE(DecodeCompleteFrame());
   EXPECT_TRUE(DecodeCompleteFrame());
 }
 
-TEST_F(TestJitterBufferNack, EmptyPackets) {
+TEST_P(TestJitterBufferNack, EmptyPackets) {
   // Make sure empty packets doesn't clog the jitter buffer.
   jitter_buffer_->SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
   EXPECT_GE(InsertFrames(kMaxNumberOfFrames, kEmptyFrame), kNoError);
   InsertFrame(kVideoFrameKey);
   EXPECT_TRUE(DecodeCompleteFrame());
 }
 
-TEST_F(TestJitterBufferNack, NackTooOldPackets) {
+TEST_P(TestJitterBufferNack, NackTooOldPackets) {
   // Insert a key frame and decode it.
   EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
   EXPECT_TRUE(DecodeCompleteFrame());
 
   // Drop one frame and insert |kNackHistoryLength| to trigger NACKing a too
   // old packet.
   DropFrame(1);
   // Insert a frame which should trigger a recycle until the next key frame.
   EXPECT_EQ(kFlushIndicator,
             InsertFrames(oldest_packet_to_nack_ + 1, kVideoFrameDelta));
@@ skipping 12 matching lines @@
   EXPECT_FALSE(DecodeIncompleteFrame());
 
   // The next complete continuous frame isn't a key frame, but we're waiting
   // for one.
   EXPECT_FALSE(DecodeCompleteFrame());
   EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
   // Skipping ahead to the key frame.
   EXPECT_TRUE(DecodeCompleteFrame());
 }
 
-TEST_F(TestJitterBufferNack, NackLargeJitterBuffer) {
+TEST_P(TestJitterBufferNack, NackLargeJitterBuffer) {
   // Insert a key frame and decode it.
   EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
   EXPECT_TRUE(DecodeCompleteFrame());
 
   // Insert a frame which should trigger a recycle until the next key frame.
   EXPECT_GE(InsertFrames(oldest_packet_to_nack_, kVideoFrameDelta), kNoError);
 
   bool request_key_frame = false;
   std::vector<uint16_t> nack_list =
       jitter_buffer_->GetNackList(&request_key_frame);
   // Verify that the jitter buffer does not request a key frame.
   EXPECT_FALSE(request_key_frame);
   // Verify that no packets are NACKed.
   EXPECT_EQ(0u, nack_list.size());
   // Verify that we can decode the next frame.
   EXPECT_TRUE(DecodeCompleteFrame());
 }
 
-TEST_F(TestJitterBufferNack, NackListFull) {
+TEST_P(TestJitterBufferNack, NackListFull) {
   // Insert a key frame and decode it.
   EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
   EXPECT_TRUE(DecodeCompleteFrame());
 
   // Generate and drop |kNackHistoryLength| packets to fill the NACK list.
   DropFrame(max_nack_list_size_ + 1);
   // Insert a frame which should trigger a recycle until the next key frame.
   EXPECT_EQ(kFlushIndicator, InsertFrame(kVideoFrameDelta));
   EXPECT_FALSE(DecodeCompleteFrame());
 
@@ skipping 12 matching lines @@
   EXPECT_TRUE(request_key_frame);
   // The next complete continuous frame isn't a key frame, but we're waiting
   // for one.
   EXPECT_FALSE(DecodeCompleteFrame());
   EXPECT_FALSE(DecodeIncompleteFrame());
   EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
   // Skipping ahead to the key frame.
   EXPECT_TRUE(DecodeCompleteFrame());
 }
 
-TEST_F(TestJitterBufferNack, NoNackListReturnedBeforeFirstDecode) {
+TEST_P(TestJitterBufferNack, NoNackListReturnedBeforeFirstDecode) {
   DropFrame(10);
   // Insert a frame and try to generate a NACK list. Shouldn't get one.
   EXPECT_GE(InsertFrame(kVideoFrameDelta), kNoError);
   bool request_key_frame = false;
   std::vector<uint16_t> nack_list =
       jitter_buffer_->GetNackList(&request_key_frame);
   // No list generated, and a key frame request is signaled.
   EXPECT_EQ(0u, nack_list.size());
   EXPECT_TRUE(request_key_frame);
 }
 
-TEST_F(TestJitterBufferNack, NackListBuiltBeforeFirstDecode) {
+TEST_P(TestJitterBufferNack, NackListBuiltBeforeFirstDecode) {
   stream_generator_->Init(0, clock_->TimeInMilliseconds());
   InsertFrame(kVideoFrameKey);
   stream_generator_->GenerateFrame(kVideoFrameDelta, 2, 0,
                                    clock_->TimeInMilliseconds());
   stream_generator_->NextPacket(NULL);  // Drop packet.
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   EXPECT_TRUE(DecodeCompleteFrame());
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
-  EXPECT_EQ(1u, nack_list.size());
+  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled")
+    EXPECT_EQ(1u, nack_sent_.size());
+  else
+    EXPECT_EQ(1u, nack_list.size());
 }
 
-TEST_F(TestJitterBufferNack, VerifyRetransmittedFlag) {
+TEST_P(TestJitterBufferNack, VerifyRetransmittedFlag) {
   stream_generator_->Init(0, clock_->TimeInMilliseconds());
   stream_generator_->GenerateFrame(kVideoFrameKey, 3, 0,
                                    clock_->TimeInMilliseconds());
   VCMPacket packet;
   stream_generator_->PopPacket(&packet, 0);
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(packet, &retransmitted));
   EXPECT_FALSE(retransmitted);
   // Drop second packet.
   stream_generator_->PopPacket(&packet, 1);
   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(packet, &retransmitted));
   EXPECT_FALSE(retransmitted);
   EXPECT_FALSE(DecodeCompleteFrame());
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
-  EXPECT_EQ(1u, nack_list.size());
+  uint16_t seq_num;
+  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
+    EXPECT_EQ(1u, nack_sent_.size());
+    seq_num = nack_sent_[0];
+  } else {
+    EXPECT_EQ(1u, nack_list.size());
+    seq_num = nack_list[0];
+  }
   stream_generator_->PopPacket(&packet, 0);
-  EXPECT_EQ(packet.seqNum, nack_list[0]);
+  EXPECT_EQ(packet.seqNum, seq_num);
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(packet, &retransmitted));
   EXPECT_TRUE(retransmitted);
   EXPECT_TRUE(DecodeCompleteFrame());
 }
 
-TEST_F(TestJitterBufferNack, UseNackToRecoverFirstKeyFrame) {
+TEST_P(TestJitterBufferNack, UseNackToRecoverFirstKeyFrame) {
   stream_generator_->Init(0, clock_->TimeInMilliseconds());
   stream_generator_->GenerateFrame(kVideoFrameKey, 3, 0,
                                    clock_->TimeInMilliseconds());
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   // Drop second packet.
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(1));
   EXPECT_FALSE(DecodeCompleteFrame());
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
-  EXPECT_EQ(1u, nack_list.size());
+  uint16_t seq_num;
+  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
+    ASSERT_EQ(1u, nack_sent_.size());
+    seq_num = nack_sent_[0];
+  } else {
+    ASSERT_EQ(1u, nack_list.size());
+    seq_num = nack_list[0];
+  }
   VCMPacket packet;
   stream_generator_->GetPacket(&packet, 0);
-  EXPECT_EQ(packet.seqNum, nack_list[0]);
+  EXPECT_EQ(packet.seqNum, seq_num);
 }
 
-TEST_F(TestJitterBufferNack, UseNackToRecoverFirstKeyFrameSecondInQueue) {
+TEST_P(TestJitterBufferNack, UseNackToRecoverFirstKeyFrameSecondInQueue) {
   VCMPacket packet;
   stream_generator_->Init(0, clock_->TimeInMilliseconds());
   // First frame is delta.
   stream_generator_->GenerateFrame(kVideoFrameDelta, 3, 0,
                                    clock_->TimeInMilliseconds());
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   // Drop second packet in frame.
   ASSERT_TRUE(stream_generator_->PopPacket(&packet, 0));
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   // Second frame is key.
   stream_generator_->GenerateFrame(kVideoFrameKey, 3, 0,
                                    clock_->TimeInMilliseconds() + 10);
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   // Drop second packet in frame.
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(1));
   EXPECT_FALSE(DecodeCompleteFrame());
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
-  EXPECT_EQ(1u, nack_list.size());
+  uint16_t seq_num;
+  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
+    ASSERT_EQ(2u, nack_sent_.size());

[stefan-webrtc, 2016/03/10 14:20:40]

Why do we have 2 here and 1 for the old behavior?

[philipel, 2016/03/10 16:39:28]

The old only look at how many packets that are in the nack list currently, while
the nack_sent_ is the total number of nacks sent.

[stefan-webrtc, 2016/03/10 17:06:29]

Acknowledged.

+    seq_num = nack_sent_[1];
+  } else {
+    ASSERT_EQ(1u, nack_list.size());
+    seq_num = nack_list[0];
+  }
   stream_generator_->GetPacket(&packet, 0);
-  EXPECT_EQ(packet.seqNum, nack_list[0]);
+  EXPECT_EQ(packet.seqNum, seq_num);
 }
 
-TEST_F(TestJitterBufferNack, NormalOperation) {
+TEST_P(TestJitterBufferNack, NormalOperation) {
   EXPECT_EQ(kNack, jitter_buffer_->nack_mode());
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
 
   EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
   EXPECT_TRUE(DecodeIncompleteFrame());
 
   //  ----------------------------------------------------------------
   // | 1 | 2 | .. | 8 | 9 | x | 11 | 12 | .. | 19 | x | 21 | .. | 100 |
   //  ----------------------------------------------------------------
   stream_generator_->GenerateFrame(kVideoFrameKey, 100, 0,
                                    clock_->TimeInMilliseconds());
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   EXPECT_EQ(kDecodableSession, InsertPacketAndPop(0));
   // Verify that the frame is incomplete.
   EXPECT_FALSE(DecodeCompleteFrame());
   while (stream_generator_->PacketsRemaining() > 1) {
     if (stream_generator_->NextSequenceNumber() % 10 != 0) {
       EXPECT_EQ(kDecodableSession, InsertPacketAndPop(0));
     } else {
       stream_generator_->NextPacket(NULL);  // Drop packet
     }
   }
   EXPECT_EQ(kDecodableSession, InsertPacketAndPop(0));
   EXPECT_EQ(0, stream_generator_->PacketsRemaining());
   EXPECT_FALSE(DecodeCompleteFrame());
   EXPECT_FALSE(DecodeIncompleteFrame());
   bool request_key_frame = false;
+
+  // Verify the NACK list.
   std::vector<uint16_t> nack_list =
       jitter_buffer_->GetNackList(&request_key_frame);
-  // Verify the NACK list.
   const size_t kExpectedNackSize = 9;
-  ASSERT_EQ(kExpectedNackSize, nack_list.size());
+  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled")
+    ASSERT_EQ(kExpectedNackSize, nack_sent_.size());
+  else
+    ASSERT_EQ(kExpectedNackSize, nack_list.size());
   for (size_t i = 0; i < nack_list.size(); ++i)
     EXPECT_EQ((1 + i) * 10, nack_list[i]);
 }
 
-TEST_F(TestJitterBufferNack, NormalOperationWrap) {
+TEST_P(TestJitterBufferNack, NormalOperationWrap) {
   bool request_key_frame = false;
   //  -------   ------------------------------------------------------------
   // | 65532 | | 65533 | 65534 | 65535 | x | 1 | .. | 9 | x | 11 |.....| 96 |
   //  -------   ------------------------------------------------------------
   stream_generator_->Init(65532, clock_->TimeInMilliseconds());
   InsertFrame(kVideoFrameKey);
   EXPECT_FALSE(request_key_frame);
   EXPECT_TRUE(DecodeCompleteFrame());
   stream_generator_->GenerateFrame(kVideoFrameDelta, 100, 0,
                                    clock_->TimeInMilliseconds());
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   while (stream_generator_->PacketsRemaining() > 1) {
     if (stream_generator_->NextSequenceNumber() % 10 != 0) {
       EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
       EXPECT_FALSE(request_key_frame);
     } else {
       stream_generator_->NextPacket(NULL);  // Drop packet
     }
   }
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   EXPECT_FALSE(request_key_frame);
   EXPECT_EQ(0, stream_generator_->PacketsRemaining());
   EXPECT_FALSE(DecodeCompleteFrame());
   EXPECT_FALSE(DecodeCompleteFrame());
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
   // Verify the NACK list.
   const size_t kExpectedNackSize = 10;
-  ASSERT_EQ(kExpectedNackSize, nack_list.size());
-  for (size_t i = 0; i < nack_list.size(); ++i)
-    EXPECT_EQ(i * 10, nack_list[i]);
+  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
+    ASSERT_EQ(kExpectedNackSize, nack_sent_.size());
+    for (size_t i = 0; i < nack_sent_.size(); ++i)
+      EXPECT_EQ(i * 10, nack_sent_[i]);
+  } else {
+    ASSERT_EQ(kExpectedNackSize, nack_list.size());
+    for (size_t i = 0; i < nack_list.size(); ++i)
+      EXPECT_EQ(i * 10, nack_list[i]);
+  }
 }
 
-TEST_F(TestJitterBufferNack, NormalOperationWrap2) {
+TEST_P(TestJitterBufferNack, NormalOperationWrap2) {
   bool request_key_frame = false;
   //  -----------------------------------
   // | 65532 | 65533 | 65534 | x | 0 | 1 |
   //  -----------------------------------
   stream_generator_->Init(65532, clock_->TimeInMilliseconds());
   InsertFrame(kVideoFrameKey);
   EXPECT_FALSE(request_key_frame);
   EXPECT_TRUE(DecodeCompleteFrame());
   stream_generator_->GenerateFrame(kVideoFrameDelta, 1, 0,
                                    clock_->TimeInMilliseconds());
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   for (int i = 0; i < 5; ++i) {
     if (stream_generator_->NextSequenceNumber() != 65535) {
       EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
       EXPECT_FALSE(request_key_frame);
     } else {
       stream_generator_->NextPacket(NULL);  // Drop packet
     }
     stream_generator_->GenerateFrame(kVideoFrameDelta, 1, 0,
                                      clock_->TimeInMilliseconds());
     clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   }
   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
   EXPECT_FALSE(request_key_frame);
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
   // Verify the NACK list.
-  ASSERT_EQ(1u, nack_list.size());
-  EXPECT_EQ(65535, nack_list[0]);
+  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
+    ASSERT_EQ(1u, nack_sent_.size());
+    EXPECT_EQ(65535, nack_sent_[0]);
+  } else {
+    ASSERT_EQ(1u, nack_list.size());
+    EXPECT_EQ(65535, nack_list[0]);
+  }
 }
 
-TEST_F(TestJitterBufferNack, ResetByFutureKeyFrameDoesntError) {
+TEST_P(TestJitterBufferNack, ResetByFutureKeyFrameDoesntError) {
   stream_generator_->Init(0, clock_->TimeInMilliseconds());
   InsertFrame(kVideoFrameKey);
   EXPECT_TRUE(DecodeCompleteFrame());
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
   EXPECT_EQ(0u, nack_list.size());
 
   // Far-into-the-future video frame, could be caused by resetting the encoder
   // or otherwise restarting. This should not fail when error when the packet is
   // a keyframe, even if all of the nack list needs to be flushed.
   stream_generator_->Init(10000, clock_->TimeInMilliseconds());
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   InsertFrame(kVideoFrameKey);
   EXPECT_TRUE(DecodeCompleteFrame());
   nack_list = jitter_buffer_->GetNackList(&extended);
   EXPECT_EQ(0u, nack_list.size());
 
   // Stream should be decodable from this point.
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   InsertFrame(kVideoFrameDelta);
   EXPECT_TRUE(DecodeCompleteFrame());
   nack_list = jitter_buffer_->GetNackList(&extended);
   EXPECT_EQ(0u, nack_list.size());
 }
 
 }  // namespace webrtc