Convert Pass()→std::move() in //media

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>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "media/cast/test/utility/udp_proxy.h"
@@ skipping 53 matching lines @@
 }  // 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 {
     counter_->Increment(packet->size());
-    pipe_->Send(packet.Pass());
+    pipe_->Send(std::move(packet));
   }
  private:
   ByteCounter* counter_;
 };
 
 void SetupByteCounters(scoped_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(pipe->Pass());
-  new_pipe->AppendToPipe(
-      scoped_ptr<media::cast::test::PacketPipe>(
-          new ByteCounterPipe(pipe_output_counter)).Pass());
+  new_pipe->AppendToPipe(std::move(*pipe));
+  new_pipe->AppendToPipe(scoped_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);
   if ((now - g_counter.Get().last_printout).InSeconds() >= 5) {
@@ skipping 57 matching lines @@
                                   static_cast<uint16_t>(remote_port));
   net::IPEndPoint local_endpoint(local_ip_number,
                                  static_cast<uint16_t>(local_port));
   scoped_ptr<media::cast::test::PacketPipe> in_pipe, out_pipe;
   scoped_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().Pass();
-    out_pipe = media::cast::test::WifiNetwork().Pass();
+    in_pipe = media::cast::test::WifiNetwork();
+    out_pipe = media::cast::test::WifiNetwork();
   } else if (network_type == "bad") {
-    in_pipe = media::cast::test::BadNetwork().Pass();
-    out_pipe = media::cast::test::BadNetwork().Pass();
+    in_pipe = media::cast::test::BadNetwork();
+    out_pipe = media::cast::test::BadNetwork();
   } else if (network_type == "evil") {
-    in_pipe = media::cast::test::EvilNetwork().Pass();
-    out_pipe = media::cast::test::EvilNetwork().Pass();
+    in_pipe = media::cast::test::EvilNetwork();
+    out_pipe = media::cast::test::EvilNetwork();
   } else if (network_type == "poisson-wifi") {
-    in_pipe = ipp->NewBuffer(128 * 1024).Pass();
-    out_pipe = ipp->NewBuffer(128 * 1024).Pass();
+    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(
-      media::cast::test::UDPProxy::Create(local_endpoint,
-                                          remote_endpoint,
-                                          in_pipe.Pass(),
-                                          out_pipe.Pass(),
-                                          NULL));
+      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;
 }