Use new wrapper types for web_bluetooth.mojom

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 <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 152 matching lines @@
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothRemoteGATTCharacteristic* characteristic) {
   // TODO(ortuno): After the Bluetooth Tree is implemented, there will
   // only be one object per characteristic. But for now we replace
   // the previous object.
   // https://crbug.com/495270
   active_characteristics_[characteristic_instance_id.utf8()] = characteristic;
 }
 
 void WebBluetoothImpl::RemoteCharacteristicValueChanged(
-    const mojo::String& characteristic_instance_id,
-    mojo::Array<uint8_t> value) {
+    const std::string& characteristic_instance_id,
+    const std::vector<uint8_t>& value) {
   // We post a task so that the event is fired after any pending promises have
   // resolved.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&WebBluetoothImpl::DispatchCharacteristicValueChanged,
-                 base::Unretained(this), characteristic_instance_id,
-                 value.PassStorage()));
+                 base::Unretained(this), characteristic_instance_id, value));
 }
 
 void WebBluetoothImpl::OnRequestDeviceComplete(
     std::unique_ptr<blink::WebBluetoothRequestDeviceCallbacks> callbacks,
     const blink::mojom::WebBluetoothResult result,
     blink::mojom::WebBluetoothDevicePtr device) {
   if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
     callbacks->onSuccess(base::MakeUnique<blink::WebBluetoothDeviceInit>(
         blink::WebString::fromUTF8(device->id.str()),
-        device->name.is_null() ? blink::WebString()
-                               : blink::WebString::fromUTF8(device->name)));
+        device->name ? blink::WebString::fromUTF8(device->name.value().c_str())
+                     : blink::WebString()));
   } else {
     callbacks->onError(ToInt32(result));
   }
 }
 
 void WebBluetoothImpl::GattServerDisconnected(
     const WebBluetoothDeviceId& device_id) {
   auto device_iter = connected_devices_.find(device_id);
   if (device_iter != connected_devices_.end()) {
     // Remove device from the map before calling dispatchGattServerDisconnected
@@ skipping 13 matching lines @@
     callbacks->onSuccess();
   } else {
     callbacks->onError(ToInt32(result));
   }
 }
 
 void WebBluetoothImpl::OnGetPrimaryServicesComplete(
     const blink::WebString& device_id,
     std::unique_ptr<blink::WebBluetoothGetPrimaryServicesCallbacks> callbacks,
     blink::mojom::WebBluetoothResult result,
-    mojo::Array<blink::mojom::WebBluetoothRemoteGATTServicePtr> services) {
+    base::Optional<std::vector<blink::mojom::WebBluetoothRemoteGATTServicePtr>>
+        services) {
   if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
     // TODO(dcheng): This WebVector should use smart pointers.
-    blink::WebVector<blink::WebBluetoothRemoteGATTService*> promise_services(
-        services.size());
-
-    for (size_t i = 0; i < services.size(); i++) {
-      promise_services[i] = new blink::WebBluetoothRemoteGATTService(
-          blink::WebString::fromUTF8(services[i]->instance_id),
-          blink::WebString::fromUTF8(services[i]->uuid), true /* isPrimary */,
-          device_id);
+    blink::WebVector<blink::WebBluetoothRemoteGATTService*> promise_services;
+    if (services) {

[ortuno, 2016/11/21 04:42:31]

Just DCHECK. If result == SUCCESS then we are guaranteed that there are
services.

[juncai, 2016/11/21 21:27:05]

Done.

+      blink::WebVector<blink::WebBluetoothRemoteGATTService*> tmp(
+          services->size());
+      promise_services.swap(tmp);
+      for (size_t i = 0; i < services->size(); i++) {
+        promise_services[i] = new blink::WebBluetoothRemoteGATTService(
+            blink::WebString::fromUTF8(services.value()[i]->instance_id),
+            blink::WebString::fromUTF8(services.value()[i]->uuid),
+            true /* isPrimary */, device_id);
+      }
     }
     callbacks->onSuccess(promise_services);
   } else {
     callbacks->onError(ToInt32(result));
   }
 }
 
 void WebBluetoothImpl::OnGetCharacteristicsComplete(
     const blink::WebString& service_instance_id,
     std::unique_ptr<blink::WebBluetoothGetCharacteristicsCallbacks> callbacks,
     blink::mojom::WebBluetoothResult result,
-    mojo::Array<blink::mojom::WebBluetoothRemoteGATTCharacteristicPtr>
+    base::Optional<
+        std::vector<blink::mojom::WebBluetoothRemoteGATTCharacteristicPtr>>
         characteristics) {
   if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
     // TODO(dcheng): This WebVector should use smart pointers.
     blink::WebVector<blink::WebBluetoothRemoteGATTCharacteristicInit*>
-        promise_characteristics(characteristics.size());
-
-    for (size_t i = 0; i < characteristics.size(); i++) {
-      promise_characteristics[i] =
-          new blink::WebBluetoothRemoteGATTCharacteristicInit(
-              service_instance_id,
-              blink::WebString::fromUTF8(characteristics[i]->instance_id),
-              blink::WebString::fromUTF8(characteristics[i]->uuid),
-              characteristics[i]->properties);
+        promise_characteristics;
+    if (characteristics) {

[ortuno, 2016/11/21 04:42:31]

Same here. Just DCHECK.

[juncai, 2016/11/21 21:27:05]

Done.

+      blink::WebVector<blink::WebBluetoothRemoteGATTCharacteristicInit*> tmp(
+          characteristics->size());
+      promise_characteristics.swap(tmp);
+      for (size_t i = 0; i < characteristics->size(); i++) {
+        promise_characteristics[i] =
+            new blink::WebBluetoothRemoteGATTCharacteristicInit(
+                service_instance_id,
+                blink::WebString::fromUTF8(
+                    characteristics.value()[i]->instance_id),
+                blink::WebString::fromUTF8(characteristics.value()[i]->uuid),
+                characteristics.value()[i]->properties);
+      }
     }
     callbacks->onSuccess(promise_characteristics);
   } else {
     callbacks->onError(ToInt32(result));
   }
 }
 
 void WebBluetoothImpl::OnReadValueComplete(
     std::unique_ptr<blink::WebBluetoothReadValueCallbacks> callbacks,
     blink::mojom::WebBluetoothResult result,
-    mojo::Array<uint8_t> value) {
+    const base::Optional<std::vector<uint8_t>>& value) {
   if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
-    callbacks->onSuccess(value.PassStorage());
+    callbacks->onSuccess(value ? value.value() : std::vector<uint8_t>());

[ortuno, 2016/11/21 04:42:31]

And here as well. Just DCHECK. Also does it make sense to move the vector?

[juncai, 2016/11/21 21:27:05]

Done.

   } else {
     callbacks->onError(ToInt32(result));
   }
 }
 
 void WebBluetoothImpl::OnWriteValueComplete(
     const blink::WebVector<uint8_t>& value,
     std::unique_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks,
     blink::mojom::WebBluetoothResult result) {
   if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
@@ skipping 33 matching lines @@
     // Create an associated interface ptr and pass it to the WebBluetoothService
     // so that it can send us events without us prompting.
     blink::mojom::WebBluetoothServiceClientAssociatedPtrInfo ptr_info;
     binding_.Bind(&ptr_info, web_bluetooth_service_.associated_group());
     web_bluetooth_service_->SetClient(std::move(ptr_info));
   }
   return *web_bluetooth_service_;
 }
 
 }  // namespace content