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

media/cast/test/utility/udp_proxy.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/test/utility/udp_proxy.h"
 
 #include <math.h>
 #include <stdlib.h>
 #include <utility>
 #include <vector>
@@ skipping 19 matching lines @@
 PacketPipe::~PacketPipe() {}
 void PacketPipe::InitOnIOThread(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     base::TickClock* clock) {
   task_runner_ = task_runner;
   clock_ = clock;
   if (pipe_) {
     pipe_->InitOnIOThread(task_runner, clock);
   }
 }
-void PacketPipe::AppendToPipe(scoped_ptr<PacketPipe> pipe) {
+void PacketPipe::AppendToPipe(std::unique_ptr<PacketPipe> pipe) {
   if (pipe_) {
     pipe_->AppendToPipe(std::move(pipe));
   } else {
     pipe_ = std::move(pipe);
   }
 }
 
 // Roughly emulates a buffer inside a device.
 // If the buffer is full, packets are dropped.
 // Packets are output at a maximum bandwidth.
 class Buffer : public PacketPipe {
  public:
   Buffer(size_t buffer_size, double max_megabits_per_second)
       : buffer_size_(0),
         max_buffer_size_(buffer_size),
         max_megabits_per_second_(max_megabits_per_second),
         weak_factory_(this) {
     CHECK_GT(max_buffer_size_, 0UL);
     CHECK_GT(max_megabits_per_second, 0);
   }
 
-  void Send(scoped_ptr<Packet> packet) final {
+  void Send(std::unique_ptr<Packet> packet) final {
     if (packet->size() + buffer_size_ <= max_buffer_size_) {
       buffer_size_ += packet->size();
       buffer_.push_back(linked_ptr<Packet>(packet.release()));
       if (buffer_.size() == 1) {
         Schedule();
       }
     }
   }
 
  private:
@@ skipping 11 matching lines @@
   void ProcessBuffer() {
     int64_t bytes_to_send = static_cast<int64_t>(
         (clock_->NowTicks() - last_schedule_).InSecondsF() *
         max_megabits_per_second_ * 1E6 / 8);
     if (bytes_to_send < static_cast<int64_t>(buffer_.front()->size())) {
       bytes_to_send = buffer_.front()->size();
     }
     while (!buffer_.empty() &&
            static_cast<int64_t>(buffer_.front()->size()) <= bytes_to_send) {
       CHECK(!buffer_.empty());
-      scoped_ptr<Packet> packet(buffer_.front().release());
+      std::unique_ptr<Packet> packet(buffer_.front().release());
       bytes_to_send -= packet->size();
       buffer_size_ -= packet->size();
       buffer_.pop_front();
       pipe_->Send(std::move(packet));
     }
     if (!buffer_.empty()) {
       Schedule();
     }
   }
 
   std::deque<linked_ptr<Packet> > buffer_;
   base::TimeTicks last_schedule_;
   size_t buffer_size_;
   size_t max_buffer_size_;
   double max_megabits_per_second_;  // megabits per second
   base::WeakPtrFactory<Buffer> weak_factory_;
 };
 
-scoped_ptr<PacketPipe> NewBuffer(size_t buffer_size, double bandwidth) {
-  return scoped_ptr<PacketPipe>(new Buffer(buffer_size, bandwidth));
+std::unique_ptr<PacketPipe> NewBuffer(size_t buffer_size, double bandwidth) {
+  return std::unique_ptr<PacketPipe>(new Buffer(buffer_size, bandwidth));
 }
 
 class RandomDrop : public PacketPipe {
  public:
   RandomDrop(double drop_fraction)
       : drop_fraction_(static_cast<int>(drop_fraction * RAND_MAX)) {}
 
-  void Send(scoped_ptr<Packet> packet) final {
+  void Send(std::unique_ptr<Packet> packet) final {
     if (rand() > drop_fraction_) {
       pipe_->Send(std::move(packet));
     }
   }
 
  private:
   int drop_fraction_;
 };
 
-scoped_ptr<PacketPipe> NewRandomDrop(double drop_fraction) {
-  return scoped_ptr<PacketPipe>(new RandomDrop(drop_fraction));
+std::unique_ptr<PacketPipe> NewRandomDrop(double drop_fraction) {
+  return std::unique_ptr<PacketPipe>(new RandomDrop(drop_fraction));
 }
 
 class SimpleDelayBase : public PacketPipe {
  public:
   SimpleDelayBase() : weak_factory_(this) {}
   ~SimpleDelayBase() override {}
 
-  void Send(scoped_ptr<Packet> packet) override {
+  void Send(std::unique_ptr<Packet> packet) override {
     double seconds = GetDelay();
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&SimpleDelayBase::SendInternal, weak_factory_.GetWeakPtr(),
                    base::Passed(&packet)),
         base::TimeDelta::FromMicroseconds(static_cast<int64_t>(seconds * 1E6)));
   }
  protected:
   virtual double GetDelay() = 0;
 
  private:
-  virtual void SendInternal(scoped_ptr<Packet> packet) {
+  virtual void SendInternal(std::unique_ptr<Packet> packet) {
     pipe_->Send(std::move(packet));
   }
 
   base::WeakPtrFactory<SimpleDelayBase> weak_factory_;
 };
 
 class ConstantDelay : public SimpleDelayBase {
  public:
   ConstantDelay(double delay_seconds) : delay_seconds_(delay_seconds) {}
   double GetDelay() final { return delay_seconds_; }
 
  private:
   double delay_seconds_;
 };
 
-scoped_ptr<PacketPipe> NewConstantDelay(double delay_seconds) {
-  return scoped_ptr<PacketPipe>(new ConstantDelay(delay_seconds));
+std::unique_ptr<PacketPipe> NewConstantDelay(double delay_seconds) {
+  return std::unique_ptr<PacketPipe>(new ConstantDelay(delay_seconds));
 }
 
 class RandomUnsortedDelay : public SimpleDelayBase {
  public:
   RandomUnsortedDelay(double random_delay) : random_delay_(random_delay) {}
 
   double GetDelay() override { return random_delay_ * base::RandDouble(); }
 
  private:
   double random_delay_;
 };
 
-scoped_ptr<PacketPipe> NewRandomUnsortedDelay(double random_delay) {
-  return scoped_ptr<PacketPipe>(new RandomUnsortedDelay(random_delay));
+std::unique_ptr<PacketPipe> NewRandomUnsortedDelay(double random_delay) {
+  return std::unique_ptr<PacketPipe>(new RandomUnsortedDelay(random_delay));
 }
 
 class DuplicateAndDelay : public RandomUnsortedDelay {
  public:
   DuplicateAndDelay(double delay_min,
                     double random_delay) :
       RandomUnsortedDelay(random_delay),
       delay_min_(delay_min) {
   }
-  void Send(scoped_ptr<Packet> packet) final {
-    pipe_->Send(scoped_ptr<Packet>(new Packet(*packet.get())));
+  void Send(std::unique_ptr<Packet> packet) final {
+    pipe_->Send(std::unique_ptr<Packet>(new Packet(*packet.get())));
     RandomUnsortedDelay::Send(std::move(packet));
   }
   double GetDelay() final {
     return RandomUnsortedDelay::GetDelay() + delay_min_;
   }
  private:
   double delay_min_;
 };
 
-scoped_ptr<PacketPipe> NewDuplicateAndDelay(double delay_min,
-                                            double random_delay) {
-  return scoped_ptr<PacketPipe>(new DuplicateAndDelay(delay_min, random_delay));
+std::unique_ptr<PacketPipe> NewDuplicateAndDelay(double delay_min,
+                                                 double random_delay) {
+  return std::unique_ptr<PacketPipe>(
+      new DuplicateAndDelay(delay_min, random_delay));
 }
 
 class RandomSortedDelay : public PacketPipe {
  public:
   RandomSortedDelay(double random_delay,
                     double extra_delay,
                     double seconds_between_extra_delay)
       : random_delay_(random_delay),
         extra_delay_(extra_delay),
         seconds_between_extra_delay_(seconds_between_extra_delay),
         weak_factory_(this) {}
 
-  void Send(scoped_ptr<Packet> packet) final {
+  void Send(std::unique_ptr<Packet> packet) final {
     buffer_.push_back(linked_ptr<Packet>(packet.release()));
     if (buffer_.size() == 1) {
       next_send_ = std::max(
           clock_->NowTicks() +
           base::TimeDelta::FromSecondsD(base::RandDouble() * random_delay_),
           next_send_);
       ProcessBuffer();
     }
   }
   void InitOnIOThread(
@@ skipping 23 matching lines @@
         next_send_);
     // An extra delay just happened, wait up to seconds_between_extra_delay_*2
     // before scheduling another one to make the average equal to
     // seconds_between_extra_delay_.
     ScheduleExtraDelay(2.0);
   }
 
   void ProcessBuffer() {
     base::TimeTicks now = clock_->NowTicks();
     while (!buffer_.empty() && next_send_ <= now) {
-      scoped_ptr<Packet> packet(buffer_.front().release());
+      std::unique_ptr<Packet> packet(buffer_.front().release());
       pipe_->Send(std::move(packet));
       buffer_.pop_front();
 
       next_send_ += base::TimeDelta::FromSecondsD(
           base::RandDouble() * random_delay_);
     }
 
     if (!buffer_.empty()) {
       task_runner_->PostDelayedTask(
           FROM_HERE,
           base::Bind(&RandomSortedDelay::ProcessBuffer,
                      weak_factory_.GetWeakPtr()),
           next_send_ - now);
     }
   }
 
   base::TimeTicks block_until_;
   std::deque<linked_ptr<Packet> > buffer_;
   double random_delay_;
   double extra_delay_;
   double seconds_between_extra_delay_;
   base::TimeTicks next_send_;
   base::WeakPtrFactory<RandomSortedDelay> weak_factory_;
 };
 
-scoped_ptr<PacketPipe> NewRandomSortedDelay(
+std::unique_ptr<PacketPipe> NewRandomSortedDelay(
     double random_delay,
     double extra_delay,
     double seconds_between_extra_delay) {
-  return scoped_ptr<PacketPipe>(new RandomSortedDelay(
+  return std::unique_ptr<PacketPipe>(new RandomSortedDelay(
       random_delay, extra_delay, seconds_between_extra_delay));
 }
 
 class NetworkGlitchPipe : public PacketPipe {
  public:
   NetworkGlitchPipe(double average_work_time, double average_outage_time)
       : works_(false),
         max_work_time_(average_work_time * 2),
         max_outage_time_(average_outage_time * 2),
         weak_factory_(this) {}
 
   void InitOnIOThread(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::TickClock* clock) final {
     PacketPipe::InitOnIOThread(task_runner, clock);
     Flip();
   }
 
-  void Send(scoped_ptr<Packet> packet) final {
+  void Send(std::unique_ptr<Packet> packet) final {
     if (works_) {
       pipe_->Send(std::move(packet));
     }
   }
 
  private:
   void Flip() {
     works_ = !works_;
     double seconds = base::RandDouble() *
         (works_ ? max_work_time_ : max_outage_time_);
     int64_t microseconds = static_cast<int64_t>(seconds * 1E6);
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&NetworkGlitchPipe::Flip, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMicroseconds(microseconds));
   }
 
   bool works_;
   double max_work_time_;
   double max_outage_time_;
   base::WeakPtrFactory<NetworkGlitchPipe> weak_factory_;
 };
 
-scoped_ptr<PacketPipe> NewNetworkGlitchPipe(double average_work_time,
-                                            double average_outage_time) {
-  return scoped_ptr<PacketPipe>(
+std::unique_ptr<PacketPipe> NewNetworkGlitchPipe(double average_work_time,
+                                                 double average_outage_time) {
+  return std::unique_ptr<PacketPipe>(
       new NetworkGlitchPipe(average_work_time, average_outage_time));
 }
 
 
 // Internal buffer object for a client of the IPP model.
 class InterruptedPoissonProcess::InternalBuffer : public PacketPipe {
  public:
   InternalBuffer(base::WeakPtr<InterruptedPoissonProcess> ipp,
                  size_t size)
       : ipp_(ipp),
         stored_size_(0),
         stored_limit_(size),
         clock_(NULL),
         weak_factory_(this) {
   }
 
-  void Send(scoped_ptr<Packet> packet) final {
+  void Send(std::unique_ptr<Packet> packet) final {
     // Drop if buffer is full.
     if (stored_size_ >= stored_limit_)
       return;
     stored_size_ += packet->size();
     buffer_.push_back(linked_ptr<Packet>(packet.release()));
     buffer_time_.push_back(clock_->NowTicks());
     DCHECK(buffer_.size() == buffer_time_.size());
   }
 
   void InitOnIOThread(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::TickClock* clock) final {
     clock_ = clock;
     if (ipp_)
       ipp_->InitOnIOThread(task_runner, clock);
     PacketPipe::InitOnIOThread(task_runner, clock);
   }
 
   void SendOnePacket() {
-    scoped_ptr<Packet> packet(buffer_.front().release());
+    std::unique_ptr<Packet> packet(buffer_.front().release());
     stored_size_ -= packet->size();
     buffer_.pop_front();
     buffer_time_.pop_front();
     pipe_->Send(std::move(packet));
     DCHECK(buffer_.size() == buffer_time_.size());
   }
 
   bool Empty() const {
     return buffer_.empty();
   }
@@ skipping 46 matching lines @@
   // Already initialized and started.
   if (task_runner_.get() && clock_)
     return;
   task_runner_ = task_runner;
   clock_ = clock;
   UpdateRates();
   SwitchOn();
   SendPacket();
 }
 
-scoped_ptr<PacketPipe> InterruptedPoissonProcess::NewBuffer(size_t size) {
-  scoped_ptr<InternalBuffer> buffer(
+std::unique_ptr<PacketPipe> InterruptedPoissonProcess::NewBuffer(size_t size) {
+  std::unique_ptr<InternalBuffer> buffer(
       new InternalBuffer(weak_factory_.GetWeakPtr(), size));
   send_buffers_.push_back(buffer->GetWeakPtr());
   return std::move(buffer);
 }
 
 base::TimeDelta InterruptedPoissonProcess::NextEvent(double rate) {
   // Rate is per milliseconds.
   // The time until next event is exponentially distributed to the
   // inverse of |rate|.
   return base::TimeDelta::FromMillisecondsD(
@@ skipping 83 matching lines @@
     break;
   }
 }
 
 class UDPProxyImpl;
 
 class PacketSender : public PacketPipe {
  public:
   PacketSender(UDPProxyImpl* udp_proxy, const net::IPEndPoint* destination)
       : udp_proxy_(udp_proxy), destination_(destination) {}
-  void Send(scoped_ptr<Packet> packet) final;
-  void AppendToPipe(scoped_ptr<PacketPipe> pipe) final { NOTREACHED(); }
+  void Send(std::unique_ptr<Packet> packet) final;
+  void AppendToPipe(std::unique_ptr<PacketPipe> pipe) final { NOTREACHED(); }
 
  private:
   UDPProxyImpl* udp_proxy_;
   const net::IPEndPoint* destination_;  // not owned
 };
 
 namespace {
-void BuildPipe(scoped_ptr<PacketPipe>* pipe, PacketPipe* next) {
+void BuildPipe(std::unique_ptr<PacketPipe>* pipe, PacketPipe* next) {
   if (*pipe) {
-    (*pipe)->AppendToPipe(scoped_ptr<PacketPipe>(next));
+    (*pipe)->AppendToPipe(std::unique_ptr<PacketPipe>(next));
   } else {
     pipe->reset(next);
   }
 }
 }  // namespace
 
-scoped_ptr<PacketPipe> GoodNetwork() {
+std::unique_ptr<PacketPipe> GoodNetwork() {
   // This represents the buffer on the sender.
-  scoped_ptr<PacketPipe> pipe;
+  std::unique_ptr<PacketPipe> pipe;
   BuildPipe(&pipe, new Buffer(2 << 20, 50));
   BuildPipe(&pipe, new ConstantDelay(1E-3));
   BuildPipe(&pipe, new RandomSortedDelay(1E-3, 2E-3, 3));
   // This represents the buffer on the receiving device.
   BuildPipe(&pipe, new Buffer(2 << 20, 50));
   return pipe;
 }
 
-scoped_ptr<PacketPipe> WifiNetwork() {
+std::unique_ptr<PacketPipe> WifiNetwork() {
   // This represents the buffer on the sender.
-  scoped_ptr<PacketPipe> pipe;
+  std::unique_ptr<PacketPipe> pipe;
   BuildPipe(&pipe, new Buffer(256 << 10, 20));
   BuildPipe(&pipe, new RandomDrop(0.005));
   // This represents the buffer on the router.
   BuildPipe(&pipe, new ConstantDelay(1E-3));
   BuildPipe(&pipe, new RandomSortedDelay(1E-3, 20E-3, 3));
   BuildPipe(&pipe, new Buffer(256 << 10, 20));
   BuildPipe(&pipe, new ConstantDelay(1E-3));
   BuildPipe(&pipe, new RandomSortedDelay(1E-3, 20E-3, 3));
   BuildPipe(&pipe, new RandomDrop(0.005));
   // This represents the buffer on the receiving device.
   BuildPipe(&pipe, new Buffer(256 << 10, 20));
   return pipe;
 }
 
-scoped_ptr<PacketPipe> BadNetwork() {
-  scoped_ptr<PacketPipe> pipe;
+std::unique_ptr<PacketPipe> BadNetwork() {
+  std::unique_ptr<PacketPipe> pipe;
   // This represents the buffer on the sender.
   BuildPipe(&pipe, new Buffer(64 << 10, 5)); // 64 kb buf, 5mbit/s
   BuildPipe(&pipe, new RandomDrop(0.05));  // 5% packet drop
   BuildPipe(&pipe, new RandomSortedDelay(2E-3, 20E-3, 1));
   // This represents the buffer on the router.
   BuildPipe(&pipe, new Buffer(64 << 10, 5));  // 64 kb buf, 4mbit/s
   BuildPipe(&pipe, new ConstantDelay(1E-3));
   // Random 40ms every other second
   //  BuildPipe(&pipe, new NetworkGlitchPipe(2, 40E-1));
   BuildPipe(&pipe, new RandomUnsortedDelay(5E-3));
   // This represents the buffer on the receiving device.
   BuildPipe(&pipe, new Buffer(64 << 10, 5));  // 64 kb buf, 5mbit/s
   return pipe;
 }
 
-
-scoped_ptr<PacketPipe> EvilNetwork() {
+std::unique_ptr<PacketPipe> EvilNetwork() {
   // This represents the buffer on the sender.
-  scoped_ptr<PacketPipe> pipe;
+  std::unique_ptr<PacketPipe> pipe;
   BuildPipe(&pipe, new Buffer(4 << 10, 5));  // 4 kb buf, 2mbit/s
   // This represents the buffer on the router.
   BuildPipe(&pipe, new RandomDrop(0.1));  // 10% packet drop
   BuildPipe(&pipe, new RandomSortedDelay(20E-3, 60E-3, 1));
   BuildPipe(&pipe, new Buffer(4 << 10, 2));  // 4 kb buf, 2mbit/s
   BuildPipe(&pipe, new RandomDrop(0.1));  // 10% packet drop
   BuildPipe(&pipe, new ConstantDelay(1E-3));
   BuildPipe(&pipe, new NetworkGlitchPipe(2.0, 0.3));
   BuildPipe(&pipe, new RandomUnsortedDelay(20E-3));
   // This represents the buffer on the receiving device.
   BuildPipe(&pipe, new Buffer(4 << 10, 2));  // 4 kb buf, 2mbit/s
   return pipe;
 }
 
-scoped_ptr<InterruptedPoissonProcess> DefaultInterruptedPoissonProcess() {
+std::unique_ptr<InterruptedPoissonProcess> DefaultInterruptedPoissonProcess() {
   // The following values are taken from a session reported from a user.
   // They are experimentally tested to demonstrate challenging network
   // conditions. The average bitrate is about 2mbits/s.
 
   // Each element in this vector is the average number of packets sent
   // per millisecond. The average changes and rotates every second.
   std::vector<double> average_rates;
   average_rates.push_back(0.609);
   average_rates.push_back(0.495);
   average_rates.push_back(0.561);
   average_rates.push_back(0.458);
   average_rates.push_back(0.538);
   average_rates.push_back(0.513);
   average_rates.push_back(0.585);
   average_rates.push_back(0.592);
   average_rates.push_back(0.658);
   average_rates.push_back(0.556);
   average_rates.push_back(0.371);
   average_rates.push_back(0.595);
   average_rates.push_back(0.490);
   average_rates.push_back(0.980);
   average_rates.push_back(0.781);
   average_rates.push_back(0.463);
 
   const double burstiness = 0.609;
   const double variance = 4.1;
 
-  scoped_ptr<InterruptedPoissonProcess> ipp(
-      new InterruptedPoissonProcess(
-          average_rates, burstiness, variance, 0));
+  std::unique_ptr<InterruptedPoissonProcess> ipp(
+      new InterruptedPoissonProcess(average_rates, burstiness, variance, 0));
   return ipp;
 }
 
 class UDPProxyImpl : public UDPProxy {
  public:
   UDPProxyImpl(const net::IPEndPoint& local_port,
                const net::IPEndPoint& destination,
-               scoped_ptr<PacketPipe> to_dest_pipe,
-               scoped_ptr<PacketPipe> from_dest_pipe,
+               std::unique_ptr<PacketPipe> to_dest_pipe,
+               std::unique_ptr<PacketPipe> from_dest_pipe,
                net::NetLog* net_log)
       : local_port_(local_port),
         destination_(destination),
         destination_is_mutable_(destination.address().empty()),
         proxy_thread_("media::cast::test::UdpProxy Thread"),
         to_dest_pipe_(std::move(to_dest_pipe)),
         from_dest_pipe_(std::move(from_dest_pipe)),
         blocked_(false),
         weak_factory_(this) {
     proxy_thread_.StartWithOptions(
@@ skipping 12 matching lines @@
     base::WaitableEvent stop_event(false, false);
     proxy_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&UDPProxyImpl::Stop,
                    base::Unretained(this),
                    base::Unretained(&stop_event)));
     stop_event.Wait();
     proxy_thread_.Stop();
   }
 
-  void Send(scoped_ptr<Packet> packet,
+  void Send(std::unique_ptr<Packet> packet,
             const net::IPEndPoint& destination) {
     if (blocked_) {
       LOG(ERROR) << "Cannot write packet right now: blocked";
       return;
     }
 
     VLOG(1) << "Sending packet, len = " << packet->size();
     // We ignore all problems, callbacks and errors.
     // If it didn't work we just drop the packet at and call it a day.
     scoped_refptr<net::IOBuffer> buf =
@@ skipping 88 matching lines @@
           &recv_address_,
           base::Bind(
               &UDPProxyImpl::ReadCallback, base::Unretained(this), recv_buf));
       if (len == net::ERR_IO_PENDING)
         break;
       ProcessPacket(recv_buf, len);
     }
   }
 
   void AllowWrite(scoped_refptr<net::IOBuffer> buf,
-                  scoped_ptr<Packet> packet,
+                  std::unique_ptr<Packet> packet,
                   int unused_len) {
     DCHECK(blocked_);
     blocked_ = false;
   }
 
   // Input
   net::IPEndPoint local_port_;
 
   net::IPEndPoint destination_;
   bool destination_is_mutable_;
 
   net::IPEndPoint return_address_;
   bool set_destination_next_;
 
   base::DefaultTickClock tick_clock_;
   base::Thread proxy_thread_;
-  scoped_ptr<net::UDPServerSocket> socket_;
-  scoped_ptr<PacketPipe> to_dest_pipe_;
-  scoped_ptr<PacketPipe> from_dest_pipe_;
+  std::unique_ptr<net::UDPServerSocket> socket_;
+  std::unique_ptr<PacketPipe> to_dest_pipe_;
+  std::unique_ptr<PacketPipe> from_dest_pipe_;
 
   // For receiving.
   net::IPEndPoint recv_address_;
-  scoped_ptr<Packet> packet_;
+  std::unique_ptr<Packet> packet_;
 
   // For sending.
   bool blocked_;
 
   base::WeakPtrFactory<UDPProxyImpl> weak_factory_;
 };
 
-void PacketSender::Send(scoped_ptr<Packet> packet) {
+void PacketSender::Send(std::unique_ptr<Packet> packet) {
   udp_proxy_->Send(std::move(packet), *destination_);
 }
 
-scoped_ptr<UDPProxy> UDPProxy::Create(
+std::unique_ptr<UDPProxy> UDPProxy::Create(
     const net::IPEndPoint& local_port,
     const net::IPEndPoint& destination,
-    scoped_ptr<PacketPipe> to_dest_pipe,
-    scoped_ptr<PacketPipe> from_dest_pipe,
+    std::unique_ptr<PacketPipe> to_dest_pipe,
+    std::unique_ptr<PacketPipe> from_dest_pipe,
     net::NetLog* net_log) {
-  scoped_ptr<UDPProxy> ret(
+  std::unique_ptr<UDPProxy> ret(
       new UDPProxyImpl(local_port, destination, std::move(to_dest_pipe),
                        std::move(from_dest_pipe), net_log));
   return ret;
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media