Convert Pass()→std::move() in //chrome

chrome/renderer/media/cast_session_delegate.cc

 // Copyright 2013 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 "chrome/renderer/media/cast_session_delegate.h"
 
+#include <utility>
+
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/renderer/media/cast_threads.h"
 #include "chrome/renderer/media/cast_transport_sender_ipc.h"
 #include "components/version_info/version_info.h"
@@ skipping 41 matching lines @@
     const net::IPEndPoint& local_endpoint,
     const net::IPEndPoint& remote_endpoint,
     scoped_ptr<base::DictionaryValue> options,
     const ErrorCallback& error_callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // CastSender uses the renderer's IO thread as the main thread. This reduces
   // thread hopping for incoming video frames and outgoing network packets.
   // TODO(hubbe): Create cast environment in ctor instead.
   cast_environment_ = new CastEnvironment(
-      scoped_ptr<base::TickClock>(new base::DefaultTickClock()).Pass(),
+      scoped_ptr<base::TickClock>(new base::DefaultTickClock()),
       base::ThreadTaskRunnerHandle::Get(),
       g_cast_threads.Get().GetAudioEncodeMessageLoopProxy(),
       g_cast_threads.Get().GetVideoEncodeMessageLoopProxy());
 
   // Rationale for using unretained: The callback cannot be called after the
   // destruction of CastTransportSenderIPC, and they both share the same thread.
   cast_transport_.reset(new CastTransportSenderIPC(
-      local_endpoint,
-      remote_endpoint,
-      options.Pass(),
+      local_endpoint, remote_endpoint, std::move(options),
       base::Bind(&CastSessionDelegateBase::ReceivePacket,
                  base::Unretained(this)),
       base::Bind(&CastSessionDelegateBase::StatusNotificationCB,
                  base::Unretained(this), error_callback),
       base::Bind(&media::cast::LogEventDispatcher::DispatchBatchOfEvents,
                  base::Unretained(cast_environment_->logger()))));
 }
 
 void CastSessionDelegateBase::StatusNotificationCB(
     const ErrorCallback& error_callback,
@@ skipping 67 matching lines @@
       create_video_encode_mem_cb);
 }
 
 
 void CastSessionDelegate::StartUDP(
     const net::IPEndPoint& local_endpoint,
     const net::IPEndPoint& remote_endpoint,
     scoped_ptr<base::DictionaryValue> options,
     const ErrorCallback& error_callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  CastSessionDelegateBase::StartUDP(local_endpoint,
-                                    remote_endpoint,
-                                    options.Pass(),
-                                    error_callback);
+  CastSessionDelegateBase::StartUDP(local_endpoint, remote_endpoint,
+                                    std::move(options), error_callback);
   event_subscribers_.reset(
       new media::cast::RawEventSubscriberBundle(cast_environment_));
 
   cast_sender_ = CastSender::Create(cast_environment_, cast_transport_.get());
 }
 
 void CastSessionDelegate::ToggleLogging(bool is_audio, bool enable) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (!event_subscribers_.get())
     return;
 
   if (enable)
     event_subscribers_->AddEventSubscribers(is_audio);
   else
     event_subscribers_->RemoveEventSubscribers(is_audio);
 }
 
 void CastSessionDelegate::GetEventLogsAndReset(
     bool is_audio,
     const std::string& extra_data,
     const EventLogsCallback& callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!event_subscribers_.get()) {
-    callback.Run(make_scoped_ptr(new base::BinaryValue).Pass());
+    callback.Run(make_scoped_ptr(new base::BinaryValue));
     return;
   }
 
   media::cast::EncodingEventSubscriber* subscriber =
       event_subscribers_->GetEncodingEventSubscriber(is_audio);
   if (!subscriber) {
-    callback.Run(make_scoped_ptr(new base::BinaryValue).Pass());
+    callback.Run(make_scoped_ptr(new base::BinaryValue));
     return;
   }
 
   media::cast::proto::LogMetadata metadata;
   media::cast::FrameEventList frame_events;
   media::cast::PacketEventList packet_events;
 
   subscriber->GetEventsAndReset(&metadata, &frame_events, &packet_events);
 
   if (!extra_data.empty())
     metadata.set_extra_data(extra_data);
   media::cast::proto::GeneralDescription* gen_desc =
       metadata.mutable_general_description();
   gen_desc->set_product(version_info::GetProductName());
   gen_desc->set_product_version(version_info::GetVersionNumber());
   gen_desc->set_os(version_info::GetOSType());
 
   scoped_ptr<char[]> serialized_log(new char[media::cast::kMaxSerializedBytes]);
   int output_bytes;
   bool success = media::cast::SerializeEvents(metadata,
                                               frame_events,
                                               packet_events,
                                               true,
                                               media::cast::kMaxSerializedBytes,
                                               serialized_log.get(),
                                               &output_bytes);
 
   if (!success) {
     DVLOG(2) << "Failed to serialize event log.";
-    callback.Run(make_scoped_ptr(new base::BinaryValue).Pass());
+    callback.Run(make_scoped_ptr(new base::BinaryValue));
     return;
   }
 
   DVLOG(2) << "Serialized log length: " << output_bytes;
 
   scoped_ptr<base::BinaryValue> blob(
-      new base::BinaryValue(serialized_log.Pass(), output_bytes));
-  callback.Run(blob.Pass());
+      new base::BinaryValue(std::move(serialized_log), output_bytes));
+  callback.Run(std::move(blob));
 }
 
 void CastSessionDelegate::GetStatsAndReset(bool is_audio,
                                            const StatsCallback& callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!event_subscribers_.get()) {
-    callback.Run(make_scoped_ptr(new base::DictionaryValue).Pass());
+    callback.Run(make_scoped_ptr(new base::DictionaryValue));
     return;
   }
 
   media::cast::StatsEventSubscriber* subscriber =
       event_subscribers_->GetStatsEventSubscriber(is_audio);
   if (!subscriber) {
-    callback.Run(make_scoped_ptr(new base::DictionaryValue).Pass());
+    callback.Run(make_scoped_ptr(new base::DictionaryValue));
     return;
   }
 
   scoped_ptr<base::DictionaryValue> stats = subscriber->GetStats();
   subscriber->Reset();
 
-  callback.Run(stats.Pass());
+  callback.Run(std::move(stats));
 }
 
 void CastSessionDelegate::OnOperationalStatusChange(
     bool is_for_audio,
     const ErrorCallback& error_callback,
     media::cast::OperationalStatus status) {
   DCHECK(cast_sender_);
 
   switch (status) {
     case media::cast::STATUS_UNINITIALIZED:
@@ skipping 35 matching lines @@
       error_callback.Run(base::StringPrintf("%s codec runtime error.",
                                             is_for_audio ? "Audio" : "Video"));
       break;
   }
 }
 
 void CastSessionDelegate::ReceivePacket(
     scoped_ptr<media::cast::Packet> packet) {
   // Do nothing (frees packet)
 }