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

chrome/browser/media/router/media_router_mojo_impl.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 "chrome/browser/media/router/media_router_mojo_impl.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/issues_observer.h"
 #include "chrome/browser/media/router/local_media_routes_observer.h"
@@ skipping 21 matching lines @@
 ConvertToPresentationSessionMessage(interfaces::RouteMessagePtr input) {
   DCHECK(!input.is_null());
   scoped_ptr<content::PresentationSessionMessage> output;
   switch (input->type) {
     case interfaces::RouteMessage::Type::TYPE_TEXT: {
       DCHECK(!input->message.is_null());
       DCHECK(input->data.is_null());
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::TEXT));
       input->message.Swap(&output->message);
-      return output.Pass();
+      return output;
     }
     case interfaces::RouteMessage::Type::TYPE_BINARY: {
       DCHECK(!input->data.is_null());
       DCHECK(input->message.is_null());
       output.reset(new content::PresentationSessionMessage(
           content::PresentationMessageType::ARRAY_BUFFER));
       output->data.reset(new std::vector<uint8_t>);
       input->data.Swap(output->data.get());
-      return output.Pass();
+      return output;
     }
   }
 
   NOTREACHED() << "Invalid route message type " << input->type;
-  return output.Pass();
+  return output;
 }
 
 }  // namespace
 
 MediaRouterMojoImpl::MediaRouterMediaRoutesObserver::
 MediaRouterMediaRoutesObserver(MediaRouterMojoImpl* router)
     : MediaRoutesObserver(router),
       router_(router) {
   DCHECK(router);
 }
@@ skipping 42 matching lines @@
 
 // static
 void MediaRouterMojoImpl::BindToRequest(
     const std::string& extension_id,
     content::BrowserContext* context,
     mojo::InterfaceRequest<interfaces::MediaRouter> request) {
   MediaRouterMojoImpl* impl = static_cast<MediaRouterMojoImpl*>(
       MediaRouterFactory::GetApiForBrowserContext(context));
   DCHECK(impl);
 
-  impl->BindToMojoRequest(request.Pass(), extension_id);
+  impl->BindToMojoRequest(std::move(request), extension_id);
 }
 
 void MediaRouterMojoImpl::BindToMojoRequest(
     mojo::InterfaceRequest<interfaces::MediaRouter> request,
     const std::string& extension_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   binding_.reset(
-      new mojo::Binding<interfaces::MediaRouter>(this, request.Pass()));
+      new mojo::Binding<interfaces::MediaRouter>(this, std::move(request)));
   binding_->set_connection_error_handler(base::Bind(
       &MediaRouterMojoImpl::OnConnectionError, base::Unretained(this)));
 
   media_route_provider_extension_id_ = extension_id;
 }
 
 void MediaRouterMojoImpl::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   media_route_provider_.reset();
@@ skipping 20 matching lines @@
   if (event_page_tracker_->IsEventPageSuspended(
           media_route_provider_extension_id_)) {
     DVLOG_WITH_INSTANCE(1)
         << "ExecutePendingRequests was called while extension is suspended.";
     media_route_provider_.reset();
     SetWakeReason(MediaRouteProviderWakeReason::REGISTER_MEDIA_ROUTE_PROVIDER);
     AttemptWakeEventPage();
     return;
   }
 
-  media_route_provider_ = media_route_provider_ptr.Pass();
+  media_route_provider_ = std::move(media_route_provider_ptr);
   media_route_provider_.set_connection_error_handler(base::Bind(
       &MediaRouterMojoImpl::OnConnectionError, base::Unretained(this)));
   callback.Run(instance_id_);
   ExecutePendingRequests();
   wakeup_attempt_count_ = 0;
 }
 
 void MediaRouterMojoImpl::OnIssue(const interfaces::IssuePtr issue) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG_WITH_INSTANCE(1) << "OnIssue " << issue->title;
@@ skipping 158 matching lines @@
 
 void MediaRouterMojoImpl::SendRouteBinaryMessage(
     const MediaRoute::Id& route_id,
     scoped_ptr<std::vector<uint8_t>> data,
     const SendRouteMessageCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SetWakeReason(MediaRouteProviderWakeReason::SEND_SESSION_BINARY_MESSAGE);
   RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoSendSessionBinaryMessage,
                         base::Unretained(this), route_id,
-                        base::Passed(data.Pass()), callback));
+                        base::Passed(std::move(data)), callback));
 }
 
 void MediaRouterMojoImpl::AddIssue(const Issue& issue) {
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.AddIssue(issue);
 }
 
 void MediaRouterMojoImpl::ClearIssue(const Issue::Id& issue_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.ClearIssue(issue_id);
@@ skipping 205 matching lines @@
   media_route_provider_->SendRouteMessage(route_id, message, callback);
 }
 
 void MediaRouterMojoImpl::DoSendSessionBinaryMessage(
     const MediaRoute::Id& route_id,
     scoped_ptr<std::vector<uint8_t>> data,
     const SendRouteMessageCallback& callback) {
   DVLOG_WITH_INSTANCE(1) << "SendRouteBinaryMessage " << route_id;
   mojo::Array<uint8_t> mojo_array;
   mojo_array.Swap(data.get());
-  media_route_provider_->SendRouteBinaryMessage(route_id, mojo_array.Pass(),
+  media_route_provider_->SendRouteBinaryMessage(route_id, std::move(mojo_array),
                                                 callback);
 }
 
 void MediaRouterMojoImpl::DoListenForRouteMessages(
     const MediaRoute::Id& route_id) {
   DVLOG_WITH_INSTANCE(1) << "ListenForRouteMessages";
   if (!ContainsValue(route_ids_listening_for_messages_, route_id)) {
     route_ids_listening_for_messages_.insert(route_id);
     media_route_provider_->ListenForRouteMessages(
         route_id, base::Bind(&MediaRouterMojoImpl::OnRouteMessagesReceived,
@@ skipping 34 matching lines @@
   }
 
   // If |messages| is empty, then |StopListeningForRouteMessages| was invoked
   // but we have added back an observer since. Keep listening for more messages,
   // but do not notify observers with empty list.
   if (!messages.storage().empty()) {
     ScopedVector<content::PresentationSessionMessage> session_messages;
     session_messages.reserve(messages.size());
     for (size_t i = 0; i < messages.size(); ++i) {
       session_messages.push_back(
-          ConvertToPresentationSessionMessage(messages[i].Pass()).Pass());
+          ConvertToPresentationSessionMessage(std::move(messages[i])));
     }
     base::ObserverList<PresentationSessionMessagesObserver>::Iterator
         observer_it(observer_list);
     bool single_observer =
         observer_it.GetNext() != nullptr && observer_it.GetNext() == nullptr;
     FOR_EACH_OBSERVER(PresentationSessionMessagesObserver, *observer_list,
                       OnMessagesReceived(session_messages, single_observer));
   }
 
   // Listen for more messages.
@@ skipping 183 matching lines @@
   if (current_wake_reason_ == MediaRouteProviderWakeReason::TOTAL_COUNT)
     current_wake_reason_ = reason;
 }
 
 void MediaRouterMojoImpl::ClearWakeReason() {
   DCHECK(current_wake_reason_ != MediaRouteProviderWakeReason::TOTAL_COUNT);
   current_wake_reason_ = MediaRouteProviderWakeReason::TOTAL_COUNT;
 }
 
 }  // namespace media_router