bluetooth: Replace old advertised uuids

device/bluetooth/bluetooth_device.cc

 // Copyright (c) 2012 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/bluetooth_device.h"
 
 #include <memory>
 #include <string>
 
 #include "base/memory/ptr_util.h"
@@ skipping 225 matching lines @@
 
 bool BluetoothDevice::IsTrustable() const {
   // Sony PlayStation Dualshock3
   if ((GetVendorID() == 0x054c && GetProductID() == 0x0268 &&
        GetName() == std::string("PLAYSTATION(R)3 Controller")))
     return true;
 
   return false;
 }
 
+BluetoothDevice::UUIDList BluetoothDevice::GetUUIDs() const {
+  if (!IsGattConnected()) {
+    DCHECK(service_uuids_.empty());
+    return advertised_uuids_;
+  }
+
+  if (IsGattServicesDiscoveryComplete()) {
+    DCHECK(advertised_uuids_.empty());
+    return service_uuids_;
+  }
+
+  DCHECK(service_uuids_.empty());
+  DCHECK(advertised_uuids_.empty());
+  return BluetoothDevice::UUIDList();
+}
+
 void BluetoothDevice::CreateGattConnection(
     const GattConnectionCallback& callback,
     const ConnectErrorCallback& error_callback) {
   create_gatt_connection_success_callbacks_.push_back(callback);
   create_gatt_connection_error_callbacks_.push_back(error_callback);
 
   if (IsGattConnected())
     return DidConnectGatt();
 
   CreateGattConnectionImpl();
@@ skipping 70 matching lines @@
   base::DictionaryValue::Iterator iter(*services_data_);
   while (!iter.IsAtEnd()) {
     BluetoothUUID uuid(iter.key());
     uuids.push_back(uuid);
     iter.Advance();
   }
   return uuids;
 }
 
 void BluetoothDevice::DidConnectGatt() {
+  advertised_uuids_.clear();
   for (const auto& callback : create_gatt_connection_success_callbacks_) {
     callback.Run(
         base::WrapUnique(new BluetoothGattConnection(adapter_, GetAddress())));
   }
   create_gatt_connection_success_callbacks_.clear();
   create_gatt_connection_error_callbacks_.clear();
   GetAdapter()->NotifyDeviceChanged(this);
 }
 
 void BluetoothDevice::DidFailToConnectGatt(ConnectErrorCode error) {
@@ skipping 26 matching lines @@
 }
 
 void BluetoothDevice::RemoveGattConnection(
     BluetoothGattConnection* connection) {
   size_t erased_count = gatt_connections_.erase(connection);
   DCHECK(erased_count);
   if (gatt_connections_.size() == 0)
     DisconnectGatt();
 }
 
+void BluetoothDevice::UpdateServiceUUIDs() {
+  std::unordered_set<BluetoothUUID, BluetoothUUIDHash> uuid_set;
+  for (const auto& gatt_service_pair : gatt_services_) {
+    uuid_set.insert(gatt_service_pair.second->GetUUID());
+  }
+  service_uuids_ = UUIDList(uuid_set.begin(), uuid_set.end());
+}
+
 void BluetoothDevice::ClearServiceData() { services_data_->Clear(); }
 
 void BluetoothDevice::SetServiceData(BluetoothUUID serviceUUID,
                                      const char* buffer, size_t size) {
   services_data_->Set(serviceUUID.value(),
                       base::BinaryValue::CreateWithCopiedBuffer(buffer, size));
 }
 
 void BluetoothDevice::SetAsExpiredForTesting() {
   last_update_time_ =
       base::Time::NowFromSystemTime() -
       (BluetoothAdapter::timeoutSec + base::TimeDelta::FromSeconds(1));
 }
 
 void BluetoothDevice::Pair(PairingDelegate* pairing_delegate,
                            const base::Closure& callback,
                            const ConnectErrorCallback& error_callback) {
   NOTREACHED();
 }
 
 void BluetoothDevice::UpdateTimestamp() {
   last_update_time_ = base::Time::NowFromSystemTime();
 }
 
 }  // namespace device