bluetooth: Update the map of GATT services when services resolve

device/bluetooth/dbus/fake_bluetooth_device_client.cc

 // Copyright (c) 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.
 
 #include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ skipping 235 matching lines @@
 const char FakeBluetoothDeviceClient::kConnectedTrustedNotPairedDevicePath[] =
     "/fake/hci0/devE";
 const char
     FakeBluetoothDeviceClient::kConnectedTrustedNotPairedDeviceAddress[] =
         "11:22:33:44:55:66";
 const char FakeBluetoothDeviceClient::kConnectedTrustedNotPairedDeviceName[] =
     "Connected Pairable Device";
 const uint32_t
     FakeBluetoothDeviceClient::kConnectedTrustedNotPairedDeviceClass = 0x7a020c;
 
-const char FakeBluetoothDeviceClient::kCachedLowEnergyPath[] =
-    "/fake/hci0/devF";
-const char FakeBluetoothDeviceClient::kCachedLowEnergyAddress[] =
-    "02:A5:11:0D:15:40";
-const char FakeBluetoothDeviceClient::kCachedLowEnergyName[] =
-    "Bluetooth 4.0 Heart Rate Monitor";
-const uint32_t FakeBluetoothDeviceClient::kCachedLowEnergyClass =
-    0x000918;  // Major class "Health", Minor class "Heart/Pulse Rate Monitor."
-
 FakeBluetoothDeviceClient::Properties::Properties(
     const PropertyChangedCallback& callback)
     : BluetoothDeviceClient::Properties(
           NULL,
           bluetooth_device::kBluetoothDeviceInterface,
           callback) {}
 
 FakeBluetoothDeviceClient::Properties::~Properties() {}
 
 void FakeBluetoothDeviceClient::Properties::Get(
@@ skipping 153 matching lines @@
   // The device can be connected.
   properties->connected.ReplaceValue(true);
   callback.Run();
 
   // Expose GATT services if connected to LE device.
   if (object_path == dbus::ObjectPath(kLowEnergyPath)) {
     FakeBluetoothGattServiceClient* gatt_service_client =
         static_cast<FakeBluetoothGattServiceClient*>(
             bluez::BluezDBusManager::Get()->GetBluetoothGattServiceClient());
     gatt_service_client->ExposeHeartRateService(object_path);
+    properties->services_resolved.ReplaceValue(true);
   }
 
   AddInputDeviceIfNeeded(object_path, properties);
 }
 
 void FakeBluetoothDeviceClient::Disconnect(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "Disconnect: " << object_path.value();
@@ skipping 288 matching lines @@
     properties->address.ReplaceValue(kJustWorksAddress);
     properties->bluetooth_class.ReplaceValue(kJustWorksClass);
     properties->name.ReplaceValue("JustWorks");
     properties->alias.ReplaceValue(kJustWorksName);
 
   } else if (device_path == dbus::ObjectPath(kLowEnergyPath)) {
     properties->address.ReplaceValue(kLowEnergyAddress);
     properties->bluetooth_class.ReplaceValue(kLowEnergyClass);
     properties->name.ReplaceValue("Heart Rate Monitor");
     properties->alias.ReplaceValue(kLowEnergyName);
+    properties->services_resolved.ReplaceValue(false);
 
     std::vector<std::string> uuids;
     uuids.push_back(FakeBluetoothGattServiceClient::kHeartRateServiceUUID);
     properties->uuids.ReplaceValue(uuids);
   } else if (device_path ==
              dbus::ObjectPath(kConnectedTrustedNotPairedDevicePath)) {
     properties->address.ReplaceValue(kConnectedTrustedNotPairedDeviceAddress);
     properties->bluetooth_class.ReplaceValue(
         kConnectedTrustedNotPairedDeviceClass);
     properties->trusted.ReplaceValue(true);
     properties->connected.ReplaceValue(true);
     properties->paired.ReplaceValue(false);
     properties->name.ReplaceValue("Connected Pairable Device");
     properties->alias.ReplaceValue(kConnectedTrustedNotPairedDeviceName);
-  } else if (device_path == dbus::ObjectPath(kCachedLowEnergyPath)) {
-    properties->address.ReplaceValue(kLowEnergyAddress);
-    properties->bluetooth_class.ReplaceValue(kLowEnergyClass);
-    properties->name.ReplaceValue("Heart Rate Monitor");
-    properties->alias.ReplaceValue(kLowEnergyName);
-    properties->alias.ReplaceValue(kLowEnergyName);
-    properties->services_resolved.ReplaceValue(false);
-
-    std::vector<std::string> uuids;
-    uuids.push_back(FakeBluetoothGattServiceClient::kHeartRateServiceUUID);
-    properties->uuids.ReplaceValue(uuids);
   } else {
     NOTREACHED();
   }
 
   properties_map_.insert(std::make_pair(device_path, std::move(properties)));
   device_list_.push_back(device_path);
 
-  // After the new properties| is added to the map, expose the heart rate
-  // service to emulate the device with cached GATT services.
-  if (device_path == dbus::ObjectPath(kCachedLowEnergyPath)) {
-    static_cast<FakeBluetoothGattServiceClient*>(
-        bluez::BluezDBusManager::Get()->GetBluetoothGattServiceClient())
-        ->ExposeHeartRateServiceWithoutDelay(device_path);
-  }
-
   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
                     DeviceAdded(device_path));
 }
 
 void FakeBluetoothDeviceClient::CreateDeviceWithProperties(
     const dbus::ObjectPath& adapter_path,
     const IncomingDeviceProperties& props) {
   dbus::ObjectPath device_path(props.device_path);
   if (std::find(device_list_.begin(), device_list_.end(), device_path) !=
       device_list_.end())
@@ skipping 995 matching lines @@
   }
   properties->type.set_valid(true);
 
   properties_map_.insert(std::make_pair(device_path, std::move(properties)));
   device_list_.push_back(device_path);
   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
                     DeviceAdded(device_path));
 }
 
 }  // namespace bluez