Only append SPS/PPS to bitstream if supplied out of bound.

webrtc/video/rtp_video_stream_receiver_unittest.cc

 /*
  *  Copyright 2017 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 101 matching lines @@
 
   WebRtcRTPHeader GetDefaultPacket() {
     WebRtcRTPHeader packet;
     memset(&packet, 0, sizeof(packet));
     packet.type.Video.codec = kRtpVideoH264;
     return packet;
   }
 
   // TODO(Johan): refactor h264_sps_pps_tracker_unittests.cc to avoid duplicate
   // code.
-  void AddSps(WebRtcRTPHeader* packet, int sps_id, std::vector<uint8_t>* data) {
+  void AddSps(WebRtcRTPHeader* packet,
+              uint8_t sps_id,
+              std::vector<uint8_t>* data) {
     NaluInfo info;
     info.type = H264::NaluType::kSps;
     info.sps_id = sps_id;
     info.pps_id = -1;
-    info.offset = data->size();
-    info.size = 2;
     data->push_back(H264::NaluType::kSps);
     data->push_back(sps_id);
     packet->type.Video.codecHeader.H264
         .nalus[packet->type.Video.codecHeader.H264.nalus_length++] = info;
   }
 
   void AddPps(WebRtcRTPHeader* packet,
-              int sps_id,
-              int pps_id,
+              uint8_t sps_id,
+              uint8_t pps_id,
               std::vector<uint8_t>* data) {
     NaluInfo info;
     info.type = H264::NaluType::kPps;
     info.sps_id = sps_id;
     info.pps_id = pps_id;
-    info.offset = data->size();
-    info.size = 2;
     data->push_back(H264::NaluType::kPps);
     data->push_back(pps_id);
     packet->type.Video.codecHeader.H264
         .nalus[packet->type.Video.codecHeader.H264.nalus_length++] = info;
   }
 
   void AddIdr(WebRtcRTPHeader* packet, int pps_id) {
     NaluInfo info;
     info.type = H264::NaluType::kIdr;
     info.sps_id = -1;
@@ skipping 55 matching lines @@
               DoOnCompleteFrameFailBitstream(_));
   rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
                                                     &rtp_header);
 }
 
 TEST_F(RtpVideoStreamReceiverTest, InBandSpsPps) {
   std::vector<uint8_t> sps_data;
   WebRtcRTPHeader sps_packet = GetDefaultPacket();
   AddSps(&sps_packet, 0, &sps_data);
   sps_packet.header.sequenceNumber = 0;
+  sps_packet.type.Video.is_first_packet_in_frame = true;
   mock_on_complete_frame_callback_.AppendExpectedBitstream(
       kH264StartCode, sizeof(kH264StartCode));
   mock_on_complete_frame_callback_.AppendExpectedBitstream(sps_data.data(),
                                                            sps_data.size());
   rtp_video_stream_receiver_->OnReceivedPayloadData(
       sps_data.data(), sps_data.size(), &sps_packet);
 
   std::vector<uint8_t> pps_data;
   WebRtcRTPHeader pps_packet = GetDefaultPacket();
   AddPps(&pps_packet, 0, 1, &pps_data);
   pps_packet.header.sequenceNumber = 1;
+  pps_packet.type.Video.is_first_packet_in_frame = true;
   mock_on_complete_frame_callback_.AppendExpectedBitstream(
       kH264StartCode, sizeof(kH264StartCode));
   mock_on_complete_frame_callback_.AppendExpectedBitstream(pps_data.data(),
                                                            pps_data.size());
   rtp_video_stream_receiver_->OnReceivedPayloadData(
       pps_data.data(), pps_data.size(), &pps_packet);
 
   std::vector<uint8_t> idr_data;
   WebRtcRTPHeader idr_packet = GetDefaultPacket();
   AddIdr(&idr_packet, 1);
   idr_packet.type.Video.is_first_packet_in_frame = true;
   idr_packet.header.sequenceNumber = 2;
   idr_packet.header.markerBit = 1;
-  idr_packet.type.Video.is_first_packet_in_frame = true;
   idr_packet.frameType = kVideoFrameKey;
-  idr_packet.type.Video.codec = kRtpVideoH264;
   idr_data.insert(idr_data.end(), {0x65, 1, 2, 3});
   mock_on_complete_frame_callback_.AppendExpectedBitstream(
       kH264StartCode, sizeof(kH264StartCode));
   mock_on_complete_frame_callback_.AppendExpectedBitstream(idr_data.data(),
                                                            idr_data.size());
   EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_));
   rtp_video_stream_receiver_->OnReceivedPayloadData(
       idr_data.data(), idr_data.size(), &idr_packet);
 }
 
@@ skipping 83 matching lines @@
   rtp_header.type.Video.is_first_packet_in_frame = true;
   rtp_header.frameType = kVideoFrameDelta;
   rtp_header.type.Video.codec = kRtpVideoGeneric;
 
   EXPECT_CALL(mock_key_frame_request_sender_, RequestKeyFrame());
   rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
                                                     &rtp_header);
 }
 
 }  // namespace webrtc