Adapter changes for implementing local GATT attributes and tests.

device/bluetooth/bluez/bluetooth_adapter_bluez.h

 // Copyright 2013 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.
 
 #ifndef DEVICE_BLUETOOTH_BLUEZ_BLUETOOTH_ADAPTER_BLUEZ_H_
 #define DEVICE_BLUETOOTH_BLUEZ_BLUETOOTH_ADAPTER_BLUEZ_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_audio_sink.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_export.h"
+#include "device/bluetooth/bluetooth_gatt_service.h"
 #include "device/bluetooth/dbus/bluetooth_adapter_client.h"
 #include "device/bluetooth/dbus/bluetooth_agent_service_provider.h"
 #include "device/bluetooth/dbus/bluetooth_device_client.h"
 #include "device/bluetooth/dbus/bluetooth_input_client.h"
 #include "device/bluetooth/dbus/bluetooth_profile_manager_client.h"
 #include "device/bluetooth/dbus/bluetooth_profile_service_provider.h"
 
 namespace base {
 class SequencedTaskRunner;
 }  // namespace base
 
 namespace device {
 class BluetoothSocketThread;
 class BluetoothTestBlueZ;
 }  // namespace device
 
 namespace bluez {
 
 class BluetoothBlueZTest;
 class BluetoothAdapterProfileBlueZ;
 class BluetoothDeviceBlueZ;
 class BluetoothLocalGattServiceBlueZ;
+class BluetoothGattApplicationServiceProvider;
 class BluetoothPairingBlueZ;
 
 // The BluetoothAdapterBlueZ class implements BluetoothAdapter for platforms
 // that use BlueZ.
 //
 // All methods are called from the dbus origin / UI thread and are generally
 // not assumed to be thread-safe.
 //
 // This class interacts with sockets using the BluetoothSocketThread to ensure
 // single-threaded calls, and posts tasks to the UI thread.
@@ skipping 85 matching lines @@
                   const dbus::ObjectPath& device_path,
                   const bluez::BluetoothProfileManagerClient::Options& options,
                   bluez::BluetoothProfileServiceProvider::Delegate* delegate,
                   const ProfileRegisteredCallback& success_callback,
                   const ErrorCompletionCallback& error_callback);
 
   // Release use of a profile by a device.
   void ReleaseProfile(const dbus::ObjectPath& device_path,
                       BluetoothAdapterProfileBlueZ* profile);
 
+  // Add a local GATT service to the list of services owned by this adapter.
   void AddLocalGattService(
       std::unique_ptr<BluetoothLocalGattServiceBlueZ> service);
 
+  // Register a GATT service. The service must belong to this adapter.
+  void RegisterGattService(
+      BluetoothLocalGattServiceBlueZ* service,
+      const base::Closure& callback,
+      const device::BluetoothGattService::ErrorCallback& error_callback);
+
+  // Unregister a GATT service. The service must already be registered.
+  void UnregisterGattService(
+      BluetoothLocalGattServiceBlueZ* service,
+      const base::Closure& callback,
+      const device::BluetoothGattService::ErrorCallback& error_callback);
+
+  // Returns the object path of the adapter.
+  dbus::ObjectPath GetApplicationObjectPath() const;
+
  protected:
   // BluetoothAdapter:
   void RemovePairingDelegateInternal(
       device::BluetoothDevice::PairingDelegate* pairing_delegate) override;
 
  private:
   friend class BluetoothBlueZTest;
   friend class BluetoothBlueZTest_Shutdown_Test;
   friend class BluetoothBlueZTest_Shutdown_OnStartDiscovery_Test;
   friend class BluetoothBlueZTest_Shutdown_OnStartDiscoveryError_Test;
@@ skipping 175 matching lines @@
   // Called by BluetoothAdapterProfileBlueZ when no users of a profile
   // remain.
   void RemoveProfile(const device::BluetoothUUID& uuid);
 
   // Processes the queued discovery requests. For each DiscoveryParamTuple in
   // the queue, this method will try to add a new discovery session. This method
   // is called whenever a pending D-Bus call to start or stop discovery has
   // ended (with either success or failure).
   void ProcessQueuedDiscoveryRequests();
 
+  // Make the call to GattManager1 to register the services currently exported
+  // by the GATT Application service provider.
+  void RegisterApplication(
+      const base::Closure& callback,
+      const device::BluetoothGattService::ErrorCallback& error_callback);
+
   InitCallback init_callback_;
 
   bool initialized_;
 
   // Set in |Shutdown()|, makes IsPresent()| return false.
   bool dbus_is_shutdown_;
 
   // Number of discovery sessions that have been added.
   int num_discovery_sessions_;
 
@@ skipping 28 matching lines @@
   // Profiles that have been released and are pending removal.
   std::map<device::BluetoothUUID, BluetoothAdapterProfileBlueZ*>
       released_profiles_;
 
   // Queue of delegates waiting for a profile to register.
   std::map<device::BluetoothUUID, std::vector<RegisterProfileCompletionPair>*>
       profile_queues_;
 
   std::unique_ptr<device::BluetoothDiscoveryFilter> current_filter_;
 
+  // List of GATT services that are owned by this adapter.
   std::vector<std::unique_ptr<BluetoothLocalGattServiceBlueZ>>
       owned_gatt_services_;
 
+  // GATT services that are currently available on the GATT server.
+  std::map<dbus::ObjectPath, BluetoothLocalGattServiceBlueZ*>
+      registered_gatt_services_;
+
+  // DBus Object Manager that acts as a service provider for all the services
+  // that are registered with this adapter.
+  std::unique_ptr<BluetoothGattApplicationServiceProvider>
+      gatt_application_provider_;
+
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<BluetoothAdapterBlueZ> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothAdapterBlueZ);
 };
 
 }  // namespace bluez
 
 #endif  // DEVICE_BLUETOOTH_BLUEZ_BLUETOOTH_ADAPTER_BLUEZ_H_