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

media/cast/test/fake_media_source.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 "media/cast/test/fake_media_source.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_fifo.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/media.h"
@@ skipping 247 matching lines @@
                                           start_time_ + video_time);
 
   // Send just enough audio data to match next video frame's time.
   base::TimeDelta audio_time = AudioFrameTime(audio_frame_count_);
   while (audio_time < video_time) {
     if (is_transcoding_audio()) {
       Decode(true);
       CHECK(!audio_bus_queue_.empty()) << "No audio decoded.";
       scoped_ptr<AudioBus> bus(audio_bus_queue_.front());
       audio_bus_queue_.pop();
-      audio_frame_input_->InsertAudio(
-          bus.Pass(), start_time_ + audio_time);
+      audio_frame_input_->InsertAudio(std::move(bus), start_time_ + audio_time);
     } else {
       audio_frame_input_->InsertAudio(
           audio_bus_factory_->NextAudioBus(
               base::TimeDelta::FromMilliseconds(kAudioFrameMs)),
           start_time_ + audio_time);
     }
     audio_time = AudioFrameTime(++audio_frame_count_);
   }
 
   // This is the time since FakeMediaSource was started.
@@ skipping 71 matching lines @@
   Decode(true);
   if (audio_bus_queue_.empty())
     return false;
 
   base::TimeDelta audio_time = audio_sent_ts_->GetTimestamp();
   if (elapsed_time < audio_time)
     return false;
   scoped_ptr<AudioBus> bus(audio_bus_queue_.front());
   audio_bus_queue_.pop();
   audio_sent_ts_->AddFrames(bus->frames());
-  audio_frame_input_->InsertAudio(
-      bus.Pass(), start_time_ + audio_time);
+  audio_frame_input_->InsertAudio(std::move(bus), start_time_ + audio_time);
 
   // Make sure queue is not empty.
   Decode(true);
   return true;
 }
 
 void FakeMediaSource::SendNextFrame() {
   // Send as much as possible. Audio is sent according to
   // system time.
   while (SendNextTranscodedAudio(clock_->NowTicks() - start_time_)) {
@@ skipping 33 matching lines @@
 void FakeMediaSource::Rewind() {
   CHECK(av_seek_frame(av_format_context_, -1, 0, AVSEEK_FLAG_BACKWARD) >= 0)
       << "Failed to rewind to the beginning.";
 }
 
 ScopedAVPacket FakeMediaSource::DemuxOnePacket(bool* audio) {
   ScopedAVPacket packet(new AVPacket());
   if (av_read_frame(av_format_context_, packet.get()) < 0) {
     VLOG(1) << "Failed to read one AVPacket.";
     packet.reset();
-    return packet.Pass();
+    return packet;
   }
 
   int stream_index = static_cast<int>(packet->stream_index);
   if (stream_index == audio_stream_index_) {
     *audio = true;
   } else if (stream_index == video_stream_index_) {
     *audio = false;
   } else {
     // Ignore unknown packet.
     LOG(INFO) << "Unknown packet.";
     packet.reset();
   }
-  return packet.Pass();
+  return packet;
 }
 
 void FakeMediaSource::DecodeAudio(ScopedAVPacket packet) {
   // Audio.
   AVFrame* avframe = av_frame_alloc();
 
   // Make a shallow copy of packet so we can slide packet.data as frames are
   // decoded from the packet; otherwise av_packet_unref() will corrupt memory.
   AVPacket packet_temp = *packet.get();
 
@@ skipping 117 matching lines @@
       return;
 
     bool audio_packet = false;
     ScopedAVPacket packet = DemuxOnePacket(&audio_packet);
     if (!packet) {
       VLOG(1) << "End of stream.";
       return;
     }
 
     if (audio_packet)
-      DecodeAudio(packet.Pass());
+      DecodeAudio(std::move(packet));
     else
-      DecodeVideo(packet.Pass());
+      DecodeVideo(std::move(packet));
   }
 }
 
 double FakeMediaSource::ProvideInput(media::AudioBus* output_bus,
                                    base::TimeDelta buffer_delay) {
   if (audio_fifo_->frames() >= output_bus->frames()) {
     audio_fifo_->Consume(output_bus, 0, output_bus->frames());
     return 1.0;
   } else {
     LOG(WARNING) << "Not enough audio data for resampling.";
@@ skipping 22 matching lines @@
 AVCodecContext* FakeMediaSource::av_audio_context() {
   return av_audio_stream()->codec;
 }
 
 AVCodecContext* FakeMediaSource::av_video_context() {
   return av_video_stream()->codec;
 }
 
 }  // namespace cast
 }  // namespace media