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

Now there is a presubmit check that doesn't allow Pass() anymore.
See https://www.chromium.org/rvalue-references for information
about std::move in chromium.

Review URL: https://codereview.chromium.org/1545723002

Cr-Commit-Position: refs/heads/master@{#366778}

12 files changed, 87 insertions, 82 deletions

diff --git a/remoting/client/audio_decode_scheduler.cc b/remoting/client/audio_decode_scheduler.cc
index ac006dd..976d7a4 100644
--- a/remoting/client/audio_decode_scheduler.cc
+++ b/remoting/client/audio_decode_scheduler.cc
@@ -4,6 +4,8 @@
 
 #include "remoting/client/audio_decode_scheduler.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ -53,11 +55,9 @@ AudioDecodeScheduler::Core::Core(
     scoped_ptr<AudioPlayer> audio_player)
     : main_task_runner_(main_task_runner),
       audio_decode_task_runner_(audio_decode_task_runner),
-      audio_player_(audio_player.Pass()) {
-}
+      audio_player_(std::move(audio_player)) {}
 
-AudioDecodeScheduler::Core::~Core() {
-}
+AudioDecodeScheduler::Core::~Core() {}
 
 void AudioDecodeScheduler::Core::Initialize(
     const protocol::SessionConfig& config) {
@@ -83,7 +83,7 @@ void AudioDecodeScheduler::Core::DecodePacket(
     scoped_ptr<AudioPacket> packet,
     const base::Closure& done) {
   DCHECK(audio_decode_task_runner_->BelongsToCurrentThread());
-  scoped_ptr<AudioPacket> decoded_packet = decoder_->Decode(packet.Pass());
+  scoped_ptr<AudioPacket> decoded_packet = decoder_->Decode(std::move(packet));
 
   main_task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioDecodeScheduler::Core::ProcessDecodedPacket, this,
@@ -96,7 +96,7 @@ void AudioDecodeScheduler::Core::ProcessDecodedPacket(
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   // Only process |packet| if it is non-null.
   if (packet.get() && audio_player_.get())
-    audio_player_->ProcessAudioPacket(packet.Pass());
+    audio_player_->ProcessAudioPacket(std::move(packet));
   done.Run();
 }
 
@@ -105,7 +105,7 @@ AudioDecodeScheduler::AudioDecodeScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner,
     scoped_ptr<AudioPlayer> audio_player)
     : core_(new Core(main_task_runner, audio_decode_task_runner,
-                     audio_player.Pass())) {
+                     std::move(audio_player))) {
 }
 
 AudioDecodeScheduler::~AudioDecodeScheduler() {
@@ -118,7 +118,7 @@ void AudioDecodeScheduler::Initialize(const protocol::SessionConfig& config) {
 
 void AudioDecodeScheduler::ProcessAudioPacket(scoped_ptr<AudioPacket> packet,
                                               const base::Closure& done) {
-  core_->ProcessAudioPacket(packet.Pass(), done);
+  core_->ProcessAudioPacket(std::move(packet), done);
 }
 
 }  // namespace remoting
diff --git a/remoting/client/audio_player_unittest.cc b/remoting/client/audio_player_unittest.cc
index 0e5381e..1bfb86f 100644
--- a/remoting/client/audio_player_unittest.cc
+++ b/remoting/client/audio_player_unittest.cc
@@ -99,7 +99,7 @@ scoped_ptr<AudioPacket> CreatePacketWithSamplingRate(
   data.resize(samples * kAudioSampleBytes, kDummyAudioData);
   packet->add_data(data);
 
-  return packet.Pass();
+  return packet;
 }
 
 scoped_ptr<AudioPacket> CreatePacket44100Hz(int samples) {
diff --git a/remoting/client/chromoting_client.cc b/remoting/client/chromoting_client.cc
index 2086553..4e5b53e 100644
--- a/remoting/client/chromoting_client.cc
+++ b/remoting/client/chromoting_client.cc
@@ -4,6 +4,8 @@
 
 #include "remoting/client/chromoting_client.h"
 
+#include <utility>
+
 #include "remoting/base/capabilities.h"
 #include "remoting/client/audio_decode_scheduler.h"
 #include "remoting/client/audio_player.h"
@@ -32,7 +34,7 @@ ChromotingClient::ChromotingClient(ClientContext* client_context,
   if (audio_player) {
     audio_decode_scheduler_.reset(new AudioDecodeScheduler(
         client_context->main_task_runner(),
-        client_context->audio_decode_task_runner(), audio_player.Pass()));
+        client_context->audio_decode_task_runner(), std::move(audio_player)));
   }
 }
 
@@ -41,9 +43,14 @@ ChromotingClient::~ChromotingClient() {
       signal_strategy_->RemoveListener(this);
 }
 
+void ChromotingClient::set_protocol_config(
+    scoped_ptr<protocol::CandidateSessionConfig> config) {
+  protocol_config_ = std::move(config);
+}
+
 void ChromotingClient::SetConnectionToHostForTests(
     scoped_ptr<protocol::ConnectionToHost> connection_to_host) {
-  connection_ = connection_to_host.Pass();
+  connection_ = std::move(connection_to_host);
 }
 
 void ChromotingClient::Start(
@@ -71,9 +78,9 @@ void ChromotingClient::Start(
     protocol_config_ = protocol::CandidateSessionConfig::CreateDefault();
   if (!audio_decode_scheduler_)
     protocol_config_->DisableAudioChannel();
-  session_manager_->set_protocol_config(protocol_config_.Pass());
+  session_manager_->set_protocol_config(std::move(protocol_config_));
 
-  authenticator_ = authenticator.Pass();
+  authenticator_ = std::move(authenticator);
 
   signal_strategy_ = signal_strategy;
   signal_strategy_->AddListener(this);
@@ -195,7 +202,7 @@ bool ChromotingClient::OnSignalStrategyIncomingStanza(
 void ChromotingClient::StartConnection() {
   DCHECK(thread_checker_.CalledOnValidThread());
   connection_->Connect(
-      session_manager_->Connect(host_jid_, authenticator_.Pass()), this);
+      session_manager_->Connect(host_jid_, std::move(authenticator_)), this);
 }
 
 void ChromotingClient::OnAuthenticated() {
diff --git a/remoting/client/chromoting_client.h b/remoting/client/chromoting_client.h
index 1079018..1fe71fa 100644
--- a/remoting/client/chromoting_client.h
+++ b/remoting/client/chromoting_client.h
@@ -55,10 +55,7 @@ class ChromotingClient : public SignalStrategy::Listener,
 
   ~ChromotingClient() override;
 
-  void set_protocol_config(
-      scoped_ptr<protocol::CandidateSessionConfig> config) {
-    protocol_config_ = config.Pass();
-  }
+  void set_protocol_config(scoped_ptr<protocol::CandidateSessionConfig> config);
 
   // Used to set fake/mock objects for tests which use the ChromotingClient.
   void SetConnectionToHostForTests(
diff --git a/remoting/client/jni/chromoting_jni_instance.cc b/remoting/client/jni/chromoting_jni_instance.cc
index 02a701f..82c34e9 100644
--- a/remoting/client/jni/chromoting_jni_instance.cc
+++ b/remoting/client/jni/chromoting_jni_instance.cc
@@ -7,6 +7,8 @@
 #include <android/log.h>
 #include <stdint.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "jingle/glue/thread_wrapper.h"
@@ -86,7 +88,7 @@ ChromotingJniInstance::ChromotingJniInstance(ChromotingJniRuntime* jni_runtime,
   authenticator_.reset(new protocol::NegotiatingClientAuthenticator(
       pairing_id, pairing_secret, host_id_,
       base::Bind(&ChromotingJniInstance::FetchSecret, this),
-      token_fetcher.Pass(), auth_methods));
+      std::move(token_fetcher), auth_methods));
 
   // Post a task to start connection
   jni_runtime_->network_task_runner()->PostTask(
@@ -430,10 +432,10 @@ void ChromotingJniInstance::ConnectToHostOnNetworkThread() {
 
   scoped_refptr<protocol::TransportContext> transport_context =
       new protocol::TransportContext(
-          signaling_.get(), port_allocator_factory.Pass(), network_settings,
+          signaling_.get(), std::move(port_allocator_factory), network_settings,
           protocol::TransportRole::CLIENT);
 
-  client_->Start(signaling_.get(), authenticator_.Pass(), transport_context,
+  client_->Start(signaling_.get(), std::move(authenticator_), transport_context,
                  host_jid_, capabilities_);
 }
 
diff --git a/remoting/client/plugin/chromoting_instance.cc b/remoting/client/plugin/chromoting_instance.cc
index 1c23317..e791ce0 100644
--- a/remoting/client/plugin/chromoting_instance.cc
+++ b/remoting/client/plugin/chromoting_instance.cc
@@ -4,12 +4,13 @@
 
 #include "remoting/client/plugin/chromoting_instance.h"
 
-#include <string>
-#include <vector>
-
 #include <nacl_io/nacl_io.h>
 #include <sys/mount.h>
 
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ -187,8 +188,7 @@ ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
   rtc::InitRandom(random_seed, sizeof(random_seed));
 
   // Send hello message.
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
-  PostLegacyJsonMessage("hello", data.Pass());
+  PostLegacyJsonMessage("hello", make_scoped_ptr(new base::DictionaryValue()));
 }
 
 ChromotingInstance::~ChromotingInstance() {
@@ -336,8 +336,8 @@ void ChromotingInstance::OnVideoDecodeError() {
 }
 
 void ChromotingInstance::OnVideoFirstFrameReceived() {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
-  PostLegacyJsonMessage("onFirstFrameReceived", data.Pass());
+  PostLegacyJsonMessage("onFirstFrameReceived",
+                        make_scoped_ptr(new base::DictionaryValue()));
 }
 
 void ChromotingInstance::OnVideoSize(const webrtc::DesktopSize& size,
@@ -352,7 +352,7 @@ void ChromotingInstance::OnVideoSize(const webrtc::DesktopSize& size,
     data->SetInteger("x_dpi", dpi.x());
   if (dpi.y())
     data->SetInteger("y_dpi", dpi.y());
-  PostLegacyJsonMessage("onDesktopSize", data.Pass());
+  PostLegacyJsonMessage("onDesktopSize", std::move(data));
 }
 
 void ChromotingInstance::OnVideoShape(const webrtc::DesktopRegion* shape) {
@@ -377,7 +377,7 @@ void ChromotingInstance::OnVideoShape(const webrtc::DesktopRegion* shape) {
     shape_message->Set("rects", rects_value.release());
   }
 
-  PostLegacyJsonMessage("onDesktopShape", shape_message.Pass());
+  PostLegacyJsonMessage("onDesktopShape", std::move(shape_message));
 }
 
 void ChromotingInstance::OnVideoFrameDirtyRegion(
@@ -396,7 +396,7 @@ void ChromotingInstance::OnVideoFrameDirtyRegion(
 
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->Set("rects", rects_value.release());
-  PostLegacyJsonMessage("onDebugRegion", data.Pass());
+  PostLegacyJsonMessage("onDebugRegion", std::move(data));
 }
 
 void ChromotingInstance::OnConnectionState(
@@ -456,7 +456,7 @@ void ChromotingInstance::OnConnectionState(
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("state", protocol::ConnectionToHost::StateToString(state));
   data->SetString("error", ConnectionErrorToString(error));
-  PostLegacyJsonMessage("onConnectionStatus", data.Pass());
+  PostLegacyJsonMessage("onConnectionStatus", std::move(data));
 }
 
 void ChromotingInstance::FetchThirdPartyToken(
@@ -473,13 +473,13 @@ void ChromotingInstance::FetchThirdPartyToken(
   data->SetString("tokenUrl", token_url.spec());
   data->SetString("hostPublicKey", host_public_key);
   data->SetString("scope", scope);
-  PostLegacyJsonMessage("fetchThirdPartyToken", data.Pass());
+  PostLegacyJsonMessage("fetchThirdPartyToken", std::move(data));
 }
 
 void ChromotingInstance::OnConnectionReady(bool ready) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetBoolean("ready", ready);
-  PostLegacyJsonMessage("onConnectionReady", data.Pass());
+  PostLegacyJsonMessage("onConnectionReady", std::move(data));
 }
 
 void ChromotingInstance::OnRouteChanged(const std::string& channel_name,
@@ -488,13 +488,13 @@ void ChromotingInstance::OnRouteChanged(const std::string& channel_name,
   data->SetString("channel", channel_name);
   data->SetString("connectionType",
                   protocol::TransportRoute::GetTypeString(route.type));
-  PostLegacyJsonMessage("onRouteChanged", data.Pass());
+  PostLegacyJsonMessage("onRouteChanged", std::move(data));
 }
 
 void ChromotingInstance::SetCapabilities(const std::string& capabilities) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("capabilities", capabilities);
-  PostLegacyJsonMessage("setCapabilities", data.Pass());
+  PostLegacyJsonMessage("setCapabilities", std::move(data));
 }
 
 void ChromotingInstance::SetPairingResponse(
@@ -502,7 +502,7 @@ void ChromotingInstance::SetPairingResponse(
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("clientId", pairing_response.client_id());
   data->SetString("sharedSecret", pairing_response.shared_secret());
-  PostLegacyJsonMessage("pairingResponse", data.Pass());
+  PostLegacyJsonMessage("pairingResponse", std::move(data));
 }
 
 void ChromotingInstance::DeliverHostMessage(
@@ -510,7 +510,7 @@ void ChromotingInstance::DeliverHostMessage(
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("type", message.type());
   data->SetString("data", message.data());
-  PostLegacyJsonMessage("extensionMessage", data.Pass());
+  PostLegacyJsonMessage("extensionMessage", std::move(data));
 }
 
 void ChromotingInstance::FetchSecretFromDialog(
@@ -523,7 +523,7 @@ void ChromotingInstance::FetchSecretFromDialog(
   secret_fetched_callback_ = secret_fetched_callback;
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetBoolean("pairingSupported", pairing_supported);
-  PostLegacyJsonMessage("fetchPin", data.Pass());
+  PostLegacyJsonMessage("fetchPin", std::move(data));
 }
 
 void ChromotingInstance::FetchSecretFromString(
@@ -548,7 +548,7 @@ void ChromotingInstance::InjectClipboardEvent(
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("mimeType", event.mime_type());
   data->SetString("item", event.data());
-  PostLegacyJsonMessage("injectClipboardItem", data.Pass());
+  PostLegacyJsonMessage("injectClipboardItem", std::move(data));
 }
 
 void ChromotingInstance::SetCursorShape(
@@ -676,9 +676,9 @@ void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
   if (!plugin_view_.is_null())
     video_renderer_->OnViewChanged(plugin_view_);
 
-  scoped_ptr<AudioPlayer> audio_player(new PepperAudioPlayer(this));
-  client_.reset(new ChromotingClient(&context_, this, video_renderer_.get(),
-                                     audio_player.Pass()));
+  client_.reset(
+      new ChromotingClient(&context_, this, video_renderer_.get(),
+                           make_scoped_ptr(new PepperAudioPlayer(this))));
 
   // Connect the input pipeline to the protocol stub & initialize components.
   mouse_input_filter_.set_input_stub(client_->input_stub());
@@ -721,7 +721,7 @@ void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
   scoped_ptr<protocol::Authenticator> authenticator(
       new protocol::NegotiatingClientAuthenticator(
           client_pairing_id, client_paired_secret, authentication_tag,
-          fetch_secret_callback, token_fetcher.Pass(), auth_methods));
+          fetch_secret_callback, std::move(token_fetcher), auth_methods));
 
   scoped_ptr<protocol::CandidateSessionConfig> config =
       protocol::CandidateSessionConfig::CreateDefault();
@@ -729,10 +729,10 @@ void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
       experiments_list.end()) {
     config->set_vp9_experiment_enabled(true);
   }
-  client_->set_protocol_config(config.Pass());
+  client_->set_protocol_config(std::move(config));
 
   // Kick off the connection.
-  client_->Start(signal_strategy_.get(), authenticator.Pass(),
+  client_->Start(signal_strategy_.get(), std::move(authenticator),
                  transport_context, host_jid, capabilities);
 
   // Start timer that periodically sends perf stats.
@@ -1036,13 +1036,13 @@ void ChromotingInstance::SendTrappedKey(uint32_t usb_keycode, bool pressed) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("usbKeycode", usb_keycode);
   data->SetBoolean("pressed", pressed);
-  PostLegacyJsonMessage("trappedKeyEvent", data.Pass());
+  PostLegacyJsonMessage("trappedKeyEvent", std::move(data));
 }
 
 void ChromotingInstance::SendOutgoingIq(const std::string& iq) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("iq", iq);
-  PostLegacyJsonMessage("sendOutgoingIq", data.Pass());
+  PostLegacyJsonMessage("sendOutgoingIq", std::move(data));
 }
 
 void ChromotingInstance::UpdatePerfStatsInUI() {
@@ -1056,7 +1056,7 @@ void ChromotingInstance::UpdatePerfStatsInUI() {
   data->SetDouble("decodeLatency", perf_tracker_.video_decode_ms());
   data->SetDouble("renderLatency", perf_tracker_.video_paint_ms());
   data->SetDouble("roundtripLatency", perf_tracker_.round_trip_ms());
-  PostLegacyJsonMessage("onPerfStats", data.Pass());
+  PostLegacyJsonMessage("onPerfStats", std::move(data));
 }
 
 // static
diff --git a/remoting/client/plugin/pepper_port_allocator.cc b/remoting/client/plugin/pepper_port_allocator.cc
index 0b24341..0b28e5a 100644
--- a/remoting/client/plugin/pepper_port_allocator.cc
+++ b/remoting/client/plugin/pepper_port_allocator.cc
@@ -6,6 +6,8 @@
 
 #include <stdint.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
@@ -209,13 +211,9 @@ void PepperPortAllocatorSession::OnResponseBodyRead(int32_t result) {
 // static
 scoped_ptr<PepperPortAllocator> PepperPortAllocator::Create(
     const pp::InstanceHandle& instance) {
-  scoped_ptr<rtc::NetworkManager> network_manager(
-      new PepperNetworkManager(instance));
-  scoped_ptr<rtc::PacketSocketFactory> socket_factory(
-      new PepperPacketSocketFactory(instance));
-  scoped_ptr<PepperPortAllocator> result(new PepperPortAllocator(
-      instance, network_manager.Pass(), socket_factory.Pass()));
-  return result.Pass();
+  return make_scoped_ptr(new PepperPortAllocator(
+      instance, make_scoped_ptr(new PepperNetworkManager(instance)),
+      make_scoped_ptr(new PepperPacketSocketFactory(instance))));
 }
 
 PepperPortAllocator::PepperPortAllocator(
@@ -226,9 +224,8 @@ PepperPortAllocator::PepperPortAllocator(
                             socket_factory.get(),
                             std::string()),
       instance_(instance),
-      network_manager_(network_manager.Pass()),
-      socket_factory_(socket_factory.Pass()) {
-}
+      network_manager_(std::move(network_manager)),
+      socket_factory_(std::move(socket_factory)) {}
 
 PepperPortAllocator::~PepperPortAllocator() {}
 
diff --git a/remoting/client/plugin/pepper_video_renderer_2d.cc b/remoting/client/plugin/pepper_video_renderer_2d.cc
index 204fdc8..4e6e4ba 100644
--- a/remoting/client/plugin/pepper_video_renderer_2d.cc
+++ b/remoting/client/plugin/pepper_video_renderer_2d.cc
@@ -6,6 +6,8 @@
 
 #include <stdint.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/strings/string_util.h"
@@ -201,7 +203,7 @@ void PepperVideoRenderer2D::Flush() {
   // |flushing_frames_done_callbacks_| so the callbacks are called when flush is
   // finished.
   DCHECK(flushing_frames_done_callbacks_.empty());
-  flushing_frames_done_callbacks_ = pending_frames_done_callbacks_.Pass();
+  flushing_frames_done_callbacks_ = std::move(pending_frames_done_callbacks_);
 
   // Flush the updated areas to the screen.
   int error = graphics2d_.Flush(
diff --git a/remoting/client/plugin/pepper_video_renderer_3d.cc b/remoting/client/plugin/pepper_video_renderer_3d.cc
index 6277f9b..732b77b 100644
--- a/remoting/client/plugin/pepper_video_renderer_3d.cc
+++ b/remoting/client/plugin/pepper_video_renderer_3d.cc
@@ -6,6 +6,8 @@
 
 #include <math.h>
 
+#include <utility>
+
 #include "base/callback_helpers.h"
 #include "base/stl_util.h"
 #include "ppapi/c/pp_codecs.h"
@@ -33,9 +35,7 @@ const uint32_t kMinimumPictureCount = 0;  // 3
 class PepperVideoRenderer3D::PendingPacket {
  public:
   PendingPacket(scoped_ptr<VideoPacket> packet, const base::Closure& done)
-      : packet_(packet.Pass()),
-        done_runner_(done) {
-  }
+      : packet_(std::move(packet)), done_runner_(done) {}
 
   ~PendingPacket() {}
 
@@ -224,7 +224,7 @@ void PepperVideoRenderer3D::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
             remoting_rect.height()));
       }
       if (!frame_shape_ || !frame_shape_->Equals(*shape)) {
-        frame_shape_ = shape.Pass();
+        frame_shape_ = std::move(shape);
         event_handler_->OnVideoShape(frame_shape_.get());
       }
     } else if (frame_shape_) {
@@ -246,7 +246,7 @@ void PepperVideoRenderer3D::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
   }
 
   pending_packets_.push_back(
-      new PendingPacket(packet.Pass(), done_runner.Release()));
+      new PendingPacket(std::move(packet), done_runner.Release()));
   DecodeNextPacket();
 }
 
@@ -340,7 +340,7 @@ void PepperVideoRenderer3D::PaintIfNeeded() {
     return;
 
   if (next_picture_)
-    current_picture_ = next_picture_.Pass();
+    current_picture_ = std::move(next_picture_);
 
   force_repaint_ = false;
 
diff --git a/remoting/client/server_log_entry_client.cc b/remoting/client/server_log_entry_client.cc
index 61e1d6c..0686159 100644
--- a/remoting/client/server_log_entry_client.cc
+++ b/remoting/client/server_log_entry_client.cc
@@ -105,7 +105,7 @@ scoped_ptr<ServerLogEntry> MakeLogEntryForSessionStateChange(
     entry->Set(kKeyConnectionError, GetValueError(error));
   }
 
-  return entry.Pass();
+  return entry;
 }
 
 scoped_ptr<ServerLogEntry> MakeLogEntryForStatistics(
@@ -127,7 +127,7 @@ scoped_ptr<ServerLogEntry> MakeLogEntryForStatistics(
   entry->Set("roundtrip-latency",
              StringPrintf("%.2f", perf_tracker->round_trip_ms()));
 
-  return entry.Pass();
+  return entry;
 }
 
 scoped_ptr<ServerLogEntry> MakeLogEntryForSessionIdOld(
@@ -136,7 +136,7 @@ scoped_ptr<ServerLogEntry> MakeLogEntryForSessionIdOld(
   entry->AddRoleField(kValueRoleClient);
   entry->AddEventNameField(kValueEventNameSessionIdOld);
   AddSessionIdToLogEntry(entry.get(), session_id);
-  return entry.Pass();
+  return entry;
 }
 
 scoped_ptr<ServerLogEntry> MakeLogEntryForSessionIdNew(
@@ -145,7 +145,7 @@ scoped_ptr<ServerLogEntry> MakeLogEntryForSessionIdNew(
   entry->AddRoleField(kValueRoleClient);
   entry->AddEventNameField(kValueEventNameSessionIdNew);
   AddSessionIdToLogEntry(entry.get(), session_id);
-  return entry.Pass();
+  return entry;
 }
 
 void AddClientFieldsToLogEntry(ServerLogEntry* entry) {
diff --git a/remoting/client/software_video_renderer.cc b/remoting/client/software_video_renderer.cc
index 8172369..9726cd5 100644
--- a/remoting/client/software_video_renderer.cc
+++ b/remoting/client/software_video_renderer.cc
@@ -4,6 +4,8 @@
 
 #include "remoting/client/software_video_renderer.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ -35,8 +37,7 @@ namespace {
 class RgbToBgrVideoDecoderFilter : public VideoDecoder {
  public:
   RgbToBgrVideoDecoderFilter(scoped_ptr<VideoDecoder> parent)
-      : parent_(parent.Pass()) {
-  }
+      : parent_(std::move(parent)) {}
 
   bool DecodePacket(const VideoPacket& packet,
                     webrtc::DesktopFrame* frame) override {
@@ -64,7 +65,7 @@ scoped_ptr<webrtc::DesktopFrame> DoDecodeFrame(
     scoped_ptr<webrtc::DesktopFrame> frame) {
   if (!decoder->DecodePacket(*packet, frame.get()))
     frame.reset();
-  return frame.Pass();
+  return frame;
 }
 
 }  // namespace
@@ -100,9 +101,8 @@ void SoftwareVideoRenderer::OnSessionConfig(
   }
 
   if (consumer_->GetPixelFormat() == FrameConsumer::FORMAT_RGBA) {
-    scoped_ptr<VideoDecoder> wrapper(
-        new RgbToBgrVideoDecoderFilter(decoder_.Pass()));
-    decoder_ = wrapper.Pass();
+    decoder_ =
+        make_scoped_ptr(new RgbToBgrVideoDecoderFilter(std::move(decoder_)));
   }
 }
 
@@ -173,7 +173,7 @@ void SoftwareVideoRenderer::RenderFrame(
     return;
   }
 
-  consumer_->DrawFrame(frame.Pass(),
+  consumer_->DrawFrame(std::move(frame),
                        base::Bind(&SoftwareVideoRenderer::OnFrameRendered,
                                   weak_factory_.GetWeakPtr(), frame_id, done));
 }
diff --git a/remoting/client/software_video_renderer_unittest.cc b/remoting/client/software_video_renderer_unittest.cc
index 9a36d72..d57e7b9 100644
--- a/remoting/client/software_video_renderer_unittest.cc
+++ b/remoting/client/software_video_renderer_unittest.cc
@@ -6,6 +6,7 @@
 
 #include <stdint.h>
 
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ -34,15 +35,14 @@ class TestFrameConsumer : public FrameConsumer {
   TestFrameConsumer() {}
   ~TestFrameConsumer() override {}
 
-  scoped_ptr<DesktopFrame> WaitForNextFrame(
-      base::Closure* out_done_callback) {
+  scoped_ptr<DesktopFrame> WaitForNextFrame(base::Closure* out_done_callback) {
     EXPECT_TRUE(thread_checker_.CalledOnValidThread());
     frame_run_loop_.reset(new base::RunLoop());
     frame_run_loop_->Run();
     frame_run_loop_.reset();
     *out_done_callback = last_frame_done_callback_;
     last_frame_done_callback_.Reset();
-    return last_frame_.Pass();
+    return std::move(last_frame_);
   }
 
   // FrameConsumer interface.
@@ -55,7 +55,7 @@ class TestFrameConsumer : public FrameConsumer {
   void DrawFrame(scoped_ptr<DesktopFrame> frame,
                  const base::Closure& done) override {
     EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    last_frame_ = frame.Pass();
+    last_frame_ = std::move(frame);
     last_frame_done_callback_ = done;
     frame_run_loop_->Quit();
   }
@@ -97,7 +97,7 @@ scoped_ptr<DesktopFrame> CreateTestFrame(int index) {
         webrtc::DesktopRect::MakeWH(index, index));
   }
 
-  return frame.Pass();
+  return frame;
 }
 
 // Returns true when frames a and b are equivalent.