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())

[dcheng, 2016/11/24 04:56:49]

Nit: no c_str() here

[juncai, 2016/11/28 22:25:21]

Done.

+                     : 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) {
+    DCHECK(services);
     // 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++) {
+        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::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) {
+    DCHECK(characteristics);
     // 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(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);
+              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());
+    DCHECK(value);
+    callbacks->onSuccess(std::move(value.value()));

[dcheng, 2016/11/24 04:56:49]

Nit: this std::move() has no effect, as |value| is const.

If it's important to move rather than copy, this parameter will have to be
wrapped in a struct.

[juncai, 2016/11/28 22:25:21]

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