arc: bluetooth: Implement Gatt Server add/delete/start/stop service

components/arc/bluetooth/arc_bluetooth_bridge.cc

 // Copyright 2016 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 "components/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 
 #include <iomanip>
@@ skipping 42 matching lines @@
 constexpr uint32_t kGattReadPermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_READ |
     BluetoothGattCharacteristic::Permission::PERMISSION_READ_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_READ_ENCRYPTED_AUTHENTICATED;
 constexpr uint32_t kGattWritePermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE |
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED;
+constexpr int32_t kInvalidGattAttributeHandle = -1;
+
+using GattStatusCallback =
+    base::Callback<void(arc::mojom::BluetoothGattStatus)>;
+using GattReadCallback =
+    base::Callback<void(arc::mojom::BluetoothGattValuePtr)>;
+
+// Example of identifier: /org/bluez/hci0/dev_E0_CF_65_8C_86_1A/service001a
+// We want to convert last digit of the identifier to int in base 16

[palmer, 2016/07/22 02:56:09]

Nit: Correct the comment: "Convert the last 4 characters of |identifier| to an
int, by interpreting them as hexadecimal digits."

[puthik_chromium, 2016/07/22 21:48:16]

Done.

+int ConvertGattIdentifierToId(const std::string identifier) {
+  return std::stoi(identifier.substr(identifier.size() - 4), nullptr, 16);

[palmer, 2016/07/22 02:56:10]

If stoi fails (e.g. because the characters were not really hex digits), it will
throw an exception. Is that expected/OK? (Maybe it is, I don't know.)

[puthik_chromium, 2016/07/22 21:48:16]

We rely on BlueZ implementation that the characters are not hex digits.
If it's not true anymore, we need to change this code anyway. So it is better
for this to be hard fail.

+}
+
+// Create GattDBElement and fill in common data for
+// Gatt Service/Characteristic/Descriptor.
+template <class RemoteGattAttribute>
+arc::mojom::BluetoothGattDBElementPtr CreateGattDBElement(
+    const arc::mojom::BluetoothGattDBAttributeType type,
+    const RemoteGattAttribute* gatt_attr) {

[palmer, 2016/07/22 02:56:09]

Style nit: Similar comment as before: My preference is to name this |attribute|.

[puthik_chromium, 2016/07/22 21:48:16]

Done.

+  arc::mojom::BluetoothGattDBElementPtr element =
+      arc::mojom::BluetoothGattDBElement::New();
+  element->type = type;
+  element->uuid = arc::mojom::BluetoothUUID::From(gatt_attr->GetUUID());
+  element->id = element->attribute_handle = element->start_handle =
+      element->end_handle =
+          ConvertGattIdentifierToId(gatt_attr->GetIdentifier());
+  element->properties = 0;
+  return element;
+}
+
+// Find Gatt Service/Characteristic/Descriptor from std::vector using UUID.

[palmer, 2016/07/22 02:56:10]

I might rewrite this comment to use the argument names rather than their types.
But, the names of the arguments and of the function can be made clear enough
such that this comment might not be necessary. (See below.)

[puthik_chromium, 2016/07/22 21:48:16]

Removed

+template <class RemoteGattAttribute>
+RemoteGattAttribute* FindGattAttributeFromUuid(

[palmer, 2016/07/22 02:56:09]

I'd rename this to |FindGattAttributeByUuid|. (We select an element *from* a
collection *by* its key.)

[puthik_chromium, 2016/07/22 21:48:16]

Done.

+    const std::vector<RemoteGattAttribute*>& gatt_attrs,

[palmer, 2016/07/22 02:56:10]

Style nit: |attributes|.

[puthik_chromium, 2016/07/22 21:48:16]

Done.

+    const BluetoothUUID& uuid) {
+  auto it = std::find_if(
+      gatt_attrs.begin(), gatt_attrs.end(),
+      [uuid](RemoteGattAttribute* attr) { return attr->GetUUID() == uuid; });
+  if (it == gatt_attrs.end())

[palmer, 2016/07/22 02:56:09]

Style nit: You could shorten this to:

  return it != attributes.end() ? *it : nullptr;

but of course it's up to you.

[puthik_chromium, 2016/07/22 21:48:16]

Done. This is more concise.

+    return nullptr;
+  return *it;
+}
+
+// Common success callback for GATT operations that only need to report
+// GattStatus back to Android.
+void OnGattOperationDone(const GattStatusCallback& callback) {
+  callback.Run(arc::mojom::BluetoothGattStatus::GATT_SUCCESS);
+}
+
+// Common error callback for GATT operations that only need to report
+// GattStatus back to Android.
+void OnGattOperationError(const GattStatusCallback& callback,
+                          BluetoothGattService::GattErrorCode error_code) {
+  callback.Run(mojo::ConvertTo<arc::mojom::BluetoothGattStatus>(error_code));
+}
+
+// Common success callback for ReadGattCharacteristic and ReadGattDescriptor
+void OnGattReadDone(const GattReadCallback& callback,
+                    const std::vector<uint8_t>& result) {
+  arc::mojom::BluetoothGattValuePtr gattValue =
+      arc::mojom::BluetoothGattValue::New();
+  gattValue->status = arc::mojom::BluetoothGattStatus::GATT_SUCCESS;
+  gattValue->value = mojo::Array<uint8_t>::From(result);
+  callback.Run(std::move(gattValue));
+}
+
+// Common error callback for ReadGattCharacteristic and ReadGattDescriptor
+void OnGattReadError(const GattReadCallback& callback,
+                     BluetoothGattService::GattErrorCode error_code) {
+  arc::mojom::BluetoothGattValuePtr gattValue =
+      arc::mojom::BluetoothGattValue::New();
+  gattValue->status =
+      mojo::ConvertTo<arc::mojom::BluetoothGattStatus>(error_code);
+  gattValue->value = nullptr;
+  callback.Run(std::move(gattValue));
+}
+
 }  // namespace
 
 namespace arc {
 
 ArcBluetoothBridge::ArcBluetoothBridge(ArcBridgeService* bridge_service)
     : ArcService(bridge_service), binding_(this), weak_factory_(this) {
   if (BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
     VLOG(1) << "registering bluetooth adapter";
     BluetoothAdapterFactory::GetAdapter(base::Bind(
         &ArcBluetoothBridge::OnAdapterInitialized, weak_factory_.GetWeakPtr()));
   } else {
     VLOG(1) << "no bluetooth adapter available";
   }
 
   arc_bridge_service()->bluetooth()->AddObserver(this);
 }
 
 ArcBluetoothBridge::~ArcBluetoothBridge() {
+  DCHECK(CalledOnValidThread());
+
   arc_bridge_service()->bluetooth()->RemoveObserver(this);
 
   if (bluetooth_adapter_)
     bluetooth_adapter_->RemoveObserver(this);
 }
 
 void ArcBluetoothBridge::OnAdapterInitialized(
     scoped_refptr<BluetoothAdapter> adapter) {
+  DCHECK(CalledOnValidThread());
+
   // We can downcast here because we are always running on Chrome OS, and
   // so our adapter uses BlueZ.
   bluetooth_adapter_ =
       static_cast<bluez::BluetoothAdapterBlueZ*>(adapter.get());
   bluetooth_adapter_->AddObserver(this);
 }
 
 void ArcBluetoothBridge::OnInstanceReady() {
   mojom::BluetoothInstance* bluetooth_instance =
       arc_bridge_service()->bluetooth()->instance();
   if (!bluetooth_instance) {
     LOG(ERROR) << "OnBluetoothInstanceReady called, "
                << "but no bluetooth instance found";
     return;
   }
   bluetooth_instance->Init(binding_.CreateInterfacePtrAndBind());
 }
 
 void ArcBluetoothBridge::AdapterPresentChanged(BluetoothAdapter* adapter,
                                                bool present) {
+  DCHECK(CalledOnValidThread());
+
   // If the adapter goes away, remove ourselves as an observer.
   if (!present && adapter == bluetooth_adapter_) {
     adapter->RemoveObserver(this);
     bluetooth_adapter_ = nullptr;
   }
 }
 
 void ArcBluetoothBridge::AdapterPoweredChanged(BluetoothAdapter* adapter,
                                                bool powered) {
   if (!HasBluetoothInstance())
@@ skipping 569 matching lines @@
     return;
   }
 
   // Discard result. Will call the callback when discovery is completed.
   device->GetGattServices();
 }
 
 void ArcBluetoothBridge::OnStartLEListenDone(
     const StartLEListenCallback& callback,
     scoped_refptr<BluetoothAdvertisement> advertisement) {
+  DCHECK(CalledOnValidThread());
   advertisment_ = advertisement;
   callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
 void ArcBluetoothBridge::OnStartLEListenError(
     const StartLEListenCallback& callback,
     BluetoothAdvertisement::ErrorCode error_code) {
+  DCHECK(CalledOnValidThread());
   advertisment_ = nullptr;
   callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE);
 }
 
 void ArcBluetoothBridge::StartLEListen(const StartLEListenCallback& callback) {
+  DCHECK(CalledOnValidThread());
   std::unique_ptr<BluetoothAdvertisement::Data> adv_data =
       base::WrapUnique(new BluetoothAdvertisement::Data(
           BluetoothAdvertisement::ADVERTISEMENT_TYPE_BROADCAST));
   bluetooth_adapter_->RegisterAdvertisement(
       std::move(adv_data), base::Bind(&ArcBluetoothBridge::OnStartLEListenDone,
                                       weak_factory_.GetWeakPtr(), callback),
       base::Bind(&ArcBluetoothBridge::OnStartLEListenError,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::OnStopLEListenDone(
     const StopLEListenCallback& callback) {
+  DCHECK(CalledOnValidThread());
   advertisment_ = nullptr;
   callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
 void ArcBluetoothBridge::OnStopLEListenError(
     const StopLEListenCallback& callback,
     BluetoothAdvertisement::ErrorCode error_code) {
+  DCHECK(CalledOnValidThread());
   advertisment_ = nullptr;
   callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE);
 }
 
 void ArcBluetoothBridge::StopLEListen(const StopLEListenCallback& callback) {
   if (!advertisment_) {
     OnStopLEListenError(
         callback,
         BluetoothAdvertisement::ErrorCode::ERROR_ADVERTISEMENT_DOES_NOT_EXIST);
     return;
   }
   advertisment_->Unregister(base::Bind(&ArcBluetoothBridge::OnStopLEListenDone,
                                        weak_factory_.GetWeakPtr(), callback),
                             base::Bind(&ArcBluetoothBridge::OnStopLEListenError,
                                        weak_factory_.GetWeakPtr(), callback));
 }
 
-// Example of identifier: /org/bluez/hci0/dev_E0_CF_65_8C_86_1A/service001a
-// We want to convert last digit of the identifier to int in base 16
-int ArcBluetoothBridge::ConvertGattIdentifierToId(
-    const std::string identifier) const {
-  return std::stoi(identifier.substr(identifier.size() - 4), nullptr, 16);
-}
-
-// Create GattDBElement and fill in common data for
-// Gatt Service/Characteristic/Descriptor.
-template <class T>
-mojom::BluetoothGattDBElementPtr ArcBluetoothBridge::CreateGattDBElement(
-    const mojom::BluetoothGattDBAttributeType type,
-    const T* gattObject) const {
-  mojom::BluetoothGattDBElementPtr element =
-      mojom::BluetoothGattDBElement::New();
-  element->type = type;
-  element->uuid = mojom::BluetoothUUID::From(gattObject->GetUUID());
-  element->id = element->attribute_handle = element->start_handle =
-      element->end_handle =
-          ConvertGattIdentifierToId(gattObject->GetIdentifier());
-  element->properties = 0;
-  return element;
-}
-
 void ArcBluetoothBridge::GetGattDB(mojom::BluetoothAddressPtr remote_addr) {
   if (!HasBluetoothInstance())
     return;
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   mojo::Array<mojom::BluetoothGattDBElementPtr> db;
   for (auto* service : device->GetGattServices()) {
-    mojom::BluetoothGattDBElementPtr service_element = CreateGattDBElement<
-        device::BluetoothRemoteGattService>(
+    mojom::BluetoothGattDBElementPtr service_element = CreateGattDBElement(
         service->IsPrimary()
             ? mojom::BluetoothGattDBAttributeType::BTGATT_DB_PRIMARY_SERVICE
             : mojom::BluetoothGattDBAttributeType::BTGATT_DB_SECONDARY_SERVICE,
         service);
 
     const auto& characteristics = service->GetCharacteristics();
     if (characteristics.size() > 0) {
       const auto& descriptors = characteristics.back()->GetDescriptors();
       service_element->start_handle =
           ConvertGattIdentifierToId(characteristics.front()->GetIdentifier());
       service_element->end_handle = ConvertGattIdentifierToId(
           descriptors.size() > 0 ? descriptors.back()->GetIdentifier()
                                  : characteristics.back()->GetIdentifier());
     }
     db.push_back(std::move(service_element));
 
     for (auto* characteristic : characteristics) {
       mojom::BluetoothGattDBElementPtr characteristic_element =
-          CreateGattDBElement<device::BluetoothRemoteGattCharacteristic>(
+          CreateGattDBElement(
               mojom::BluetoothGattDBAttributeType::BTGATT_DB_CHARACTERISTIC,
               characteristic);
       characteristic_element->properties = characteristic->GetProperties();
       db.push_back(std::move(characteristic_element));
 
       for (auto* descriptor : characteristic->GetDescriptors()) {
-        db.push_back(CreateGattDBElement<device::BluetoothRemoteGattDescriptor>(
+        db.push_back(CreateGattDBElement(
             mojom::BluetoothGattDBAttributeType::BTGATT_DB_DESCRIPTOR,
             descriptor));
       }
     }
   }
 
   arc_bridge_service()->bluetooth()->instance()->OnGetGattDB(
       std::move(remote_addr), std::move(db));
 }
 
-// Find Gatt Service/Characteristic/Descriptor from std::vector from UUID.
-template <class T>
-T* ArcBluetoothBridge::FindGattObjectFromUuid(
-    const std::vector<T*> gatt_objs,
-    const device::BluetoothUUID uuid) const {
-  auto it = std::find_if(gatt_objs.begin(), gatt_objs.end(),
-                         [&](T* obj) { return obj->GetUUID() == uuid; });
-  if (it == gatt_objs.end())
-    return nullptr;
-  return *it;
-}
-
 BluetoothRemoteGattCharacteristic* ArcBluetoothBridge::FindGattCharacteristic(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id) const {
   DCHECK(remote_addr);
   DCHECK(service_id);
   DCHECK(char_id);
 
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   if (!device)
     return nullptr;
 
-  BluetoothRemoteGattService* service =
-      FindGattObjectFromUuid<BluetoothRemoteGattService>(
-          device->GetGattServices(), service_id->id->uuid.To<BluetoothUUID>());
+  BluetoothRemoteGattService* service = FindGattAttributeFromUuid(
+      device->GetGattServices(), service_id->id->uuid.To<BluetoothUUID>());
   if (!service)
     return nullptr;
 
-  return FindGattObjectFromUuid<BluetoothRemoteGattCharacteristic>(
-      service->GetCharacteristics(), char_id->uuid.To<BluetoothUUID>());
+  return FindGattAttributeFromUuid(service->GetCharacteristics(),
+                                   char_id->uuid.To<BluetoothUUID>());
 }
 
 BluetoothRemoteGattDescriptor* ArcBluetoothBridge::FindGattDescriptor(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattIDPtr desc_id) const {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
   if (!characteristic)
     return nullptr;
 
-  return FindGattObjectFromUuid<BluetoothRemoteGattDescriptor>(
-      characteristic->GetDescriptors(), desc_id->uuid.To<BluetoothUUID>());
-}
-
-// Same callback for both ReadGattCharacteristic and ReadGattDescriptor
-void ArcBluetoothBridge::OnGattReadDone(
-    const GattReadCallback& callback,
-    const std::vector<uint8_t>& result) const {
-  mojom::BluetoothGattValuePtr gattValue = mojom::BluetoothGattValue::New();
-  gattValue->status = mojom::BluetoothGattStatus::GATT_SUCCESS;
-  gattValue->value = mojo::Array<uint8_t>::From(result);
-  callback.Run(std::move(gattValue));
-}
-
-void ArcBluetoothBridge::OnGattReadError(
-    const GattReadCallback& callback,
-    BluetoothGattService::GattErrorCode error_code) const {
-  mojom::BluetoothGattValuePtr gattValue = mojom::BluetoothGattValue::New();
-  gattValue->status = mojo::ConvertTo<mojom::BluetoothGattStatus>(error_code);
-  gattValue->value = nullptr;
-
-  callback.Run(std::move(gattValue));
-}
-
-// Same callback for both WriteGattCharacteristic and WriteGattDescriptor
-void ArcBluetoothBridge::OnGattWriteDone(
-    const GattWriteCallback& callback) const {
-  callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
-}
-
-void ArcBluetoothBridge::OnGattWriteError(
-    const GattWriteCallback& callback,
-    BluetoothGattService::GattErrorCode error_code) const {
-  callback.Run(mojo::ConvertTo<mojom::BluetoothGattStatus>(error_code));
+  return FindGattAttributeFromUuid(characteristic->GetDescriptors(),
+                                   desc_id->uuid.To<BluetoothUUID>());
 }
 
 void ArcBluetoothBridge::ReadGattCharacteristic(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     const ReadGattCharacteristicCallback& callback) {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
   DCHECK(characteristic);
   DCHECK(characteristic->GetPermissions() & kGattReadPermission);
 
   characteristic->ReadRemoteCharacteristic(
-      base::Bind(&ArcBluetoothBridge::OnGattReadDone,
-                 weak_factory_.GetWeakPtr(), callback),
-      base::Bind(&ArcBluetoothBridge::OnGattReadError,
-                 weak_factory_.GetWeakPtr(), callback));
+      base::Bind(&OnGattReadDone, callback),
+      base::Bind(&OnGattReadError, callback));
 }
 
 void ArcBluetoothBridge::WriteGattCharacteristic(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattValuePtr value,
     const WriteGattCharacteristicCallback& callback) {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
   DCHECK(characteristic);
   DCHECK(characteristic->GetPermissions() & kGattWritePermission);
 
   characteristic->WriteRemoteCharacteristic(
       value->value.To<std::vector<uint8_t>>(),
-      base::Bind(&ArcBluetoothBridge::OnGattWriteDone,
-                 weak_factory_.GetWeakPtr(), callback),
-      base::Bind(&ArcBluetoothBridge::OnGattWriteError,
-                 weak_factory_.GetWeakPtr(), callback));
+      base::Bind(&OnGattOperationDone, callback),
+      base::Bind(&OnGattOperationError, callback));
 }
 
 void ArcBluetoothBridge::ReadGattDescriptor(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattIDPtr desc_id,
     const ReadGattDescriptorCallback& callback) {
   BluetoothRemoteGattDescriptor* descriptor =
       FindGattDescriptor(std::move(remote_addr), std::move(service_id),
                          std::move(char_id), std::move(desc_id));
   DCHECK(descriptor);
   DCHECK(descriptor->GetPermissions() & kGattReadPermission);
 
-  descriptor->ReadRemoteDescriptor(
-      base::Bind(&ArcBluetoothBridge::OnGattReadDone,
-                 weak_factory_.GetWeakPtr(), callback),
-      base::Bind(&ArcBluetoothBridge::OnGattReadError,
-                 weak_factory_.GetWeakPtr(), callback));
+  descriptor->ReadRemoteDescriptor(base::Bind(&OnGattReadDone, callback),
+                                   base::Bind(&OnGattReadError, callback));
 }
 
 void ArcBluetoothBridge::WriteGattDescriptor(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattIDPtr desc_id,
     mojom::BluetoothGattValuePtr value,
     const WriteGattDescriptorCallback& callback) {
   BluetoothRemoteGattDescriptor* descriptor =
       FindGattDescriptor(std::move(remote_addr), std::move(service_id),
                          std::move(char_id), std::move(desc_id));
   DCHECK(descriptor);
   DCHECK(descriptor->GetPermissions() & kGattWritePermission);
 
   // To register / deregister GATT notification, we need to
   // 1) Write to CCC Descriptor to enable/disable the notification
   // 2) Ask BT hw to register / deregister the notification
   // The Chrome API groups both steps into one API, and does not support writing
   // directly to the CCC Descriptor. Therefore, until we fix
   // https://crbug.com/622832, we return successfully when we encounter this.
   // TODO(http://crbug.com/622832)
   if (descriptor->GetUUID() ==
       BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid()) {
-    OnGattWriteDone(callback);
+    OnGattOperationDone(callback);
     return;
   }
 
   descriptor->WriteRemoteDescriptor(
       value->value.To<std::vector<uint8_t>>(),
-      base::Bind(&ArcBluetoothBridge::OnGattWriteDone,
-                 weak_factory_.GetWeakPtr(), callback),
-      base::Bind(&ArcBluetoothBridge::OnGattWriteError,
-                 weak_factory_.GetWeakPtr(), callback));
+      base::Bind(&OnGattOperationDone, callback),
+      base::Bind(&OnGattOperationError, callback));
 }
 
 void ArcBluetoothBridge::OnGattNotifyStartDone(
     const RegisterForGattNotificationCallback& callback,
     const std::string char_string_id,
     std::unique_ptr<BluetoothGattNotifySession> notify_session) {
+  DCHECK(CalledOnValidThread());
   notification_session_[char_string_id] = std::move(notify_session);
   callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
-void ArcBluetoothBridge::OnGattNotifyStartError(
-    const RegisterForGattNotificationCallback& callback,
-    BluetoothGattService::GattErrorCode error_code) const {
-  callback.Run(mojo::ConvertTo<mojom::BluetoothGattStatus>(error_code));
-}
-
-void ArcBluetoothBridge::OnGattNotifyStopDone(
-    const DeregisterForGattNotificationCallback& callback) const {
-  callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
-}
-
 void ArcBluetoothBridge::RegisterForGattNotification(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     const RegisterForGattNotificationCallback& callback) {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
 
   if (!characteristic) {
     LOG(WARNING) << __func__ << " Characteristic is not existed.";
     return;
   }
 
   if (characteristic->IsNotifying()) {
     callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
     return;
   }
 
   characteristic->StartNotifySession(
       base::Bind(&ArcBluetoothBridge::OnGattNotifyStartDone,
                  weak_factory_.GetWeakPtr(), callback,
                  characteristic->GetIdentifier()),
-      base::Bind(&ArcBluetoothBridge::OnGattNotifyStartError,
-                 weak_factory_.GetWeakPtr(), callback));
+      base::Bind(&OnGattOperationError, callback));
 }
 
 void ArcBluetoothBridge::DeregisterForGattNotification(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     const DeregisterForGattNotificationCallback& callback) {
+  DCHECK(CalledOnValidThread());
+
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
 
   if (!characteristic) {
     LOG(WARNING) << __func__ << " Characteristic is not existed.";
     return;
   }
 
   if (!characteristic->IsNotifying()) {
     callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
     return;
   }
 
   std::string char_id_str = characteristic->GetIdentifier();
   std::unique_ptr<BluetoothGattNotifySession> notify =
       std::move(notification_session_[char_id_str]);
   notification_session_.erase(char_id_str);
-  notify->Stop(base::Bind(&ArcBluetoothBridge::OnGattNotifyStopDone,
-                          weak_factory_.GetWeakPtr(), callback));
+  notify->Stop(base::Bind(&OnGattOperationDone, callback));
 }
 
 void ArcBluetoothBridge::ReadRemoteRssi(
     mojom::BluetoothAddressPtr remote_addr,
     const ReadRemoteRssiCallback& callback) {
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   int rssi = device->GetInquiryRSSI();
   callback.Run(rssi);
 }
 
+template <class LocalGattAttribute>
+int32_t ArcBluetoothBridge::CreateGattAttributeHandle(
+    LocalGattAttribute* gatt_attr) {
+  DCHECK(CalledOnValidThread());
+  if (!gatt_attr)
+    return kInvalidGattAttributeHandle;
+  int32_t handle = next_gatt_server_attribute_handle();
+  const std::string& identifier = gatt_attr->GetIdentifier();
+  gatt_identifier_[handle] = identifier;

[palmer, 2016/07/22 02:56:10]

Style nit: You could just do

  gatt_identifier_[handle] = attribute->GetIdentifier();

[puthik_chromium, 2016/07/22 21:48:16]

Won't fix.
identifier will be used in next CL.

+  return handle;
+}
+
 void ArcBluetoothBridge::AddService(mojom::BluetoothGattServiceIDPtr service_id,
                                     int32_t num_handles,
-                                    const AddServiceCallback& callback) {}
+                                    const AddServiceCallback& callback) {
+  base::WeakPtr<BluetoothLocalGattService> service =
+      BluetoothLocalGattService::Create(
+          bluetooth_adapter_.get(), service_id->id->uuid.To<BluetoothUUID>(),
+          service_id->is_primary, nullptr /* included_service */,
+          this /* delegate */);
+  callback.Run(CreateGattAttributeHandle(service.get()));
+}
 
 void ArcBluetoothBridge::AddCharacteristic(
     int32_t service_handle,
     mojom::BluetoothUUIDPtr uuid,
     int32_t properties,
     int32_t permissions,
-    const AddCharacteristicCallback& callback) {}
+    const AddCharacteristicCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(gatt_identifier_.find(service_handle) != gatt_identifier_.end());
+  base::WeakPtr<BluetoothLocalGattCharacteristic> characteristic =
+      BluetoothLocalGattCharacteristic::Create(
+          uuid.To<BluetoothUUID>(), properties, permissions,
+          bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]));
+  int32_t characteristic_handle =
+      CreateGattAttributeHandle(characteristic.get());
+  last_characteristic_[service_handle] = characteristic_handle;
+  callback.Run(characteristic_handle);
+}
 
 void ArcBluetoothBridge::AddDescriptor(int32_t service_handle,
                                        mojom::BluetoothUUIDPtr uuid,
                                        int32_t permissions,
-                                       const AddDescriptorCallback& callback) {}
+                                       const AddDescriptorCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  // Chrome automatically adds a CCC Descriptor to a characteristic when needed.
+  // We will generate a bogus handle for Android.
+  if (uuid.To<BluetoothUUID>() ==
+      BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid()) {
+    int32_t handle = next_gatt_server_attribute_handle();
+    callback.Run(handle);
+    return;
+  }
+
+  DCHECK(gatt_identifier_.find(service_handle) != gatt_identifier_.end());
+  BluetoothLocalGattService* service =
+      bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  DCHECK(service);
+  // Since the Android API does not give information about which characteristic
+  // is the parent of the new descriptor, we assume that it would be the last
+  // characteristic that was added to the given service. This matches the
+  // Android framework code at android/bluetooth/BluetoothGattServer.java#594.
+  // Link: https://goo.gl/cJZl1u
+  DCHECK(last_characteristic_.find(service_handle) !=
+         last_characteristic_.end());
+  int32_t last_characteristic_handle = last_characteristic_[service_handle];
+
+  DCHECK(gatt_identifier_.find(last_characteristic_handle) !=
+         gatt_identifier_.end());
+  BluetoothLocalGattCharacteristic* characteristic =
+      service->GetCharacteristic(gatt_identifier_[last_characteristic_handle]);
+  DCHECK(characteristic);
+
+  base::WeakPtr<BluetoothLocalGattDescriptor> descriptor =
+      BluetoothLocalGattDescriptor::Create(uuid.To<BluetoothUUID>(),
+                                           permissions, characteristic);
+  callback.Run(CreateGattAttributeHandle(descriptor.get()));
+}
 
 void ArcBluetoothBridge::StartService(int32_t service_handle,
-                                      const StartServiceCallback& callback) {}
+                                      const StartServiceCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(gatt_identifier_.find(service_handle) != gatt_identifier_.end());
+  BluetoothLocalGattService* service =
+      bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  DCHECK(service);
+  service->Register(base::Bind(&OnGattOperationDone, callback),
+                    base::Bind(&OnGattOperationError, callback));
+}
 
 void ArcBluetoothBridge::StopService(int32_t service_handle,
-                                     const StopServiceCallback& callback) {}
+                                     const StopServiceCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(gatt_identifier_.find(service_handle) != gatt_identifier_.end());
+  BluetoothLocalGattService* service =
+      bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  DCHECK(service);
+  service->Unregister(base::Bind(&OnGattOperationDone, callback),
+                      base::Bind(&OnGattOperationError, callback));
+}
 
 void ArcBluetoothBridge::DeleteService(int32_t service_handle,
-                                       const DeleteServiceCallback& callback) {}
+                                       const DeleteServiceCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(gatt_identifier_.find(service_handle) != gatt_identifier_.end());
+  BluetoothLocalGattService* service =
+      bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  DCHECK(service);
+
+  service->Delete();
+  gatt_identifier_.erase(service_handle);
+  OnGattOperationDone(callback);
+}
 
 void ArcBluetoothBridge::SendIndication(
     int32_t attribute_handle,
     mojom::BluetoothAddressPtr address,
     bool confirm,
     mojo::Array<uint8_t> value,
     const SendIndicationCallback& callback) {}
 
 void ArcBluetoothBridge::OnDiscoveryError() {
   LOG(WARNING) << "failed to change discovery state";
@@ skipping 325 matching lines @@
 bool ArcBluetoothBridge::CheckBluetoothInstanceVersion(
     uint32_t version_need) const {
   uint32_t version = arc_bridge_service()->bluetooth()->version();
   if (version >= version_need)
     return true;
   LOG(WARNING) << "Bluetooth instance is too old (version " << version
                << ") need version " << version_need;
   return false;
 }
 
+bool ArcBluetoothBridge::CalledOnValidThread() {
+  return thread_checker_.CalledOnValidThread();
+}
+
 }  // namespace arc