Let PacketSource::NextPacket() return an std::unique_ptr

webrtc/modules/audio_coding/acm2/audio_coding_module_unittest_oldapi.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.
  */
 
@@ skipping 1131 matching lines @@
     checksum_string = rtc::hex_encode(checksum_result, rtc::Md5Digest::kSize);
     EXPECT_EQ(payload_checksum_ref, checksum_string);
 
     // Verify number of packets produced.
     EXPECT_EQ(expected_packets, packet_count_);
 
     // Delete the output file.
     remove(output_file_name.c_str());
   }
 
-  // Returns a pointer to the next packet. Returns NULL if the source is
-  // depleted (i.e., the test duration is exceeded), or if an error occurred.
   // Inherited from test::PacketSource.
-  test::Packet* NextPacket() override {
+  std::unique_ptr<test::Packet> NextPacket() override {
     // Get the next packet from AcmSendTest. Ownership of |packet| is
     // transferred to this method.

[kwiberg-webrtc, 2016/05/24 09:04:56]

The last sentence is no longer needed. Perhaps the whole comment can be
eliminated?

[hlundin-webrtc, 2016/05/24 10:59:15]

Done.

-    test::Packet* packet = send_test_->NextPacket();
+    auto packet = send_test_->NextPacket();
     if (!packet)
       return NULL;
 
-    VerifyPacket(packet);
+    VerifyPacket(packet.get());
     // TODO(henrik.lundin) Save the packet to file as well.
 
     // Pass it on to the caller. The caller becomes the owner of |packet|.
     return packet;
   }
 
   // Verifies the packet.
   void VerifyPacket(const test::Packet* packet) {
     EXPECT_TRUE(packet->valid_header());
     // (We can check the header fields even if valid_header() is false.)
@@ skipping 300 matching lines @@
     return send_test_->RegisterCodec(payload_name, sampling_freq_hz, channels,
                                      payload_type, frame_size_samples);
   }
 
   // Runs the test. SetUpSender() and RegisterSendCodec() must have been called
   // before calling this method.
   void Run(int target_bitrate_bps, int expected_total_bits) {
     ASSERT_TRUE(send_test_->acm());
     send_test_->acm()->SetBitRate(target_bitrate_bps);
     int nr_bytes = 0;
-    while (test::Packet* next_packet = send_test_->NextPacket()) {
+    while (std::unique_ptr<test::Packet> next_packet =
+               send_test_->NextPacket()) {
       nr_bytes += next_packet->payload_length_bytes();
-      delete next_packet;
     }
     EXPECT_EQ(expected_total_bits, nr_bytes * 8);
   }
 
   void SetUpTest(const char* codec_name,
                  int codec_sample_rate_hz,
                  int channels,
                  int payload_type,
                  int codec_frame_size_samples,
                  int codec_frame_size_rtp_timestamps) {
@@ skipping 74 matching lines @@
   // Runs the test. SetUpSender() and RegisterSendCodec() must have been called
   // before calling this method.
   void Run(int target_bitrate_bps,
            int expected_before_switch_bits,
            int expected_after_switch_bits) {
     ASSERT_TRUE(send_test_->acm());
     int nr_packets =
         sampling_freq_hz_ * kTestDurationMs / (frame_size_samples_ * 1000);
     int nr_bytes_before = 0, nr_bytes_after = 0;
     int packet_counter = 0;
-    while (test::Packet* next_packet = send_test_->NextPacket()) {
+    while (std::unique_ptr<test::Packet> next_packet =
+               send_test_->NextPacket()) {
       if (packet_counter == nr_packets / 2)
         send_test_->acm()->SetBitRate(target_bitrate_bps);
       if (packet_counter < nr_packets / 2)
         nr_bytes_before += next_packet->payload_length_bytes();
       else
         nr_bytes_after += next_packet->payload_length_bytes();
       packet_counter++;
-      delete next_packet;
     }
     EXPECT_EQ(expected_before_switch_bits, nr_bytes_before * 8);
     EXPECT_EQ(expected_after_switch_bits, nr_bytes_after * 8);
   }
 
   uint32_t sampling_freq_hz_;
   uint32_t frame_size_samples_;
 };
 
 TEST_F(AcmChangeBitRateOldApi, Opus_48khz_20ms_10kbps) {
@@ skipping 127 matching lines @@
     output_freq_2_ = output_freq_2;
 
     // This is where the actual test is executed.
     receive_test.Run();
 
     // Delete output file.
     remove(output_file_name.c_str());
   }
 
   // Inherited from test::PacketSource.
-  test::Packet* NextPacket() override {
+  std::unique_ptr<test::Packet> NextPacket() override {
     // Check if it is time to terminate the test. The packet source is of type
     // ConstantPcmPacketSource, which is infinite, so we must end the test
     // "manually".
     if (num_packets_++ > kTestNumPackets) {
       EXPECT_TRUE(has_toggled_);
       return NULL;  // Test ended.
     }
 
     // Get the next packet from the source.
     return packet_source_.NextPacket();
@@ skipping 42 matching lines @@
   Run(16000, 8000, 1000);
 }
 
 TEST_F(AcmSwitchingOutputFrequencyOldApi, Toggle8KhzTo16Khz) {
   Run(8000, 16000, 1000);
 }
 
 #endif
 
 }  // namespace webrtc