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

content/browser/bluetooth/bluetooth_dispatcher_host.cc

 // Copyright 2014 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.
 
 // ID Not In Map Note:
 // A service, characteristic, or descriptor ID not in the corresponding
 // BluetoothDispatcherHost map [service_to_device_, characteristic_to_service_,
 // descriptor_to_characteristic_] implies a hostile renderer because a renderer
 // obtains the corresponding ID from this class and it will be added to the map
 // at that time.
@@ skipping 322 matching lines @@
     std::set<BluetoothUUID> services;
     for (const BluetoothScanFilter& filter : filters) {
       services.insert(filter.services.begin(), filter.services.end());
     }
     scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter(
         new device::BluetoothDiscoveryFilter(
             device::BluetoothDiscoveryFilter::TRANSPORT_DUAL));
     for (const BluetoothUUID& service : services) {
       discovery_filter->AddUUID(service);
     }
-    return discovery_filter.Pass();
+    return discovery_filter;
   }
 
   const int thread_id;
   const int request_id;
   const std::vector<BluetoothScanFilter> filters;
   const std::vector<BluetoothUUID> optional_services;
   scoped_ptr<BluetoothChooser> chooser;
   scoped_ptr<device::BluetoothDiscoverySession> discovery_session;
 };
 
@@ skipping 81 matching lines @@
   }
 }
 
 void BluetoothDispatcherHost::StopDeviceDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (IDMap<RequestDeviceSession, IDMapOwnPointer>::iterator iter(
            &request_device_sessions_);
        !iter.IsAtEnd(); iter.Advance()) {
     RequestDeviceSession* session = iter.GetCurrentValue();
     if (session->discovery_session) {
-      StopDiscoverySession(session->discovery_session.Pass());
+      StopDiscoverySession(std::move(session->discovery_session));
     }
     if (session->chooser) {
       session->chooser->ShowDiscoveryState(
           BluetoothChooser::DiscoveryState::IDLE);
     }
   }
 }
 
 void BluetoothDispatcherHost::AdapterPoweredChanged(
     device::BluetoothAdapter* adapter,
@@ skipping 528 matching lines @@
   }
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStarted(
     int chooser_id,
     scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   VLOG(1) << "Started discovery session for " << chooser_id;
   if (RequestDeviceSession* session =
           request_device_sessions_.Lookup(chooser_id)) {
-    session->discovery_session = discovery_session.Pass();
+    session->discovery_session = std::move(discovery_session);
 
     // Arrange to stop discovery later.
     discovery_session_timer_.Reset();
   } else {
     VLOG(1) << "Chooser " << chooser_id
             << " was closed before the session finished starting. Stopping.";
-    StopDiscoverySession(discovery_session.Pass());
+    StopDiscoverySession(std::move(discovery_session));
   }
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStartedError(int chooser_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   VLOG(1) << "Failed to start discovery session for " << chooser_id;
   if (RequestDeviceSession* session =
           request_device_sessions_.Lookup(chooser_id)) {
     if (session->chooser && !session->discovery_session) {
       session->chooser->ShowDiscoveryState(
@@ skipping 120 matching lines @@
   request_device_sessions_.Remove(chooser_id);
 }
 
 void BluetoothDispatcherHost::OnGATTConnectionCreated(
     int thread_id,
     int request_id,
     const std::string& device_id,
     base::TimeTicks start_time,
     scoped_ptr<device::BluetoothGattConnection> connection) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  connections_.push_back(connection.Pass());
+  connections_.push_back(std::move(connection));
   RecordConnectGATTTimeSuccess(base::TimeTicks::Now() - start_time);
   RecordConnectGATTOutcome(UMAConnectGATTOutcome::SUCCESS);
   Send(new BluetoothMsg_ConnectGATTSuccess(thread_id, request_id, device_id));
 }
 
 void BluetoothDispatcherHost::OnCreateGATTConnectionError(
     int thread_id,
     int request_id,
     const std::string& device_id,
     base::TimeTicks start_time,
@@ skipping 69 matching lines @@
     int thread_id,
     int request_id,
     scoped_ptr<device::BluetoothGattNotifySession> notify_session) {
   RecordStartNotificationsOutcome(UMAGATTOperationOutcome::SUCCESS);
 
   // Copy Characteristic Instance ID before passing scoped pointer because
   // compilers may evaluate arguments in any order.
   const std::string characteristic_instance_id =
       notify_session->GetCharacteristicIdentifier();
   characteristic_id_to_notify_session_.insert(
-      std::make_pair(characteristic_instance_id, notify_session.Pass()));
+      std::make_pair(characteristic_instance_id, std::move(notify_session)));
 
   Send(new BluetoothMsg_StartNotificationsSuccess(thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::OnStartNotifySessionFailed(
     int thread_id,
     int request_id,
     device::BluetoothGattService::GattErrorCode error_code) {
   // TranslateGATTError calls RecordGATTOperationOutcome.
   Send(new BluetoothMsg_StartNotificationsError(
@@ skipping 103 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowNeedLocationLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 }  // namespace content