Convert Pass()→std::move() in //content/browser

content/browser/presentation/presentation_service_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 "content/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <algorithm>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/browser/presentation/presentation_type_converters.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/presentation_session_message.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 35 matching lines @@
   } else {
     // string message
     output->type =
         presentation::PresentationMessageType::PRESENTATION_MESSAGE_TYPE_TEXT;
     if (pass_ownership) {
       output->message.Swap(&input->message);
     } else {
       output->message = input->message;
     }
   }
-  return output.Pass();
+  return output;
 }
 
 scoped_ptr<PresentationSessionMessage> GetPresentationSessionMessage(
     presentation::SessionMessagePtr input) {
   DCHECK(!input.is_null());
   scoped_ptr<content::PresentationSessionMessage> output;
   switch (input->type) {
     case presentation::PRESENTATION_MESSAGE_TYPE_TEXT: {
       DCHECK(!input->message.is_null());
       DCHECK(input->data.is_null());
       // Return null PresentationSessionMessage if size exceeds.
       if (input->message.size() > content::kMaxPresentationSessionMessageSize)
-        return output.Pass();
+        return output;
 
       output.reset(
           new PresentationSessionMessage(PresentationMessageType::TEXT));
       input->message.Swap(&output->message);
-      return output.Pass();
+      return output;
     }
     case presentation::PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER: {
       DCHECK(!input->data.is_null());
       DCHECK(input->message.is_null());
       if (input->data.size() > content::kMaxPresentationSessionMessageSize)
-        return output.Pass();
+        return output;
 
       output.reset(new PresentationSessionMessage(
           PresentationMessageType::ARRAY_BUFFER));
       output->data.reset(new std::vector<uint8_t>);
       input->data.Swap(output->data.get());
-      return output.Pass();
+      return output;
     }
     case presentation::PRESENTATION_MESSAGE_TYPE_BLOB: {
       DCHECK(!input->data.is_null());
       DCHECK(input->message.is_null());
       if (input->data.size() > content::kMaxPresentationSessionMessageSize)
-        return output.Pass();
+        return output;
 
       output.reset(
           new PresentationSessionMessage(PresentationMessageType::BLOB));
       output->data.reset(new std::vector<uint8_t>);
       input->data.Swap(output->data.get());
-      return output.Pass();
+      return output;
     }
   }
 
   NOTREACHED() << "Invalid presentation message type " << input->type;
-  return output.Pass();
+  return output;
 }
 
 void InvokeNewSessionMojoCallbackWithError(
     const NewSessionMojoCallback& callback) {
   callback.Run(
         presentation::PresentationSessionInfoPtr(),
         presentation::PresentationError::From(
             PresentationError(PRESENTATION_ERROR_UNKNOWN, "Internal error")));
 }
 
@@ skipping 33 matching lines @@
   DCHECK(web_contents);
 
   // This object will be deleted when the RenderFrameHost is about to be
   // deleted (RenderFrameDeleted) or if a connection error occurred
   // (OnConnectionError).
   PresentationServiceImpl* impl = new PresentationServiceImpl(
       render_frame_host,
       web_contents,
       GetContentClient()->browser()->GetPresentationServiceDelegate(
           web_contents));
-  impl->Bind(request.Pass());
+  impl->Bind(std::move(request));
 }
 
 void PresentationServiceImpl::Bind(
     mojo::InterfaceRequest<presentation::PresentationService> request) {
   binding_.reset(new mojo::Binding<presentation::PresentationService>(
-      this, request.Pass()));
+      this, std::move(request)));
   binding_->set_connection_error_handler([this]() {
     DVLOG(1) << "Connection error";
     delete this;
   });
 }
 
 void PresentationServiceImpl::SetClient(
     presentation::PresentationServiceClientPtr client) {
   DCHECK(!client_.get());
   // TODO(imcheng): Set ErrorHandler to listen for errors.
-  client_ = client.Pass();
+  client_ = std::move(client);
 }
 
 void PresentationServiceImpl::ListenForScreenAvailability(
       const mojo::String& url) {
   DVLOG(2) << "ListenForScreenAvailability " << url;
   if (!delegate_) {
     client_->OnScreenAvailabilityUpdated(url, false);
     return;
   }
 
   const std::string& availability_url = url.get();
   if (screen_availability_listeners_.count(availability_url))
     return;
 
   scoped_ptr<ScreenAvailabilityListenerImpl> listener(
       new ScreenAvailabilityListenerImpl(availability_url, this));
   if (delegate_->AddScreenAvailabilityListener(
       render_process_id_,
       render_frame_id_,
       listener.get())) {
-    screen_availability_listeners_[availability_url] = listener.Pass();
+    screen_availability_listeners_[availability_url] = std::move(listener);
   } else {
     DVLOG(1) << "AddScreenAvailabilityListener failed. Ignoring request.";
   }
 }
 
 void PresentationServiceImpl::StopListeningForScreenAvailability(
     const mojo::String& url) {
   DVLOG(2) << "StopListeningForScreenAvailability " << url;
   if (!delegate_)
     return;
@@ skipping 139 matching lines @@
 
 bool PresentationServiceImpl::RunAndEraseJoinSessionMojoCallback(
     int request_session_id,
     presentation::PresentationSessionInfoPtr session,
     presentation::PresentationErrorPtr error) {
   auto it = pending_join_session_cbs_.find(request_session_id);
   if (it == pending_join_session_cbs_.end())
     return false;
 
   DCHECK(it->second.get());
-  it->second->Run(session.Pass(), error.Pass());
+  it->second->Run(std::move(session), std::move(error));
   pending_join_session_cbs_.erase(it);
   return true;
 }
 
 void PresentationServiceImpl::SetDefaultPresentationURL(
     const mojo::String& url) {
   DVLOG(2) << "SetDefaultPresentationURL";
   if (!delegate_)
     return;
 
@@ skipping 18 matching lines @@
   // send_message_callback_ with new callback will drop the old callback.
   if (!delegate_ || send_message_callback_) {
     callback.Run(false);
     return;
   }
 
   send_message_callback_.reset(new SendMessageMojoCallback(callback));
   delegate_->SendMessage(
       render_process_id_, render_frame_id_,
       session.To<PresentationSessionInfo>(),
-      GetPresentationSessionMessage(session_message.Pass()),
+      GetPresentationSessionMessage(std::move(session_message)),
       base::Bind(&PresentationServiceImpl::OnSendMessageCallback,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PresentationServiceImpl::OnSendMessageCallback(bool sent) {
   // It is possible that Reset() is invoked before receiving this callback.
   // So, always check send_message_callback_ for non-null.
   if (send_message_callback_) {
     send_message_callback_->Run(sent);
     send_message_callback_.reset();
@@ skipping 53 matching lines @@
     bool pass_ownership) {
   DCHECK(client_);
 
   DVLOG(2) << "OnSessionMessages";
   mojo::Array<presentation::SessionMessagePtr> mojoMessages(messages.size());
   for (size_t i = 0; i < messages.size(); ++i)
     mojoMessages[i] = ToMojoSessionMessage(messages[i], pass_ownership);
 
   client_->OnSessionMessagesReceived(
       presentation::PresentationSessionInfo::From(session),
-      mojoMessages.Pass());
+      std::move(mojoMessages));
 }
 
 void PresentationServiceImpl::DidNavigateAnyFrame(
     content::RenderFrameHost* render_frame_host,
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   DVLOG(2) << "PresentationServiceImpl::DidNavigateAnyFrame";
   if (!FrameMatches(render_frame_host))
     return;
 
@@ skipping 103 matching lines @@
 PresentationServiceImpl::NewSessionMojoCallbackWrapper
 ::~NewSessionMojoCallbackWrapper() {
   if (!callback_.is_null())
     InvokeNewSessionMojoCallbackWithError(callback_);
 }
 
 void PresentationServiceImpl::NewSessionMojoCallbackWrapper::Run(
     presentation::PresentationSessionInfoPtr session,
     presentation::PresentationErrorPtr error) {
   DCHECK(!callback_.is_null());
-  callback_.Run(session.Pass(), error.Pass());
+  callback_.Run(std::move(session), std::move(error));
   callback_.reset();
 }
 
 }  // namespace content