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

remoting/host/video_frame_recorder.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 "remoting/host/video_frame_recorder.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/proto/video.pb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
@@ skipping 36 matching lines @@
 
   base::WeakPtrFactory<RecordingVideoEncoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RecordingVideoEncoder);
 };
 
 VideoFrameRecorder::RecordingVideoEncoder::RecordingVideoEncoder(
     scoped_ptr<VideoEncoder> encoder,
     scoped_refptr<base::TaskRunner> recorder_task_runner,
     base::WeakPtr<VideoFrameRecorder> recorder)
-    : encoder_(encoder.Pass()),
+    : encoder_(std::move(encoder)),
       recorder_task_runner_(recorder_task_runner),
       recorder_(recorder),
       enable_recording_(false),
       weak_factory_(this) {
   DCHECK(encoder_);
   DCHECK(recorder_task_runner_.get());
 }
 
 base::WeakPtr<VideoFrameRecorder::RecordingVideoEncoder>
 VideoFrameRecorder::RecordingVideoEncoder::AsWeakPtr() {
@@ skipping 53 matching lines @@
   DetachVideoEncoderWrapper();
 }
 
 scoped_ptr<VideoEncoder> VideoFrameRecorder::WrapVideoEncoder(
     scoped_ptr<VideoEncoder> encoder) {
   DCHECK(!encoder_task_runner_.get());
   DCHECK(!caller_task_runner_.get());
   caller_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   scoped_ptr<RecordingVideoEncoder> recording_encoder(
-      new RecordingVideoEncoder(encoder.Pass(),
+      new RecordingVideoEncoder(std::move(encoder),
                                 caller_task_runner_,
                                 weak_factory_.GetWeakPtr()));
   recording_encoder_ = recording_encoder->AsWeakPtr();
 
-  return recording_encoder.Pass();
+  return std::move(recording_encoder);
 }
 
 void VideoFrameRecorder::DetachVideoEncoderWrapper() {
   DCHECK(!caller_task_runner_.get() ||
          caller_task_runner_->BelongsToCurrentThread());
 
   // Immediately detach the wrapper from this recorder.
   weak_factory_.InvalidateWeakPtrs();
 
   // Clean up any pending recorded frames.
@@ skipping 41 matching lines @@
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<webrtc::DesktopFrame> frame;
   if (!recorded_frames_.empty()) {
     frame.reset(recorded_frames_.front());
     recorded_frames_.pop_front();
     content_bytes_ -= FrameContentSize(frame.get());
     DCHECK_GE(content_bytes_, 0);
   }
 
-  return frame.Pass();
+  return frame;
 }
 
 void VideoFrameRecorder::SetEncoderTaskRunner(
     scoped_refptr<base::TaskRunner> task_runner) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!encoder_task_runner_.get());
   DCHECK(task_runner.get());
 
   encoder_task_runner_ = task_runner;
 
@@ skipping 25 matching lines @@
   if (content_bytes_ + frame_bytes > max_content_bytes_) {
     return;
   }
 
   // Store the frame and update the content byte count.
   recorded_frames_.push_back(frame.release());
   content_bytes_ += frame_bytes;
 }
 
 }  // namespace remoting