Reland of Rename RTPVideoHeader.isFirstPacket to .is_first_packet_in_frame.

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.
  */
 
@@ skipping 22 matching lines @@
 
 namespace {
 const uint32_t kProcessIntervalSec = 60;
 }  // namespace
 
 class Vp9SsMapTest : public ::testing::Test {
  protected:
   Vp9SsMapTest() : packet_() {}
 
   virtual void SetUp() {
-    packet_.isFirstPacket = true;
+    packet_.is_first_packet_in_frame = true;
     packet_.dataPtr = data_;
     packet_.sizeBytes = 1400;
     packet_.seqNum = 1234;
     packet_.timestamp = 1;
     packet_.markerBit = true;
     packet_.frameType = kVideoFrameKey;
     packet_.codec = kVideoCodecVP9;
     packet_.video_header.codec = kRtpVideoVp9;
     packet_.video_header.codecHeader.VP9.flexible_mode = false;
     packet_.video_header.codecHeader.VP9.gof_idx = 0;
@@ skipping 417 matching lines @@
 
   // No packets inserted.
   EXPECT_TRUE(NULL == DecodeCompleteFrame());
   EXPECT_TRUE(NULL == DecodeIncompleteFrame());
 }
 
 TEST_F(TestBasicJitterBuffer, SinglePacketFrame) {
   // Always start with a complete key frame when not allowing errors.
   jitter_buffer_->SetDecodeErrorMode(kNoErrors);
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = 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) {
   metrics::Reset();
   // Always start with a complete key frame when not allowing errors.
   jitter_buffer_->SetDecodeErrorMode(kNoErrors);
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->timestamp += 123 * 90;
 
   // Insert single packet frame 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());
@@ skipping 14 matching lines @@
   jitter_buffer_->Stop();
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DiscardedPacketsInPercent"));
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DuplicatedPacketsInPercent"));
   EXPECT_EQ(
       1, metrics::NumSamples("WebRTC.Video.CompleteFramesReceivedPerSecond"));
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille"));
 }
 
 TEST_F(TestBasicJitterBuffer, DualPacketFrame) {
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = 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_->is_first_packet_in_frame = 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) {
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   // Frame should not be complete.
   EXPECT_TRUE(frame_out == NULL);
 
   // Insert 98 frames.
   int loop = 0;
   do {
     seq_num_++;
-    packet_->isFirstPacket = false;
+    packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     loop++;
   } while (loop < 98);
 
   // Insert last packet.
   ++seq_num_;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   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) {
   // Always start with a complete key frame.
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
 
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_FALSE(frame_out == NULL);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   ++seq_num_;
   packet_->seqNum = seq_num_;
   packet_->markerBit = false;
   packet_->frameType = kVideoFrameDelta;
   packet_->timestamp += 33 * 90;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
 
   // Frame should not be complete.
   EXPECT_TRUE(frame_out == NULL);
 
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   // Insert 98 frames.
   int loop = 0;
   do {
     ++seq_num_;
     packet_->seqNum = seq_num_;
 
     // Insert a packet into a frame.
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     loop++;
   } while (loop < 98);
 
   // Insert the last packet.
   ++seq_num_;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   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) {
   // Insert the "first" packet last.
   seq_num_ += 100;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   EXPECT_TRUE(frame_out == NULL);
 
   // Insert 98 packets.
   int loop = 0;
   do {
     seq_num_--;
-    packet_->isFirstPacket = false;
+    packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     loop++;
   } while (loop < 98);
 
   // Insert the last packet.
   seq_num_--;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
 
   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, FrameReordering2Frames2PacketsEach) {
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   EXPECT_TRUE(frame_out == NULL);
 
   seq_num_++;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   // check that we fail to get frame since seqnum is not continuous
   frame_out = DecodeCompleteFrame();
   EXPECT_TRUE(frame_out == NULL);
 
   seq_num_ -= 3;
   timestamp_ -= 33 * 90;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
 
   // It should not be complete.
   EXPECT_TRUE(frame_out == NULL);
 
   seq_num_++;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = 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);
 
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 2 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 TEST_F(TestBasicJitterBuffer, TestReorderingWithPadding) {
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = 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);
   jitter_buffer_->ReleaseFrame(frame_out);
 
@@ skipping 41 matching lines @@
             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) {
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = 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,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   EXPECT_TRUE(frame_out == NULL);
   EXPECT_EQ(1, jitter_buffer_->num_packets());
   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
 
   // Insert a packet into a frame.
   EXPECT_EQ(kDuplicatePacket,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(2, jitter_buffer_->num_packets());
   EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets());
 
   seq_num_++;
   packet_->seqNum = seq_num_;
   packet_->markerBit = true;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   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) {
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = 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;
   // Insert first complete frame.
   EXPECT_EQ(kCompleteSession,
@@ skipping 42 matching lines @@
   // | 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;
   packet_->codec = kVideoCodecVP9;
   packet_->video_header.codec = kRtpVideoVp9;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->video_header.codecHeader.VP9.flexible_mode = false;
   packet_->video_header.codecHeader.VP9.spatial_idx = 0;
   packet_->video_header.codecHeader.VP9.beginning_of_frame = true;
   packet_->video_header.codecHeader.VP9.end_of_frame = true;
   packet_->video_header.codecHeader.VP9.temporal_up_switch = false;
 
   packet_->seqNum = 65485;
   packet_->timestamp = 1000;
   packet_->frameType = kVideoFrameKey;
@@ skipping 32 matching lines @@
   // | 65486 | 65487 | 65485 |...
   // | pid:6 | pid:7 | pid:5 |...
   // | tid:2 | tid:1 | tid:0 |...
   // |       |       |  ss   |
   //  --------------------------------
   // |<--------tl0idx:200--------->|
 
   bool re = false;
   packet_->codec = kVideoCodecVP9;
   packet_->video_header.codec = kRtpVideoVp9;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->video_header.codecHeader.VP9.flexible_mode = false;
   packet_->video_header.codecHeader.VP9.spatial_idx = 0;
   packet_->video_header.codecHeader.VP9.beginning_of_frame = true;
   packet_->video_header.codecHeader.VP9.end_of_frame = true;
   packet_->video_header.codecHeader.VP9.tl0_pic_idx = 200;
 
   packet_->seqNum = 65486;
   packet_->timestamp = 6000;
   packet_->frameType = kVideoFrameDelta;
@@ skipping 60 matching lines @@
   // |<-----------tl0idx:200------------>|
 
   bool re = false;
   packet_->codec = kVideoCodecVP9;
   packet_->video_header.codec = kRtpVideoVp9;
   packet_->video_header.codecHeader.VP9.flexible_mode = false;
   packet_->video_header.codecHeader.VP9.beginning_of_frame = true;
   packet_->video_header.codecHeader.VP9.end_of_frame = true;
   packet_->video_header.codecHeader.VP9.tl0_pic_idx = 200;
 
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = 65486;
   packet_->timestamp = 6000;
   packet_->frameType = kVideoFrameDelta;
   packet_->video_header.codecHeader.VP9.spatial_idx = 0;
   packet_->video_header.codecHeader.VP9.picture_id = 6;
   packet_->video_header.codecHeader.VP9.temporal_idx = 1;
   packet_->video_header.codecHeader.VP9.temporal_up_switch = true;
   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &re));
 
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = 65487;
   packet_->frameType = kVideoFrameDelta;
   packet_->video_header.codecHeader.VP9.spatial_idx = 1;
   packet_->video_header.codecHeader.VP9.picture_id = 6;
   packet_->video_header.codecHeader.VP9.temporal_idx = 1;
   packet_->video_header.codecHeader.VP9.temporal_up_switch = true;
   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
 
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = 65485;
   packet_->timestamp = 3000;
   packet_->frameType = kVideoFrameKey;
   packet_->video_header.codecHeader.VP9.spatial_idx = 1;
   packet_->video_header.codecHeader.VP9.picture_id = 5;
   packet_->video_header.codecHeader.VP9.temporal_idx = 0;
   packet_->video_header.codecHeader.VP9.temporal_up_switch = false;
   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &re));
 
   // Insert first frame with SS data.
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = 65484;
   packet_->frameType = kVideoFrameKey;
   packet_->width = 352;
   packet_->height = 288;
   packet_->video_header.codecHeader.VP9.spatial_idx = 0;
   packet_->video_header.codecHeader.VP9.picture_id = 5;
   packet_->video_header.codecHeader.VP9.temporal_idx = 0;
   packet_->video_header.codecHeader.VP9.temporal_up_switch = false;
   packet_->video_header.codecHeader.VP9.ss_data_available = true;
@@ skipping 12 matching lines @@
   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) {
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = 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));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   // Frame should not be complete.
   EXPECT_TRUE(frame_out == NULL);
 
   seq_num_++;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   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_F(TestBasicJitterBuffer, SpsAndPpsHandling) {
   jitter_buffer_->SetDecodeErrorMode(kNoErrors);
 
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->codec = kVideoCodecH264;
   packet_->video_header.codec = kRtpVideoH264;
   packet_->video_header.codecHeader.H264.nalu_type = H264::NaluType::kIdr;
   packet_->video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
   packet_->video_header.codecHeader.H264.nalus[0].sps_id = -1;
   packet_->video_header.codecHeader.H264.nalus[0].pps_id = 0;
   packet_->video_header.codecHeader.H264.nalus_length = 1;
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   // Not decodable since sps and pps are missing.
   EXPECT_EQ(nullptr, DecodeCompleteFrame());
 
   timestamp_ += 3000;
   packet_->timestamp = timestamp_;
   ++seq_num_;
   packet_->seqNum = seq_num_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->codec = kVideoCodecH264;
   packet_->video_header.codec = kRtpVideoH264;
   packet_->video_header.codecHeader.H264.nalu_type = H264::NaluType::kStapA;
   packet_->video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kSps;
   packet_->video_header.codecHeader.H264.nalus[0].sps_id = 0;
   packet_->video_header.codecHeader.H264.nalus[0].pps_id = -1;
   packet_->video_header.codecHeader.H264.nalus[1].type = H264::NaluType::kPps;
   packet_->video_header.codecHeader.H264.nalus[1].sps_id = 0;
   packet_->video_header.codecHeader.H264.nalus[1].pps_id = 0;
   packet_->video_header.codecHeader.H264.nalus_length = 2;
   // Not complete since the marker bit hasn't been received.
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   ++seq_num_;
   packet_->seqNum = seq_num_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->codec = kVideoCodecH264;
   packet_->video_header.codec = kRtpVideoH264;
   packet_->video_header.codecHeader.H264.nalu_type = H264::NaluType::kIdr;
   packet_->video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
   packet_->video_header.codecHeader.H264.nalus[0].sps_id = -1;
   packet_->video_header.codecHeader.H264.nalus[0].pps_id = 0;
   packet_->video_header.codecHeader.H264.nalus_length = 1;
   // Complete and decodable since the pps and sps are received in the first
   // packet of this frame.
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   ASSERT_NE(nullptr, frame_out);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   timestamp_ += 3000;
   packet_->timestamp = timestamp_;
   ++seq_num_;
   packet_->seqNum = seq_num_;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->codec = kVideoCodecH264;
   packet_->video_header.codec = kRtpVideoH264;
   packet_->video_header.codecHeader.H264.nalu_type = H264::NaluType::kSlice;
   packet_->video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kSlice;
   packet_->video_header.codecHeader.H264.nalus[0].sps_id = -1;
   packet_->video_header.codecHeader.H264.nalus[0].pps_id = 0;
   packet_->video_header.codecHeader.H264.nalus_length = 1;
   // Complete and decodable since sps, pps and key frame has been received.
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   frame_out = DecodeCompleteFrame();
   ASSERT_NE(nullptr, frame_out);
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 // Test threshold conditions of decodable state.
 TEST_F(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_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t timestamp = 0;
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   for (int i = 1; i < 9; ++i) {
     packet_->seqNum++;
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
     EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   // last packet
   packet_->markerBit = true;
   packet_->seqNum++;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 10 * size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // An incomplete frame can only be decoded once a subsequent frame has begun
   // to arrive. Insert packet in distant frame for this purpose.
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum += 100;
   packet_->timestamp += 33 * 90 * 8;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   // Insert second frame
   packet_->seqNum -= 99;
   packet_->timestamp -= 33 * 90 * 7;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   for (int i = 1; i < 8; ++i) {
     packet_->seqNum++;
     EXPECT_EQ(kDecodableSession,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
     EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   packet_->seqNum++;
   EXPECT_EQ(kDecodableSession,
@@ skipping 10 matching lines @@
   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) {
   jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
   // Always start with a key frame.
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   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);
 
   // An incomplete frame can only be decoded once a subsequent frame has begun
   // to arrive. Insert packet in distant frame for this purpose.
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = false;
   packet_->seqNum += 100;
   packet_->timestamp += 33 * 90 * 8;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t timestamp;
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   // Insert second frame - an incomplete key frame.
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->seqNum -= 99;
   packet_->timestamp -= 33 * 90 * 7;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   // Insert a few more packets. Make sure we're waiting for the key frame to be
   // complete.
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   for (int i = 1; i < 5; ++i) {
     packet_->seqNum++;
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
     EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   // Complete key frame.
   packet_->markerBit = true;
   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) {
   jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
   // Always start with a key frame.
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   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);
 
   // An incomplete frame can only be decoded once a subsequent frame has begun
   // to arrive. Insert packet in distant frame for this purpose.
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = false;
   packet_->seqNum += 100;
   packet_->timestamp += 33 * 90 * 8;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t timestamp;
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   // Insert second frame with the first packet missing. Make sure we're waiting
   // for the key frame to be complete.
   packet_->seqNum -= 98;
   packet_->timestamp -= 33 * 90 * 7;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   for (int i = 0; i < 5; ++i) {
     packet_->seqNum++;
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
     EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   // Add first packet. Frame should now be decodable, but incomplete.
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->seqNum -= 6;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   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) {
   // Will use one packet per frame.
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t next_timestamp;
   VCMEncodedFrame* frame = jitter_buffer_->NextCompleteFrame(0);
   EXPECT_NE(frame, nullptr);
   EXPECT_EQ(packet_->timestamp, frame->TimeStamp());
   frame = jitter_buffer_->ExtractAndSetDecode(frame->TimeStamp());
   EXPECT_TRUE(frame != NULL);
   jitter_buffer_->ReleaseFrame(frame);
 
   // Drop a complete frame.
   timestamp_ += 2 * 33 * 90;
   seq_num_ += 2;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   // Insert a packet (so the previous one will be released).
   timestamp_ += 33 * 90;
   seq_num_ += 2;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&next_timestamp));
   EXPECT_EQ(packet_->timestamp - 33 * 90, next_timestamp);
 }
 
 TEST_F(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_++;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->completeNALU = kNaluStart;
 
   bool retransmitted = false;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   for (int i = 0; i < 11; ++i) {
     webrtc::FrameType frametype = kVideoFrameDelta;
     seq_num_++;
     timestamp_ += 33 * 90;
     packet_->frameType = frametype;
-    packet_->isFirstPacket = true;
+    packet_->is_first_packet_in_frame = true;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
     packet_->timestamp = timestamp_;
     packet_->completeNALU = kNaluStart;
 
     EXPECT_EQ(kDecodableSession,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
     VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
     // Should not be complete.
     EXPECT_TRUE(frame_out == NULL);
 
     seq_num_ += 2;
-    packet_->isFirstPacket = false;
+    packet_->is_first_packet_in_frame = false;
     packet_->markerBit = true;
     packet_->seqNum = seq_num_;
     packet_->completeNALU = kNaluEnd;
 
     EXPECT_EQ(jitter_buffer_->InsertPacket(*packet_, &retransmitted),
               kDecodableSession);
 
     // Insert an empty (non-media) packet.
     seq_num_++;
-    packet_->isFirstPacket = false;
+    packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
     packet_->completeNALU = kNaluEnd;
     packet_->frameType = kEmptyFrame;
 
     EXPECT_EQ(jitter_buffer_->InsertPacket(*packet_, &retransmitted),
               kDecodableSession);
     frame_out = DecodeIncompleteFrame();
 
     // One of the packets has been discarded by the jitter buffer.
@@ skipping 32 matching lines @@
 
   jitter_buffer_->Flush();
 
   // This statistic shouldn't be reset by a flush.
   EXPECT_EQ(3, jitter_buffer_->num_discarded_packets());
 }
 
 TEST_F(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
   seq_num_ = 0xfff0;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   EXPECT_TRUE(frame_out == NULL);
 
   int loop = 0;
   do {
     seq_num_++;
-    packet_->isFirstPacket = false;
+    packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
     frame_out = DecodeCompleteFrame();
 
     EXPECT_TRUE(frame_out == NULL);
 
     loop++;
   } while (loop < 98);
 
   seq_num_++;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   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, PacketReorderingReverseWithNegSeqNumWrap) {
   // Insert "first" packet last seqnum.
   seq_num_ = 10;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   // Should not be complete.
   EXPECT_TRUE(frame_out == NULL);
 
   // Insert 98 frames.
   int loop = 0;
   do {
     seq_num_--;
-    packet_->isFirstPacket = false;
+    packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
     frame_out = DecodeCompleteFrame();
 
     EXPECT_TRUE(frame_out == NULL);
 
     loop++;
   } while (loop < 98);
 
   // Insert last packet.
   seq_num_--;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
 
   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) {
   //   -------      -------
   //  |   2   |    |   1   |
   //   -------      -------
   //  t = 3000     t = 2000
   seq_num_ = 2;
   timestamp_ = 3000;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->timestamp = timestamp_;
   packet_->seqNum = seq_num_;
 
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_EQ(3000u, frame_out->TimeStamp());
   CheckOutFrame(frame_out, size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   seq_num_--;
   timestamp_ = 2000;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 }
 
 TEST_F(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
   //   -------      -------
   //  |   2   |    |   1   |
   //   -------      -------
   //  t = 3000     t = 0xffffff00
 
   seq_num_ = 2;
   timestamp_ = 3000;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_EQ(timestamp_, frame_out->TimeStamp());
 
   CheckOutFrame(frame_out, size_, false);
 
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
 
   jitter_buffer_->ReleaseFrame(frame_out);
 
   seq_num_--;
   timestamp_ = 0xffffff00;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = 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) {
   //  ---------------     ---------------
   // |   1   |   2   |   |   3   |   4   |
   //  ---------------     ---------------
   //  t = 0xffffff00        t = 33*90
 
   timestamp_ = 0xffffff00;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_TRUE(frame_out == NULL);
 
   seq_num_++;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = 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);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   seq_num_++;
   timestamp_ += 33 * 90;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
   EXPECT_TRUE(frame_out == NULL);
 
   seq_num_++;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = 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(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 TEST_F(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
   //   -------          -------
   //  |   1   |        |   2   |
   //   -------          -------
   // t = 0xffffff00    t = 2700
 
   timestamp_ = 0xffffff00;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   // Insert first frame (session will be complete).
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   // Insert next frame.
   seq_num_++;
   timestamp_ = 2700;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_EQ(0xffffff00, frame_out->TimeStamp());
   CheckOutFrame(frame_out, size_, false);
   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) {
   //   -------          -------
   //  |   2   |        |   1   |
   //   -------          -------
   //  t = 2700        t = 0xffffff00
 
   seq_num_ = 2;
   timestamp_ = 2700;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   // Insert second frame
   seq_num_--;
   timestamp_ = 0xffffff00;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_EQ(0xffffff00, frame_out->TimeStamp());
   CheckOutFrame(frame_out, size_, false);
   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) {
   int loop = 0;
   bool firstPacket = true;
   bool retransmitted = false;
   // Insert kMaxPacketsInJitterBuffer into frame.
   do {
     seq_num_++;
-    packet_->isFirstPacket = false;
+    packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     if (firstPacket) {
       EXPECT_EQ(kIncomplete,
                 jitter_buffer_->InsertPacket(*packet_, &retransmitted));
       firstPacket = false;
     } else {
       EXPECT_EQ(kIncomplete,
                 jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     }
 
     loop++;
   } while (loop < kMaxPacketsInSession);
 
   // Max number of packets inserted.
   // Insert one more packet.
   seq_num_++;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = 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 fill JB with more than max number of frame (50 delta frames +
@@ skipping 10 matching lines @@
   jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0);
 
   int loop = 0;
   seq_num_ = 65485;
   uint32_t first_key_frame_timestamp = 0;
   bool retransmitted = false;
   // Insert MAX_NUMBER_OF_FRAMES frames.
   do {
     timestamp_ += 33 * 90;
     seq_num_++;
-    packet_->isFirstPacket = true;
+    packet_->is_first_packet_in_frame = true;
     packet_->markerBit = true;
     packet_->seqNum = seq_num_;
     packet_->timestamp = timestamp_;
 
     if (loop == 50) {
       first_key_frame_timestamp = packet_->timestamp;
       packet_->frameType = kVideoFrameKey;
     }
 
     // Insert frame.
     EXPECT_EQ(kCompleteSession,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
     loop++;
   } while (loop < kMaxNumberOfFrames);
 
   // Max number of frames inserted.
 
   // Insert one more frame.
   timestamp_ += 33 * 90;
   seq_num_++;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   // Now, no free frame - frames will be recycled until first key frame.
   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) {
   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_->is_first_packet_in_frame = 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) {
   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_->is_first_packet_in_frame = true;
   packet_->completeNALU = kNaluStart;
   packet_->markerBit = false;
   bool retransmitted = false;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   seq_num_ += 2;  // Skip one packet.
   packet_->seqNum = seq_num_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->completeNALU = kNaluIncomplete;
   packet_->markerBit = false;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   seq_num_++;
   packet_->seqNum = seq_num_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->completeNALU = kNaluEnd;
   packet_->markerBit = false;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   seq_num_++;
   packet_->seqNum = seq_num_;
   packet_->completeNALU = kNaluComplete;
   packet_->markerBit = true;  // Last packet.
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   // The JB will only output (incomplete) frames if a packet belonging to a
   // subsequent frame was already inserted. Insert one packet of a subsequent
   // frame. place high timestamp so the JB would always have a next frame
   // (otherwise, for every inserted frame we need to take care of the next
   // frame as well).
   packet_->seqNum = 1;
   packet_->timestamp = timestamp_ + 33 * 90 * 10;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->completeNALU = kNaluStart;
   packet_->markerBit = false;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeIncompleteFrame();
 
   // We can decode everything from a NALU until a packet has been lost.
   // Thus we can decode the first packet of the first NALU and the second NALU
   // which consists of one packet.
   CheckOutFrame(frame_out, packet_->sizeBytes * 2, false);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // Test reordered start frame + 1 lost.
   seq_num_ += 2;  // Re-order 1 frame.
   timestamp_ += 33 * 90;
   insertedLength = 0;
 
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->completeNALU = kNaluEnd;
   packet_->markerBit = false;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   insertedLength += packet_->sizeBytes;  // This packet should be decoded.
   seq_num_--;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->completeNALU = kNaluStart;
   packet_->markerBit = false;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   insertedLength += packet_->sizeBytes;  // This packet should be decoded.
 
   seq_num_ += 3;  // One packet drop.
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->completeNALU = kNaluComplete;
   packet_->markerBit = false;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   insertedLength += packet_->sizeBytes;  // This packet should be decoded.
   seq_num_++;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->completeNALU = kNaluStart;
   packet_->markerBit = false;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   // This packet should be decoded since it's the beginning of a NAL.
   insertedLength += packet_->sizeBytes;
 
   seq_num_ += 2;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->completeNALU = kNaluEnd;
   packet_->markerBit = true;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   // This packet should not be decoded because it is an incomplete NAL if it
   // is the last.
   frame_out = DecodeIncompleteFrame();
   // Only last NALU is complete.
   CheckOutFrame(frame_out, insertedLength, false);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // Test to insert empty packet.
   seq_num_++;
   timestamp_ += 33 * 90;
   WebRtcRTPHeader rtpHeader;
   memset(&rtpHeader, 0, sizeof(rtpHeader));
   VCMPacket emptypacket(data_, 0, rtpHeader);
   emptypacket.seqNum = seq_num_;
   emptypacket.timestamp = timestamp_;
   emptypacket.frameType = kVideoFrameKey;
-  emptypacket.isFirstPacket = true;
+  emptypacket.is_first_packet_in_frame = true;
   emptypacket.completeNALU = kNaluComplete;
   emptypacket.markerBit = true;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(emptypacket, &retransmitted));
   // This packet should not be decoded because it is an incomplete NAL if it
   // is the last.
 
   // Will be sent to the decoder, as a packet belonging to a subsequent frame
   // has arrived.
   frame_out = DecodeIncompleteFrame();
   EXPECT_TRUE(frame_out != NULL);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // Test that a frame can include an empty packet.
   seq_num_++;
   timestamp_ += 33 * 90;
 
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
   packet_->completeNALU = kNaluComplete;
   packet_->markerBit = false;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   seq_num_++;
   emptypacket.seqNum = seq_num_;
   emptypacket.timestamp = timestamp_;
   emptypacket.frameType = kVideoFrameKey;
-  emptypacket.isFirstPacket = true;
+  emptypacket.is_first_packet_in_frame = true;
   emptypacket.completeNALU = kNaluComplete;
   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 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_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   bool retransmitted = false;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_TRUE(frame_out != NULL);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   packet_->seqNum += 2;
   packet_->timestamp += 33 * 90;
   packet_->frameType = kVideoFrameDelta;
-  packet_->isFirstPacket = false;
+  packet_->is_first_packet_in_frame = false;
   packet_->markerBit = false;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeIncompleteFrame();
   EXPECT_TRUE(frame_out == NULL);
 
   packet_->seqNum += 2;
   packet_->timestamp += 33 * 90;
-  packet_->isFirstPacket = true;
+  packet_->is_first_packet_in_frame = true;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeIncompleteFrame();
   CheckOutFrame(frame_out, packet_->sizeBytes, false);
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 TEST_F(TestRunningJitterBuffer, Full) {
@@ skipping 444 matching lines @@
   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