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 156 matching lines @@
     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;
+  return find(api_properties.begin(), api_properties.end(), property) !=
+         api_properties.end();
+}
+
+bool HasPermission(
+    const std::vector<apibtle::DescriptorPermission>& api_permissions,
+    apibtle::DescriptorPermission permission) {
+  return find(api_permissions.begin(), api_permissions.end(), permission) !=
+         api_permissions.end();
 }
 
 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))
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_BROADCAST)) {
     properties |= device::BluetoothGattCharacteristic::PROPERTY_BROADCAST;
+  }
 
-  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_READ))
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_READ)) {
     properties |= device::BluetoothGattCharacteristic::PROPERTY_READ;
+  }
+
   if (HasProperty(api_properties,
-                  apibtle::CHARACTERISTIC_PROPERTY_WRITEWITHOUTRESPONSE))
+                  apibtle::CHARACTERISTIC_PROPERTY_WRITEWITHOUTRESPONSE)) {
     properties |=
         device::BluetoothGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE;
-  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_WRITE))
+  }
+
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_WRITE)) {
     properties |= device::BluetoothGattCharacteristic::PROPERTY_WRITE;
+  }
 
-  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_NOTIFY))
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_NOTIFY)) {
     properties |= device::BluetoothGattCharacteristic::PROPERTY_NOTIFY;
+  }
 
-  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_INDICATE))
+  if (HasProperty(api_properties, apibtle::CHARACTERISTIC_PROPERTY_INDICATE)) {
     properties |= device::BluetoothGattCharacteristic::PROPERTY_INDICATE;
+  }
 
   if (HasProperty(api_properties,
-                  apibtle::CHARACTERISTIC_PROPERTY_AUTHENTICATEDSIGNEDWRITES))
+                  apibtle::CHARACTERISTIC_PROPERTY_AUTHENTICATEDSIGNEDWRITES)) {
     properties |= device::BluetoothGattCharacteristic::
         PROPERTY_AUTHENTICATED_SIGNED_WRITES;
+  }
+
   if (HasProperty(api_properties,
-                  apibtle::CHARACTERISTIC_PROPERTY_EXTENDEDPROPERTIES))
+                  apibtle::CHARACTERISTIC_PROPERTY_EXTENDEDPROPERTIES)) {
     properties |=
         device::BluetoothGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES;
+  }
+
   if (HasProperty(api_properties,
-                  apibtle::CHARACTERISTIC_PROPERTY_RELIABLEWRITE))
+                  apibtle::CHARACTERISTIC_PROPERTY_RELIABLEWRITE)) {
     properties |= device::BluetoothGattCharacteristic::PROPERTY_RELIABLE_WRITE;
+  }
+
   if (HasProperty(api_properties,
-                  apibtle::CHARACTERISTIC_PROPERTY_WRITABLEAUXILIARIES))
+                  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 descriptor permissions 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