CallbackPromiseAdapter types should be more compatible with WebCallbacks (2/3).

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 "base/lazy_instance.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/WebBluetoothGATTCharacteristic.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTRemoteServer.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTService.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebRequestDeviceOptions.h"
 
 using blink::WebBluetoothConnectGATTCallbacks;
 using blink::WebBluetoothDevice;
 using blink::WebBluetoothError;
@@ skipping 209 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(new WebBluetoothDevice(
+      ->onSuccess(blink::adoptWebPtr(new WebBluetoothDevice(
           WebString::fromUTF8(device.instance_id), WebString(device.name),
           device.device_class, GetWebVendorIdSource(device.vendor_id_source),
           device.vendor_id, device.product_id, device.product_version,
-          device.paired, uuids));
+          device.paired, uuids)));
   pending_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnRequestDeviceError(int thread_id,
                                                int request_id,
                                                WebBluetoothError error) {
   DCHECK(pending_requests_.Lookup(request_id)) << request_id;
-  pending_requests_.Lookup(request_id)->onError(new WebBluetoothError(error));
+  pending_requests_.Lookup(request_id)->onError(WebBluetoothError(error));
   pending_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnConnectGATTSuccess(
     int thread_id,
     int request_id,
     const std::string& device_instance_id) {
   DCHECK(pending_connect_requests_.Lookup(request_id)) << request_id;
   pending_connect_requests_.Lookup(request_id)
-      ->onSuccess(new WebBluetoothGATTRemoteServer(
-          WebString::fromUTF8(device_instance_id), true /* connected */));
+      ->onSuccess(blink::adoptWebPtr(new WebBluetoothGATTRemoteServer(
+          WebString::fromUTF8(device_instance_id), true /* connected */)));
   pending_connect_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnConnectGATTError(int thread_id,
                                              int request_id,
                                              WebBluetoothError error) {
   DCHECK(pending_connect_requests_.Lookup(request_id)) << request_id;
   pending_connect_requests_.Lookup(request_id)
-      ->onError(new WebBluetoothError(error));
+      ->onError(WebBluetoothError(error));
   pending_connect_requests_.Remove(request_id);
 }
 
 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(new WebBluetoothGATTService(
+  request->callbacks->onSuccess(blink::adoptWebPtr(new WebBluetoothGATTService(
       WebString::fromUTF8(service_instance_id), request->service_uuid,
-      true /* isPrimary */, request->device_instance_id));
+      true /* isPrimary */, request->device_instance_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;
 
   // Since we couldn't find the service return null. See Step 3 of
   // getPrimaryService algorithm:
   // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothgattremoteserver-getprimaryservice
   if (error == WebBluetoothError::ServiceNotFound) {
     pending_primary_service_requests_.Lookup(request_id)
         ->callbacks->onSuccess(nullptr);
     pending_primary_service_requests_.Remove(request_id);
     return;
   }
 
   pending_primary_service_requests_.Lookup(request_id)
-      ->callbacks->onError(new WebBluetoothError(error));
+      ->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) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
 
   BluetoothCharacteristicRequest* request =
       pending_characteristic_requests_.Lookup(request_id);
-  request->callbacks->onSuccess(new WebBluetoothGATTCharacteristic(
-      WebString::fromUTF8(characteristic_instance_id),
-      request->service_instance_id, request->characteristic_uuid));
+  request->callbacks->onSuccess(
+      blink::adoptWebPtr(new WebBluetoothGATTCharacteristic(
+          WebString::fromUTF8(characteristic_instance_id),
+          request->service_instance_id, request->characteristic_uuid)));
 
   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;
 
   // Since we couldn't find the characteristic return null. See Step 3 of
   // getCharacteristic algorithm:
   // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothgattservice-getcharacteristic
   if (error == WebBluetoothError::CharacteristicNotFound) {
     pending_characteristic_requests_.Lookup(request_id)
         ->callbacks->onSuccess(nullptr);
   } else {
     pending_characteristic_requests_.Lookup(request_id)
-        ->callbacks->onError(new WebBluetoothError(error));
+        ->callbacks->onError(WebBluetoothError(error));
   }
   pending_characteristic_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnReadValueSuccess(
     int thread_id,
     int request_id,
     const std::vector<uint8_t>& value) {
   DCHECK(pending_read_value_requests_.Lookup(request_id)) << request_id;
 
   // WebArrayBuffer is not accessible from Source/modules so we pass a
   // WebVector instead.
-  pending_read_value_requests_.Lookup(request_id)
-      ->onSuccess(new WebVector<uint8_t>(value));
+  pending_read_value_requests_.Lookup(request_id)->onSuccess(value);
 
   pending_read_value_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnReadValueError(int thread_id,
                                            int request_id,
                                            WebBluetoothError error) {
   DCHECK(pending_read_value_requests_.Lookup(request_id)) << request_id;
 
   pending_read_value_requests_.Lookup(request_id)
-      ->onError(new WebBluetoothError(error));
+      ->onError(WebBluetoothError(error));
 
   pending_read_value_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnWriteValueSuccess(int thread_id, int request_id) {
   DCHECK(pending_write_value_requests_.Lookup(request_id)) << request_id;
 
   pending_write_value_requests_.Lookup(request_id)->onSuccess();
 
   pending_write_value_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnWriteValueError(int thread_id,
                                             int request_id,
                                             WebBluetoothError error) {
   DCHECK(pending_write_value_requests_.Lookup(request_id)) << request_id;
 
   pending_write_value_requests_.Lookup(request_id)
-      ->onError(new WebBluetoothError(error));
+      ->onError(WebBluetoothError(error));
 
   pending_write_value_requests_.Remove(request_id);
 }
 
 }  // namespace content