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

remoting/client/plugin/chromoting_instance.cc

 // Copyright (c) 2012 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/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"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
@@ skipping 157 matching lines @@
 
   // Resister this instance to handle debug log messsages.
   RegisterLoggingInstance();
 
   // Initialize random seed for libjingle. It's necessary only with OpenSSL.
   char random_seed[kRandomSeedSize];
   crypto::RandBytes(random_seed, sizeof(random_seed));
   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() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // Disconnect the client.
   Disconnect();
 
   // Unregister this instance so that debug log messages will no longer be sent
   // to it. This will stop all logging in all Chromoting instances.
@@ skipping 127 matching lines @@
 
   // Assume that the decoder failure was caused by the host not encoding video
   // correctly and report it as a protocol error.
   // TODO(sergeyu): Consider using a different error code in case the decoder
   // error was caused by some other problem.
   OnConnectionState(protocol::ConnectionToHost::FAILED,
                     protocol::INCOMPATIBLE_PROTOCOL);
 }
 
 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,
                                      const webrtc::DesktopVector& dpi) {
   mouse_input_filter_.set_output_size(size);
   touch_input_scaler_.set_output_size(size);
 
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("width", size.width());
   data->SetInteger("height", size.height());
   if (dpi.x())
     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) {
   if ((shape && desktop_shape_ && shape->Equals(*desktop_shape_)) ||
       (!shape && !desktop_shape_)) {
     return;
   }
 
   scoped_ptr<base::DictionaryValue> shape_message(new base::DictionaryValue());
   if (shape) {
     desktop_shape_ = make_scoped_ptr(new webrtc::DesktopRegion(*shape));
     scoped_ptr<base::ListValue> rects_value(new base::ListValue());
     for (webrtc::DesktopRegion::Iterator i(*shape); !i.IsAtEnd(); i.Advance()) {
       const webrtc::DesktopRect& rect = i.rect();
       scoped_ptr<base::ListValue> rect_value(new base::ListValue());
       rect_value->AppendInteger(rect.left());
       rect_value->AppendInteger(rect.top());
       rect_value->AppendInteger(rect.width());
       rect_value->AppendInteger(rect.height());
       rects_value->Append(rect_value.release());
     }
     shape_message->Set("rects", rects_value.release());
   }
 
-  PostLegacyJsonMessage("onDesktopShape", shape_message.Pass());
+  PostLegacyJsonMessage("onDesktopShape", std::move(shape_message));
 }
 
 void ChromotingInstance::OnVideoFrameDirtyRegion(
     const webrtc::DesktopRegion& dirty_region) {
   scoped_ptr<base::ListValue> rects_value(new base::ListValue());
   for (webrtc::DesktopRegion::Iterator i(dirty_region); !i.IsAtEnd();
        i.Advance()) {
     const webrtc::DesktopRect& rect = i.rect();
     scoped_ptr<base::ListValue> rect_value(new base::ListValue());
     rect_value->AppendInteger(rect.left());
     rect_value->AppendInteger(rect.top());
     rect_value->AppendInteger(rect.width());
     rect_value->AppendInteger(rect.height());
     rects_value->Append(rect_value.release());
   }
 
   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(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
   pp::UMAPrivate uma(this);
 
   switch (state) {
     case protocol::ConnectionToHost::INITIALIZING:
       NOTREACHED();
@@ skipping 39 matching lines @@
             kConnectionDurationHistogramMinMinutes,
             kConnectionDurationHistogramMaxMinutes,
             kConnectionDurationHistogramBuckets);
       }
       break;
   }
 
   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(
     const GURL& token_url,
     const std::string& host_public_key,
     const std::string& scope,
     base::WeakPtr<TokenFetcherProxy> token_fetcher_proxy) {
   // Once the Session object calls this function, it won't continue the
   // authentication until the callback is called (or connection is canceled).
   // So, it's impossible to reach this with a callback already registered.
   DCHECK(!token_fetcher_proxy_.get());
   token_fetcher_proxy_ = token_fetcher_proxy;
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   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,
                                         const protocol::TransportRoute& route) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   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(
     const protocol::PairingResponse& pairing_response) {
   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(
     const protocol::ExtensionMessage& message) {
   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(
     bool pairing_supported,
     const protocol::SecretFetchedCallback& secret_fetched_callback) {
   // Once the Session object calls this function, it won't continue the
   // authentication until the callback is called (or connection is canceled).
   // So, it's impossible to reach this with a callback already registered.
   DCHECK(secret_fetched_callback_.is_null());
   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(
     const std::string& shared_secret,
     bool pairing_supported,
     const protocol::SecretFetchedCallback& secret_fetched_callback) {
   secret_fetched_callback.Run(shared_secret);
 }
 
 protocol::ClipboardStub* ChromotingInstance::GetClipboardStub() {
   // TODO(sergeyu): Move clipboard handling to a separate class.
   // crbug.com/138108
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingInstance::GetCursorShapeStub() {
   return &empty_cursor_filter_;
 }
 
 void ChromotingInstance::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   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(
     const protocol::CursorShapeInfo& cursor_shape) {
   // If the delegated cursor is empty then stop rendering a DOM cursor.
   if (IsCursorShapeEmpty(cursor_shape)) {
     PostChromotingMessage("unsetCursorShape", pp::VarDictionary());
     return;
   }
 
@@ skipping 107 matching lines @@
       base::Bind(&ChromotingInstance::UpdateUmaCustomHistogram,
                  weak_factory_.GetWeakPtr(), true),
       base::Bind(&ChromotingInstance::UpdateUmaCustomHistogram,
                  weak_factory_.GetWeakPtr(), false),
       base::Bind(&ChromotingInstance::UpdateUmaEnumHistogram,
                  weak_factory_.GetWeakPtr()));
 
   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());
   if (!plugin_view_.is_null()) {
     webrtc::DesktopSize size(plugin_view_.GetRect().width(),
                              plugin_view_.GetRect().height());
     mouse_input_filter_.set_input_size(size);
     touch_input_scaler_.set_input_size(size);
   }
 
@@ skipping 22 matching lines @@
   auth_methods.push_back(protocol::AuthenticationMethod::ThirdParty());
   auth_methods.push_back(protocol::AuthenticationMethod::Spake2Pair());
   auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
       protocol::AuthenticationMethod::HMAC_SHA256));
   auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
       protocol::AuthenticationMethod::NONE));
 
   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();
   if (std::find(experiments_list.begin(), experiments_list.end(), "vp9") !=
       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.
   stats_update_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kUIStatsUpdatePeriodSeconds),
       base::Bind(&ChromotingInstance::UpdatePerfStatsInUI,
                  base::Unretained(this)));
 }
 
 void ChromotingInstance::HandleDisconnect(const base::DictionaryValue& data) {
@@ skipping 283 matching lines @@
 
   std::string message_json;
   base::JSONWriter::Write(message, &message_json);
   PostMessage(pp::Var(message_json));
 }
 
 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() {
   // Fetch performance stats from the VideoRenderer and send them to the client
   // for display to users.
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetDouble("videoBandwidth", perf_tracker_.video_bandwidth());
   data->SetDouble("videoFrameRate", perf_tracker_.video_frame_rate());
   data->SetDouble("captureLatency", perf_tracker_.video_capture_ms());
   data->SetDouble("encodeLatency", perf_tracker_.video_encode_ms());
   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
 void ChromotingInstance::RegisterLogMessageHandler() {
   base::AutoLock lock(g_logging_lock.Get());
 
   // Set up log message handler.
   // This is not thread-safe so we need it within our lock.
   logging::SetLogMessageHandler(&LogToUI);
 }
@@ skipping 79 matching lines @@
   if (is_custom_counts_histogram) {
     uma.HistogramCustomCounts(histogram_name, value, histogram_min,
                               histogram_max, histogram_buckets);
   } else {
     uma.HistogramCustomTimes(histogram_name, value, histogram_min,
                              histogram_max, histogram_buckets);
   }
 }
 
 }  // namespace remoting