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

media/cast/test/end2end_unittest.cc

 // Copyright 2013 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 test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
-
 #include <functional>
 #include <list>
 #include <map>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
@@ skipping 132 matching lines @@
 // PacketReceiverCallback.
 class LoopBackPacketPipe : public test::PacketPipe {
  public:
   explicit LoopBackPacketPipe(const PacketReceiverCallback& packet_receiver)
       : packet_receiver_(packet_receiver) {}
 
   ~LoopBackPacketPipe() final {}
 
   // PacketPipe implementations.
   void Send(scoped_ptr<Packet> packet) final {
-    packet_receiver_.Run(packet.Pass());
+    packet_receiver_.Run(std::move(packet));
   }
 
  private:
   PacketReceiverCallback packet_receiver_;
 };
 
 // Class that sends the packet direct from sender into the receiver with the
 // ability to drop packets between the two.
 //
 // TODO(miu): This should be reconciled/merged into
 // media/cast/test/loopback_transport.*.  It's roughly the same class and has
 // exactly the same name (and when it was outside of the anonymous namespace bad
 // things happened when linking on Android!).
 class LoopBackTransport : public PacketSender {
  public:
   explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
       : send_packets_(true),
         drop_packets_belonging_to_odd_frames_(false),
         cast_environment_(cast_environment),
         bytes_sent_(0) {}
 
   void SetPacketReceiver(
       const PacketReceiverCallback& packet_receiver,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::TickClock* clock) {
     scoped_ptr<test::PacketPipe> loopback_pipe(
         new LoopBackPacketPipe(packet_receiver));
     if (packet_pipe_) {
-      packet_pipe_->AppendToPipe(loopback_pipe.Pass());
+      packet_pipe_->AppendToPipe(std::move(loopback_pipe));
     } else {
-      packet_pipe_ = loopback_pipe.Pass();
+      packet_pipe_ = std::move(loopback_pipe);
     }
     packet_pipe_->InitOnIOThread(task_runner, clock);
   }
 
   bool SendPacket(PacketRef packet, const base::Closure& cb) final {
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
     if (!send_packets_)
       return true;
 
     bytes_sent_ += packet->data.size();
     if (drop_packets_belonging_to_odd_frames_) {
       uint32_t frame_id = packet->data[13];
       if (frame_id % 2 == 1)
         return true;
     }
 
     scoped_ptr<Packet> packet_copy(new Packet(packet->data));
-    packet_pipe_->Send(packet_copy.Pass());
+    packet_pipe_->Send(std::move(packet_copy));
     return true;
   }
 
   int64_t GetBytesSent() final { return bytes_sent_; }
 
   void SetSendPackets(bool send_packets) { send_packets_ = send_packets; }
 
   void DropAllPacketsBelongingToOddFrames() {
     drop_packets_belonging_to_odd_frames_ = true;
   }
 
   void SetPacketPipe(scoped_ptr<test::PacketPipe> pipe) {
     // Append the loopback pipe to the end.
-    pipe->AppendToPipe(packet_pipe_.Pass());
-    packet_pipe_ = pipe.Pass();
+    pipe->AppendToPipe(std::move(packet_pipe_));
+    packet_pipe_ = std::move(pipe);
   }
 
  private:
   bool send_packets_;
   bool drop_packets_belonging_to_odd_frames_;
   scoped_refptr<CastEnvironment> cast_environment_;
   scoped_ptr<test::PacketPipe> packet_pipe_;
   int64_t bytes_sent_;
 };
 
@@ skipping 10 matching lines @@
 
   void SetExpectedSamplingFrequency(int expected_sampling_frequency) {
     expected_sampling_frequency_ = expected_sampling_frequency;
   }
 
   void AddExpectedResult(const AudioBus& audio_bus,
                          const base::TimeTicks& playout_time) {
     scoped_ptr<ExpectedAudioFrame> expected_audio_frame(
         new ExpectedAudioFrame());
     expected_audio_frame->audio_bus =
-        AudioBus::Create(audio_bus.channels(), audio_bus.frames()).Pass();
+        AudioBus::Create(audio_bus.channels(), audio_bus.frames());
     audio_bus.CopyTo(expected_audio_frame->audio_bus.get());
     expected_audio_frame->playout_time = playout_time;
     expected_frames_.push_back(expected_audio_frame.release());
   }
 
   void IgnoreAudioFrame(scoped_ptr<AudioBus> audio_bus,
                         const base::TimeTicks& playout_time,
                         bool is_continuous) {
     ++num_called_;
   }
@@ skipping 49 matching lines @@
     int16_t* const pcm_data =
         reinterpret_cast<int16_t*>(audio_frame->mutable_bytes());
     for (int i = 0; i < num_elements; ++i)
       pcm_data[i] = static_cast<int16_t>(base::NetToHost16(pcm_data[i]));
     scoped_ptr<AudioBus> audio_bus(
         AudioBus::Create(expected_audio_frame.audio_bus->channels(),
                          expected_audio_frame.audio_bus->frames()));
     audio_bus->FromInterleaved(pcm_data, audio_bus->frames(), sizeof(int16_t));
 
     // Delegate the checking from here...
-    CheckAudioFrame(audio_bus.Pass(), audio_frame->reference_time, true);
+    CheckAudioFrame(std::move(audio_bus), audio_frame->reference_time, true);
   }
 
   int number_times_called() const { return num_called_; }
 
  protected:
   virtual ~TestReceiverAudioCallback() {
     STLDeleteElements(&expected_frames_);
   }
 
  private:
@@ skipping 85 matching lines @@
   End2EndTest()
       : 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_),
         test_receiver_audio_callback_(new TestReceiverAudioCallback()),
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_sender_->logger()->Subscribe(&event_subscriber_sender_);
@@ skipping 79 matching lines @@
           base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs)));
       const base::TimeTicks reference_time =
           testing_clock_sender_->NowTicks() +
               i * base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs);
       if (will_be_checked) {
         test_receiver_audio_callback_->AddExpectedResult(
             *audio_bus,
             reference_time +
                 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs));
       }
-      audio_frame_input_->InsertAudio(audio_bus.Pass(), reference_time);
+      audio_frame_input_->InsertAudio(std::move(audio_bus), reference_time);
     }
   }
 
   void FeedAudioFramesWithExpectedDelay(int count,
                                         const base::TimeDelta& delay) {
     for (int i = 0; i < count; ++i) {
       scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
           base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs)));
       const base::TimeTicks reference_time =
           testing_clock_sender_->NowTicks() +
               i * base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs);
       test_receiver_audio_callback_->AddExpectedResult(
           *audio_bus,
           reference_time + delay +
               base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs));
-      audio_frame_input_->InsertAudio(audio_bus.Pass(), reference_time);
+      audio_frame_input_->InsertAudio(std::move(audio_bus), reference_time);
     }
   }
 
   void RequestAudioFrames(int count, bool with_check) {
     for (int i = 0; i < count; ++i) {
       cast_receiver_->RequestDecodedAudioFrame(
           base::Bind(with_check ? &TestReceiverAudioCallback::CheckAudioFrame :
                                   &TestReceiverAudioCallback::IgnoreAudioFrame,
                      test_receiver_audio_callback_));
     }
   }
 
   void ReceivePacket(scoped_ptr<Packet> packet) {
-    cast_receiver_->ReceivePacket(packet.Pass());
+    cast_receiver_->ReceivePacket(std::move(packet));
   }
 
   void Create() {
     net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new CastTransportSenderImpl(
         nullptr, testing_clock_sender_, dummy_endpoint, dummy_endpoint,
         make_scoped_ptr(new base::DictionaryValue),
         base::Bind(&UpdateCastTransportStatus),
         base::Bind(&LogEventDispatcher::DispatchBatchOfEvents,
                    base::Unretained(cast_environment_sender_->logger())),
@@ skipping 735 matching lines @@
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(kLongTestIterations, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, EvilNetwork) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000,
             1);
-  receiver_to_sender_.SetPacketPipe(test::EvilNetwork().Pass());
-  sender_to_receiver_.SetPacketPipe(test::EvilNetwork().Pass());
+  receiver_to_sender_.SetPacketPipe(test::EvilNetwork());
+  sender_to_receiver_.SetPacketPipe(test::EvilNetwork());
   Create();
   StartBasicPlayer();
 
   for (size_t frames_counter = 0;
        frames_counter < kLongTestIterations;
        ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   base::TimeTicks test_end = testing_clock_receiver_->NowTicks();
   RunTasks(100 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_GT(video_ticks_.size(), kLongTestIterations / 100);
   VLOG(1) << "Fully transmitted " << video_ticks_.size() << " frames.";
   EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000);
 }
 
 // Tests that a system configured for 30 FPS drops frames when input is provided
 // at a much higher frame rate.
 TEST_F(End2EndTest, ShoveHighFrameRateDownYerThroat) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000,
             1);
-  receiver_to_sender_.SetPacketPipe(test::EvilNetwork().Pass());
-  sender_to_receiver_.SetPacketPipe(test::EvilNetwork().Pass());
+  receiver_to_sender_.SetPacketPipe(test::EvilNetwork());
+  sender_to_receiver_.SetPacketPipe(test::EvilNetwork());
   Create();
   StartBasicPlayer();
 
   for (size_t frames_counter = 0;
        frames_counter < kLongTestIterations;
        ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(10 /* 10 ms, but 33.3 expected by system */);
   }
   base::TimeTicks test_end = testing_clock_receiver_->NowTicks();
@@ skipping 11 matching lines @@
       test::NewDuplicateAndDelay(1, 10 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 20 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 40 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 80 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 160 * kFrameTimerMs));
 
-  receiver_to_sender_.SetPacketPipe(echo_chamber.Pass());
+  receiver_to_sender_.SetPacketPipe(std::move(echo_chamber));
   Create();
   StartBasicPlayer();
 
   SetExpectedVideoPlayoutSmoothness(
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 90 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 110 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 10);
 
   for (size_t frames_counter = 0;
        frames_counter < kLongTestIterations;
@@ skipping 44 matching lines @@
   EXPECT_LT(jump, 220u);
 }
 
 // TODO(pwestin): Add repeatable packet loss test.
 // TODO(pwestin): Add test for misaligned send get calls.
 // TODO(pwestin): Add more tests that does not resample.
 // TODO(pwestin): Add test when we have starvation for our RunTask.
 
 }  // namespace cast
 }  // namespace media