Replace scoped_ptr with unique_ptr in webrtc/modules/video_coding/

webrtc/modules/video_coding/test/rtp_player.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.
  */
 
 #include "webrtc/modules/video_coding/test/rtp_player.h"
 
 #include <stdio.h>
 
 #include <map>
+#include <memory>
 
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 #include "webrtc/modules/video_coding/test/test_util.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/test/rtp_file_reader.h"
 
@@ skipping 27 matching lines @@
   }
 
   const uint8_t* data() const { return data_.get(); }
   size_t length() const { return length_; }
   int64_t resend_time_ms() const { return resend_time_ms_; }
   void set_resend_time_ms(int64_t timeMs) { resend_time_ms_ = timeMs; }
   uint32_t ssrc() const { return ssrc_; }
   uint16_t seq_num() const { return seq_num_; }
 
  private:
-  rtc::scoped_ptr<uint8_t[]> data_;
+  std::unique_ptr<uint8_t[]> data_;
   size_t length_;
   int64_t resend_time_ms_;
   uint32_t ssrc_;
   uint16_t seq_num_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RawRtpPacket);
 };
 
 class LostPackets {
  public:
@@ skipping 94 matching lines @@
       printf("%u, ", (*it)->seq_num());
     }
     printf("\n");
   }
 
  private:
   typedef std::vector<RawRtpPacket*> RtpPacketList;
   typedef RtpPacketList::iterator RtpPacketIterator;
   typedef RtpPacketList::const_iterator ConstRtpPacketIterator;
 
-  rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
+  std::unique_ptr<CriticalSectionWrapper> crit_sect_;
   FILE* debug_file_;
   int loss_count_;
   RtpPacketList packets_;
   Clock* clock_;
   int64_t rtt_ms_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(LostPackets);
 };
 
 class SsrcHandlers {
@@ skipping 12 matching lines @@
       handlers_.erase(handlers_.begin());
     }
   }
 
   int RegisterSsrc(uint32_t ssrc, LostPackets* lost_packets, Clock* clock) {
     if (handlers_.count(ssrc) > 0) {
       return 0;
     }
     DEBUG_LOG1("Registering handler for ssrc=%08x", ssrc);
 
-    rtc::scoped_ptr<Handler> handler(
+    std::unique_ptr<Handler> handler(
         new Handler(ssrc, payload_types_, lost_packets));
     handler->payload_sink_.reset(payload_sink_factory_->Create(handler.get()));
     if (handler->payload_sink_.get() == NULL) {
       return -1;
     }
 
     RtpRtcp::Configuration configuration;
     configuration.clock = clock;
     configuration.audio = false;
     handler->rtp_module_.reset(RtpReceiver::CreateVideoReceiver(
@@ skipping 61 matching lines @@
                                uint16_t length) {
       assert(sequence_numbers);
       for (uint16_t i = 0; i < length; i++) {
         lost_packets_->SetResendTime(ssrc_, sequence_numbers[i]);
       }
     }
 
     virtual uint32_t ssrc() const { return ssrc_; }
     virtual const PayloadTypes& payload_types() const { return payload_types_; }
 
-    rtc::scoped_ptr<RtpHeaderParser> rtp_header_parser_;
-    rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
-    rtc::scoped_ptr<RtpReceiver> rtp_module_;
-    rtc::scoped_ptr<PayloadSinkInterface> payload_sink_;
+    std::unique_ptr<RtpHeaderParser> rtp_header_parser_;
+    std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_;
+    std::unique_ptr<RtpReceiver> rtp_module_;
+    std::unique_ptr<PayloadSinkInterface> payload_sink_;
 
    private:
     uint32_t ssrc_;
     const PayloadTypes& payload_types_;
     LostPackets* lost_packets_;
 
     RTC_DISALLOW_COPY_AND_ASSIGN(Handler);
   };
 
   typedef std::map<uint32_t, Handler*> HandlerMap;
   typedef std::map<uint32_t, Handler*>::iterator HandlerMapIt;
 
   PayloadSinkFactoryInterface* payload_sink_factory_;
   PayloadTypes payload_types_;
   HandlerMap handlers_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(SsrcHandlers);
 };
 
 class RtpPlayerImpl : public RtpPlayerInterface {
  public:
   RtpPlayerImpl(PayloadSinkFactoryInterface* payload_sink_factory,
                 const PayloadTypes& payload_types,
                 Clock* clock,
-                rtc::scoped_ptr<test::RtpFileReader>* packet_source,
+                std::unique_ptr<test::RtpFileReader>* packet_source,
                 float loss_rate,
                 int64_t rtt_ms,
                 bool reordering)
       : ssrc_handlers_(payload_sink_factory, payload_types),
         clock_(clock),
         next_rtp_time_(0),
         first_packet_(true),
         first_packet_rtp_time_(0),
         first_packet_time_ms_(0),
         loss_rate_(loss_rate),
@@ skipping 78 matching lines @@
   virtual void Print() const {
     printf("Resent packets: %u\n", resend_packet_count_);
     lost_packets_.Print();
   }
 
  private:
   int SendPacket(const uint8_t* data, size_t length) {
     assert(data);
     assert(length > 0);
 
-    rtc::scoped_ptr<RtpHeaderParser> rtp_header_parser(
+    std::unique_ptr<RtpHeaderParser> rtp_header_parser(
         RtpHeaderParser::Create());
     if (!rtp_header_parser->IsRtcp(data, length)) {
       RTPHeader header;
       if (!rtp_header_parser->Parse(data, length, &header)) {
         return -1;
       }
       uint32_t ssrc = header.ssrc;
       if (ssrc_handlers_.RegisterSsrc(ssrc, &lost_packets_, clock_) < 0) {
         DEBUG_LOG1("Unable to register ssrc: %d", ssrc);
         return -1;
       }
 
       if (no_loss_startup_ > 0) {
         no_loss_startup_--;
       } else if ((rand() + 1.0) / (RAND_MAX + 1.0) < loss_rate_) {  // NOLINT
         uint16_t seq_num = header.sequenceNumber;
         lost_packets_.AddPacket(new RawRtpPacket(data, length, ssrc, seq_num));
         DEBUG_LOG1("Dropped packet: %d!", header.header.sequenceNumber);
         return 0;
       }
     }
 
     ssrc_handlers_.IncomingPacket(data, length);
     return 1;
   }
 
   SsrcHandlers ssrc_handlers_;
   Clock* clock_;
-  rtc::scoped_ptr<test::RtpFileReader> packet_source_;
+  std::unique_ptr<test::RtpFileReader> packet_source_;
   test::RtpPacket next_packet_;
   uint32_t next_rtp_time_;
   bool first_packet_;
   int64_t first_packet_rtp_time_;
   int64_t first_packet_time_ms_;
   float loss_rate_;
   LostPackets lost_packets_;
   uint32_t resend_packet_count_;
   uint32_t no_loss_startup_;
   bool end_of_file_;
   bool reordering_;
-  rtc::scoped_ptr<RawRtpPacket> reorder_buffer_;
+  std::unique_ptr<RawRtpPacket> reorder_buffer_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RtpPlayerImpl);
 };
 
 RtpPlayerInterface* Create(const std::string& input_filename,
                            PayloadSinkFactoryInterface* payload_sink_factory,
                            Clock* clock,
                            const PayloadTypes& payload_types,
                            float loss_rate,
                            int64_t rtt_ms,
                            bool reordering) {
-  rtc::scoped_ptr<test::RtpFileReader> packet_source(
+  std::unique_ptr<test::RtpFileReader> packet_source(
       test::RtpFileReader::Create(test::RtpFileReader::kRtpDump,
                                   input_filename));
   if (packet_source.get() == NULL) {
     packet_source.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
                                                     input_filename));
     if (packet_source.get() == NULL) {
       return NULL;
     }
   }
 
-  rtc::scoped_ptr<RtpPlayerImpl> impl(
+  std::unique_ptr<RtpPlayerImpl> impl(
       new RtpPlayerImpl(payload_sink_factory, payload_types, clock,
                         &packet_source, loss_rate, rtt_ms, reordering));
   return impl.release();
 }
 }  // namespace rtpplayer
 }  // namespace webrtc