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

media/cast/test/utility/udp_proxy_main.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 <stdint.h>
 #include <cstdio>
 #include <cstdlib>
 #include <deque>
 #include <string>
 #include <utility>
@@ skipping 62 matching lines @@
   ByteCounter out_pipe_output_counter;
 };
 }  // namespace
 
 base::LazyInstance<GlobalCounter>::Leaky g_counter =
     LAZY_INSTANCE_INITIALIZER;
 
 class ByteCounterPipe : public media::cast::test::PacketPipe {
  public:
   ByteCounterPipe(ByteCounter* counter) : counter_(counter) {}
-  void Send(scoped_ptr<media::cast::Packet> packet) final {
+  void Send(std::unique_ptr<media::cast::Packet> packet) final {
     counter_->Increment(packet->size());
     pipe_->Send(std::move(packet));
   }
  private:
   ByteCounter* counter_;
 };
 
-void SetupByteCounters(scoped_ptr<media::cast::test::PacketPipe>* pipe,
+void SetupByteCounters(std::unique_ptr<media::cast::test::PacketPipe>* pipe,
                        ByteCounter* pipe_input_counter,
                        ByteCounter* pipe_output_counter) {
   media::cast::test::PacketPipe* new_pipe =
       new ByteCounterPipe(pipe_input_counter);
   new_pipe->AppendToPipe(std::move(*pipe));
-  new_pipe->AppendToPipe(scoped_ptr<media::cast::test::PacketPipe>(
+  new_pipe->AppendToPipe(std::unique_ptr<media::cast::test::PacketPipe>(
       new ByteCounterPipe(pipe_output_counter)));
   pipe->reset(new_pipe);
 }
 
 void CheckByteCounters() {
   base::TimeTicks now = base::TimeTicks::Now();
   g_counter.Get().in_pipe_input_counter.push(now);
   g_counter.Get().in_pipe_output_counter.push(now);
   g_counter.Get().out_pipe_input_counter.push(now);
   g_counter.Get().out_pipe_output_counter.push(now);
@@ skipping 49 matching lines @@
   }
   if (local_port < 0 || local_port > 65535 || remote_port < 0 ||
       remote_port > 65535) {
     fprintf(stderr, "Port numbers must be between 0 and 65535\n");
     exit(1);
   }
   net::IPEndPoint remote_endpoint(remote_ip_address,
                                   static_cast<uint16_t>(remote_port));
   net::IPEndPoint local_endpoint(net::IPAddress::IPv4AllZeros(),
                                  static_cast<uint16_t>(local_port));
-  scoped_ptr<media::cast::test::PacketPipe> in_pipe, out_pipe;
-  scoped_ptr<media::cast::test::InterruptedPoissonProcess> ipp(
+  std::unique_ptr<media::cast::test::PacketPipe> in_pipe, out_pipe;
+  std::unique_ptr<media::cast::test::InterruptedPoissonProcess> ipp(
       media::cast::test::DefaultInterruptedPoissonProcess());
 
   if (network_type == "perfect") {
     // No action needed.
   } else if (network_type == "wifi") {
     in_pipe = media::cast::test::WifiNetwork();
     out_pipe = media::cast::test::WifiNetwork();
   } else if (network_type == "bad") {
     in_pipe = media::cast::test::BadNetwork();
     out_pipe = media::cast::test::BadNetwork();
   } else if (network_type == "evil") {
     in_pipe = media::cast::test::EvilNetwork();
     out_pipe = media::cast::test::EvilNetwork();
   } else if (network_type == "poisson-wifi") {
     in_pipe = ipp->NewBuffer(128 * 1024);
     out_pipe = ipp->NewBuffer(128 * 1024);
   } else {
     fprintf(stderr, "Unknown network type.\n");
     exit(1);
   }
 
   SetupByteCounters(&in_pipe, &(g_counter.Get().in_pipe_input_counter),
                     &(g_counter.Get().in_pipe_output_counter));
   SetupByteCounters(
       &out_pipe, &(g_counter.Get().out_pipe_input_counter),
       &(g_counter.Get().out_pipe_output_counter));
 
   printf("Press Ctrl-C when done.\n");
-  scoped_ptr<media::cast::test::UDPProxy> proxy(
+  std::unique_ptr<media::cast::test::UDPProxy> proxy(
       media::cast::test::UDPProxy::Create(local_endpoint, remote_endpoint,
                                           std::move(in_pipe),
                                           std::move(out_pipe), NULL));
   base::MessageLoop message_loop;
   g_counter.Get().last_printout = base::TimeTicks::Now();
   CheckByteCounters();
   message_loop.Run();
   return 1;
 }