diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn
index 055d712377..49ccafea88 100644
--- a/modules/rtp_rtcp/BUILD.gn
+++ b/modules/rtp_rtcp/BUILD.gn
@@ -447,6 +447,7 @@ if (rtc_include_tests) {
       "../../test:test_common",
       "../../test:test_support",
       "../audio_coding:audio_format_conversion",
+      "../video_coding:codec_globals_headers",
       "//third_party/abseil-cpp/absl/memory",
       "//third_party/abseil-cpp/absl/types:optional",
     ]
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc b/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
index abc0c8972a..174e24c712 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
@@ -10,68 +10,17 @@
 
 #include "modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h"
 
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "test/gmock.h"
 #include "test/gtest.h"
 
 namespace webrtc {
+namespace {
 
-namespace test {
+using ::testing::ElementsAreArray;
 
 constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr;
 
-RtpFormatVp8TestHelper::RtpFormatVp8TestHelper(const RTPVideoHeaderVP8* hdr)
-    : packet_(kNoExtensions),
-      payload_data_(NULL),
-      data_ptr_(NULL),
-      hdr_info_(hdr),
-      payload_start_(0),
-      payload_size_(0),
-      sloppy_partitioning_(false),
-      inited_(false) {}
-
-RtpFormatVp8TestHelper::~RtpFormatVp8TestHelper() {
-  delete[] payload_data_;
-}
-
-bool RtpFormatVp8TestHelper::Init(const size_t* partition_sizes,
-                                  size_t num_partitions) {
-  if (inited_)
-    return false;
-  payload_size_ = 0;
-  // Calculate sum payload size.
-  for (size_t p = 0; p < num_partitions; ++p) {
-    payload_size_ += partition_sizes[p];
-  }
-  payload_data_ = new uint8_t[payload_size_];
-  size_t j = 0;
-  // Loop through the partitions again.
-  for (size_t p = 0; p < num_partitions; ++p) {
-    for (size_t i = 0; i < partition_sizes[p]; ++i) {
-      assert(j < payload_size_);
-      payload_data_[j++] = p;  // Set the payload value to the partition index.
-    }
-  }
-  data_ptr_ = payload_data_;
-  inited_ = true;
-  return true;
-}
-
-void RtpFormatVp8TestHelper::GetAllPacketsAndCheck(
-    RtpPacketizerVp8* packetizer,
-    const size_t* expected_sizes,
-    const int* expected_part,
-    const bool* expected_frag_start,
-    size_t expected_num_packets) {
-  ASSERT_TRUE(inited_);
-  for (size_t i = 0; i < expected_num_packets; ++i) {
-    std::ostringstream ss;
-    ss << "Checking packet " << i;
-    SCOPED_TRACE(ss.str());
-    EXPECT_TRUE(packetizer->NextPacket(&packet_));
-    CheckPacket(expected_sizes[i], i + 1 == expected_num_packets,
-                expected_frag_start[i]);
-  }
-}
-
 // Payload descriptor
 //       0 1 2 3 4 5 6 7
 //      +-+-+-+-+-+-+-+-+
@@ -79,159 +28,145 @@ void RtpFormatVp8TestHelper::GetAllPacketsAndCheck(
 //      +-+-+-+-+-+-+-+-+
 // X:   |I|L|T|K|  RSV  | (OPTIONAL)
 //      +-+-+-+-+-+-+-+-+
-// I:   |   PictureID   | (OPTIONAL)
+//      |M| PictureID   |
+// I:   +-+-+-+-+-+-+-+-+ (OPTIONAL)
+//      |   PictureID   |
 //      +-+-+-+-+-+-+-+-+
 // L:   |   TL0PICIDX   | (OPTIONAL)
 //      +-+-+-+-+-+-+-+-+
-// T/K: | TID | KEYIDX  | (OPTIONAL)
+// T/K: |TID|Y| KEYIDX  | (OPTIONAL)
 //      +-+-+-+-+-+-+-+-+
 
-// First octet tests.
-#define EXPECT_BIT_EQ(x, n, a) EXPECT_EQ((((x) >> (n)) & 0x1), a)
+int Bit(uint8_t byte, int position) {
+  return (byte >> position) & 0x01;
+}
 
-#define EXPECT_RSV_ZERO(x) EXPECT_EQ(((x)&0xE0), 0)
+}  // namespace
 
-#define EXPECT_BIT_X_EQ(x, a) EXPECT_BIT_EQ(x, 7, a)
+RtpFormatVp8TestHelper::RtpFormatVp8TestHelper(const RTPVideoHeaderVP8* hdr,
+                                               size_t payload_len)
+    : hdr_info_(hdr), payload_(payload_len) {
+  for (size_t i = 0; i < payload_.size(); ++i) {
+    payload_[i] = i;
+  }
+}
 
-#define EXPECT_BIT_N_EQ(x, a) EXPECT_BIT_EQ(x, 5, a)
+RtpFormatVp8TestHelper::~RtpFormatVp8TestHelper() = default;
 
-#define EXPECT_BIT_S_EQ(x, a) EXPECT_BIT_EQ(x, 4, a)
+void RtpFormatVp8TestHelper::GetAllPacketsAndCheck(
+    RtpPacketizerVp8* packetizer,
+    rtc::ArrayView<const size_t> expected_sizes) {
+  EXPECT_EQ(packetizer->NumPackets(), expected_sizes.size());
+  const uint8_t* data_ptr = payload_.begin();
+  RtpPacketToSend packet(kNoExtensions);
+  for (size_t i = 0; i < expected_sizes.size(); ++i) {
+    EXPECT_TRUE(packetizer->NextPacket(&packet));
+    auto rtp_payload = packet.payload();
+    EXPECT_EQ(rtp_payload.size(), expected_sizes[i]);
 
-#define EXPECT_PART_ID_EQ(x, a) EXPECT_EQ(((x)&0x0F), a)
+    int payload_offset = CheckHeader(rtp_payload, /*first=*/i == 0);
+    // Verify that the payload (i.e., after the headers) of the packet is
+    // identical to the expected (as found in data_ptr).
+    auto vp8_payload = rtp_payload.subview(payload_offset);
+    ASSERT_GE(payload_.end() - data_ptr, static_cast<int>(vp8_payload.size()));
+    EXPECT_THAT(vp8_payload, ElementsAreArray(data_ptr, vp8_payload.size()));
+    data_ptr += vp8_payload.size();
+  }
+  EXPECT_EQ(payload_.end() - data_ptr, 0);
+}
 
-// Extension fields tests
-#define EXPECT_BIT_I_EQ(x, a) EXPECT_BIT_EQ(x, 7, a)
-
-#define EXPECT_BIT_L_EQ(x, a) EXPECT_BIT_EQ(x, 6, a)
-
-#define EXPECT_BIT_T_EQ(x, a) EXPECT_BIT_EQ(x, 5, a)
-
-#define EXPECT_BIT_K_EQ(x, a) EXPECT_BIT_EQ(x, 4, a)
-
-#define EXPECT_TID_EQ(x, a) EXPECT_EQ((((x)&0xC0) >> 6), a)
-
-#define EXPECT_BIT_Y_EQ(x, a) EXPECT_BIT_EQ(x, 5, a)
-
-#define EXPECT_KEYIDX_EQ(x, a) EXPECT_EQ(((x)&0x1F), a)
-
-void RtpFormatVp8TestHelper::CheckHeader(bool frag_start) {
-  payload_start_ = 1;
-  rtc::ArrayView<const uint8_t> buffer = packet_.payload();
-  EXPECT_BIT_EQ(buffer[0], 6, 0);  // Check reserved bit.
-  EXPECT_PART_ID_EQ(buffer[0], 0);  // In equal size mode, PartID is always 0.
+int RtpFormatVp8TestHelper::CheckHeader(rtc::ArrayView<const uint8_t> buffer,
+                                        bool first) {
+  int x_bit = Bit(buffer[0], 7);
+  EXPECT_EQ(Bit(buffer[0], 6), 0);  // Reserved.
+  EXPECT_EQ(Bit(buffer[0], 5), hdr_info_->nonReference ? 1 : 0);
+  EXPECT_EQ(Bit(buffer[0], 4), first ? 1 : 0);
+  EXPECT_EQ(buffer[0] & 0x0f, 0);  // RtpPacketizerVp8 always uses partition 0.
 
+  int payload_offset = 1;
   if (hdr_info_->pictureId != kNoPictureId ||
       hdr_info_->temporalIdx != kNoTemporalIdx ||
       hdr_info_->tl0PicIdx != kNoTl0PicIdx || hdr_info_->keyIdx != kNoKeyIdx) {
-    EXPECT_BIT_X_EQ(buffer[0], 1);
-    ++payload_start_;
-    CheckPictureID();
-    CheckTl0PicIdx();
-    CheckTIDAndKeyIdx();
+    EXPECT_EQ(x_bit, 1);
+    ++payload_offset;
+    CheckPictureID(buffer, &payload_offset);
+    CheckTl0PicIdx(buffer, &payload_offset);
+    CheckTIDAndKeyIdx(buffer, &payload_offset);
+    EXPECT_EQ(buffer[1] & 0x07, 0);  // Reserved.
   } else {
-    EXPECT_BIT_X_EQ(buffer[0], 0);
+    EXPECT_EQ(x_bit, 0);
   }
 
-  EXPECT_BIT_N_EQ(buffer[0], hdr_info_->nonReference ? 1 : 0);
-  EXPECT_BIT_S_EQ(buffer[0], frag_start ? 1 : 0);
-
-  // Check partition index.
-  if (!sloppy_partitioning_) {
-    // The test payload data is constructed such that the payload value is the
-    // same as the partition index.
-    EXPECT_EQ(buffer[0] & 0x0F, buffer[payload_start_]);
-  } else {
-    // Partition should be set to 0.
-    EXPECT_EQ(buffer[0] & 0x0F, 0);
-  }
+  return payload_offset;
 }
 
 // Verify that the I bit and the PictureID field are both set in accordance
 // with the information in hdr_info_->pictureId.
-void RtpFormatVp8TestHelper::CheckPictureID() {
-  auto buffer = packet_.payload();
+void RtpFormatVp8TestHelper::CheckPictureID(
+    rtc::ArrayView<const uint8_t> buffer,
+    int* offset) {
+  int i_bit = Bit(buffer[1], 7);
   if (hdr_info_->pictureId != kNoPictureId) {
-    EXPECT_BIT_I_EQ(buffer[1], 1);
-    EXPECT_BIT_EQ(buffer[payload_start_], 7, 1);
-    EXPECT_EQ(buffer[payload_start_] & 0x7F,
-              (hdr_info_->pictureId >> 8) & 0x7F);
-    EXPECT_EQ(buffer[payload_start_ + 1], hdr_info_->pictureId & 0xFF);
-    payload_start_ += 2;
+    EXPECT_EQ(i_bit, 1);
+    int two_byte_picture_id = Bit(buffer[*offset], 7);
+    EXPECT_EQ(two_byte_picture_id, 1);
+    EXPECT_EQ(buffer[*offset] & 0x7F, (hdr_info_->pictureId >> 8) & 0x7F);
+    EXPECT_EQ(buffer[(*offset) + 1], hdr_info_->pictureId & 0xFF);
+    (*offset) += 2;
   } else {
-    EXPECT_BIT_I_EQ(buffer[1], 0);
+    EXPECT_EQ(i_bit, 0);
   }
 }
 
 // Verify that the L bit and the TL0PICIDX field are both set in accordance
 // with the information in hdr_info_->tl0PicIdx.
-void RtpFormatVp8TestHelper::CheckTl0PicIdx() {
-  auto buffer = packet_.payload();
+void RtpFormatVp8TestHelper::CheckTl0PicIdx(
+    rtc::ArrayView<const uint8_t> buffer,
+    int* offset) {
+  int l_bit = Bit(buffer[1], 6);
   if (hdr_info_->tl0PicIdx != kNoTl0PicIdx) {
-    EXPECT_BIT_L_EQ(buffer[1], 1);
-    EXPECT_EQ(buffer[payload_start_], hdr_info_->tl0PicIdx);
-    ++payload_start_;
+    EXPECT_EQ(l_bit, 1);
+    EXPECT_EQ(buffer[*offset], hdr_info_->tl0PicIdx);
+    ++*offset;
   } else {
-    EXPECT_BIT_L_EQ(buffer[1], 0);
+    EXPECT_EQ(l_bit, 0);
   }
 }
 
 // Verify that the T bit and the TL0PICIDX field, and the K bit and KEYIDX
 // field are all set in accordance with the information in
 // hdr_info_->temporalIdx and hdr_info_->keyIdx, respectively.
-void RtpFormatVp8TestHelper::CheckTIDAndKeyIdx() {
-  auto buffer = packet_.payload();
+void RtpFormatVp8TestHelper::CheckTIDAndKeyIdx(
+    rtc::ArrayView<const uint8_t> buffer,
+    int* offset) {
+  int t_bit = Bit(buffer[1], 5);
+  int k_bit = Bit(buffer[1], 4);
   if (hdr_info_->temporalIdx == kNoTemporalIdx &&
       hdr_info_->keyIdx == kNoKeyIdx) {
-    EXPECT_BIT_T_EQ(buffer[1], 0);
-    EXPECT_BIT_K_EQ(buffer[1], 0);
+    EXPECT_EQ(t_bit, 0);
+    EXPECT_EQ(k_bit, 0);
     return;
   }
+  int temporal_id = (buffer[*offset] & 0xC0) >> 6;
+  int y_bit = Bit(buffer[*offset], 5);
+  int key_idx = buffer[*offset] & 0x1f;
   if (hdr_info_->temporalIdx != kNoTemporalIdx) {
-    EXPECT_BIT_T_EQ(buffer[1], 1);
-    EXPECT_TID_EQ(buffer[payload_start_], hdr_info_->temporalIdx);
-    EXPECT_BIT_Y_EQ(buffer[payload_start_], hdr_info_->layerSync ? 1 : 0);
+    EXPECT_EQ(t_bit, 1);
+    EXPECT_EQ(temporal_id, hdr_info_->temporalIdx);
+    EXPECT_EQ(y_bit, hdr_info_->layerSync ? 1 : 0);
   } else {
-    EXPECT_BIT_T_EQ(buffer[1], 0);
-    EXPECT_TID_EQ(buffer[payload_start_], 0);
-    EXPECT_BIT_Y_EQ(buffer[payload_start_], 0);
+    EXPECT_EQ(t_bit, 0);
+    EXPECT_EQ(temporal_id, 0);
+    EXPECT_EQ(y_bit, 0);
   }
   if (hdr_info_->keyIdx != kNoKeyIdx) {
-    EXPECT_BIT_K_EQ(buffer[1], 1);
-    EXPECT_KEYIDX_EQ(buffer[payload_start_], hdr_info_->keyIdx);
+    EXPECT_EQ(k_bit, 1);
+    EXPECT_EQ(key_idx, hdr_info_->keyIdx);
   } else {
-    EXPECT_BIT_K_EQ(buffer[1], 0);
-    EXPECT_KEYIDX_EQ(buffer[payload_start_], 0);
+    EXPECT_EQ(k_bit, 0);
+    EXPECT_EQ(key_idx, 0);
   }
-  ++payload_start_;
+  ++*offset;
 }
 
-// Verify that the payload (i.e., after the headers) of the packet stored in
-// buffer_ is identical to the expected (as found in data_ptr_).
-void RtpFormatVp8TestHelper::CheckPayload() {
-  auto buffer = packet_.payload();
-  size_t payload_end = buffer.size();
-  for (size_t i = payload_start_; i < payload_end; ++i, ++data_ptr_)
-    EXPECT_EQ(buffer[i], *data_ptr_);
-}
-
-// Verify that the input variable "last" agrees with the position of data_ptr_.
-// If data_ptr_ has advanced payload_size_ bytes from the start (payload_data_)
-// we are at the end and last should be true. Otherwise, it should be false.
-void RtpFormatVp8TestHelper::CheckLast(bool last) const {
-  EXPECT_EQ(last, data_ptr_ == payload_data_ + payload_size_);
-}
-
-// Verify the contents of a packet. Check the length versus expected_bytes,
-// the header, payload, and "last" flag.
-void RtpFormatVp8TestHelper::CheckPacket(size_t expect_bytes,
-                                         bool last,
-                                         bool frag_start) {
-  EXPECT_EQ(expect_bytes, packet_.payload_size());
-  CheckHeader(frag_start);
-  CheckPayload();
-  CheckLast(last);
-}
-
-}  // namespace test
-
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h b/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
index 7d5a09029d..07f5f6490a 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
+++ b/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
@@ -18,59 +18,39 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP8_TEST_HELPER_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP8_TEST_HELPER_H_
 
-#include "modules/include/module_common_types.h"
+#include "api/array_view.h"
 #include "modules/rtp_rtcp/source/rtp_format_vp8.h"
-#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/video_coding/codecs/vp8/include/vp8_globals.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
-namespace test {
-
 class RtpFormatVp8TestHelper {
  public:
-  explicit RtpFormatVp8TestHelper(const RTPVideoHeaderVP8* hdr);
+  RtpFormatVp8TestHelper(const RTPVideoHeaderVP8* hdr, size_t payload_len);
   ~RtpFormatVp8TestHelper();
-  bool Init(const size_t* partition_sizes, size_t num_partitions);
   void GetAllPacketsAndCheck(RtpPacketizerVp8* packetizer,
-                             const size_t* expected_sizes,
-                             const int* expected_part,
-                             const bool* expected_frag_start,
-                             size_t expected_num_packets);
+                             rtc::ArrayView<const size_t> expected_sizes);
 
-  rtc::ArrayView<const uint8_t> payload() const {
-    return rtc::ArrayView<const uint8_t>(payload_data_, payload_size_);
-  }
-  size_t payload_size() const { return payload_size_; }
-  size_t buffer_size() const {
-    static constexpr size_t kVp8PayloadDescriptorMaxSize = 6;
-    return payload_size_ + kVp8PayloadDescriptorMaxSize;
-  }
-  void set_sloppy_partitioning(bool value) { sloppy_partitioning_ = value; }
+  rtc::ArrayView<const uint8_t> payload() const { return payload_; }
+  size_t payload_size() const { return payload_.size(); }
 
  private:
-  void CheckHeader(bool frag_start);
-  void CheckPictureID();
-  void CheckTl0PicIdx();
-  void CheckTIDAndKeyIdx();
-  void CheckPayload();
-  void CheckLast(bool last) const;
-  void CheckPacket(size_t expect_bytes, bool last, bool frag_start);
+  // Returns header size, i.e. payload offset.
+  int CheckHeader(rtc::ArrayView<const uint8_t> rtp_payload, bool first);
+  void CheckPictureID(rtc::ArrayView<const uint8_t> rtp_payload, int* offset);
+  void CheckTl0PicIdx(rtc::ArrayView<const uint8_t> rtp_payload, int* offset);
+  void CheckTIDAndKeyIdx(rtc::ArrayView<const uint8_t> rtp_payload,
+                         int* offset);
+  void CheckPayload(const uint8_t* data_ptr);
 
-  RtpPacketToSend packet_;
-  uint8_t* payload_data_;
-  uint8_t* data_ptr_;
-  const RTPVideoHeaderVP8* hdr_info_;
-  int payload_start_;
-  size_t payload_size_;
-  bool sloppy_partitioning_;
-  bool inited_;
+  const RTPVideoHeaderVP8* const hdr_info_;
+  rtc::Buffer payload_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtpFormatVp8TestHelper);
 };
 
-}  // namespace test
-
 }  // namespace webrtc
 
 #endif  // MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP8_TEST_HELPER_H_
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc b/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
index b1096d8e14..eb2132d13e 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
@@ -16,10 +16,6 @@
 #include "test/gmock.h"
 #include "test/gtest.h"
 
-#define CHECK_ARRAY_SIZE(expected_size, array)                     \
-  static_assert(expected_size == sizeof(array) / sizeof(array[0]), \
-                "check array size");
-
 namespace webrtc {
 namespace {
 
@@ -27,6 +23,7 @@ using ::testing::ElementsAreArray;
 using ::testing::make_tuple;
 
 constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr;
+constexpr RtpPacketizer::PayloadSizeLimits kNoSizeLimits;
 // Payload descriptor
 //       0 1 2 3 4 5 6 7
 //      +-+-+-+-+-+-+-+-+
@@ -76,67 +73,33 @@ void VerifyExtensions(RTPVideoHeader* header,
   EXPECT_EQ(temporal_idx, header->vp8().temporalIdx);
   EXPECT_EQ(key_idx, header->vp8().keyIdx);
 }
+
 }  // namespace
 
-class RtpPacketizerVp8Test : public ::testing::Test {
- protected:
-  RtpPacketizerVp8Test() : helper_(NULL) {}
-  void TearDown() override { delete helper_; }
-  bool Init(const size_t* partition_sizes, size_t num_partitions) {
-    hdr_info_.pictureId = kNoPictureId;
-    hdr_info_.nonReference = false;
-    hdr_info_.temporalIdx = kNoTemporalIdx;
-    hdr_info_.layerSync = false;
-    hdr_info_.tl0PicIdx = kNoTl0PicIdx;
-    hdr_info_.keyIdx = kNoKeyIdx;
-    if (helper_ != NULL)
-      return false;
-    helper_ = new test::RtpFormatVp8TestHelper(&hdr_info_);
-    return helper_->Init(partition_sizes, num_partitions);
-  }
+TEST(RtpPacketizerVp8Test, ResultPacketsAreAlmostEqualSize) {
+  RTPVideoHeaderVP8 hdr_info;
+  hdr_info.InitRTPVideoHeaderVP8();
+  hdr_info.pictureId = 200;
+  RtpFormatVp8TestHelper helper(&hdr_info, /*payload_len=*/30);
 
-  RTPVideoHeaderVP8 hdr_info_;
-  test::RtpFormatVp8TestHelper* helper_;
-};
-
-// Verify that EqualSize mode is forced if fragmentation info is missing.
-TEST_F(RtpPacketizerVp8Test, TestEqualSizeModeFallback) {
-  const size_t kSizeVector[] = {10, 10, 10};
-  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
-  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
-
-  hdr_info_.pictureId = 200;          // > 0x7F should produce 2-byte PictureID
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 12;  // Small enough to produce 4 packets.
-  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
-  size_t num_packets = packetizer.NumPackets();
+  RtpPacketizerVp8 packetizer(helper.payload(), limits, hdr_info);
 
-  // Expecting three full packets, and one with the remainder.
   const size_t kExpectedSizes[] = {11, 11, 12, 12};
-  const int kExpectedPart[] = {0, 0, 0, 0};  // Always 0 for equal size mode.
-  // Frag start only true for first packet in equal size mode.
-  const bool kExpectedFragStart[] = {true, false, false, false};
-  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
-  ASSERT_EQ(num_packets, kExpectedNum);
-
-  helper_->set_sloppy_partitioning(true);
-  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
-                                 kExpectedFragStart, kExpectedNum);
+  helper.GetAllPacketsAndCheck(&packetizer, kExpectedSizes);
 }
 
-TEST_F(RtpPacketizerVp8Test, TestEqualSizeWithLastPacketReduction) {
-  const size_t kSizeVector[] = {30, 10, 3};
-  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
-  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+TEST(RtpPacketizerVp8Test, EqualSizeWithLastPacketReduction) {
+  RTPVideoHeaderVP8 hdr_info;
+  hdr_info.InitRTPVideoHeaderVP8();
+  hdr_info.pictureId = 200;
+  RtpFormatVp8TestHelper helper(&hdr_info, /*payload_len=*/43);
 
-  hdr_info_.pictureId = 200;
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 15;  // Small enough to produce 5 packets.
   limits.last_packet_reduction_len = 5;
-  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
-  size_t num_packets = packetizer.NumPackets();
+  RtpPacketizerVp8 packetizer(helper.payload(), limits, hdr_info);
 
   // Calculated by hand. VP8 payload descriptors are 4 byte each. 5 packets is
   // minimum possible to fit 43 payload bytes into packets with capacity of
@@ -144,125 +107,63 @@ TEST_F(RtpPacketizerVp8Test, TestEqualSizeWithLastPacketReduction) {
   // almost equal in size, even last packet if counted with free space (which
   // will be filled up the stack by extra long RTP header).
   const size_t kExpectedSizes[] = {13, 13, 14, 14, 9};
-  const int kExpectedPart[] = {0, 0, 0, 0, 0};  // Always 0 for equal size mode.
-  // Frag start only true for first packet in equal size mode.
-  const bool kExpectedFragStart[] = {true, false, false, false, false};
-  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
-  ASSERT_EQ(num_packets, kExpectedNum);
-
-  helper_->set_sloppy_partitioning(true);
-  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
-                                 kExpectedFragStart, kExpectedNum);
+  helper.GetAllPacketsAndCheck(&packetizer, kExpectedSizes);
 }
 
-// Verify that non-reference bit is set. EqualSize mode fallback is expected.
-TEST_F(RtpPacketizerVp8Test, TestNonReferenceBit) {
-  const size_t kSizeVector[] = {10, 10, 10};
-  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
-  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+// Verify that non-reference bit is set.
+TEST(RtpPacketizerVp8Test, NonReferenceBit) {
+  RTPVideoHeaderVP8 hdr_info;
+  hdr_info.InitRTPVideoHeaderVP8();
+  hdr_info.nonReference = true;
+  RtpFormatVp8TestHelper helper(&hdr_info, /*payload_len=*/30);
 
-  hdr_info_.nonReference = true;
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 25;  // Small enough to produce two packets.
-  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
-  size_t num_packets = packetizer.NumPackets();
+  RtpPacketizerVp8 packetizer(helper.payload(), limits, hdr_info);
 
-  // EqualSize mode => First packet full; other not.
   const size_t kExpectedSizes[] = {16, 16};
-  const int kExpectedPart[] = {0, 0};  // Always 0 for equal size mode.
-  // Frag start only true for first packet in equal size mode.
-  const bool kExpectedFragStart[] = {true, false};
-  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
-  ASSERT_EQ(num_packets, kExpectedNum);
-
-  helper_->set_sloppy_partitioning(true);
-  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
-                                 kExpectedFragStart, kExpectedNum);
+  helper.GetAllPacketsAndCheck(&packetizer, kExpectedSizes);
 }
 
 // Verify Tl0PicIdx and TID fields, and layerSync bit.
-TEST_F(RtpPacketizerVp8Test, TestTl0PicIdxAndTID) {
-  const size_t kSizeVector[] = {10, 10, 10};
-  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
-  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+TEST(RtpPacketizerVp8Test, Tl0PicIdxAndTID) {
+  RTPVideoHeaderVP8 hdr_info;
+  hdr_info.InitRTPVideoHeaderVP8();
+  hdr_info.tl0PicIdx = 117;
+  hdr_info.temporalIdx = 2;
+  hdr_info.layerSync = true;
+  RtpFormatVp8TestHelper helper(&hdr_info, /*payload_len=*/30);
 
-  hdr_info_.tl0PicIdx = 117;
-  hdr_info_.temporalIdx = 2;
-  hdr_info_.layerSync = true;
-  RtpPacketizer::PayloadSizeLimits limits;
-  // max_payload_len is only limited by allocated buffer size.
-  limits.max_payload_len = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
-  size_t num_packets = packetizer.NumPackets();
+  RtpPacketizerVp8 packetizer(helper.payload(), kNoSizeLimits, hdr_info);
 
-  // Expect one single packet of payload_size() + 4 bytes header.
-  const size_t kExpectedSizes[1] = {helper_->payload_size() + 4};
-  const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
-  const bool kExpectedFragStart[1] = {true};
-  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
-  ASSERT_EQ(num_packets, kExpectedNum);
-
-  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
-                                 kExpectedFragStart, kExpectedNum);
+  const size_t kExpectedSizes[1] = {helper.payload_size() + 4};
+  helper.GetAllPacketsAndCheck(&packetizer, kExpectedSizes);
 }
 
-// Verify KeyIdx field.
-TEST_F(RtpPacketizerVp8Test, TestKeyIdx) {
-  const size_t kSizeVector[] = {10, 10, 10};
-  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
-  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+TEST(RtpPacketizerVp8Test, KeyIdx) {
+  RTPVideoHeaderVP8 hdr_info;
+  hdr_info.InitRTPVideoHeaderVP8();
+  hdr_info.keyIdx = 17;
+  RtpFormatVp8TestHelper helper(&hdr_info, /*payload_len=*/30);
 
-  hdr_info_.keyIdx = 17;
-  RtpPacketizer::PayloadSizeLimits limits;
-  // max payload len is only limited by allocated buffer size.
-  limits.max_payload_len = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
-  size_t num_packets = packetizer.NumPackets();
+  RtpPacketizerVp8 packetizer(helper.payload(), kNoSizeLimits, hdr_info);
 
-  // Expect one single packet of payload_size() + 3 bytes header.
-  const size_t kExpectedSizes[1] = {helper_->payload_size() + 3};
-  const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
-  const bool kExpectedFragStart[1] = {true};
-  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
-  ASSERT_EQ(num_packets, kExpectedNum);
-
-  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
-                                 kExpectedFragStart, kExpectedNum);
+  const size_t kExpectedSizes[1] = {helper.payload_size() + 3};
+  helper.GetAllPacketsAndCheck(&packetizer, kExpectedSizes);
 }
 
 // Verify TID field and KeyIdx field in combination.
-TEST_F(RtpPacketizerVp8Test, TestTIDAndKeyIdx) {
-  const size_t kSizeVector[] = {10, 10, 10};
-  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
-  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+TEST(RtpPacketizerVp8Test, TIDAndKeyIdx) {
+  RTPVideoHeaderVP8 hdr_info;
+  hdr_info.InitRTPVideoHeaderVP8();
+  hdr_info.temporalIdx = 1;
+  hdr_info.keyIdx = 5;
+  RtpFormatVp8TestHelper helper(&hdr_info, /*payload_len=*/30);
 
-  hdr_info_.temporalIdx = 1;
-  hdr_info_.keyIdx = 5;
-  RtpPacketizer::PayloadSizeLimits limits;
-  // max_payload_len is only limited by allocated buffer size.
-  limits.max_payload_len = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
-  size_t num_packets = packetizer.NumPackets();
+  RtpPacketizerVp8 packetizer(helper.payload(), kNoSizeLimits, hdr_info);
 
-  // Expect one single packet of payload_size() + 3 bytes header.
-  const size_t kExpectedSizes[1] = {helper_->payload_size() + 3};
-  const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
-  const bool kExpectedFragStart[1] = {true};
-  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
-  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
-  ASSERT_EQ(num_packets, kExpectedNum);
-
-  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
-                                 kExpectedFragStart, kExpectedNum);
+  const size_t kExpectedSizes[1] = {helper.payload_size() + 3};
+  helper.GetAllPacketsAndCheck(&packetizer, kExpectedSizes);
 }
 
 class RtpDepacketizerVp8Test : public ::testing::Test {
@@ -274,10 +175,9 @@ class RtpDepacketizerVp8Test : public ::testing::Test {
                     const uint8_t* data,
                     size_t length) {
     ASSERT_TRUE(parsed_payload != NULL);
-    EXPECT_THAT(std::vector<uint8_t>(
-                    parsed_payload->payload,
-                    parsed_payload->payload + parsed_payload->payload_length),
-                ::testing::ElementsAreArray(data, length));
+    EXPECT_THAT(
+        make_tuple(parsed_payload->payload, parsed_payload->payload_length),
+        ElementsAreArray(data, length));
   }
 
   std::unique_ptr<RtpDepacketizer> depacketizer_;