NetEq: Changed Packet::payload to be an rtc::Buffer

webrtc/modules/audio_coding/neteq/packet_buffer_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 41 matching lines @@
 
 Packet* PacketGenerator::NextPacket(int payload_size_bytes) {
   Packet* packet = new Packet;
   packet->header.sequenceNumber = seq_no_;
   packet->header.timestamp = ts_;
   packet->header.payloadType = pt_;
   packet->header.markerBit = false;
   packet->header.ssrc = 0x12345678;
   packet->header.numCSRCs = 0;
   packet->header.paddingLength = 0;
-  packet->payload_length = payload_size_bytes;
   packet->primary = true;
-  packet->payload = new uint8_t[payload_size_bytes];
+  packet->payload = rtc::Buffer(payload_size_bytes);

[kwiberg-webrtc, 2016/08/30 16:04:36]

packet->payload.SetSize(payload_size_bytes);

Also, I wonder what the test is doing with all those uninitialized packets...

[ossu, 2016/08/30 16:27:14]

Acknowledged.

   ++seq_no_;
   ts_ += frame_size_;
   return packet;
 }
 
 struct PacketsToInsert {
   uint16_t sequence_number;
   uint32_t timestamp;
   uint8_t payload_type;
   bool primary;
@@ skipping 200 matching lines @@
     }
   }
 
   EXPECT_EQ(kExpectPacketsInBuffer, buffer.NumPacketsInBuffer());
 
   size_t drop_count;
   for (size_t i = 0; i < kExpectPacketsInBuffer; ++i) {
     Packet* packet = buffer.GetNextPacket(&drop_count);
     EXPECT_EQ(0u, drop_count);
     EXPECT_EQ(packet, expect_order[i]);  // Compare pointer addresses.
-    delete[] packet->payload;
     delete packet;
   }
   EXPECT_TRUE(buffer.Empty());
 }
 
 TEST(PacketBuffer, DiscardPackets) {
   TickTimer tick_timer;
   PacketBuffer buffer(100, &tick_timer);  // 100 packets.
   const uint16_t start_seq_no = 17;
   const uint32_t start_ts = 4711;
@@ skipping 54 matching lines @@
                                                        &current_cng_pt));
   EXPECT_EQ(10u, buffer.NumPacketsInBuffer());
 
   // Extract them and make sure that come out in the right order.
   uint32_t current_ts = start_ts;
   for (int i = 0; i < 10; ++i) {
     Packet* packet = buffer.GetNextPacket(NULL);
     ASSERT_FALSE(packet == NULL);
     EXPECT_EQ(current_ts, packet->header.timestamp);
     current_ts += ts_increment;
-    delete [] packet->payload;
     delete packet;
   }
   EXPECT_TRUE(buffer.Empty());
 
   EXPECT_CALL(decoder_database, Die());  // Called when object is deleted.
 }
 
 TEST(PacketBuffer, Failures) {
   const uint16_t start_seq_no = 17;
   const uint32_t start_ts = 4711;
   const uint32_t ts_increment = 10;
   int payload_len = 100;
   PacketGenerator gen(start_seq_no, start_ts, 0, ts_increment);
   TickTimer tick_timer;
 
   PacketBuffer* buffer = new PacketBuffer(100, &tick_timer);  // 100 packets.
   Packet* packet = NULL;
   EXPECT_EQ(PacketBuffer::kInvalidPacket, buffer->InsertPacket(packet));
   packet = gen.NextPacket(payload_len);
-  delete [] packet->payload;
-  packet->payload = NULL;
+  packet->payload.Clear();
   EXPECT_EQ(PacketBuffer::kInvalidPacket, buffer->InsertPacket(packet));
   // Packet is deleted by the PacketBuffer.
 
   // Buffer should still be empty. Test all empty-checks.
   uint32_t temp_ts;
   EXPECT_EQ(PacketBuffer::kBufferEmpty, buffer->NextTimestamp(&temp_ts));
   EXPECT_EQ(PacketBuffer::kBufferEmpty,
             buffer->NextHigherTimestamp(0, &temp_ts));
   EXPECT_EQ(NULL, buffer->NextRtpHeader());
   EXPECT_EQ(NULL, buffer->GetNextPacket(NULL));
   EXPECT_EQ(PacketBuffer::kBufferEmpty, buffer->DiscardNextPacket());
   EXPECT_EQ(0, buffer->DiscardAllOldPackets(0));  // 0 packets discarded.
 
   // Insert one packet to make the buffer non-empty.
   packet = gen.NextPacket(payload_len);
   EXPECT_EQ(PacketBuffer::kOK, buffer->InsertPacket(packet));
   EXPECT_EQ(PacketBuffer::kInvalidPointer, buffer->NextTimestamp(NULL));
   EXPECT_EQ(PacketBuffer::kInvalidPointer,
             buffer->NextHigherTimestamp(0, NULL));
   delete buffer;
 
   // Insert packet list of three packets, where the second packet has an invalid
   // payload.  Expect first packet to be inserted, and the remaining two to be
   // discarded.
   buffer = new PacketBuffer(100, &tick_timer);  // 100 packets.
   PacketList list;
   list.push_back(gen.NextPacket(payload_len));  // Valid packet.
   packet = gen.NextPacket(payload_len);
-  delete [] packet->payload;
-  packet->payload = NULL;  // Invalid.
+  packet->payload.Clear();  // Invalid.
   list.push_back(packet);
   list.push_back(gen.NextPacket(payload_len));  // Valid packet.
   MockDecoderDatabase decoder_database;
   uint8_t current_pt = 0xFF;
   uint8_t current_cng_pt = 0xFF;
   EXPECT_EQ(PacketBuffer::kInvalidPacket,
             buffer->InsertPacketList(&list,
                                      decoder_database,
                                      &current_pt,
                                      &current_cng_pt));
@@ skipping 55 matching lines @@
   a->header.sequenceNumber = b->header.sequenceNumber;
   a->primary = false;
   b->primary = true;
   EXPECT_FALSE(*a == *b);
   EXPECT_TRUE(*a != *b);
   EXPECT_FALSE(*a < *b);
   EXPECT_TRUE(*a > *b);
   EXPECT_FALSE(*a <= *b);
   EXPECT_TRUE(*a >= *b);
 
-  delete [] a->payload;
   delete a;
-  delete [] b->payload;
   delete b;
 }
 
 // Test the DeleteFirstPacket DeleteAllPackets methods.
 TEST(PacketBuffer, DeleteAllPackets) {
   PacketGenerator gen(0, 0, 0, 10);
   PacketList list;
   const int payload_len = 10;
 
   // Insert 10 small packets.
@@ skipping 64 matching lines @@
 // Test the IsObsoleteTimestamp method with different limit timestamps.
 TEST(PacketBuffer, IsObsoleteTimestamp) {
   TestIsObsoleteTimestamp(0);
   TestIsObsoleteTimestamp(1);
   TestIsObsoleteTimestamp(0xFFFFFFFF);  // -1 in uint32_t.
   TestIsObsoleteTimestamp(0x80000000);  // 2^31.
   TestIsObsoleteTimestamp(0x80000001);  // 2^31 + 1.
   TestIsObsoleteTimestamp(0x7FFFFFFF);  // 2^31 - 1.
 }
 }  // namespace webrtc