API changes to support sending characteristic properties.

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.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 "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <iterator>
 #include <vector>
@@ skipping 153 matching lines @@
   std::unique_ptr<device::BluetoothAdvertisement::ServiceData> created_data(
       new device::BluetoothAdvertisement::ServiceData());
   for (const auto& it : *service_data) {
     std::vector<uint8_t> data(it.data.size());
     std::copy(it.data.begin(), it.data.end(), data.begin());
     (*created_data)[it.uuid] = data;
   }
   return created_data;
 }
 
+bool HasProperty(
+    const std::vector<apibtle::CharacteristicProperty>& api_properties,
+    apibtle::CharacteristicProperty property) {
+  if (find(api_properties.begin(), api_properties.end(), property) !=
+      api_properties.end())
+    return true;
+  return false;
+}
+
+device::BluetoothGattCharacteristic::Properties GetBluetoothProperties(
+    const std::vector<apibtle::CharacteristicProperty>& api_properties) {
+  device::BluetoothGattCharacteristic::Properties properties =
+      device::BluetoothGattCharacteristic::PROPERTY_NONE;
+

[scheib, 2016/05/07 01:15:06]

Add a compile time check that all enum values are handled here, likely
be adding a NUM_PROPERTY to the enum. EG:

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ext...

[rkc, 2016/05/07 20:39:23]

Done.

+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_BROADCAST))
+    properties |= device::BluetoothGattCharacteristic::PROPERTY_BROADCAST;
+
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_READ))
+    properties |= device::BluetoothGattCharacteristic::PROPERTY_READ;
+  if (HasProperty(api_properties,
+                  apibtle::CHARACTERISTIC_PROPERTY_WRITEWITHOUTRESPONSE))
+    properties |=
+        device::BluetoothGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE;
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_WRITE))
+    properties |= device::BluetoothGattCharacteristic::PROPERTY_WRITE;
+
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_NOTIFY))
+    properties |= device::BluetoothGattCharacteristic::PROPERTY_NOTIFY;
+
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_INDICATE))
+    properties |= device::BluetoothGattCharacteristic::PROPERTY_INDICATE;
+
+  if (HasProperty(api_properties,
+                  apibtle::CHARACTERISTIC_PROPERTY_AUTHENTICATEDSIGNEDWRITES))
+    properties |= device::BluetoothGattCharacteristic::
+        PROPERTY_AUTHENTICATED_SIGNED_WRITES;
+  if (HasProperty(api_properties,
+                  apibtle::CHARACTERISTIC_PROPERTY_EXTENDEDPROPERTIES))
+    properties |=
+        device::BluetoothGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES;
+  if (HasProperty(api_properties,
+                  apibtle::CHARACTERISTIC_PROPERTY_RELIABLEWRITE))
+    properties |= device::BluetoothGattCharacteristic::PROPERTY_RELIABLE_WRITE;
+  if (HasProperty(api_properties,
+                  apibtle::CHARACTERISTIC_PROPERTY_WRITABLEAUXILIARIES))
+    properties |=
+        device::BluetoothGattCharacteristic::PROPERTY_WRITABLE_AUXILIARIES;
+
+  return properties;
+}
+
 }  // namespace
 
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI>*
 BluetoothLowEnergyAPI::GetFactoryInstance() {
   return g_factory.Pointer();
@@ skipping 989 matching lines @@
   device::BluetoothLocalGattService* service =
       event_router_->adapter()->GetGattService(params_->service_id);
   if (!service) {
     Respond(Error(kErrorInvalidServiceId));
     return;
   }
 
   base::WeakPtr<device::BluetoothLocalGattCharacteristic> characteristic =
       device::BluetoothLocalGattCharacteristic::Create(
           device::BluetoothUUID(params_->characteristic.uuid),
-          device::BluetoothGattCharacteristic::Properties(),
+          GetBluetoothProperties(params_->characteristic.properties),
           device::BluetoothGattCharacteristic::Permissions(), service);
 
   // Keep a track of this characteristic so we can look it up later if a
   // descriptor lists it as its parent.
   event_router_->AddLocalCharacteristic(characteristic->GetIdentifier(),
                                         service->GetIdentifier());
 
   Respond(ArgumentList(apibtle::CreateCharacteristic::Results::Create(
       characteristic->GetIdentifier())));
 }
@@ skipping 76 matching lines @@
   std::vector<uint8_t> uint8_vector(params_->response.value->begin(),
                                     params_->response.value->end());
   event_router_->HandleRequestResponse(
       extension(), params_->response.request_id, params_->response.is_error,
       uint8_vector);
   Respond(NoArguments());
 }
 
 }  // namespace api
 }  // namespace extensions