Convert //content/browser from scoped_ptr to std::unique_ptr

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 190 matching lines @@
     case BluetoothGattService::GATT_ERROR_NOT_SUPPORTED:
       RecordGATTOperationOutcome(operation,
                                  UMAGATTOperationOutcome::NOT_SUPPORTED);
       return blink::WebBluetoothError::GATT_NOT_SUPPORTED;
   }
   NOTREACHED();
   return blink::WebBluetoothError::GATT_UNTRANSLATED_ERROR_CODE;
 }
 
 void StopDiscoverySession(
-    scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
+    std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) {
   // Nothing goes wrong if the discovery session fails to stop, and we don't
   // need to wait for it before letting the user's script proceed, so we ignore
   // the results here.
   discovery_session->Stop(base::Bind(&base::DoNothing),
                           base::Bind(&base::DoNothing));
 }
 
 // TODO(ortuno): This should really be a BluetoothDevice method.
 // Replace when implemented. http://crbug.com/552022
 std::vector<BluetoothGattService*> GetPrimaryServicesByUUID(
@@ skipping 156 matching lines @@
         origin(origin),
         filters(filters),
         optional_services(optional_services) {}
 
   void AddFilteredDevice(const device::BluetoothDevice& device) {
     if (chooser && MatchesFilters(device, filters)) {
       chooser->AddDevice(device.GetAddress(), device.GetName());
     }
   }
 
-  scoped_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter() const {
+  std::unique_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter() const {
     std::set<BluetoothUUID> services;
     for (const BluetoothScanFilter& filter : filters) {
       services.insert(filter.services.begin(), filter.services.end());
     }
-    scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter(
+    std::unique_ptr<device::BluetoothDiscoveryFilter> discovery_filter(
         new device::BluetoothDiscoveryFilter(
             device::BluetoothDiscoveryFilter::TRANSPORT_DUAL));
     for (const BluetoothUUID& service : services) {
       discovery_filter->AddUUID(service);
     }
     return discovery_filter;
   }
 
   const int thread_id;
   const int request_id;
   const int frame_routing_id;
   const url::Origin origin;
   const std::vector<BluetoothScanFilter> filters;
   const std::vector<BluetoothUUID> optional_services;
-  scoped_ptr<BluetoothChooser> chooser;
-  scoped_ptr<device::BluetoothDiscoverySession> discovery_session;
+  std::unique_ptr<BluetoothChooser> chooser;
+  std::unique_ptr<device::BluetoothDiscoverySession> discovery_session;
 };
 
 BluetoothDispatcherHost::CacheQueryResult::CacheQueryResult() {}
 
 BluetoothDispatcherHost::CacheQueryResult::CacheQueryResult(
     CacheQueryOutcome outcome)
     : outcome(outcome) {}
 
 BluetoothDispatcherHost::CacheQueryResult::~CacheQueryResult() {}
 
@@ skipping 49 matching lines @@
   auto connection_iter = device_id_to_connection_map_.find(device_id);
   if (connection_iter != device_id_to_connection_map_.end()) {
     return connection_iter->second->IsConnected();
   }
   return false;
 }
 
 void BluetoothDispatcherHost::ConnectedDevicesMap::InsertOrReplace(
     int frame_routing_id,
     const std::string& device_id,
-    scoped_ptr<device::BluetoothGattConnection> connection) {
+    std::unique_ptr<device::BluetoothGattConnection> connection) {
   auto connection_iter = device_id_to_connection_map_.find(device_id);
   if (connection_iter == device_id_to_connection_map_.end()) {
     IncrementBluetoothConnectedDeviceCount(frame_routing_id);
     frame_ids_device_ids_.insert(std::make_pair(frame_routing_id, device_id));
   } else {
     device_id_to_connection_map_.erase(connection_iter);
   }
   device_id_to_connection_map_[device_id] = std::move(connection);
 }
 
@@ skipping 813 matching lines @@
     session->chooser->SetAdapterPresence(
         BluetoothChooser::AdapterPresence::POWERED_OFF);
     return;
   }
 
   StartDeviceDiscovery(session, chooser_id);
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStarted(
     int chooser_id,
-    scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
+    std::unique_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 = std::move(discovery_session);
 
     // Arrange to stop discovery later.
     discovery_session_timer_.Reset();
   } else {
     VLOG(1) << "Chooser " << chooser_id
@@ skipping 141 matching lines @@
                                              session->request_id, device_ipc));
   request_device_sessions_.Remove(chooser_id);
 }
 
 void BluetoothDispatcherHost::OnGATTConnectionCreated(
     int thread_id,
     int request_id,
     int frame_routing_id,
     const std::string& device_id,
     base::TimeTicks start_time,
-    scoped_ptr<device::BluetoothGattConnection> connection) {
+    std::unique_ptr<device::BluetoothGattConnection> connection) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordConnectGATTTimeSuccess(base::TimeTicks::Now() - start_time);
   RecordConnectGATTOutcome(UMAConnectGATTOutcome::SUCCESS);
   connected_devices_map_->InsertOrReplace(frame_routing_id, device_id,
                                           std::move(connection));
   Send(new BluetoothMsg_GATTServerConnectSuccess(thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::OnCreateGATTConnectionError(
     int thread_id,
@@ skipping 46 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // TranslateGATTError calls RecordGATTOperationOutcome.
   Send(new BluetoothMsg_ReadCharacteristicValueError(
       thread_id, request_id,
       TranslateGATTError(error_code, UMAGATTOperation::CHARACTERISTIC_READ)));
 }
 
 void BluetoothDispatcherHost::OnStartNotifySessionSuccess(
     int thread_id,
     int request_id,
-    scoped_ptr<device::BluetoothGattNotifySession> notify_session) {
+    std::unique_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, std::move(notify_session)));
 
   Send(new BluetoothMsg_StartNotificationsSuccess(thread_id, request_id));
@@ skipping 124 matching lines @@
 
 bool BluetoothDispatcherHost::CanFrameAccessCharacteristicInstance(
     int frame_routing_id,
     const std::string& characteristic_instance_id) {
   return QueryCacheForCharacteristic(GetOrigin(frame_routing_id),
                                      characteristic_instance_id)
              .outcome != CacheQueryOutcome::BAD_RENDERER;
 }
 
 }  // namespace content