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

media/cast/sender/external_video_encoder.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/sender/external_video_encoder.h"
 
 #include <cmath>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 63 matching lines @@
       const scoped_refptr<base::SingleThreadTaskRunner>& encoder_task_runner,
       scoped_ptr<media::VideoEncodeAccelerator> vea,
       int max_frame_rate,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
       : cast_environment_(cast_environment),
         task_runner_(encoder_task_runner),
         max_frame_rate_(max_frame_rate),
         status_change_cb_(status_change_cb),
         create_video_encode_memory_cb_(create_video_encode_memory_cb),
-        video_encode_accelerator_(vea.Pass()),
+        video_encode_accelerator_(std::move(vea)),
         encoder_active_(false),
         next_frame_id_(0u),
         key_frame_encountered_(false),
         codec_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
         key_frame_quantizer_parsable_(false),
         requested_bit_rate_(-1),
         has_seen_zero_length_encoded_frame_(false) {}
 
   base::SingleThreadTaskRunner* task_runner() const {
     return task_runner_.get();
@@ skipping 259 matching lines @@
   void OnCreateSharedMemory(scoped_ptr<base::SharedMemory> memory) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&VEAClientImpl::OnReceivedSharedMemory,
                                       this,
                                       base::Passed(&memory)));
   }
 
   void OnReceivedSharedMemory(scoped_ptr<base::SharedMemory> memory) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
-    output_buffers_.push_back(memory.Pass());
+    output_buffers_.push_back(std::move(memory));
 
     // Wait until all requested buffers are received.
     if (output_buffers_.size() < kOutputBufferCount)
       return;
 
     // Immediately provide all output buffers to the VEA.
     for (size_t i = 0; i < output_buffers_.size(); ++i) {
       video_encode_accelerator_->UseOutputBitstreamBuffer(
           media::BitstreamBuffer(static_cast<int32_t>(i),
                                  output_buffers_[i]->handle(),
@@ skipping 209 matching lines @@
       // ...flow through to next case...
     default:
       cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
         base::Bind(status_change_cb, STATUS_UNSUPPORTED_CODEC));
       return;
   }
 
   DCHECK(!client_);
-  client_ = new VEAClientImpl(cast_environment_,
-                              encoder_task_runner,
-                              vea.Pass(),
-                              video_config.max_frame_rate,
-                              status_change_cb,
-                              create_video_encode_memory_cb_);
+  client_ = new VEAClientImpl(cast_environment_, encoder_task_runner,
+                              std::move(vea), video_config.max_frame_rate,
+                              status_change_cb, create_video_encode_memory_cb_);
   client_->task_runner()->PostTask(FROM_HERE,
                                    base::Bind(&VEAClientImpl::Initialize,
                                               client_,
                                               frame_size_,
                                               codec_profile,
                                               bit_rate_,
                                               first_frame_id));
 }
 
 SizeAdaptableExternalVideoEncoder::SizeAdaptableExternalVideoEncoder(
@@ skipping 170 matching lines @@
   const double kEntropyAtMaxQuantizer = 7.5;
   const double slope =
       (MAX_VP8_QUANTIZER - MIN_VP8_QUANTIZER) / kEntropyAtMaxQuantizer;
   const double quantizer = std::min<double>(
       MAX_VP8_QUANTIZER, MIN_VP8_QUANTIZER + slope * shannon_entropy);
   return quantizer;
 }
 
 }  //  namespace cast
 }  //  namespace media