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

content/renderer/bluetooth/web_bluetooth_impl.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.
 
 #include "content/renderer/bluetooth/web_bluetooth_impl.h"
 
+#include "base/memory/ptr_util.h"
 #include "content/child/mojo/type_converters.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/public/common/service_registry.h"
 #include "content/renderer/bluetooth/bluetooth_dispatcher.h"
 #include "ipc/ipc_message.h"
 #include "mojo/public/cpp/bindings/array.h"
 
 namespace content {
 
 WebBluetoothImpl::WebBluetoothImpl(ServiceRegistry* service_registry,
@@ skipping 55 matching lines @@
 
 void WebBluetoothImpl::writeValue(
     const blink::WebString& characteristic_instance_id,
     const blink::WebVector<uint8_t>& value,
     blink::WebBluetoothWriteValueCallbacks* callbacks) {
   GetWebBluetoothService().RemoteCharacteristicWriteValue(
       mojo::String::From(characteristic_instance_id),
       mojo::Array<uint8_t>::From(value),
       base::Bind(&WebBluetoothImpl::OnWriteValueComplete,
                  base::Unretained(this), value,
-                 base::Passed(make_scoped_ptr(callbacks))));
+                 base::Passed(base::WrapUnique(callbacks))));
 }
 
 void WebBluetoothImpl::startNotifications(
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothRemoteGATTCharacteristic* characteristic,
     blink::WebBluetoothNotificationsCallbacks* callbacks) {
   GetDispatcher()->startNotifications(
       frame_routing_id_, characteristic_instance_id, characteristic, callbacks);
 }
 
@@ skipping 14 matching lines @@
 
 void WebBluetoothImpl::registerCharacteristicObject(
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothRemoteGATTCharacteristic* characteristic) {
   GetDispatcher()->registerCharacteristicObject(
       frame_routing_id_, characteristic_instance_id, characteristic);
 }
 
 void WebBluetoothImpl::OnWriteValueComplete(
     const blink::WebVector<uint8_t>& value,
-    scoped_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks,
+    std::unique_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks,
     blink::mojom::WebBluetoothError error) {
   if (error == blink::mojom::WebBluetoothError::SUCCESS) {
     callbacks->onSuccess(value);
   } else {
     callbacks->onError(error);
   }
 }
 
 BluetoothDispatcher* WebBluetoothImpl::GetDispatcher() {
   return BluetoothDispatcher::GetOrCreateThreadSpecificInstance(
       thread_safe_sender_.get());
 }
 
 blink::mojom::WebBluetoothService& WebBluetoothImpl::GetWebBluetoothService() {
   if (!web_bluetooth_service_) {
     service_registry_->ConnectToRemoteService(
         mojo::GetProxy(&web_bluetooth_service_));
   }
   return *web_bluetooth_service_;
 }
 
 }  // namespace content