Use std::move() instead of scoped_ptr<>::Pass().

remoting/protocol/video_frame_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/protocol/video_frame_pump.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 17 matching lines @@
 static const int kKeepAlivePacketIntervalMs = 200;
 
 static bool g_enable_timestamps = false;
 
 VideoFramePump::FrameTimestamps::FrameTimestamps() {}
 VideoFramePump::FrameTimestamps::~FrameTimestamps() {}
 
 VideoFramePump::PacketWithTimestamps::PacketWithTimestamps(
     scoped_ptr<VideoPacket> packet,
     scoped_ptr<FrameTimestamps> timestamps)
-    : packet(packet.Pass()), timestamps(timestamps.Pass()) {}
+    : packet(std::move(packet)), timestamps(std::move(timestamps)) {}
 
 VideoFramePump::PacketWithTimestamps::~PacketWithTimestamps() {}
 
 // static
 void VideoFramePump::EnableTimestampsForTests() {
   g_enable_timestamps = true;
 }
 
 VideoFramePump::VideoFramePump(
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_ptr<webrtc::DesktopCapturer> capturer,
     scoped_ptr<VideoEncoder> encoder,
     protocol::VideoStub* video_stub)
     : encode_task_runner_(encode_task_runner),
-      capturer_(capturer.Pass()),
-      encoder_(encoder.Pass()),
+      capturer_(std::move(capturer)),
+      encoder_(std::move(encoder)),
       video_stub_(video_stub),
       keep_alive_timer_(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kKeepAlivePacketIntervalMs),
           base::Bind(&VideoFramePump::SendKeepAlivePacket,
                      base::Unretained(this)),
           false),
       capture_scheduler_(base::Bind(&VideoFramePump::CaptureNextFrame,
                                     base::Unretained(this))),
       weak_factory_(this) {
@@ skipping 75 matching lines @@
 
 void VideoFramePump::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // |next_frame_timestamps_| is not set if no input events were received since
   // the previous frame. In that case create FrameTimestamps instance without
   // setting |input_event_client_timestamp| and |input_event_received_time|.
   if (!next_frame_timestamps_)
     next_frame_timestamps_.reset(new FrameTimestamps());
 
-  captured_frame_timestamps_ = next_frame_timestamps_.Pass();
+  captured_frame_timestamps_ = std::move(next_frame_timestamps_);
   captured_frame_timestamps_->capture_started_time = base::TimeTicks::Now();
 
   capturer_->Capture(webrtc::DesktopRegion());
 }
 
 // static
 scoped_ptr<VideoFramePump::PacketWithTimestamps> VideoFramePump::EncodeFrame(
     VideoEncoder* encoder,
     scoped_ptr<webrtc::DesktopFrame> frame,
     scoped_ptr<FrameTimestamps> timestamps) {
@@ skipping 11 matching lines @@
 
   if (frame)
     packet->set_capture_time_ms(frame->capture_time_ms());
 
   timestamps->encode_ended_time = base::TimeTicks::Now();
   packet->set_encode_time_ms(
       (timestamps->encode_ended_time - timestamps->encode_started_time)
           .InMilliseconds());
 
   return make_scoped_ptr(
-      new PacketWithTimestamps(packet.Pass(), timestamps.Pass()));
+      new PacketWithTimestamps(std::move(packet), std::move(timestamps)));
 }
 
 void VideoFramePump::OnFrameEncoded(scoped_ptr<PacketWithTimestamps> packet) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   capture_scheduler_.OnFrameEncoded(packet->packet.get());
 
   if (send_pending_) {
-    pending_packets_.push_back(packet.Pass());
+    pending_packets_.push_back(std::move(packet));
   } else {
-    SendPacket(packet.Pass());
+    SendPacket(std::move(packet));
   }
 }
 
 void VideoFramePump::SendPacket(scoped_ptr<PacketWithTimestamps> packet) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!send_pending_);
 
   packet->timestamps->can_send_time = base::TimeTicks::Now();
   UpdateFrameTimers(packet->packet.get(), packet->timestamps.get());
 
   send_pending_ = true;
-  video_stub_->ProcessVideoPacket(packet->packet.Pass(),
+  video_stub_->ProcessVideoPacket(std::move(packet->packet),
                                   base::Bind(&VideoFramePump::OnVideoPacketSent,
                                              weak_factory_.GetWeakPtr()));
 }
 
 void VideoFramePump::UpdateFrameTimers(VideoPacket* packet,
                                        FrameTimestamps* timestamps) {
   if (g_enable_timestamps)
     packet->set_timestamp(timestamps->capture_ended_time.ToInternalValue());
 
 
@@ skipping 23 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   send_pending_ = false;
   capture_scheduler_.OnFrameSent();
   keep_alive_timer_.Reset();
 
   // Send next packet if any.
   if (!pending_packets_.empty()) {
     scoped_ptr<PacketWithTimestamps> next(pending_packets_.front());
     pending_packets_.weak_erase(pending_packets_.begin());
-    SendPacket(next.Pass());
+    SendPacket(std::move(next));
   }
 }
 
 void VideoFramePump::SendKeepAlivePacket() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   video_stub_->ProcessVideoPacket(
       make_scoped_ptr(new VideoPacket()),
       base::Bind(&VideoFramePump::OnKeepAlivePacketSent,
                  weak_factory_.GetWeakPtr()));
 }
 
 void VideoFramePump::OnKeepAlivePacketSent() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   keep_alive_timer_.Reset();
 }
 
 }  // namespace protocol
 }  // namespace remoting