bluetooth: Only add new devices, connected devices and devices that changed.

content/browser/bluetooth/bluetooth_device_chooser_controller.cc

 // Copyright 2016 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 "content/browser/bluetooth/bluetooth_device_chooser_controller.h"
 
 #include <set>
 #include <string>
 #include <unordered_set>
 
@@ skipping 303 matching lines @@
         blink::mojom::WebBluetoothError::WEB_BLUETOOTH_NOT_SUPPORTED);
   }
 
   if (!chooser_->CanAskForScanningPermission()) {
     VLOG(1) << "Closing immediately because Chooser cannot obtain permission.";
     OnBluetoothChooserEvent(BluetoothChooser::Event::DENIED_PERMISSION,
                             "" /* device_address */);
     return;
   }
 
-  PopulateFoundDevices();
+  PopulateConnectedDevices();
   if (!chooser_.get()) {
     // If the dialog's closing, no need to do any of the rest of this.
     return;
   }
 
   if (!adapter_->IsPowered()) {
     chooser_->SetAdapterPresence(
         BluetoothChooser::AdapterPresence::POWERED_OFF);
     return;
   }
 
   StartDeviceDiscovery();
 }
 
 void BluetoothDeviceChooserController::AddFilteredDevice(
     const device::BluetoothDevice& device) {
   if (chooser_.get() && MatchesFilters(device, options_->filters)) {
-    VLOG(1) << "Adding device to chooser: " << device.GetAddress();
     chooser_->AddOrUpdateDevice(device.GetAddress(),
                                 device.GetNameForDisplay());
   }
 }
 
 void BluetoothDeviceChooserController::AdapterPoweredChanged(bool powered) {
   if (!powered && discovery_session_.get()) {
     StopDiscoverySession(std::move(discovery_session_));
   }
 
   if (chooser_.get()) {
     chooser_->SetAdapterPresence(
         powered ? BluetoothChooser::AdapterPresence::POWERED_ON
                 : BluetoothChooser::AdapterPresence::POWERED_OFF);
     if (powered) {
       OnBluetoothChooserEvent(BluetoothChooser::Event::RESCAN,
                               "" /* device_address */);
     }
   }
 
   if (!powered) {
     discovery_session_timer_.Stop();
   }
 }
 
 void BluetoothDeviceChooserController::SetTestScanDurationForTesting() {
   BluetoothDeviceChooserController::use_test_scan_duration_ = true;
 }
 
-void BluetoothDeviceChooserController::PopulateFoundDevices() {
-  VLOG(1) << "Populating " << adapter_->GetDevices().size()
-          << " devices in chooser.";
+void BluetoothDeviceChooserController::PopulateConnectedDevices() {
   for (const device::BluetoothDevice* device : adapter_->GetDevices()) {
-    AddFilteredDevice(*device);
+    if (device->IsGattConnected()) {
+      AddFilteredDevice(*device);
+    }
   }
 }
 
 void BluetoothDeviceChooserController::StartDeviceDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (discovery_session_.get() && discovery_session_->IsActive()) {
     // Already running; just increase the timeout.
     discovery_session_timer_.Reset();
     return;
@@ skipping 39 matching lines @@
 
 void BluetoothDeviceChooserController::OnBluetoothChooserEvent(
     BluetoothChooser::Event event,
     const std::string& device_address) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Shouldn't recieve an event from a closed chooser.
   DCHECK(chooser_.get());
 
   switch (event) {
     case BluetoothChooser::Event::RESCAN:
-      PopulateFoundDevices();
+      PopulateConnectedDevices();
       DCHECK(chooser_);
       StartDeviceDiscovery();
       // No need to close the chooser so we return.
       return;
     case BluetoothChooser::Event::DENIED_PERMISSION:
       RecordRequestDeviceOutcome(OutcomeFromChooserEvent(event));
       PostErrorCallback(blink::mojom::WebBluetoothError::
                             CHOOSER_NOT_SHOWN_USER_DENIED_PERMISSION_TO_SCAN);
       break;
     case BluetoothChooser::Event::CANCELLED:
@@ skipping 35 matching lines @@
 
 void BluetoothDeviceChooserController::PostErrorCallback(
     blink::mojom::WebBluetoothError error) {
   if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(error_callback_, error))) {
     LOG(WARNING) << "No TaskRunner.";
   }
 }
 
 }  // namespace content