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

content/browser/background_sync/background_sync_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/background_sync/background_sync_service_impl.h"
 
+#include <utility>
+
 #include "background_sync_registration_handle.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
 #include "content/browser/background_sync/background_sync_context_impl.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 namespace {
 
@@ skipping 17 matching lines @@
   SyncRegistrationPtr out(content::SyncRegistration::New());
   out->handle_id = in.handle_id();
   out->tag = in.options()->tag;
   out->min_period_ms = in.options()->min_period;
   out->periodicity = static_cast<content::BackgroundSyncPeriodicity>(
       in.options()->periodicity);
   out->power_state =
       static_cast<content::BackgroundSyncPowerState>(in.options()->power_state);
   out->network_state = static_cast<content::BackgroundSyncNetworkState>(
       in.options()->network_state);
-  return out.Pass();
+  return out;
 }
 
 }  // namespace
 
 #define COMPILE_ASSERT_MATCHING_ENUM(mojo_name, manager_name) \
   static_assert(static_cast<int>(content::mojo_name) ==       \
                     static_cast<int>(content::manager_name),  \
                 "mojo and manager enums must match")
 
 // TODO(iclelland): Move these tests somewhere else
@@ skipping 35 matching lines @@
 
 BackgroundSyncServiceImpl::~BackgroundSyncServiceImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(background_sync_context_->background_sync_manager());
 }
 
 BackgroundSyncServiceImpl::BackgroundSyncServiceImpl(
     BackgroundSyncContextImpl* background_sync_context,
     mojo::InterfaceRequest<BackgroundSyncService> request)
     : background_sync_context_(background_sync_context),
-      binding_(this, request.Pass()),
+      binding_(this, std::move(request)),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(background_sync_context);
 
   binding_.set_connection_error_handler(
       base::Bind(&BackgroundSyncServiceImpl::OnConnectionError,
                  base::Unretained(this) /* the channel is owned by this */));
 }
 
 void BackgroundSyncServiceImpl::OnConnectionError() {
@@ skipping 94 matching lines @@
 
   if (!registration_handle) {
     callback.Run(BACKGROUND_SYNC_ERROR_NOT_FOUND,
                  SyncRegistrationPtr(content::SyncRegistration::New()));
     return;
   }
 
   active_handles_.AddWithID(registration_handle.release(),
                             handle_ptr->handle_id());
   SyncRegistrationPtr mojoResult = ToMojoRegistration(*handle_ptr);
-  callback.Run(BACKGROUND_SYNC_ERROR_NONE, mojoResult.Pass());
+  callback.Run(BACKGROUND_SYNC_ERROR_NONE, std::move(mojoResult));
 }
 
 void BackgroundSyncServiceImpl::ReleaseRegistration(
     BackgroundSyncRegistrationHandle::HandleId handle_id) {
   if (!active_handles_.Lookup(handle_id)) {
     // TODO(jkarlin): Abort client.
     LOG(WARNING) << "Client attempted to release non-existing registration";
     return;
   }
 
@@ skipping 27 matching lines @@
   if (status != BACKGROUND_SYNC_STATUS_OK) {
     callback.Run(static_cast<content::BackgroundSyncError>(status),
                  SyncRegistrationPtr(content::SyncRegistration::New()));
     return;
   }
 
   DCHECK(result);
   active_handles_.AddWithID(result.release(), result_ptr->handle_id());
   SyncRegistrationPtr mojoResult = ToMojoRegistration(*result_ptr);
   callback.Run(static_cast<content::BackgroundSyncError>(status),
-               mojoResult.Pass());
+               std::move(mojoResult));
 }
 
 void BackgroundSyncServiceImpl::OnUnregisterResult(
     const UnregisterCallback& callback,
     BackgroundSyncStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback.Run(static_cast<content::BackgroundSyncError>(status));
 }
 
 void BackgroundSyncServiceImpl::OnGetRegistrationsResult(
     const GetRegistrationsCallback& callback,
     BackgroundSyncStatus status,
     scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
         result_registrations) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(result_registrations);
 
   mojo::Array<content::SyncRegistrationPtr> mojo_registrations(0);
   for (BackgroundSyncRegistrationHandle* registration : *result_registrations) {
     active_handles_.AddWithID(registration, registration->handle_id());
     mojo_registrations.push_back(ToMojoRegistration(*registration));
   }
 
   result_registrations->weak_clear();
 
   callback.Run(static_cast<content::BackgroundSyncError>(status),
-               mojo_registrations.Pass());
+               std::move(mojo_registrations));
 }
 
 void BackgroundSyncServiceImpl::OnNotifyWhenFinishedResult(
     const NotifyWhenFinishedCallback& callback,
     BackgroundSyncStatus status,
     BackgroundSyncState sync_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback.Run(static_cast<content::BackgroundSyncError>(status), sync_state);
 }
 
 }  // namespace content