Use signal strength of detected networks when displaying remembered networks.

chrome/browser/chromeos/dom_ui/internet_options_handler.cc

 // Copyright (c) 2010 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/chromeos/dom_ui/internet_options_handler.h"
 
 #include <ctype.h>
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/i18n/time_formatting.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
@@ skipping 973 matching lines @@
         true,
         chromeos::TYPE_WIFI,
         false,
         chromeos::ACTIVATION_STATE_UNKNOWN,
         false));
   }
 
   return list;
 }
 
+std::string GetWifiUniqueIdentifier(const chromeos::WifiNetwork* wifi) {
+  return wifi->encryption() + "|" + wifi->name();
+}
+
 ListValue* InternetOptionsHandler::GetRememberedList() {
   chromeos::NetworkLibrary* cros =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   ListValue* list = new ListValue();
 
+  const chromeos::WifiNetworkVector& remembered_wifi_networks =
+      cros->remembered_wifi_networks();
   const chromeos::WifiNetworkVector& wifi_networks =
-      cros->remembered_wifi_networks();
-  for (chromeos::WifiNetworkVector::const_iterator it =
-      wifi_networks.begin(); it != wifi_networks.end(); ++it) {
-    SkBitmap icon = *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_BARS0_BLACK);
-    if ((*it)->encrypted()) {
+      cros->wifi_networks();
+
+  // The remembered networks from libcros/flimflam don't include the signal
+  // strength, so fall back to the detected networks for this data.  We
+  // consider networks to be the same if they have the same name and encryption
+  // type, so create a map of detected networks indexed by name + encryption.
+  std::map<std::string, chromeos::WifiNetwork*> wifi_map;
+  for (chromeos::WifiNetworkVector::const_iterator it = wifi_networks.begin();
+       it != wifi_networks.end(); ++it) {
+    wifi_map[GetWifiUniqueIdentifier(*it)] = *it;
+  }
+
+  for (chromeos::WifiNetworkVector::const_iterator rit =
+           remembered_wifi_networks.begin();
+       rit != remembered_wifi_networks.end(); ++rit) {
+    chromeos::WifiNetwork* wifi = *rit;
+    // Check if this remembered network has a matching detected network.
+    std::map<std::string, chromeos::WifiNetwork*>::const_iterator it =
+        wifi_map.find(GetWifiUniqueIdentifier(wifi));
+    bool found = it != wifi_map.end();
+
+    // Don't show the active network in the remembered list.
+    if (found && (it->second)->connected())
+      continue;
+    SkBitmap icon;
+    if (found)
+      icon = chromeos::NetworkMenu::IconForNetworkStrength(it->second, true);
+    else
+      icon = *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_BARS0_BLACK);
+    // Place the secure badge on the icon if the remembered network is
+    // encrypted (the matching detected network, if any, will have the same
+    // encrypted property by definition).
+    if (wifi->encrypted()) {
       icon = chromeos::NetworkMenu::IconForDisplay(icon,
           *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_SECURE));
     }
     list->Append(GetNetwork(
-        (*it)->service_path(),
+        wifi->service_path(),
         icon,
-        (*it)->name(),
-        (*it)->connecting(),
-        (*it)->connected(),
+        wifi->name(),
+        wifi->connecting(),
+        wifi->connected(),
         true,
         chromeos::TYPE_WIFI,
         true,
         chromeos::ACTIVATION_STATE_UNKNOWN,
         false));
   }
   return list;
 }
 
 void InternetOptionsHandler::FillNetworkInfo(
     DictionaryValue* dictionary, chromeos::NetworkLibrary* cros) {
   dictionary->SetBoolean("accessLocked", cros->IsLocked());
   dictionary->Set("wiredList", GetWiredList());
   dictionary->Set("wirelessList", GetWirelessList());
   dictionary->Set("rememberedList", GetRememberedList());
   dictionary->SetBoolean("wifiAvailable", cros->wifi_available());
   dictionary->SetBoolean("wifiEnabled", cros->wifi_enabled());
   dictionary->SetBoolean("cellularAvailable", cros->cellular_available());
   dictionary->SetBoolean("cellularEnabled", cros->cellular_enabled());
 }