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

media/cast/test/simulator.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.
 
 // Simulate end to end streaming.
 //
 // Input:
 // --source=
 //   WebM used as the source of video and audio frames.
 // --output=
@@ skipping 18 matching lines @@
 //   File path to write YUV decoded frames in YUV4MPEG2 format.
 // --no-simulation
 //   Do not run network simulation.
 //
 // Output:
 // - Raw event log of the simulation session tagged with the unique test ID,
 //   written out to the specified file path.
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 245 matching lines @@
   // Fake clock. Make sure start time is non zero.
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromSeconds(1));
 
   // Task runner.
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner =
       new test::FakeSingleThreadTaskRunner(&testing_clock);
   base::ThreadTaskRunnerHandle task_runner_handle(task_runner);
 
   // CastEnvironments.
-  scoped_refptr<CastEnvironment> sender_env =
-      new CastEnvironment(
-          scoped_ptr<base::TickClock>(
-              new test::SkewedTickClock(&testing_clock)).Pass(),
-          task_runner,
-          task_runner,
-          task_runner);
-  scoped_refptr<CastEnvironment> receiver_env =
-      new CastEnvironment(
-          scoped_ptr<base::TickClock>(
-              new test::SkewedTickClock(&testing_clock)).Pass(),
-          task_runner,
-          task_runner,
-          task_runner);
+  scoped_refptr<CastEnvironment> sender_env = new CastEnvironment(
+      scoped_ptr<base::TickClock>(new test::SkewedTickClock(&testing_clock)),
+      task_runner, task_runner, task_runner);
+  scoped_refptr<CastEnvironment> receiver_env = new CastEnvironment(
+      scoped_ptr<base::TickClock>(new test::SkewedTickClock(&testing_clock)),
+      task_runner, task_runner, task_runner);
 
   // Event subscriber. Store at most 1 hour of events.
   EncodingEventSubscriber audio_event_subscriber(AUDIO_EVENT,
                                                  100 * 60 * 60);
   EncodingEventSubscriber video_event_subscriber(VIDEO_EVENT,
                                                  30 * 60 * 60);
   sender_env->logger()->Subscribe(&audio_event_subscriber);
   sender_env->logger()->Subscribe(&video_event_subscriber);
 
   // Audio sender config.
@@ skipping 25 matching lines @@
       video_sender_config.max_playout_delay.InMilliseconds();
 
   // Loopback transport.
   LoopBackTransport receiver_to_sender(receiver_env);
   LoopBackTransport sender_to_receiver(sender_env);
 
   struct PacketProxy {
     PacketProxy() : receiver(NULL) {}
     void ReceivePacket(scoped_ptr<Packet> packet) {
       if (receiver)
-        receiver->ReceivePacket(packet.Pass());
+        receiver->ReceivePacket(std::move(packet));
     }
     CastReceiver* receiver;
   };
 
   PacketProxy packet_proxy;
 
   // Cast receiver.
   scoped_ptr<CastTransportSender> transport_receiver(
       new CastTransportSenderImpl(
           nullptr, &testing_clock, net::IPEndPoint(), net::IPEndPoint(),
@@ skipping 32 matching lines @@
   if (use_network_simulation) {
     LOG(INFO) << "Running Poisson based network simulation.";
     const IPPModel& ipp_model = model.ipp();
     std::vector<double> average_rates(ipp_model.average_rate_size());
     std::copy(ipp_model.average_rate().begin(),
               ipp_model.average_rate().end(),
               average_rates.begin());
     ipp.reset(new test::InterruptedPoissonProcess(
         average_rates,
         ipp_model.coef_burstiness(), ipp_model.coef_variance(), 0));
-    receiver_to_sender.Initialize(
-        ipp->NewBuffer(128 * 1024).Pass(),
-        transport_sender->PacketReceiverForTesting(),
-        task_runner, &testing_clock);
+    receiver_to_sender.Initialize(ipp->NewBuffer(128 * 1024),
+                                  transport_sender->PacketReceiverForTesting(),
+                                  task_runner, &testing_clock);
     sender_to_receiver.Initialize(
-        ipp->NewBuffer(128 * 1024).Pass(),
+        ipp->NewBuffer(128 * 1024),
         transport_receiver->PacketReceiverForTesting(), task_runner,
         &testing_clock);
   } else {
     LOG(INFO) << "No network simulation.";
     receiver_to_sender.Initialize(
         scoped_ptr<test::PacketPipe>(),
         transport_sender->PacketReceiverForTesting(),
         task_runner, &testing_clock);
     sender_to_receiver.Initialize(
         scoped_ptr<test::PacketPipe>(),
@@ skipping 294 matching lines @@
   values.SetString("sim-id", sim_id);
 
   std::string extra_data;
   base::JSONWriter::Write(values, &extra_data);
 
   // Run.
   media::cast::RunSimulation(source_path, log_output_path, metrics_output_path,
                              yuv_output_path, extra_data, model);
   return 0;
 }