Convert //media/cast from scoped_ptr to std::unique_ptr

media/cast/net/cast_transport_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/net/cast_transport_impl.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 23 matching lines @@
   int ret;
   if (options.GetInteger(path, &ret)) {
     return ret;
   } else {
     return default_value;
   }
 }
 
 }  // namespace
 
-scoped_ptr<CastTransport> CastTransport::Create(
+std::unique_ptr<CastTransport> CastTransport::Create(
     base::TickClock* clock,  // Owned by the caller.
     base::TimeDelta logging_flush_interval,
-    scoped_ptr<Client> client,
-    scoped_ptr<PacketTransport> transport,
+    std::unique_ptr<Client> client,
+    std::unique_ptr<PacketTransport> transport,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) {
-  return scoped_ptr<CastTransport>(
+  return std::unique_ptr<CastTransport>(
       new CastTransportImpl(clock, logging_flush_interval, std::move(client),
                             std::move(transport), transport_task_runner.get()));
 }
 
 PacketReceiverCallback CastTransport::PacketReceiverForTesting() {
   return PacketReceiverCallback();
 }
 
 CastTransportImpl::CastTransportImpl(
     base::TickClock* clock,
     base::TimeDelta logging_flush_interval,
-    scoped_ptr<Client> client,
-    scoped_ptr<PacketTransport> transport,
+    std::unique_ptr<Client> client,
+    std::unique_ptr<PacketTransport> transport,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner)
     : clock_(clock),
       logging_flush_interval_(logging_flush_interval),
       transport_client_(std::move(client)),
       transport_(std::move(transport)),
       transport_task_runner_(transport_task_runner),
       pacer_(kTargetBurstSize,
              kMaxBurstSize,
              clock,
              logging_flush_interval > base::TimeDelta() ? &recent_packet_events_
@@ skipping 178 matching lines @@
 
 PacketReceiverCallback CastTransportImpl::PacketReceiverForTesting() {
   return base::Bind(base::IgnoreResult(&CastTransportImpl::OnReceivedPacket),
                     weak_factory_.GetWeakPtr());
 }
 
 void CastTransportImpl::SendRawEvents() {
   DCHECK(logging_flush_interval_ > base::TimeDelta());
 
   if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) {
-    scoped_ptr<std::vector<FrameEvent>> frame_events(
+    std::unique_ptr<std::vector<FrameEvent>> frame_events(
         new std::vector<FrameEvent>());
     frame_events->swap(recent_frame_events_);
-    scoped_ptr<std::vector<PacketEvent>> packet_events(
+    std::unique_ptr<std::vector<PacketEvent>> packet_events(
         new std::vector<PacketEvent>());
     packet_events->swap(recent_packet_events_);
     transport_client_->OnLoggingEventsReceived(std::move(frame_events),
                                                std::move(packet_events));
   }
 
   transport_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CastTransportImpl::SendRawEvents, weak_factory_.GetWeakPtr()),
       logging_flush_interval_);
 }
 
-bool CastTransportImpl::OnReceivedPacket(scoped_ptr<Packet> packet) {
+bool CastTransportImpl::OnReceivedPacket(std::unique_ptr<Packet> packet) {
   const uint8_t* const data = &packet->front();
   const size_t length = packet->size();
   uint32_t ssrc;
   if (IsRtcpPacket(data, length)) {
     ssrc = GetSsrcOfSender(data, length);
   } else if (!RtpParser::ParseSsrc(data, length, &ssrc)) {
     VLOG(1) << "Invalid RTP packet.";
     return false;
   }
   if (valid_sender_ssrcs_.find(ssrc) == valid_sender_ssrcs_.end()) {
@@ skipping 192 matching lines @@
                "calling CastTransportImpl::SendRtcpFromRtpReceiver.";
     return;
   }
   pacer_.SendRtcpPacket(rtcp_builder_at_rtp_receiver_->local_ssrc(),
                         rtcp_builder_at_rtp_receiver_->Finish());
   rtcp_builder_at_rtp_receiver_.reset();
 }
 
 }  // namespace cast
 }  // namespace media