Use std::move() instead of .Pass() in remoting/host

remoting/host/audio_pump.cc

 // Copyright 2015 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 "remoting/host/audio_pump.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 39 matching lines @@
   int bytes_pending_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 AudioPump::Core::Core(base::WeakPtr<AudioPump> pump,
                       scoped_ptr<AudioCapturer> audio_capturer,
                       scoped_ptr<AudioEncoder> audio_encoder)
     : pump_(pump),
       pump_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      audio_capturer_(audio_capturer.Pass()),
-      audio_encoder_(audio_encoder.Pass()),
+      audio_capturer_(std::move(audio_capturer)),
+      audio_encoder_(std::move(audio_encoder)),
       enabled_(true),
       bytes_pending_(0) {
   thread_checker_.DetachFromThread();
 }
 
 AudioPump::Core::~Core() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void AudioPump::Core::Start() {
@@ skipping 19 matching lines @@
 void AudioPump::Core::EncodeAudioPacket(scoped_ptr<AudioPacket> packet) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(packet);
 
   int max_buffered_bytes =
       audio_encoder_->GetBitrate() * kMaxBufferedIntervalMs / 1000 / 8;
   if (!enabled_ || bytes_pending_ > max_buffered_bytes)
     return;
 
   scoped_ptr<AudioPacket> encoded_packet =
-      audio_encoder_->Encode(packet.Pass());
+      audio_encoder_->Encode(std::move(packet));
 
   // The audio encoder returns a null audio packet if there's no audio to send.
   if (!encoded_packet)
     return;
 
   int packet_size = encoded_packet->ByteSize();
   bytes_pending_ += packet_size;
 
   pump_task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioPump::SendAudioPacket, pump_,
                             base::Passed(&encoded_packet), packet_size));
 }
 
 AudioPump::AudioPump(
     scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
     scoped_ptr<AudioCapturer> audio_capturer,
     scoped_ptr<AudioEncoder> audio_encoder,
     protocol::AudioStub* audio_stub)
     : audio_task_runner_(audio_task_runner),
       audio_stub_(audio_stub),
       weak_factory_(this) {
   DCHECK(audio_stub_);
 
-  core_.reset(new Core(weak_factory_.GetWeakPtr(), audio_capturer.Pass(),
-                       audio_encoder.Pass()));
+  core_.reset(new Core(weak_factory_.GetWeakPtr(), std::move(audio_capturer),
+                       std::move(audio_encoder)));
 
   audio_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::Start, base::Unretained(core_.get())));
 }
 
 AudioPump::~AudioPump() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   audio_task_runner_->DeleteSoon(FROM_HERE, core_.release());
 }
 
 void AudioPump::Pause(bool pause) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   audio_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Core::Pause, base::Unretained(core_.get()), pause));
 }
 
 void AudioPump::SendAudioPacket(scoped_ptr<AudioPacket> packet, int size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(packet);
 
   audio_stub_->ProcessAudioPacket(
-      packet.Pass(),
+      std::move(packet),
       base::Bind(&AudioPump::OnPacketSent, weak_factory_.GetWeakPtr(), size));
 }
 
 void AudioPump::OnPacketSent(int size) {
   audio_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Core::OnPacketSent, base::Unretained(core_.get()), size));
 }
 
 }  // namespace remoting