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

webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc

 /*
  *  Copyright (c) 2013 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 475 matching lines @@
   std::unique_ptr<uint8_t[]> payload;
   size_t payload_mem_size_bytes = 0;
   if (replace_payload) {
     // Initially assume that the frame size is 30 ms at the initial sample rate.
     // This value will be replaced with the correct one as soon as two
     // consecutive packets are found.
     input_frame_size_timestamps = 30 * sample_rate_hz / 1000;
     replacement_audio.reset(new int16_t[input_frame_size_timestamps]);
     payload_mem_size_bytes = 2 * input_frame_size_timestamps;
     payload.reset(new uint8_t[payload_mem_size_bytes]);
-    next_packet.reset(file_source->NextPacket());
+    next_packet = file_source->NextPacket();
     assert(next_packet);
     next_packet_available = true;
   }
 
   // This is the main simulation loop.
   // Set the simulation clock to start immediately with the first packet.
   int64_t start_time_ms = rtc::checked_cast<int64_t>(packet->time_ms());
   int64_t time_now_ms = start_time_ms;
   int64_t next_input_time_ms = time_now_ms;
   int64_t next_output_time_ms = time_now_ms;
@@ skipping 52 matching lines @@
           std::cerr << "  PT = "
                     << static_cast<int>(rtp_header.header.payloadType)
                     << std::endl;
           std::cerr << "  SN = " << rtp_header.header.sequenceNumber
                     << std::endl;
           std::cerr << "  TS = " << rtp_header.header.timestamp << std::endl;
         }
       }
 
       // Get next packet from file.
-      Packet* temp_packet = file_source->NextPacket();
+      std::unique_ptr<Packet> temp_packet = file_source->NextPacket();
       if (temp_packet) {
-        packet.reset(temp_packet);
+        packet = std::move(temp_packet);
         if (replace_payload) {
           // At this point |packet| contains the packet *after* |next_packet|.
           // Swap Packet objects between |packet| and |next_packet|.
           packet.swap(next_packet);
           // Swap the status indicators unless they're already the same.
           if (packet_available != next_packet_available) {
             packet_available = !packet_available;
             next_packet_available = !next_packet_available;
           }
         }
         next_input_time_ms = rtc::checked_cast<int64_t>(packet->time_ms());
       } else {
         // Set next input time to the maximum value of int64_t to prevent the
         // time_now_ms from becoming stuck at the final value.
         next_input_time_ms = std::numeric_limits<int64_t>::max();
         packet_available = false;
       }
+      RTC_DCHECK(!temp_packet);  // Must have transferred to another variable.
     }
 
     // Check if it is time to get output audio.
     while (time_now_ms >= next_output_time_ms && output_event_available) {
       AudioFrame out_frame;
       bool muted;
       int error = neteq->GetAudio(&out_frame, &muted);
       RTC_CHECK(!muted);
       if (error != NetEq::kOK) {
         std::cerr << "GetAudio returned error code " <<
@@ skipping 25 matching lines @@
   printf("Produced %i ms of audio\n",
          static_cast<int>(time_now_ms - start_time_ms));
 
   delete neteq;
   Trace::ReturnTrace();
   return 0;
 }
 
 }  // namespace test
 }  // namespace webrtc