Replace scoped_ptr with unique_ptr in webrtc/video/

webrtc/video/replay.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.
  */
 
 #include <stdio.h>
 
 #include <map>
+#include <memory>
 #include <sstream>
 
 #include "gflags/gflags.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/checks.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/call.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/fake_decoder.h"
 #include "webrtc/test/rtp_file_reader.h"
 #include "webrtc/test/run_loop.h"
@@ skipping 171 matching lines @@
 
   virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
     fwrite(encoded_frame.data_, 1, encoded_frame.length_, file_);
   }
 
  private:
   FILE* file_;
 };
 
 void RtpReplay() {
-  rtc::scoped_ptr<test::VideoRenderer> playback_video(
+  std::unique_ptr<test::VideoRenderer> playback_video(
       test::VideoRenderer::Create("Playback Video", 640, 480));
   FileRenderPassthrough file_passthrough(flags::OutBase(),
                                          playback_video.get());
 
-  rtc::scoped_ptr<Call> call(Call::Create(Call::Config()));
+  std::unique_ptr<Call> call(Call::Create(Call::Config()));
 
   test::NullTransport transport;
   VideoReceiveStream::Config receive_config(&transport);
   receive_config.rtp.remote_ssrc = flags::Ssrc();
   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
   receive_config.rtp.fec.ulpfec_payload_type = flags::FecPayloadType();
   receive_config.rtp.fec.red_payload_type = flags::RedPayloadType();
   receive_config.rtp.nack.rtp_history_ms = 1000;
   if (flags::TransmissionOffsetId() != -1) {
     receive_config.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kTOffset, flags::TransmissionOffsetId()));
   }
   if (flags::AbsSendTimeId() != -1) {
     receive_config.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kAbsSendTime, flags::AbsSendTimeId()));
   }
   receive_config.renderer = &file_passthrough;
 
   VideoSendStream::Config::EncoderSettings encoder_settings;
   encoder_settings.payload_name = flags::Codec();
   encoder_settings.payload_type = flags::PayloadType();
   VideoReceiveStream::Decoder decoder;
-  rtc::scoped_ptr<DecoderBitstreamFileWriter> bitstream_writer;
+  std::unique_ptr<DecoderBitstreamFileWriter> bitstream_writer;
   if (!flags::DecoderBitstreamFilename().empty()) {
     bitstream_writer.reset(new DecoderBitstreamFileWriter(
         flags::DecoderBitstreamFilename().c_str()));
     receive_config.pre_decode_callback = bitstream_writer.get();
   }
   decoder = test::CreateMatchingDecoder(encoder_settings);
   if (!flags::DecoderBitstreamFilename().empty()) {
     // Replace with a null decoder if we're writing the bitstream to a file
     // instead.
     delete decoder.decoder;
     decoder.decoder = new test::FakeNullDecoder();
   }
   receive_config.decoders.push_back(decoder);
 
   VideoReceiveStream* receive_stream =
       call->CreateVideoReceiveStream(receive_config);
 
-  rtc::scoped_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create(
+  std::unique_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create(
       test::RtpFileReader::kRtpDump, flags::InputFile()));
   if (rtp_reader.get() == nullptr) {
     rtp_reader.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
                                                  flags::InputFile()));
     if (rtp_reader.get() == nullptr) {
       fprintf(stderr,
               "Couldn't open input file as either a rtpdump or .pcap. Note "
               "that .pcapng is not supported.\nTrying to interpret the file as "
               "length/packet interleaved.\n");
       rtp_reader.reset(test::RtpFileReader::Create(
@@ skipping 14 matching lines @@
     test::RtpPacket packet;
     if (!rtp_reader->NextPacket(&packet))
       break;
     ++num_packets;
     switch (call->Receiver()->DeliverPacket(webrtc::MediaType::ANY, packet.data,
                                             packet.length, PacketTime())) {
       case PacketReceiver::DELIVERY_OK:
         break;
       case PacketReceiver::DELIVERY_UNKNOWN_SSRC: {
         RTPHeader header;
-        rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
+        std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
         parser->Parse(packet.data, packet.length, &header);
         if (unknown_packets[header.ssrc] == 0)
           fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc);
         ++unknown_packets[header.ssrc];
         break;
       }
       case PacketReceiver::DELIVERY_PACKET_ERROR:
         fprintf(stderr, "Packet error, corrupt packets or incorrect setup?\n");
         break;
     }
@@ skipping 17 matching lines @@
 }
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   ::testing::InitGoogleTest(&argc, argv);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
   webrtc::test::RunTest(webrtc::RtpReplay);
   return 0;
 }