Revert of Rename RTPVideoHeader.isFirstPacket to .is_first_packet_in_frame.

webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc

 /*
  *  Copyright (c) 2014 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 547 matching lines @@
 };
 
 TEST_F(RtpDepacketizerH264Test, TestSingleNalu) {
   uint8_t packet[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5 (IDR).
   RtpDepacketizer::ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
-  EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
+  EXPECT_TRUE(payload.type.Video.isFirstPacket);
   EXPECT_EQ(kH264SingleNalu,
             payload.type.Video.codecHeader.H264.packetization_type);
   EXPECT_EQ(kIdr, payload.type.Video.codecHeader.H264.nalu_type);
 }
 
 TEST_F(RtpDepacketizerH264Test, TestSingleNaluSpsWithResolution) {
   uint8_t packet[] = {kSps, 0x7A, 0x00, 0x1F, 0xBC, 0xD9, 0x40, 0x50,
                       0x05, 0xBA, 0x10, 0x00, 0x00, 0x03, 0x00, 0xC0,
                       0x00, 0x00, 0x03, 0x2A, 0xE0, 0xF1, 0x83, 0x25};
   RtpDepacketizer::ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
-  EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
+  EXPECT_TRUE(payload.type.Video.isFirstPacket);
   EXPECT_EQ(kH264SingleNalu,
             payload.type.Video.codecHeader.H264.packetization_type);
   EXPECT_EQ(1280u, payload.type.Video.width);
   EXPECT_EQ(720u, payload.type.Video.height);
 }
 
 TEST_F(RtpDepacketizerH264Test, TestStapAKey) {
   // clang-format off
   const NaluInfo kExpectedNalus[] = { {H264::kSps, 0, -1},
                                       {H264::kPps, 1, 2},
                                       {H264::kIdr, -1, 0} };
   uint8_t packet[] = {kStapA,  // F=0, NRI=0, Type=24.
                       // Length, nal header, payload.
                       0, 0x18, kExpectedNalus[0].type,
                         0x7A, 0x00, 0x1F, 0xBC, 0xD9, 0x40, 0x50, 0x05, 0xBA,
                         0x10, 0x00, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x03,
                         0x2A, 0xE0, 0xF1, 0x83, 0x25,
                       0, 0xD, kExpectedNalus[1].type,
                         0x69, 0xFC, 0x0, 0x0, 0x3, 0x0, 0x7, 0xFF, 0xFF, 0xFF,
                         0xF6, 0x40,
                       0, 0xB, kExpectedNalus[2].type,
                         0x85, 0xB8, 0x0, 0x4, 0x0, 0x0, 0x13, 0x93, 0x12, 0x0};
   // clang-format on
 
   RtpDepacketizer::ParsedPayload payload;
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
-  EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
+  EXPECT_TRUE(payload.type.Video.isFirstPacket);
   const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
   EXPECT_EQ(kH264StapA, h264.packetization_type);
   // NALU type for aggregated packets is the type of the first packet only.
   EXPECT_EQ(kSps, h264.nalu_type);
   ASSERT_EQ(3u, h264.nalus_length);
   for (size_t i = 0; i < h264.nalus_length; ++i) {
     EXPECT_EQ(kExpectedNalus[i].type, h264.nalus[i].type)
         << "Failed parsing nalu " << i;
     EXPECT_EQ(kExpectedNalus[i].sps_id, h264.nalus[i].sps_id)
         << "Failed parsing nalu " << i;
@@ skipping 10 matching lines @@
                       0x00, 0x00, 0x03, 0x2A, 0xE0, 0xF1, 0x83, 0x25, 0x80,
                       0x00, 0x03, kIdr, 0xFF, 0x00, 0x00, 0x04, kIdr, 0xFF,
                       0x00, 0x11};
 
   RtpDepacketizer::ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
-  EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
+  EXPECT_TRUE(payload.type.Video.isFirstPacket);
   EXPECT_EQ(kH264StapA, payload.type.Video.codecHeader.H264.packetization_type);
   EXPECT_EQ(1280u, payload.type.Video.width);
   EXPECT_EQ(720u, payload.type.Video.height);
 }
 
 TEST_F(RtpDepacketizerH264Test, TestEmptyStapARejected) {
   uint8_t lone_empty_packet[] = {kStapA, 0x00, 0x00};
 
   uint8_t leading_empty_packet[] = {kStapA, 0x00, 0x00, 0x00, 0x04,
                                     kIdr,   0xFF, 0x00, 0x11};
@@ skipping 106 matching lines @@
   uint8_t packet[16] = {kStapA,  // F=0, NRI=0, Type=24.
                         // Length, nal header, payload.
                         0,      0x02, kSlice, 0xFF,   0,    0x03, kSlice, 0xFF,
                         0x00,   0,    0x04,   kSlice, 0xFF, 0x00, 0x11};
   RtpDepacketizer::ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
-  EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
+  EXPECT_TRUE(payload.type.Video.isFirstPacket);
   EXPECT_EQ(kH264StapA, payload.type.Video.codecHeader.H264.packetization_type);
   // NALU type for aggregated packets is the type of the first packet only.
   EXPECT_EQ(kSlice, payload.type.Video.codecHeader.H264.nalu_type);
 }
 
 TEST_F(RtpDepacketizerH264Test, TestFuA) {
   // clang-format off
   uint8_t packet1[] = {
       kFuA,          // F=0, NRI=0, Type=28.
       kSBit | kIdr,  // FU header.
@@ skipping 18 matching lines @@
   const uint8_t kExpected3[] = {0x03};
 
   RtpDepacketizer::ParsedPayload payload;
 
   // We expect that the first packet is one byte shorter since the FU-A header
   // has been replaced by the original nal header.
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet1, sizeof(packet1)));
   ExpectPacket(&payload, kExpected1, sizeof(kExpected1));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
-  EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
+  EXPECT_TRUE(payload.type.Video.isFirstPacket);
   const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
   EXPECT_EQ(kH264FuA, h264.packetization_type);
   EXPECT_EQ(kIdr, h264.nalu_type);
   ASSERT_EQ(1u, h264.nalus_length);
   EXPECT_EQ(static_cast<H264::NaluType>(kIdr), h264.nalus[0].type);
   EXPECT_EQ(-1, h264.nalus[0].sps_id);
   EXPECT_EQ(0, h264.nalus[0].pps_id);
 
   // Following packets will be 2 bytes shorter since they will only be appended
   // onto the first packet.
   payload = RtpDepacketizer::ParsedPayload();
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet2, sizeof(packet2)));
   ExpectPacket(&payload, kExpected2, sizeof(kExpected2));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
-  EXPECT_FALSE(payload.type.Video.is_first_packet_in_frame);
+  EXPECT_FALSE(payload.type.Video.isFirstPacket);
   {
     const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
     EXPECT_EQ(kH264FuA, h264.packetization_type);
     EXPECT_EQ(kIdr, h264.nalu_type);
     // NALU info is only expected for the first FU-A packet.
     EXPECT_EQ(0u, h264.nalus_length);
   }
 
   payload = RtpDepacketizer::ParsedPayload();
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet3, sizeof(packet3)));
   ExpectPacket(&payload, kExpected3, sizeof(kExpected3));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
-  EXPECT_FALSE(payload.type.Video.is_first_packet_in_frame);
+  EXPECT_FALSE(payload.type.Video.isFirstPacket);
   {
     const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
     EXPECT_EQ(kH264FuA, h264.packetization_type);
     EXPECT_EQ(kIdr, h264.nalu_type);
     // NALU info is only expected for the first FU-A packet.
     ASSERT_EQ(0u, h264.nalus_length);
   }
 }
 
 TEST_F(RtpDepacketizerH264Test, TestEmptyPayload) {
@@ skipping 37 matching lines @@
   const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
   EXPECT_EQ(kH264SingleNalu, h264.packetization_type);
   EXPECT_EQ(kSei, h264.nalu_type);
   ASSERT_EQ(1u, h264.nalus_length);
   EXPECT_EQ(static_cast<H264::NaluType>(kSei), h264.nalus[0].type);
   EXPECT_EQ(-1, h264.nalus[0].sps_id);
   EXPECT_EQ(-1, h264.nalus[0].pps_id);
 }
 
 }  // namespace webrtc