bluetooth: Refactor how we update based on Advertising Data

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 <iterator>
 #include <memory>
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service.h"
 #include "grit/bluetooth_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace device {
 
+BluetoothDevice::DeviceUUIDs::DeviceUUIDs() {}
+
+BluetoothDevice::DeviceUUIDs::~DeviceUUIDs() {}
+
+void BluetoothDevice::DeviceUUIDs::ReplaceAdvertisedUUIDs(
+    UUIDList new_advertised_uuids) {
+  advertised_uuids_.clear();
+  for (auto& it : new_advertised_uuids) {
+    advertised_uuids_.insert(std::move(it));
+  }
+  UpdateDeviceUUIDs();
+}
+
+void BluetoothDevice::DeviceUUIDs::ClearAdvertisedUUIDs() {
+  advertised_uuids_.clear();
+  UpdateDeviceUUIDs();
+}
+
+void BluetoothDevice::DeviceUUIDs::ReplaceServiceUUIDs(
+    const GattServiceMap& gatt_services) {
+  service_uuids_.clear();
+  for (const auto& gatt_service_pair : gatt_services) {
+    service_uuids_.insert(gatt_service_pair.second->GetUUID());
+  }
+  UpdateDeviceUUIDs();
+}
+
+void BluetoothDevice::DeviceUUIDs::ClearServiceUUIDs() {
+  service_uuids_.clear();
+  UpdateDeviceUUIDs();
+}
+
+const BluetoothDevice::UUIDSet& BluetoothDevice::DeviceUUIDs::GetUUIDs() const {
+  return device_uuids_;
+}
+
+void BluetoothDevice::DeviceUUIDs::UpdateDeviceUUIDs() {
+  device_uuids_.clear();
+  std::set_union(advertised_uuids_.begin(), advertised_uuids_.end(),
+                 service_uuids_.begin(), service_uuids_.end(),
+                 std::inserter(device_uuids_, device_uuids_.begin()));
+}
+
 BluetoothDevice::BluetoothDevice(BluetoothAdapter* adapter)
     : adapter_(adapter),
       gatt_services_discovery_complete_(false),
-      services_data_(new base::DictionaryValue()),
       last_update_time_(base::Time()) {}
 
 BluetoothDevice::~BluetoothDevice() {
   for (BluetoothGattConnection* connection : gatt_connections_) {
     connection->InvalidateConnectionReference();
   }
 }
 
 BluetoothDevice::ConnectionInfo::ConnectionInfo()
     : rssi(kUnknownPower),
@@ skipping 198 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_;
+BluetoothDevice::UUIDSet BluetoothDevice::GetUUIDs() const {
+  return device_uuids_.GetUUIDs();
+}
+
+const BluetoothDevice::ServiceDataMap& BluetoothDevice::GetServiceData() const {
+  return service_data_;
+}
+
+BluetoothDevice::UUIDSet BluetoothDevice::GetServiceDataUUIDs() const {
+  UUIDSet service_data_uuids;
+  for (const auto& uuid_service_data_pair : service_data_) {
+    service_data_uuids.insert(uuid_service_data_pair.first);
   }
+  return service_data_uuids;
+}
 
-  if (IsGattServicesDiscoveryComplete()) {
-    DCHECK(advertised_uuids_.empty());
-    return service_uuids_;
+const std::vector<uint8_t>* BluetoothDevice::GetServiceDataForUUID(
+    const BluetoothUUID& uuid) const {
+  auto it = service_data_.find(uuid);
+  if (it != service_data_.end()) {
+    return &it->second;
   }
-
-  DCHECK(service_uuids_.empty());
-  DCHECK(advertised_uuids_.empty());
-  return BluetoothDevice::UUIDList();
+  return nullptr;
 }
 
 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();
@@ skipping 52 matching lines @@
 
       canonicalized[i] = base::ToUpperASCII(canonicalized[i]);
     }
   }
 
   return canonicalized;
 }
 
 std::string BluetoothDevice::GetIdentifier() const { return GetAddress(); }
 
-base::BinaryValue* BluetoothDevice::GetServiceData(
-    BluetoothUUID serviceUUID) const {
-  base::BinaryValue* value;
-  if (!services_data_->GetBinary(serviceUUID.value(), &value))
-    return NULL;
-  return value;
+void BluetoothDevice::UpdateAdvertisementData(UUIDList advertised_uuids,
+                                              ServiceDataMap service_data) {
+  UpdateTimestamp();
+  device_uuids_.ReplaceAdvertisedUUIDs(std::move(advertised_uuids));
+  service_data_ = std::move(service_data);
 }
 
-BluetoothDevice::UUIDList BluetoothDevice::GetServiceDataUUIDs() const {
-  std::vector<device::BluetoothUUID> uuids;
-  base::DictionaryValue::Iterator iter(*services_data_);
-  while (!iter.IsAtEnd()) {
-    BluetoothUUID uuid(iter.key());
-    uuids.push_back(uuid);
-    iter.Advance();
-  }
-  return uuids;
+void BluetoothDevice::ClearAdvertisementData() {
+  device_uuids_.ClearAdvertisedUUIDs();
+  service_data_.clear();
+  GetAdapter()->NotifyDeviceChanged(this);
 }
 
 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