bluetooth: Implement RSSI indicator on android

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 200 matching lines @@
           FROM_HERE,
           // TODO(jyasskin): Add a way for tests to control the dialog
           // directly, and change this to a reasonable discovery timeout.
           base::TimeDelta::FromSeconds(
               use_test_scan_duration_ ? kTestScanDuration : kScanDuration),
           base::Bind(&BluetoothDeviceChooserController::StopDeviceDiscovery,
                      // base::Timer guarantees it won't call back after its
                      // destructor starts.
                      base::Unretained(this)),
           /*is_repeating=*/false),
+      should_update_chooser_(false),
       weak_ptr_factory_(this) {
   CHECK(adapter_);
 }
 
 BluetoothDeviceChooserController::~BluetoothDeviceChooserController() {
   if (chooser_) {
     DCHECK(!error_callback_.is_null());
     error_callback_.Run(blink::mojom::WebBluetoothError::CHOOSER_CANCELLED);
   }
 }
@@ skipping 97 matching lines @@
     return;
   }
 
   if (!chooser_->CanAskForScanningPermission()) {
     VLOG(1) << "Closing immediately because Chooser cannot obtain permission.";
     OnBluetoothChooserEvent(BluetoothChooser::Event::DENIED_PERMISSION,
                             "" /* device_address */);
     return;
   }
 
+  should_update_chooser_ = true;
   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)) {
+  if (should_update_chooser_ && chooser_.get() &&
+      MatchesFilters(device, options_->filters)) {
     base::Optional<int8_t> rssi = device.GetInquiryRSSI();
     chooser_->AddOrUpdateDevice(
         device.GetAddress(), !!device.GetName() /* should_update_name */,
         device.GetNameForDisplay(), device.IsGattConnected(),
         web_bluetooth_service_->IsDevicePaired(device.GetAddress()),
         rssi ? CalculateSignalStrengthLevel(rssi.value()) : -1);
   }
 }
 
 void BluetoothDeviceChooserController::AdapterPoweredChanged(bool powered) {
@@ skipping 56 matching lines @@
       base::Bind(
           &BluetoothDeviceChooserController::OnStartDiscoverySessionSuccess,
           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(
           &BluetoothDeviceChooserController::OnStartDiscoverySessionFailed,
           weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothDeviceChooserController::StopDeviceDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  should_update_chooser_ = false;
   StopDiscoverySession(std::move(discovery_session_));
   if (chooser_) {
     chooser_->ShowDiscoveryState(BluetoothChooser::DiscoveryState::IDLE);
   }
 }
 
 void BluetoothDeviceChooserController::OnStartDiscoverySessionSuccess(
     std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   VLOG(1) << "Started discovery session.";
@@ skipping 14 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:
+      should_update_chooser_ = true;
       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;
@@ skipping 36 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