Add signal strength indicator icon to WebBluetooth chooser on non-Mac desktops

chrome/browser/ui/bluetooth/bluetooth_chooser_controller.cc

 // Copyright 2015 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 "chrome/browser/ui/bluetooth/bluetooth_chooser_controller.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 10 matching lines @@
 
 namespace {
 
 Browser* GetBrowser() {
   chrome::ScopedTabbedBrowserDisplayer browser_displayer(
       ProfileManager::GetActiveUserProfile());
   DCHECK(browser_displayer.browser());
   return browser_displayer.browser();
 }
 
+// Anything worse than or equal to this will show 0 bars.
+const int kMinRSSI = -100;
+// Anything better than or equal to this will show the maximum bars.
+const int kMaxRSSI = -55;
+// Number of RSSI levels used in the signal strength icon.
+const int kNumLevels = 5;
+
+// Received Signal Strength Indicator (RSSI) is a measurement of the power
+// present in a received radio signal.
+int CalculateSignalLevel(int8_t rssi) {

[Jeffrey Yasskin, 2016/08/19 17:46:54]

Write a test that this returns the right levels.

[ortuno, 2016/08/19 17:58:36]

Could you actually move this to BluetoothDeviceChooserController in this patch
and have AddOrUpdateDevice take the level directly? Otherwise we would have to
repeat the same algorithm in the android implementation.

[juncai, 2016/08/19 22:59:17]

Done.

[juncai, 2016/08/19 22:59:17]

Done.

+  if (rssi <= kMinRSSI)
+    return 0;
+
+  if (rssi >= kMaxRSSI)
+    return kNumLevels - 1;
+
+  double input_range = kMaxRSSI - kMinRSSI;
+  double output_range = kNumLevels - 1;
+  return static_cast<int>((rssi - kMinRSSI) * output_range / input_range);
+}
+
 }  // namespace
 
 BluetoothChooserController::BluetoothChooserController(
     content::RenderFrameHost* owner,
     const content::BluetoothChooser::EventHandler& event_handler)
     : ChooserController(owner,
                         IDS_BLUETOOTH_DEVICE_CHOOSER_PROMPT_ORIGIN,
                         IDS_BLUETOOTH_DEVICE_CHOOSER_PROMPT_EXTENSION_NAME),
       event_handler_(event_handler),
       no_devices_text_(l10n_util::GetStringUTF16(
           IDS_BLUETOOTH_DEVICE_CHOOSER_NO_DEVICES_FOUND_PROMPT)) {}
 
 BluetoothChooserController::~BluetoothChooserController() {}
 
+bool BluetoothChooserController::ShouldShowIconBeforeText() const {
+  return true;
+}
+
 base::string16 BluetoothChooserController::GetNoOptionsText() const {
   return no_devices_text_;
 }
 
 base::string16 BluetoothChooserController::GetOkButtonLabel() const {
   return l10n_util::GetStringUTF16(
       IDS_BLUETOOTH_DEVICE_CHOOSER_PAIR_BUTTON_TEXT);
 }
 
 size_t BluetoothChooserController::NumOptions() const {
-  return device_ids_.size();
+  return devices_.size();
+}
+
+int BluetoothChooserController::GetSignalStrengthLevel(size_t index) const {
+  return devices_[index].signal_strength_level;
 }
 
 base::string16 BluetoothChooserController::GetOption(size_t index) const {
-  DCHECK_LT(index, device_ids_.size());
-  const std::string& device_id = device_ids_[index];
+  DCHECK_LT(index, devices_.size());
+  const std::string& device_id = devices_[index].id;
   const auto& device_name_it = device_id_to_name_map_.find(device_id);
   DCHECK(device_name_it != device_id_to_name_map_.end());
   const auto& it = device_name_counts_.find(device_name_it->second);
   DCHECK(it != device_name_counts_.end());
   return it->second == 1
              ? device_name_it->second
              : l10n_util::GetStringFUTF16(
                    IDS_DEVICE_CHOOSER_DEVICE_NAME_WITH_ID,
                    device_name_it->second, base::UTF8ToUTF16(device_id));
 }
 
 void BluetoothChooserController::RefreshOptions() {
   if (event_handler_.is_null())
     return;
   ClearAllDevices();
   event_handler_.Run(content::BluetoothChooser::Event::RESCAN, std::string());
 }
 
 base::string16 BluetoothChooserController::GetStatus() const {
   return status_text_;
 }
 
 void BluetoothChooserController::Select(size_t index) {
   if (event_handler_.is_null()) {
     content::RecordRequestDeviceOutcome(
         content::UMARequestDeviceOutcome::
             BLUETOOTH_CHOOSER_EVENT_HANDLER_INVALID);
     return;
   }
-  DCHECK_LT(index, device_ids_.size());
+  DCHECK_LT(index, devices_.size());
   event_handler_.Run(content::BluetoothChooser::Event::SELECTED,
-                     device_ids_[index]);
+                     devices_[index].id);
 }
 
 void BluetoothChooserController::Cancel() {
   if (event_handler_.is_null())
     return;
   event_handler_.Run(content::BluetoothChooser::Event::CANCELLED,
                      std::string());
 }
 
 void BluetoothChooserController::Close() {
@@ skipping 62 matching lines @@
   }
 }
 
 void BluetoothChooserController::AddOrUpdateDevice(
     const std::string& device_id,
     bool should_update_name,
     const base::string16& device_name,
     bool is_gatt_connected,
     bool is_paired,
     const int8_t* rssi) {
+  int level = rssi ? CalculateSignalLevel(*rssi) : -1;

[Jeffrey Yasskin, 2016/08/19 17:46:54]

Name this either signal_level or signal_strength_level.

[juncai, 2016/08/19 22:59:17]

Done.

   auto name_it = device_id_to_name_map_.find(device_id);
   if (name_it != device_id_to_name_map_.end()) {
     if (should_update_name) {
       base::string16 previous_device_name = name_it->second;
       name_it->second = device_name;
 
       const auto& it = device_name_counts_.find(previous_device_name);
       DCHECK(it != device_name_counts_.end());
       DCHECK_GT(it->second, 0);
 
       if (--(it->second) == 0)
         device_name_counts_.erase(it);
 
       ++device_name_counts_[device_name];
     }
 
-    size_t index = std::distance(
-        device_ids_.begin(),
-        std::find(device_ids_.begin(), device_ids_.end(), device_id));
-    DCHECK_NE(device_ids_.size(), index);
+    size_t index;
+    for (index = 0; index < devices_.size(); ++index) {

[Jeffrey Yasskin, 2016/08/19 17:46:54]

You could use
auto device_it = std::find_if(devices_.begin(), devices_.end(),
[&device_id](const BluetoothDeviceInfo& device) {
    return device.id == device_id;
  });

DCHECK(device_it != devices_.end());
device_it->signal_strength_level = signal_strength_level;
view()->OnOptionUpdated(device_id - devices_.begin());

[juncai, 2016/08/19 22:59:17]

Done.

+      if (devices_[index].id == device_id)
+        break;
+    }
+
+    DCHECK_NE(devices_.size(), index);
     // http://crbug.com/543466 Update connection and paired status
-    // http://crbug.com/629689 Update RSSI.
+    devices_[index].signal_strength_level = level;
     if (view())
       view()->OnOptionUpdated(index);
     return;
   }
 
-  device_ids_.push_back(device_id);
+  devices_.push_back({device_id, level});
   device_id_to_name_map_.insert({device_id, device_name});
   ++device_name_counts_[device_name];
   if (view())
-    view()->OnOptionAdded(device_ids_.size() - 1);
+    view()->OnOptionAdded(devices_.size() - 1);
 }
 
 void BluetoothChooserController::RemoveDevice(const std::string& device_id) {
   const auto& name_it = device_id_to_name_map_.find(device_id);
   if (name_it == device_id_to_name_map_.end())
     return;
 
   size_t index = 0;
-  for (const auto& saved_device_id : device_ids_) {
-    if (saved_device_id != device_id) {
+  for (const auto& saved_device_info : devices_) {
+    if (saved_device_info.id != device_id) {
       ++index;
       continue;
     }
 
-    device_ids_.erase(device_ids_.begin() + index);
+    devices_.erase(devices_.begin() + index);
 
     const auto& it = device_name_counts_.find(name_it->second);
     DCHECK(it != device_name_counts_.end());
     DCHECK_GT(it->second, 0);
 
     if (--(it->second) == 0)
       device_name_counts_.erase(it);
 
     device_id_to_name_map_.erase(name_it);
 
     if (view())
       view()->OnOptionRemoved(index);
     return;
   }
 }
 
 void BluetoothChooserController::ResetEventHandler() {
   event_handler_.Reset();
 }
 
 void BluetoothChooserController::ClearAllDevices() {
-  device_ids_.clear();
+  devices_.clear();
   device_id_to_name_map_.clear();
   device_name_counts_.clear();
 }