RtpPacketizer::NextPacket fills RtpPacket instead of payload.

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.
  */
 
 #include <memory>
 #include <vector>
 
+#include "webrtc/base/array_view.h"
 #include "webrtc/common_video/h264/h264_common.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
+
+using ::testing::ElementsAreArray;
+
+constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr;
 const size_t kMaxPayloadSize = 1200;
 const size_t kLengthFieldLength = 2;
 
 enum Nalu {
   kSlice = 1,
   kIdr = 5,
   kSei = 6,
   kSps = 7,
   kPps = 8,
   kStapA = 24,
   kFuA = 28
 };
 
 static const size_t kNalHeaderSize = 1;
 static const size_t kFuAHeaderSize = 2;
 
 // Bit masks for FU (A and B) indicators.
 enum NalDefs { kFBit = 0x80, kNriMask = 0x60, kTypeMask = 0x1F };
 
 // Bit masks for FU (A and B) headers.
 enum FuDefs { kSBit = 0x80, kEBit = 0x40, kRBit = 0x20 };
 
 void VerifyFua(size_t fua_index,
                const uint8_t* expected_payload,
                int offset,
-               const uint8_t* packet,
-               size_t length,
+               rtc::ArrayView<const uint8_t> packet,
                const std::vector<size_t>& expected_sizes) {
-  ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, length)
+  ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, packet.size())
       << "FUA index: " << fua_index;
   const uint8_t kFuIndicator = 0x1C;  // F=0, NRI=0, Type=28.
   EXPECT_EQ(kFuIndicator, packet[0]) << "FUA index: " << fua_index;
   bool should_be_last_fua = (fua_index == expected_sizes.size() - 1);
   uint8_t fu_header = 0;
   if (fua_index == 0)
     fu_header = 0x85;  // S=1, E=0, R=0, Type=5.
   else if (should_be_last_fua)
     fu_header = 0x45;  // S=0, E=1, R=0, Type=5.
   else
     fu_header = 0x05;  // S=0, E=0, R=0, Type=5.
   EXPECT_EQ(fu_header, packet[1]) << "FUA index: " << fua_index;
   std::vector<uint8_t> expected_packet_payload(
       &expected_payload[offset],
       &expected_payload[offset + expected_sizes[fua_index]]);
-  EXPECT_THAT(
-      expected_packet_payload,
-      ::testing::ElementsAreArray(&packet[2], expected_sizes[fua_index]))
+  EXPECT_THAT(expected_packet_payload,
+              ElementsAreArray(&packet[2], expected_sizes[fua_index]))
       << "FUA index: " << fua_index;
 }
 
 void TestFua(size_t frame_size,
              size_t max_payload_size,
              const std::vector<size_t>& expected_sizes) {
   std::unique_ptr<uint8_t[]> frame;
   frame.reset(new uint8_t[frame_size]);
   frame[0] = 0x05;  // F=0, NRI=0, Type=5.
   for (size_t i = 0; i < frame_size - kNalHeaderSize; ++i) {
     frame[i + kNalHeaderSize] = i;
   }
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(1);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = frame_size;
   std::unique_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
       kRtpVideoH264, max_payload_size, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation);
 
-  std::unique_ptr<uint8_t[]> packet(new uint8_t[max_payload_size]);
-  size_t length = 0;
+  RtpPacketToSend packet(kNoExtensions);
+  ASSERT_LE(max_payload_size, packet.FreeCapacity());
   bool last = false;
   size_t offset = kNalHeaderSize;
   for (size_t i = 0; i < expected_sizes.size(); ++i) {
-    ASSERT_TRUE(packetizer->NextPacket(packet.get(), &length, &last));
-    VerifyFua(i, frame.get(), offset, packet.get(), length, expected_sizes);
+    ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+    VerifyFua(i, frame.get(), offset, packet.payload(), expected_sizes);
     EXPECT_EQ(i == expected_sizes.size() - 1, last) << "FUA index: " << i;
     offset += expected_sizes[i];
   }
 
-  EXPECT_FALSE(packetizer->NextPacket(packet.get(), &length, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
 }
 
 size_t GetExpectedNaluOffset(const RTPFragmentationHeader& fragmentation,
                              size_t start_index,
                              size_t nalu_index) {
   assert(nalu_index < fragmentation.fragmentationVectorSize);
   size_t expected_nalu_offset = kNalHeaderSize;  // STAP-A header.
   for (size_t i = start_index; i < nalu_index; ++i) {
     expected_nalu_offset +=
         kLengthFieldLength + fragmentation.fragmentationLength[i];
   }
   return expected_nalu_offset;
 }
 
 void VerifyStapAPayload(const RTPFragmentationHeader& fragmentation,
                         size_t first_stapa_index,
                         size_t nalu_index,
-                        const uint8_t* frame,
-                        size_t frame_length,
-                        const uint8_t* packet,
-                        size_t packet_length) {
+                        rtc::ArrayView<const uint8_t> frame,
+                        rtc::ArrayView<const uint8_t> packet) {
   size_t expected_payload_offset =
       GetExpectedNaluOffset(fragmentation, first_stapa_index, nalu_index) +
       kLengthFieldLength;
   size_t offset = fragmentation.fragmentationOffset[nalu_index];
   const uint8_t* expected_payload = &frame[offset];
   size_t expected_payload_length =
       fragmentation.fragmentationLength[nalu_index];
-  ASSERT_LE(offset + expected_payload_length, frame_length);
-  ASSERT_LE(expected_payload_offset + expected_payload_length, packet_length);
+  ASSERT_LE(offset + expected_payload_length, frame.size());
+  ASSERT_LE(expected_payload_offset + expected_payload_length, packet.size());
   std::vector<uint8_t> expected_payload_vector(
       expected_payload, &expected_payload[expected_payload_length]);
   EXPECT_THAT(expected_payload_vector,
-              ::testing::ElementsAreArray(&packet[expected_payload_offset],
-                                          expected_payload_length));
+              ElementsAreArray(&packet[expected_payload_offset],
+                               expected_payload_length));
 }
 
 void VerifySingleNaluPayload(const RTPFragmentationHeader& fragmentation,
                              size_t nalu_index,
-                             const uint8_t* frame,
-                             size_t frame_length,
-                             const uint8_t* packet,
-                             size_t packet_length) {
-  std::vector<uint8_t> expected_payload_vector(
-      &frame[fragmentation.fragmentationOffset[nalu_index]],
-      &frame[fragmentation.fragmentationOffset[nalu_index] +
-             fragmentation.fragmentationLength[nalu_index]]);
-  EXPECT_THAT(expected_payload_vector,
-              ::testing::ElementsAreArray(packet, packet_length));
+                             rtc::ArrayView<const uint8_t> frame,
+                             rtc::ArrayView<const uint8_t> packet) {
+  auto fragment = frame.subview(fragmentation.fragmentationOffset[nalu_index],
+                                fragmentation.fragmentationLength[nalu_index]);
+  EXPECT_THAT(packet, ElementsAreArray(fragment.begin(), fragment.end()));
 }
 }  // namespace
 
 TEST(RtpPacketizerH264Test, TestSingleNalu) {
   const uint8_t frame[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5.
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(1);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = sizeof(frame);
   std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation);
-  uint8_t packet[kMaxPayloadSize] = {0};
-  size_t length = 0;
+  RtpPacketToSend packet(kNoExtensions);
+  ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
   bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
-  EXPECT_EQ(2u, length);
+  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  EXPECT_EQ(2u, packet.payload_size());
   EXPECT_TRUE(last);
-  VerifySingleNaluPayload(
-      fragmentation, 0, frame, sizeof(frame), packet, length);
-  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
+  VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload());
+  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
 }
 
 TEST(RtpPacketizerH264Test, TestSingleNaluTwoPackets) {
   const size_t kFrameSize = kMaxPayloadSize + 100;
   uint8_t frame[kFrameSize] = {0};
   for (size_t i = 0; i < kFrameSize; ++i)
     frame[i] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(2);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = kMaxPayloadSize;
   fragmentation.fragmentationOffset[1] = kMaxPayloadSize;
   fragmentation.fragmentationLength[1] = 100;
   // Set NAL headers.
   frame[fragmentation.fragmentationOffset[0]] = 0x01;
   frame[fragmentation.fragmentationOffset[1]] = 0x01;
 
   std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
-  uint8_t packet[kMaxPayloadSize] = {0};
-  size_t length = 0;
+  RtpPacketToSend packet(kNoExtensions);
   bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
-  ASSERT_EQ(fragmentation.fragmentationOffset[1], length);
-  VerifySingleNaluPayload(fragmentation, 0, frame, kFrameSize, packet, length);
+  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_EQ(fragmentation.fragmentationOffset[1], packet.payload_size());
+  VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload());
 
-  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
-  ASSERT_EQ(fragmentation.fragmentationLength[1], length);
-  VerifySingleNaluPayload(fragmentation, 1, frame, kFrameSize, packet, length);
+  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_EQ(fragmentation.fragmentationLength[1], packet.payload_size());
+  VerifySingleNaluPayload(fragmentation, 1, frame, packet.payload());
   EXPECT_TRUE(last);
 
-  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
 }
 
 TEST(RtpPacketizerH264Test, TestStapA) {
   const size_t kFrameSize =
       kMaxPayloadSize - 3 * kLengthFieldLength - kNalHeaderSize;
   uint8_t frame[kFrameSize] = {0x07, 0xFF,  // F=0, NRI=0, Type=7 (SPS).
                                0x08, 0xFF,  // F=0, NRI=0, Type=8 (PPS).
                                0x05};       // F=0, NRI=0, Type=5 (IDR).
   const size_t kPayloadOffset = 5;
   for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i)
     frame[i + kPayloadOffset] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(3);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = 2;
   fragmentation.fragmentationOffset[1] = 2;
   fragmentation.fragmentationLength[1] = 2;
   fragmentation.fragmentationOffset[2] = 4;
   fragmentation.fragmentationLength[2] =
       kNalHeaderSize + kFrameSize - kPayloadOffset;
   std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
-  uint8_t packet[kMaxPayloadSize] = {0};
-  size_t length = 0;
+  RtpPacketToSend packet(kNoExtensions);
+  ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
   bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
   size_t expected_packet_size =
       kNalHeaderSize + 3 * kLengthFieldLength + kFrameSize;
-  ASSERT_EQ(expected_packet_size, length);
+  ASSERT_EQ(expected_packet_size, packet.payload_size());
   EXPECT_TRUE(last);
   for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i)
-    VerifyStapAPayload(fragmentation, 0, i, frame, kFrameSize, packet, length);
+    VerifyStapAPayload(fragmentation, 0, i, frame, packet.payload());
 
-  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
 }
 
 TEST(RtpPacketizerH264Test, TestTooSmallForStapAHeaders) {
   const size_t kFrameSize = kMaxPayloadSize - 1;
   uint8_t frame[kFrameSize] = {0x07, 0xFF,  // F=0, NRI=0, Type=7.
                                0x08, 0xFF,  // F=0, NRI=0, Type=8.
                                0x05};       // F=0, NRI=0, Type=5.
   const size_t kPayloadOffset = 5;
   for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i)
     frame[i + kPayloadOffset] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(3);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = 2;
   fragmentation.fragmentationOffset[1] = 2;
   fragmentation.fragmentationLength[1] = 2;
   fragmentation.fragmentationOffset[2] = 4;
   fragmentation.fragmentationLength[2] =
       kNalHeaderSize + kFrameSize - kPayloadOffset;
   std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
-  uint8_t packet[kMaxPayloadSize] = {0};
-  size_t length = 0;
+  RtpPacketToSend packet(kNoExtensions);
+  ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
   bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
   size_t expected_packet_size = kNalHeaderSize;
   for (size_t i = 0; i < 2; ++i) {
     expected_packet_size +=
         kLengthFieldLength + fragmentation.fragmentationLength[i];
   }
-  ASSERT_EQ(expected_packet_size, length);
+  ASSERT_EQ(expected_packet_size, packet.payload_size());
   EXPECT_FALSE(last);
   for (size_t i = 0; i < 2; ++i)
-    VerifyStapAPayload(fragmentation, 0, i, frame, kFrameSize, packet, length);
+    VerifyStapAPayload(fragmentation, 0, i, frame, packet.payload());
 
-  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
   expected_packet_size = fragmentation.fragmentationLength[2];
-  ASSERT_EQ(expected_packet_size, length);
+  ASSERT_EQ(expected_packet_size, packet.payload_size());
   EXPECT_TRUE(last);
-  VerifySingleNaluPayload(fragmentation, 2, frame, kFrameSize, packet, length);
+  VerifySingleNaluPayload(fragmentation, 2, frame, packet.payload());
 
-  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
 }
 
 TEST(RtpPacketizerH264Test, TestMixedStapA_FUA) {
   const size_t kFuaNaluSize = 2 * (kMaxPayloadSize - 100);
   const size_t kStapANaluSize = 100;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(3);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = kFuaNaluSize;
   fragmentation.fragmentationOffset[1] = kFuaNaluSize;
@@ skipping 11 matching lines @@
     }
   }
   std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   // First expecting two FU-A packets.
   std::vector<size_t> fua_sizes;
   fua_sizes.push_back(1100);
   fua_sizes.push_back(1099);
-  uint8_t packet[kMaxPayloadSize] = {0};
-  size_t length = 0;
+  RtpPacketToSend packet(kNoExtensions);
+  ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
   bool last = false;
   int fua_offset = kNalHeaderSize;
   for (size_t i = 0; i < 2; ++i) {
-    ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
-    VerifyFua(i, frame, fua_offset, packet, length, fua_sizes);
+    ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+    VerifyFua(i, frame, fua_offset, packet.payload(), fua_sizes);
     EXPECT_FALSE(last);
     fua_offset += fua_sizes[i];
   }
   // Then expecting one STAP-A packet with two nal units.
-  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
   size_t expected_packet_size =
       kNalHeaderSize + 2 * kLengthFieldLength + 2 * kStapANaluSize;
-  ASSERT_EQ(expected_packet_size, length);
+  ASSERT_EQ(expected_packet_size, packet.payload_size());
   EXPECT_TRUE(last);
   for (size_t i = 1; i < fragmentation.fragmentationVectorSize; ++i)
-    VerifyStapAPayload(fragmentation, 1, i, frame, kFrameSize, packet, length);
+    VerifyStapAPayload(fragmentation, 1, i, frame, packet.payload());
 
-  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
 }
 
 TEST(RtpPacketizerH264Test, TestFUAOddSize) {
   const size_t kExpectedPayloadSizes[2] = {600, 600};
   TestFua(
       kMaxPayloadSize + 1,
       kMaxPayloadSize,
       std::vector<size_t>(kExpectedPayloadSizes,
                           kExpectedPayloadSizes +
                               sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
@@ skipping 74 matching lines @@
 
   // Set size to fragment SPS into two FU-A packets.
   packetizer_.reset(RtpPacketizer::Create(
       kRtpVideoH264, sizeof(kOriginalSps) - 2 + kHeaderOverhead, nullptr,
       kEmptyFrame));
 
   packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(),
                               &fragmentation_header_);
 
   bool last_packet = true;
-  uint8_t buffer[sizeof(kOriginalSps) + kHeaderOverhead] = {};
-  size_t num_bytes = 0;
+  RtpPacketToSend packet(kNoExtensions);
+  ASSERT_LE(sizeof(kOriginalSps) + kHeaderOverhead, packet.FreeCapacity());
 
-  EXPECT_TRUE(packetizer_->NextPacket(buffer, &num_bytes, &last_packet));
+  EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet));
   size_t offset = H264::kNaluTypeSize;
-  size_t length = num_bytes - kFuAHeaderSize;
-  std::vector<uint8_t> expected_payload(&kRewrittenSps[offset],
-                                        &kRewrittenSps[offset + length]);
-  EXPECT_THAT(expected_payload,
-              ::testing::ElementsAreArray(&buffer[kFuAHeaderSize], length));
+  size_t length = packet.payload_size() - kFuAHeaderSize;
+  EXPECT_THAT(packet.payload().subview(kFuAHeaderSize),
+              ElementsAreArray(&kRewrittenSps[offset], length));
   offset += length;
 
-  EXPECT_TRUE(packetizer_->NextPacket(buffer, &num_bytes, &last_packet));
-  length = num_bytes - kFuAHeaderSize;
-  expected_payload = std::vector<uint8_t>(&kRewrittenSps[offset],
-                                          &kRewrittenSps[offset + length]);
-  EXPECT_THAT(expected_payload,
-              ::testing::ElementsAreArray(&buffer[kFuAHeaderSize], length));
+  EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet));
+  length = packet.payload_size() - kFuAHeaderSize;
+  EXPECT_THAT(packet.payload().subview(kFuAHeaderSize),
+              ElementsAreArray(&kRewrittenSps[offset], length));
   offset += length;
 
   EXPECT_EQ(offset, sizeof(kRewrittenSps));
 }
 
 TEST_F(RtpPacketizerH264TestSpsRewriting, StapASps) {
   const size_t kHeaderOverhead = kFuAHeaderSize + 1;
   const size_t kExpectedTotalSize = H264::kNaluTypeSize +  // Stap-A type.
                                     sizeof(kRewrittenSps) + sizeof(kIdrOne) +
                                     sizeof(kIdrTwo) + (kLengthFieldLength * 3);
 
   // Set size to include SPS and the rest of the packets in a Stap-A package.
   packetizer_.reset(RtpPacketizer::Create(kRtpVideoH264,
                                           kExpectedTotalSize + kHeaderOverhead,
                                           nullptr, kEmptyFrame));
 
   packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(),
                               &fragmentation_header_);
 
   bool last_packet = true;
-  uint8_t buffer[kExpectedTotalSize + kHeaderOverhead] = {};
-  size_t num_bytes = 0;
+  RtpPacketToSend packet(kNoExtensions);
+  ASSERT_LE(kExpectedTotalSize + kHeaderOverhead, packet.FreeCapacity());
 
-  EXPECT_TRUE(packetizer_->NextPacket(buffer, &num_bytes, &last_packet));
-  EXPECT_EQ(kExpectedTotalSize, num_bytes);
-
-  std::vector<uint8_t> expected_payload(kRewrittenSps,
-                                        &kRewrittenSps[sizeof(kRewrittenSps)]);
-  EXPECT_THAT(expected_payload,
-              ::testing::ElementsAreArray(
-                  &buffer[H264::kNaluTypeSize + kLengthFieldLength],
-                  sizeof(kRewrittenSps)));
+  EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet));
+  EXPECT_EQ(kExpectedTotalSize, packet.payload_size());
+  EXPECT_THAT(packet.payload().subview(H264::kNaluTypeSize + kLengthFieldLength,
+                                       sizeof(kRewrittenSps)),
+              ElementsAreArray(kRewrittenSps));
 }
 
 class RtpDepacketizerH264Test : public ::testing::Test {
  protected:
   RtpDepacketizerH264Test()
       : depacketizer_(RtpDepacketizer::Create(kRtpVideoH264)) {}
 
   void ExpectPacket(RtpDepacketizer::ParsedPayload* parsed_payload,
                     const uint8_t* data,
                     size_t length) {
@@ skipping 339 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