bluetooth: Implement BluetoothCharacteristicProperties

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.cc

 // Copyright 2015 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/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/location.h"
@@ skipping 322 matching lines @@
 LayoutTestBluetoothAdapterProvider::GetGenericAccessAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   scoped_ptr<NiceMockBluetoothDevice> device(
       GetGenericAccessDevice(adapter.get()));
 
   scoped_ptr<NiceMockBluetoothGattService> generic_access(
       GetBaseGATTService(device.get(), kGenericAccessServiceUUID));
 
   scoped_ptr<NiceMockBluetoothGattCharacteristic> device_name(
-      GetBaseGATTCharacteristic(generic_access.get(), kDeviceNameUUID));
+      GetBaseGATTCharacteristic(
+          generic_access.get(),
+          kDeviceNameUUID,
+          BluetoothGattCharacteristic::PROPERTY_READ |
+          BluetoothGattCharacteristic::PROPERTY_WRITE));
 
   // Read response.
   std::string device_name_str = device->GetDeviceName();
   std::vector<uint8_t> device_name_value(device_name_str.begin(),
                                          device_name_str.end());
 
   ON_CALL(*device_name, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallback<0>(device_name_value));
 
   // Write response.
@@ skipping 15 matching lines @@
   NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
 
   scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
   scoped_ptr<NiceMockBluetoothGattService> heart_rate(
       GetBaseGATTService(device.get(), kHeartRateServiceUUID));
 
   // TODO(ortuno): Implement the rest of the service's characteristics
   // See: http://crbug.com/529975
 
   // Body Sensor Location Characteristic
+
   scoped_ptr<NiceMockBluetoothGattCharacteristic> body_sensor_location(
-      GetBaseGATTCharacteristic(heart_rate.get(), kBodySensorLocation));
+      GetBaseGATTCharacteristic(
+          heart_rate.get(),
+          kBodySensorLocation,
+          BluetoothGattCharacteristic::PROPERTY_READ));
   BluetoothGattCharacteristic* location_ptr = body_sensor_location.get();
 
   ON_CALL(*body_sensor_location, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter_ptr, location_ptr]() {
             std::vector<uint8_t> location(1 /* size */);
             location[0] = 1;  // Chest
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
             FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
                               adapter_ptr->GetObservers(),
                               GattCharacteristicValueChanged(
                                   adapter_ptr, location_ptr, location));
             return location;
           }));
 
   // Heart Rate Measurement Characteristic
   scoped_ptr<NiceMockBluetoothGattCharacteristic> heart_rate_measurement(
-      GetBaseGATTCharacteristic(heart_rate.get(), kHeartRateMeasurementUUID));
+      GetBaseGATTCharacteristic(
+          heart_rate.get(),
+          kHeartRateMeasurementUUID,
+          BluetoothGattCharacteristic::PROPERTY_NOTIFY));
   NiceMockBluetoothGattCharacteristic* measurement_ptr =
       heart_rate_measurement.get();
 
   ON_CALL(*heart_rate_measurement, StartNotifySession(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter_ptr, measurement_ptr]() {
             scoped_ptr<NiceMockBluetoothGattNotifySession> notify_session(
                 GetBaseGATTNotifySession(measurement_ptr->GetIdentifier()));
 
             std::vector<uint8_t> rate(1 /* size */);
@@ skipping 215 matching lines @@
 
   return service.Pass();
 }
 
 // Characteristics
 
 // static
 scoped_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTCharacteristic(
     MockBluetoothGattService* service,
-    const std::string& uuid) {
+    const std::string& uuid,
+    BluetoothGattCharacteristic::Properties properties) {
   return make_scoped_ptr(new NiceMockBluetoothGattCharacteristic(
       service, uuid + " Identifier", BluetoothUUID(uuid), false /* is_local */,
-      NULL /* properties */, NULL /* permissions */));
+      properties, NULL /* permissions */));
 }
 
 // static
 scoped_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetErrorCharacteristic(
     MockBluetoothGattService* service,
     BluetoothGattService::GattErrorCode error_code) {
   uint32_t error_alias = error_code + 0xA1;  // Error UUIDs start at 0xA1.
   scoped_ptr<NiceMockBluetoothGattCharacteristic> characteristic(
-      GetBaseGATTCharacteristic(service, errorUUID(error_alias)));
+      GetBaseGATTCharacteristic(
+          service,
+          errorUUID(error_alias),
+          BluetoothGattCharacteristic::PROPERTY_READ |
+          BluetoothGattCharacteristic::PROPERTY_WRITE |
+          BluetoothGattCharacteristic::PROPERTY_INDICATE));
+
 
   // Read response.
   ON_CALL(*characteristic, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
   // Write response.
   ON_CALL(*characteristic, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>(error_code));
 
   // StartNotifySession response
@@ skipping 29 matching lines @@
   return base::StringPrintf("%08x-97e5-4cd7-b9f1-f5a427670c59", alias);
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content