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

media/cast/test/cast_benchmarks.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.
 //
 // This program benchmarks the theoretical throughput of the cast library.
 // It runs using a fake clock, simulated network and fake codecs. This allows
 // tests to run much faster than real time.
 // To run the program, run:
 // $ ./out/Release/cast_benchmarks | tee benchmarkoutput.asc
 // This may take a while, when it is done, you can view the data with
 // meshlab by running:
 // $ meshlab benchmarkoutput.asc
 // After starting meshlab, turn on Render->Show Axis. The red axis will
 // represent bandwidth (in megabits) the blue axis will be packet drop
 // (in percent) and the green axis will be latency (in milliseconds).
 //
 // This program can also be used for profiling. On linux it has
 // built-in support for this. Simply set the environment variable
 // PROFILE_FILE before running it, like so:
 // $ export PROFILE_FILE=cast_benchmark.profile
 // Then after running the program, you can view the profile with:
 // $ pprof ./out/Release/cast_benchmarks $PROFILE_FILE --gv
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
-
 #include <map>
+#include <utility>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/profiler.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
@@ skipping 165 matching lines @@
   RunOneBenchmark()
       : start_time_(),
         task_runner_(new test::FakeSingleThreadTaskRunner(&testing_clock_)),
         testing_clock_sender_(new test::SkewedTickClock(&testing_clock_)),
         task_runner_sender_(
             new test::SkewedSingleThreadTaskRunner(task_runner_)),
         testing_clock_receiver_(new test::SkewedTickClock(&testing_clock_)),
         task_runner_receiver_(
             new test::SkewedSingleThreadTaskRunner(task_runner_)),
         cast_environment_sender_(new CastEnvironment(
-            scoped_ptr<base::TickClock>(testing_clock_sender_).Pass(),
+            scoped_ptr<base::TickClock>(testing_clock_sender_),
             task_runner_sender_,
             task_runner_sender_,
             task_runner_sender_)),
         cast_environment_receiver_(new CastEnvironment(
-            scoped_ptr<base::TickClock>(testing_clock_receiver_).Pass(),
+            scoped_ptr<base::TickClock>(testing_clock_receiver_),
             task_runner_receiver_,
             task_runner_receiver_,
             task_runner_receiver_)),
         receiver_to_sender_(cast_environment_receiver_),
         sender_to_receiver_(cast_environment_sender_),
         video_bytes_encoded_(0),
         audio_bytes_encoded_(0),
         frames_sent_(0) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
@@ skipping 81 matching lines @@
 
     cast_sender_->InitializeAudio(
         audio_sender_config_,
         base::Bind(&ExpectAudioSuccess));
     cast_sender_->InitializeVideo(
         video_sender_config_,
         base::Bind(&ExpectVideoSuccess),
         CreateDefaultVideoEncodeAcceleratorCallback(),
         CreateDefaultVideoEncodeMemoryCallback());
 
-    receiver_to_sender_.Initialize(
-        CreateSimplePipe(p).Pass(),
-        transport_sender_.PacketReceiverForTesting(),
-        task_runner_, &testing_clock_);
+    receiver_to_sender_.Initialize(CreateSimplePipe(p),
+                                   transport_sender_.PacketReceiverForTesting(),
+                                   task_runner_, &testing_clock_);
     sender_to_receiver_.Initialize(
-        CreateSimplePipe(p).Pass(),
-        transport_receiver_->PacketReceiverForTesting(),
+        CreateSimplePipe(p), transport_receiver_->PacketReceiverForTesting(),
         task_runner_, &testing_clock_);
 
     task_runner_->RunTasks();
   }
 
   void ReceivePacket(scoped_ptr<Packet> packet) {
-    cast_receiver_->ReceivePacket(packet.Pass());
+    cast_receiver_->ReceivePacket(std::move(packet));
   }
 
   virtual ~RunOneBenchmark() {
     cast_sender_.reset();
     cast_receiver_.reset();
     task_runner_->RunTasks();
   }
 
   base::TimeDelta VideoTimestamp(int frame_number) {
     return (frame_number * base::TimeDelta::FromSeconds(1)) /
@@ skipping 34 matching lines @@
 
   void StartBasicPlayer() {
     cast_receiver_->RequestDecodedVideoFrame(base::Bind(
         &RunOneBenchmark::BasicPlayerGotVideoFrame, base::Unretained(this)));
     cast_receiver_->RequestDecodedAudioFrame(base::Bind(
         &RunOneBenchmark::BasicPlayerGotAudioFrame, base::Unretained(this)));
   }
 
   scoped_ptr<test::PacketPipe> CreateSimplePipe(const MeasuringPoint& p) {
     scoped_ptr<test::PacketPipe> pipe = test::NewBuffer(65536, p.bitrate);
-    pipe->AppendToPipe(
-        test::NewRandomDrop(p.percent_packet_drop / 100.0).Pass());
+    pipe->AppendToPipe(test::NewRandomDrop(p.percent_packet_drop / 100.0));
     pipe->AppendToPipe(test::NewConstantDelay(p.latency / 1000.0));
-    return pipe.Pass();
+    return pipe;
   }
 
   void Run(const MeasuringPoint& p) {
     available_bitrate_ = p.bitrate;
     Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
     Create(p);
     StartBasicPlayer();
 
     for (int frame = 0; frame < 1000; frame++) {
       SendFakeVideoFrame();
@@ skipping 317 matching lines @@
   media::cast::CastBenchmark benchmark;
   if (getenv("PROFILE_FILE")) {
     std::string profile_file(getenv("PROFILE_FILE"));
     base::debug::StartProfiling(profile_file);
     benchmark.Run();
     base::debug::StopProfiling();
   } else {
     benchmark.Run();
   }
 }