Revert of Clear the BLE services list on disconnect.

content/browser/bluetooth/bluetooth_dispatcher_host.cc

 // Copyright 2014 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.
 
 // ID Not In Map Note:
 // A service, characteristic, or descriptor ID not in the corresponding
 // BluetoothDispatcherHost map [service_to_device_, characteristic_to_service_,
 // descriptor_to_characteristic_] implies a hostile renderer because a renderer
 // obtains the corresponding ID from this class and it will be added to the map
 // at that time.
@@ skipping 304 matching lines @@
 
     // The following data structures are cleaned up when a
     // device/service/characteristic is removed.
     // Since this can happen after the test is done and the cleanup function is
     // called, we clean them here.
     service_to_device_.clear();
     characteristic_to_service_.clear();
     characteristic_id_to_notify_session_.clear();
     active_characteristic_threads_.clear();
     connections_.clear();
+    devices_with_discovered_services_.clear();
   }
 
   set_adapter(std::move(mock_adapter));
 }
 
 BluetoothDispatcherHost::~BluetoothDispatcherHost() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Clear adapter, releasing observer references.
   set_adapter(scoped_refptr<device::BluetoothAdapter>());
 }
@@ skipping 181 matching lines @@
   }
 }
 
 void BluetoothDispatcherHost::GattServicesDiscovered(
     device::BluetoothAdapter* adapter,
     device::BluetoothDevice* device) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const std::string& device_id = device->GetAddress();
   VLOG(1) << "Services discovered for device: " << device_id;
 
+  devices_with_discovered_services_.insert(device_id);
+
   auto iter = pending_primary_services_requests_.find(device_id);
   if (iter == pending_primary_services_requests_.end()) {
     return;
   }
   std::vector<PrimaryServicesRequest> requests;
   requests.swap(iter->second);
   pending_primary_services_requests_.erase(iter);
 
   for (const PrimaryServicesRequest& request : requests) {
     std::vector<BluetoothGattService*> services =
@@ skipping 242 matching lines @@
   if (!services.empty()) {
     VLOG(1) << "Service found in device.";
     const BluetoothGattService& service = *services[0];
     DCHECK(service.IsPrimary());
     AddToServicesMapAndSendGetPrimaryServiceSuccess(service, thread_id,
                                                     request_id);
     return;
   }
 
   // 3.
-  if (query_result.device->IsGattServicesDiscoveryComplete()) {
+  if (IsServicesDiscoveryCompleteForDevice(device_id)) {
     VLOG(1) << "Service not found in device.";
     RecordGetPrimaryServiceOutcome(UMAGetPrimaryServiceOutcome::NOT_FOUND);
     Send(new BluetoothMsg_GetPrimaryServiceError(
         thread_id, request_id, WebBluetoothError::ServiceNotFound));
     return;
   }
 
   VLOG(1) << "Adding service request to pending requests.";
   // 4.
   AddToPendingPrimaryServicesRequest(
@@ skipping 535 matching lines @@
   result.characteristic =
       result.service->GetCharacteristic(characteristic_instance_id);
 
   if (result.characteristic == nullptr) {
     result.outcome = CacheQueryOutcome::NO_CHARACTERISTIC;
   }
 
   return result;
 }
 
+bool BluetoothDispatcherHost::IsServicesDiscoveryCompleteForDevice(
+    const std::string& device_id) {
+  return ContainsKey(devices_with_discovered_services_, device_id);
+}
+
 void BluetoothDispatcherHost::AddToPendingPrimaryServicesRequest(
     const std::string& device_id,
     const PrimaryServicesRequest& request) {
   pending_primary_services_requests_[device_id].push_back(request);
 }
 
 void BluetoothDispatcherHost::ShowBluetoothOverviewLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowBluetoothPairingLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowBluetoothAdapterOffLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowNeedLocationLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 }  // namespace content