Add permission parsing and the removeService API.

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 162 matching lines @@
 
 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;
 }
 
+bool HasPermission(
+    const std::vector<apibtle::DescriptorPermission>& api_permissions,
+    apibtle::DescriptorPermission permission) {
+  if (find(api_permissions.begin(), api_permissions.end(), permission) !=

[xiyuan, 2016/05/12 19:25:37]

nit: just a return ?

  return find(api_permissions.begin(), api_permissions.end(), permission) !=
api_permissions.end();

[rkc, 2016/05/12 20:32:53]

Done.

+      api_permissions.end())
+    return true;
+  return false;
+}
+
 device::BluetoothGattCharacteristic::Properties GetBluetoothProperties(
     const std::vector<apibtle::CharacteristicProperty>& api_properties) {
   device::BluetoothGattCharacteristic::Properties properties =
       device::BluetoothGattCharacteristic::PROPERTY_NONE;
 
   static_assert(
       apibtle::CHARACTERISTIC_PROPERTY_LAST == 14,
       "Update required if the number of characteristic properties changes.");
 
   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 |=

[xiyuan, 2016/05/12 19:25:37]

nit: wrap with {} if condition and branch takes more than one line, here and
other places.

[rkc, 2016/05/12 20:32:53]

Done.

         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;
 
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_ENCRYPTREAD))
+    properties |= device::BluetoothGattCharacteristic::PROPERTY_READ_ENCRYPTED;
+
+  if (HasProperty(api_properties,
+                  apibtle::CHARACTERISTIC_PROPERTY_ENCRYPTWRITE))
+    properties |= device::BluetoothGattCharacteristic::PROPERTY_WRITE_ENCRYPTED;
+
+  if (HasProperty(api_properties,
+                  apibtle::CHARACTERISTIC_PROPERTY_ENCRYPTAUTHENTICATEDREAD))
+    properties |= device::BluetoothGattCharacteristic::
+        PROPERTY_READ_ENCRYPTED_AUTHENTICATED;
+
+  if (HasProperty(api_properties,
+                  apibtle::CHARACTERISTIC_PROPERTY_ENCRYPTAUTHENTICATEDWRITE))
+    properties |= device::BluetoothGattCharacteristic::
+        PROPERTY_WRITE_ENCRYPTED_AUTHENTICATED;
+
   return properties;
 }
 
+device::BluetoothGattCharacteristic::Permissions GetBluetoothPermissions(
+    const std::vector<apibtle::DescriptorPermission>& api_permissions) {
+  device::BluetoothGattCharacteristic::Permissions permissions =
+      device::BluetoothGattCharacteristic::PERMISSION_NONE;
+
+  static_assert(
+      apibtle::DESCRIPTOR_PERMISSION_LAST == 6,
+      "Update required if the number of characteristic properties changes.");
+
+  if (HasPermission(api_permissions, apibtle::DESCRIPTOR_PERMISSION_READ))
+    permissions |= device::BluetoothGattCharacteristic::PERMISSION_READ;
+
+  if (HasPermission(api_permissions, apibtle::DESCRIPTOR_PERMISSION_WRITE))
+    permissions |= device::BluetoothGattCharacteristic::PERMISSION_WRITE;
+
+  if (HasPermission(api_permissions,
+                    apibtle::DESCRIPTOR_PERMISSION_ENCRYPTEDREAD))
+    permissions |=
+        device::BluetoothGattCharacteristic::PERMISSION_READ_ENCRYPTED;
+
+  if (HasPermission(api_permissions,
+                    apibtle::DESCRIPTOR_PERMISSION_ENCRYPTEDWRITE))
+    permissions |=
+        device::BluetoothGattCharacteristic::PERMISSION_WRITE_ENCRYPTED;
+
+  if (HasPermission(api_permissions,
+                    apibtle::DESCRIPTOR_PERMISSION_ENCRYPTEDAUTHENTICATEDREAD))
+    permissions |= device::BluetoothGattCharacteristic::
+        PERMISSION_READ_ENCRYPTED_AUTHENTICATED;
+
+  if (HasPermission(api_permissions,
+                    apibtle::DESCRIPTOR_PERMISSION_ENCRYPTEDAUTHENTICATEDWRITE))
+    permissions |= device::BluetoothGattCharacteristic::
+        PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED;
+
+  return permissions;
+}
+
 }  // namespace
 
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI>*
 BluetoothLowEnergyAPI::GetFactoryInstance() {
   return g_factory.Pointer();
@@ skipping 1018 matching lines @@
   device::BluetoothLocalGattCharacteristic* characteristic =
       event_router_->GetLocalCharacteristic(params_->characteristic_id);
   if (!characteristic) {
     Respond(Error(kErrorInvalidCharacteristicId));
     return;
   }
 
   base::WeakPtr<device::BluetoothLocalGattDescriptor> descriptor =
       device::BluetoothLocalGattDescriptor::Create(
           device::BluetoothUUID(params_->descriptor.uuid),
-          device::BluetoothGattCharacteristic::Permissions(), characteristic);
+          GetBluetoothPermissions(params_->descriptor.permissions),
+          characteristic);
 
   Respond(ArgumentList(
       apibtle::CreateDescriptor::Results::Create(descriptor->GetIdentifier())));
 }
 
 // registerService:
 
 template class BLEPeripheralExtensionFunction<apibtle::RegisterService::Params>;
 
 void BluetoothLowEnergyRegisterServiceFunction::DoWork() {
@@ skipping 44 matching lines @@
 
 void BluetoothLowEnergyNotifyCharacteristicValueChangedFunction::DoWork() {
   Respond(Error(kErrorPermissionDenied));
 }
 
 // removeService:
 
 template class BLEPeripheralExtensionFunction<apibtle::RemoveService::Params>;
 
 void BluetoothLowEnergyRemoveServiceFunction::DoWork() {
-  Respond(Error(kErrorPermissionDenied));
+  device::BluetoothLocalGattService* service =
+      event_router_->adapter()->GetGattService(params_->service_id);
+  if (!service) {
+    Respond(Error(kErrorInvalidServiceId));
+    return;
+  }
+  event_router_->RemoveServiceFromApp(extension_id(), service->GetIdentifier());
+  service->Delete();
+  Respond(NoArguments());
 }
 
 // sendRequestResponse:
 
 template class BLEPeripheralExtensionFunction<
     apibtle::SendRequestResponse::Params>;
 
 void BluetoothLowEnergySendRequestResponseFunction::DoWork() {
   std::vector<uint8_t> uint8_vector;
   if (params_->response.value) {
     uint8_vector.assign(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