Nuke WebPassOwnPtr<T> and replace it with std::unique_ptr<T>.

content/renderer/bluetooth/bluetooth_dispatcher.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/bluetooth_dispatcher.h"
 
 #include <stddef.h>
 
+#include <memory>
+#include <utility>
+
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/bluetooth/bluetooth_messages.h"
 #include "device/bluetooth/bluetooth_uuid.h"
-#include "third_party/WebKit/public/platform/WebPassOwnPtr.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothDevice.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothError.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothRemoteGATTCharacteristic.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothRemoteGATTCharacteristicInit.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothRemoteGATTService.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebRequestDeviceOptions.h"
 
 using blink::WebBluetoothDevice;
 using blink::WebBluetoothError;
 using blink::WebBluetoothRemoteGATTCharacteristicInit;
@@ skipping 557 matching lines @@
     int thread_id,
     int request_id,
     const BluetoothDevice& device) {
   DCHECK(pending_requests_.Lookup(request_id)) << request_id;
 
   WebVector<WebString> uuids(device.uuids.size());
   for (size_t i = 0; i < device.uuids.size(); ++i)
     uuids[i] = WebString::fromUTF8(device.uuids[i].c_str());
 
   pending_requests_.Lookup(request_id)
-      ->onSuccess(blink::adoptWebPtr(new WebBluetoothDevice(
+      ->onSuccess(base::WrapUnique(new WebBluetoothDevice(
           WebString::fromUTF8(device.id), WebString(device.name),
           device.tx_power, device.rssi, device.device_class,
           GetWebVendorIdSource(device.vendor_id_source), device.vendor_id,
           device.product_id, device.product_version, uuids)));
   pending_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnRequestDeviceError(int thread_id,
                                                int request_id,
                                                WebBluetoothError error) {
@@ skipping 19 matching lines @@
 }
 
 void BluetoothDispatcher::OnGetPrimaryServiceSuccess(
     int thread_id,
     int request_id,
     const std::string& service_instance_id) {
   DCHECK(pending_primary_service_requests_.Lookup(request_id)) << request_id;
   BluetoothPrimaryServiceRequest* request =
       pending_primary_service_requests_.Lookup(request_id);
   request->callbacks->onSuccess(
-      blink::adoptWebPtr(new WebBluetoothRemoteGATTService(
+      base::WrapUnique(new WebBluetoothRemoteGATTService(
           WebString::fromUTF8(service_instance_id), request->service_uuid,
           true /* isPrimary */, request->device_id)));
   pending_primary_service_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetPrimaryServiceError(int thread_id,
                                                    int request_id,
                                                    WebBluetoothError error) {
   DCHECK(pending_primary_service_requests_.Lookup(request_id)) << request_id;
 
   pending_primary_service_requests_.Lookup(request_id)
       ->callbacks->onError(WebBluetoothError(error));
   pending_primary_service_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicSuccess(
     int thread_id,
     int request_id,
     const std::string& characteristic_instance_id,
     uint32_t characteristic_properties) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
 
   BluetoothCharacteristicRequest* request =
       pending_characteristic_requests_.Lookup(request_id);
   request->callbacks->onSuccess(
-      blink::adoptWebPtr(new WebBluetoothRemoteGATTCharacteristicInit(
+      base::WrapUnique(new WebBluetoothRemoteGATTCharacteristicInit(
           request->service_instance_id,
           WebString::fromUTF8(characteristic_instance_id),
           request->characteristic_uuid, characteristic_properties)));
 
   pending_characteristic_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicError(int thread_id,
                                                    int request_id,
                                                    WebBluetoothError error) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
 
   pending_characteristic_requests_.Lookup(request_id)
       ->callbacks->onError(WebBluetoothError(error));
 
   pending_characteristic_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicsSuccess(
     int thread_id,
     int request_id,
     const std::vector<std::string>& characteristics_instance_ids,
     const std::vector<std::string>& characteristics_uuids,
     const std::vector<uint32_t>& characteristics_properties) {
   DCHECK(pending_characteristics_requests_.Lookup(request_id)) << request_id;
 
   BluetoothCharacteristicsRequest* request =
       pending_characteristics_requests_.Lookup(request_id);
 
-  WebVector<blink::WebBluetoothRemoteGATTCharacteristicInit*>* characteristics =
-      new WebVector<WebBluetoothRemoteGATTCharacteristicInit*>(
-          characteristics_instance_ids.size());
+  // TODO(dcheng): This WebVector should use smart pointers.
+  std::unique_ptr<WebVector<blink::WebBluetoothRemoteGATTCharacteristicInit*>>
+  characteristics(new WebVector<WebBluetoothRemoteGATTCharacteristicInit*>(
+      characteristics_instance_ids.size()));
 
   for (size_t i = 0; i < characteristics_instance_ids.size(); i++) {
     (*characteristics)[i] = new WebBluetoothRemoteGATTCharacteristicInit(
         request->service_instance_id,
         WebString::fromUTF8(characteristics_instance_ids[i]),
         WebString::fromUTF8(characteristics_uuids[i]),
         characteristics_properties[i]);
   }
 
-  request->callbacks->onSuccess(blink::adoptWebPtr(characteristics));
+  request->callbacks->onSuccess(std::move(characteristics));
 
   pending_characteristics_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicsError(int thread_id,
                                                     int request_id,
                                                     WebBluetoothError error) {
   DCHECK(pending_characteristics_requests_.Lookup(request_id)) << request_id;
 
   pending_characteristics_requests_.Lookup(request_id)
@@ skipping 107 matching lines @@
     int thread_id,
     const std::string& characteristic_instance_id,
     const std::vector<uint8_t> new_value) {
   auto active_iter = active_characteristics_.find(characteristic_instance_id);
   if (active_iter != active_characteristics_.end()) {
     active_iter->second->dispatchCharacteristicValueChanged(new_value);
   }
 }
 
 }  // namespace content