Delete unused support for vp8 partitions.

webrtc/modules/video_coding/session_info_unittest.cc

 /*
  *  Copyright (c) 2012 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 43 matching lines @@
   enum { kPacketBufferSize = 10 };
 
   uint8_t packet_buffer_[kPacketBufferSize];
   uint8_t frame_buffer_[10 * kPacketBufferSize];
 
   VCMSessionInfo session_;
   VCMPacket packet_;
   FrameData frame_data;
 };
 
-class TestVP8Partitions : public TestSessionInfo {
- protected:
-  enum { kMaxVP8Partitions = 9 };
-
-  virtual void SetUp() {
-    TestSessionInfo::SetUp();
-    vp8_header_ = &packet_header_.type.Video.codecHeader.VP8;
-    packet_header_.frameType = kVideoFrameDelta;
-    packet_header_.type.Video.codec = kRtpVideoVp8;
-    vp8_header_->InitRTPVideoHeaderVP8();
-    fragmentation_.VerifyAndAllocateFragmentationHeader(kMaxVP8Partitions);
-  }
-
-  bool VerifyPartition(int partition_id,
-                       int packets_expected,
-                       int start_value) {
-    EXPECT_EQ(packets_expected * packet_buffer_size(),
-              fragmentation_.fragmentationLength[partition_id]);
-    for (int i = 0; i < packets_expected; ++i) {
-      size_t packet_index = fragmentation_.fragmentationOffset[partition_id] +
-                            i * packet_buffer_size();
-      if (packet_index + packet_buffer_size() > frame_buffer_size())
-        return false;
-      VerifyPacket(frame_buffer_ + packet_index, start_value + i);
-    }
-    return true;
-  }
-
-  WebRtcRTPHeader packet_header_;
-  RTPVideoHeaderVP8* vp8_header_;
-  RTPFragmentationHeader fragmentation_;
-};
-
 class TestNalUnits : public TestSessionInfo {
  protected:
   virtual void SetUp() {
     TestSessionInfo::SetUp();
     packet_.codec = kVideoCodecVP8;
   }
 
   bool VerifyNalu(int offset, int packets_expected, int start_value) {
     EXPECT_GE(session_.SessionLength(),
               packets_expected * packet_buffer_size());
@@ skipping 302 matching lines @@
                                                       kNoErrors, frame_data)));
 
   packet_.seqNum = 0x0009;
   packet_.isFirstPacket = false;
   packet_.markerBit = false;
   FillPacket(1);
   EXPECT_EQ(
       -3, session_.InsertPacket(packet_, frame_buffer_, kNoErrors, frame_data));
 }
 
-TEST_F(TestVP8Partitions, TwoPartitionsOneLoss) {
-  // Partition 0 | Partition 1
-  // [ 0 ] [ 2 ] | [ 3 ]
-  packet_header_.type.Video.isFirstPacket = true;
-  vp8_header_->beginningOfPartition = true;
-  vp8_header_->partitionId = 0;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber = 0;
-  FillPacket(0);
-  VCMPacket* packet =
-      new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 0;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 2;
-  FillPacket(2);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = true;
-  packet_header_.header.markerBit = true;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(3);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  // One packet should be removed (end of partition 0).
-  EXPECT_EQ(2 * packet_buffer_size(),
-            session_.BuildVP8FragmentationHeader(
-                frame_buffer_, frame_buffer_size(), &fragmentation_));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(0, 1, 0));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(1, 1, 3));
-}
-
-TEST_F(TestVP8Partitions, TwoPartitionsOneLoss2) {
-  // Partition 0 | Partition 1
-  // [ 1 ] [ 2 ] | [ 3 ] [ 5 ]
-  packet_header_.type.Video.isFirstPacket = true;
-  vp8_header_->beginningOfPartition = true;
-  vp8_header_->partitionId = 0;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber = 1;
-  FillPacket(1);
-  VCMPacket* packet =
-      new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 0;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(2);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = true;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(3);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = true;
-  packet_header_.header.sequenceNumber += 2;
-  FillPacket(5);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  // One packet should be removed (end of partition 2), 3 left.
-  EXPECT_EQ(3 * packet_buffer_size(),
-            session_.BuildVP8FragmentationHeader(
-                frame_buffer_, frame_buffer_size(), &fragmentation_));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(0, 2, 1));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(1, 1, 3));
-}
-
-TEST_F(TestVP8Partitions, TwoPartitionsNoLossWrap) {
-  // Partition 0       | Partition 1
-  // [ fffd ] [ fffe ] | [ ffff ] [ 0 ]
-  packet_header_.type.Video.isFirstPacket = true;
-  vp8_header_->beginningOfPartition = true;
-  vp8_header_->partitionId = 0;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber = 0xfffd;
-  FillPacket(0);
-  VCMPacket* packet =
-      new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 0;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(1);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = true;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(2);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = true;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(3);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  // No packet should be removed.
-  EXPECT_EQ(4 * packet_buffer_size(),
-            session_.BuildVP8FragmentationHeader(
-                frame_buffer_, frame_buffer_size(), &fragmentation_));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(0, 2, 0));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(1, 2, 2));
-}
-
-TEST_F(TestVP8Partitions, TwoPartitionsLossWrap) {
-  // Partition 0       | Partition 1
-  // [ fffd ] [ fffe ] | [ ffff ] [ 1 ]
-  packet_header_.type.Video.isFirstPacket = true;
-  vp8_header_->beginningOfPartition = true;
-  vp8_header_->partitionId = 0;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber = 0xfffd;
-  FillPacket(0);
-  VCMPacket* packet =
-      new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 0;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(1);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = true;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(2);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = true;
-  packet_header_.header.sequenceNumber += 2;
-  FillPacket(3);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  // One packet should be removed from the last partition
-  EXPECT_EQ(3 * packet_buffer_size(),
-            session_.BuildVP8FragmentationHeader(
-                frame_buffer_, frame_buffer_size(), &fragmentation_));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(0, 2, 0));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(1, 1, 2));
-}
-
-TEST_F(TestVP8Partitions, ThreePartitionsOneMissing) {
-  // Partition 1  |Partition 2    | Partition 3
-  // [ 1 ] [ 2 ]  |               | [ 5 ] | [ 6 ]
-  packet_header_.type.Video.isFirstPacket = true;
-  vp8_header_->beginningOfPartition = true;
-  vp8_header_->partitionId = 0;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber = 1;
-  FillPacket(1);
-  VCMPacket* packet =
-      new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 0;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(2);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 2;
-  vp8_header_->beginningOfPartition = true;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 3;
-  FillPacket(5);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 2;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = true;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(6);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  // No packet should be removed.
-  EXPECT_EQ(4 * packet_buffer_size(),
-            session_.BuildVP8FragmentationHeader(
-                frame_buffer_, frame_buffer_size(), &fragmentation_));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(0, 2, 1));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(2, 2, 5));
-}
-
-TEST_F(TestVP8Partitions, ThreePartitionsLossInSecond) {
-  // Partition 0  |Partition 1          | Partition 2
-  // [ 1 ] [ 2 ]  |        [ 4 ] [ 5 ]  | [ 6 ] [ 7 ]
-  packet_header_.type.Video.isFirstPacket = true;
-  vp8_header_->beginningOfPartition = true;
-  vp8_header_->partitionId = 0;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber = 1;
-  FillPacket(1);
-  VCMPacket* packet =
-      new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 0;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(2);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 2;
-  FillPacket(4);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(5);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 2;
-  vp8_header_->beginningOfPartition = true;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(6);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 2;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = true;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(7);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  // 2 partitions left. 2 packets removed from second partition
-  EXPECT_EQ(4 * packet_buffer_size(),
-            session_.BuildVP8FragmentationHeader(
-                frame_buffer_, frame_buffer_size(), &fragmentation_));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(0, 2, 1));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(2, 2, 6));
-}
-
-TEST_F(TestVP8Partitions, AggregationOverTwoPackets) {
-  // Partition 0   | Partition 1         | Partition 2
-  // [ 0           |           ]  [ 1 ]  | [ 2 ]
-  packet_header_.type.Video.isFirstPacket = true;
-  vp8_header_->beginningOfPartition = true;
-  vp8_header_->partitionId = 0;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber = 0;
-  FillPacket(0);
-  VCMPacket* packet =
-      new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 1;
-  vp8_header_->beginningOfPartition = false;
-  packet_header_.header.markerBit = false;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(1);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  packet_header_.type.Video.isFirstPacket = false;
-  vp8_header_->partitionId = 2;
-  vp8_header_->beginningOfPartition = true;
-  packet_header_.header.markerBit = true;
-  packet_header_.header.sequenceNumber += 1;
-  FillPacket(2);
-  packet = new VCMPacket(packet_buffer_, packet_buffer_size(), packet_header_);
-  EXPECT_EQ(packet_buffer_size(),
-            static_cast<size_t>(session_.InsertPacket(*packet, frame_buffer_,
-                                                      kNoErrors, frame_data)));
-  delete packet;
-
-  // No packets removed.
-  EXPECT_EQ(3 * packet_buffer_size(),
-            session_.BuildVP8FragmentationHeader(
-                frame_buffer_, frame_buffer_size(), &fragmentation_));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(0, 2, 0));
-  // This partition is aggregated in partition 0
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(1, 0, 0));
-  SCOPED_TRACE("Calling VerifyPartition");
-  EXPECT_TRUE(VerifyPartition(2, 1, 2));
-}
-
 TEST_F(TestNalUnits, OnlyReceivedEmptyPacket) {
   packet_.isFirstPacket = false;
   packet_.completeNALU = kNaluComplete;
   packet_.frameType = kEmptyFrame;
   packet_.sizeBytes = 0;
   packet_.seqNum = 0;
   packet_.markerBit = false;
   EXPECT_EQ(
       0, session_.InsertPacket(packet_, frame_buffer_, kNoErrors, frame_data));
 
@@ skipping 155 matching lines @@
   FillPacket(1);
   EXPECT_EQ(packet_buffer_size(),
             static_cast<size_t>(session_.InsertPacket(packet_, frame_buffer_,
                                                       kNoErrors, frame_data)));
 
   EXPECT_EQ(2 * packet_buffer_size(), session_.MakeDecodable());
   EXPECT_EQ(0U, session_.SessionLength());
 }
 
 }  // namespace webrtc