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

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 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/filters/gpu_video_decoder.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "build/build_config.h"
@@ skipping 14 matching lines @@
 // Higher values allow better pipelining in the GPU, but also require more
 // resources.
 enum { kMaxInFlightDecodes = 4 };
 
 // Size of shared-memory segments we allocate.  Since we reuse them we let them
 // be on the beefy side.
 static const size_t kSharedMemorySegmentBytes = 100 << 10;
 
 GpuVideoDecoder::SHMBuffer::SHMBuffer(scoped_ptr<base::SharedMemory> m,
                                       size_t s)
-    : shm(m.Pass()), size(s) {
-}
+    : shm(std::move(m)), size(s) {}
 
 GpuVideoDecoder::SHMBuffer::~SHMBuffer() {}
 
 GpuVideoDecoder::PendingDecoderBuffer::PendingDecoderBuffer(
     SHMBuffer* s,
     const scoped_refptr<DecoderBuffer>& b,
     const DecodeCB& done_cb)
     : shm_buffer(s), buffer(b), done_cb(done_cb) {
 }
 
@@ skipping 123 matching lines @@
   output_cb_ = BindToCurrentLoop(output_cb);
 
   if (previously_initialized) {
     // Reinitialization with a different config (but same codec and profile).
     // VDA should handle it by detecting this in-stream by itself,
     // no need to notify it.
     bound_init_cb.Run(true);
     return;
   }
 
-  vda_ = factories_->CreateVideoDecodeAccelerator().Pass();
+  vda_ = factories_->CreateVideoDecodeAccelerator();
 
   VideoDecodeAccelerator::Config vda_config(config);
 
   if (!vda_ || !vda_->Initialize(vda_config, this)) {
     DVLOG(1) << "VDA initialization failed.";
     bound_init_cb.Run(false);
     return;
   }
 
   if (config.is_encrypted()) {
@@ skipping 361 matching lines @@
     size_t min_size) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (available_shm_segments_.empty() ||
       available_shm_segments_.back()->size < min_size) {
     size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
     scoped_ptr<base::SharedMemory> shm =
         factories_->CreateSharedMemory(size_to_allocate);
     // CreateSharedMemory() can return NULL during Shutdown.
     if (!shm)
       return NULL;
-    return make_scoped_ptr(new SHMBuffer(shm.Pass(), size_to_allocate));
+    return make_scoped_ptr(new SHMBuffer(std::move(shm), size_to_allocate));
   }
   scoped_ptr<SHMBuffer> ret(available_shm_segments_.back());
   available_shm_segments_.pop_back();
-  return ret.Pass();
+  return ret;
 }
 
 void GpuVideoDecoder::PutSHM(scoped_ptr<SHMBuffer> shm_buffer) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   available_shm_segments_.push_back(shm_buffer.release());
 }
 
 void GpuVideoDecoder::NotifyEndOfBitstreamBuffer(int32_t id) {
   DVLOG(3) << "NotifyEndOfBitstreamBuffer(" << id << ")";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
@@ skipping 89 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media