Landing change for ers@chromium.org: http://codereview.chromium.org/4134012/s...

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 <string>
 #include <vector>
@@ skipping 38 matching lines @@
       output.push_back(':');
     }
     output.push_back(toupper(address[i]));
   }
   return output;
 }
 
 }  // namespace
 
 InternetOptionsHandler::InternetOptionsHandler() {
-  chromeos::CrosLibrary::Get()->GetNetworkLibrary()->AddObserver(this);
+  chromeos::NetworkLibrary* netlib =
+      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
+  netlib->AddNetworkManagerObserver(this);
+  netlib->AddCellularDataPlanObserver(this);
+  MonitorActiveNetwork(netlib);
 }
 
 InternetOptionsHandler::~InternetOptionsHandler() {
-  chromeos::CrosLibrary::Get()->GetNetworkLibrary()->RemoveObserver(this);
+  chromeos::NetworkLibrary *netlib =
+      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
+  netlib->RemoveNetworkManagerObserver(this);
+  netlib->RemoveCellularDataPlanObserver(this);
+  netlib->RemoveObserverForAllNetworks(this);
 }
 
 void InternetOptionsHandler::GetLocalizedValues(
     DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
   // Internet page - ChromeOS
   localized_strings->SetString("internetPage",
       l10n_util::GetStringUTF16(IDS_OPTIONS_INTERNET_TAB_LABEL));
 
   localized_strings->SetString("wired_title",
@@ skipping 186 matching lines @@
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CUSTOMER_SUPPORT));
 
   localized_strings->SetString("enableWifi",
       l10n_util::GetStringFUTF16(
           IDS_STATUSBAR_NETWORK_DEVICE_ENABLE,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_WIFI)));
   localized_strings->SetString("disableWifi",
       l10n_util::GetStringFUTF16(
           IDS_STATUSBAR_NETWORK_DEVICE_DISABLE,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_WIFI)));
- localized_strings->SetString("enableCellular",
+  localized_strings->SetString("enableCellular",
       l10n_util::GetStringFUTF16(
           IDS_STATUSBAR_NETWORK_DEVICE_ENABLE,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CELLULAR)));
   localized_strings->SetString("disableCellular",
       l10n_util::GetStringFUTF16(
           IDS_STATUSBAR_NETWORK_DEVICE_DISABLE,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CELLULAR)));
   localized_strings->SetString("generalNetworkingTitle",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_CONTROL_TITLE));
@@ skipping 69 matching lines @@
 
 void InternetOptionsHandler::BuyDataPlanCallback(const ListValue* args) {
   if (!dom_ui_)
     return;
   Browser* browser = BrowserList::FindBrowserWithFeature(
       dom_ui_->GetProfile(), Browser::FEATURE_TABSTRIP);
   if (browser)
     browser->OpenMobilePlanTabAndActivate();
 }
 
-void InternetOptionsHandler::NetworkChanged(chromeos::NetworkLibrary* cros) {
-  if (!dom_ui_)
-    return;
-
+void InternetOptionsHandler::RefreshNetworkData(
+    chromeos::NetworkLibrary* cros) {
   DictionaryValue dictionary;
   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());
   dom_ui_->CallJavascriptFunction(
       L"options.InternetOptions.refreshNetworkData", dictionary);
 }
 
-void InternetOptionsHandler::CellularDataPlanChanged(
+void InternetOptionsHandler::OnNetworkManagerChanged(
+    chromeos::NetworkLibrary* cros) {
+  if (!dom_ui_)
+    return;
+  MonitorActiveNetwork(cros);
+  RefreshNetworkData(cros);
+}
+
+void InternetOptionsHandler::OnNetworkChanged(
+    chromeos::NetworkLibrary* cros,
+    const chromeos::Network* network) {
+  if (dom_ui_)
+    RefreshNetworkData(cros);
+}
+
+// Add an observer for the active network, if any, so
+// that we can dynamically display the correct icon for
+// that network's signal strength.
+// TODO(ers) Ideally, on this page we'd monitor all networks for
+// signal strength changes, not just the active network.
+void InternetOptionsHandler::MonitorActiveNetwork(
+    chromeos::NetworkLibrary* cros) {
+  const chromeos::Network* network = cros->active_network();
+  if (active_network_.empty() || network == NULL ||
+      active_network_ != network->service_path()) {
+    if (!active_network_.empty()) {
+      cros->RemoveNetworkObserver(active_network_, this);
+    }
+    if (network != NULL) {
+      cros->AddNetworkObserver(network->service_path(), this);
+    }
+  }
+  if (network != NULL)
+    active_network_ = network->service_path();
+  else
+    active_network_ = "";
+}
+
+void InternetOptionsHandler::OnCellularDataPlanChanged(
     chromeos::NetworkLibrary* obj) {
   if (!dom_ui_)
     return;
   chromeos::CellularNetwork* cellular = obj->cellular_network();
   if (!cellular)
     return;
   const chromeos::CellularDataPlanVector& plans = cellular->GetDataPlans();
   DictionaryValue connection_plans;
   ListValue* plan_list = new ListValue();
   for (chromeos::CellularDataPlanVector::const_iterator iter = plans.begin();
@@ skipping 186 matching lines @@
   dictionary.SetBoolean("connecting", net->connecting());
   dictionary.SetBoolean("connected", net->connected());
   dictionary.SetString("connectionState", net->GetStateString());
   if (type == chromeos::TYPE_WIFI) {
     chromeos::WifiNetwork* wireless =
         cros->FindWifiNetworkByPath(net->service_path());
     if (!wireless) {
       LOG(WARNING) << "Cannot find network " << net->service_path();
     } else {
       dictionary.SetString("ssid", wireless->name());
-      dictionary.SetBoolean("autoConnect",wireless->auto_connect());
+      dictionary.SetBoolean("autoConnect", wireless->auto_connect());
       if (wireless->encrypted()) {
         dictionary.SetBoolean("encrypted", true);
         if (wireless->encryption() == chromeos::SECURITY_8021X) {
           bool certificate_in_pkcs11 =
               is_certificate_in_pkcs11(wireless->cert_path());
           if (certificate_in_pkcs11) {
             dictionary.SetBoolean("certInPkcs", true);
           } else {
             dictionary.SetBoolean("certInPkcs", false);
           }
-          dictionary.SetString("certPath",wireless->cert_path());
-          dictionary.SetString("ident",wireless->identity());
+          dictionary.SetString("certPath", wireless->cert_path());
+          dictionary.SetString("ident", wireless->identity());
           dictionary.SetBoolean("certNeeded", true);
-          dictionary.SetString("certPass",wireless->passphrase());
+          dictionary.SetString("certPass", wireless->passphrase());
         } else {
           dictionary.SetBoolean("certNeeded", false);
         }
       } else {
         dictionary.SetBoolean("encrypted", false);
       }
     }
   } else if (type == chromeos::TYPE_CELLULAR) {
     chromeos::CellularNetwork* cellular =
         cros->FindCellularNetworkByPath(net->service_path());
@@ skipping 40 matching lines @@
                          FormatHardwareAddress(hardware_address));
   }
 
   dom_ui_->CallJavascriptFunction(
       L"options.InternetOptions.showDetailedInfo", dictionary);
 }
 
 void InternetOptionsHandler::PopupWirelessPassword(
     const chromeos::WifiNetwork* network) {
   DictionaryValue dictionary;
-  dictionary.SetString("servicePath",network->service_path());
+  dictionary.SetString("servicePath", network->service_path());
   if (network->encryption() == chromeos::SECURITY_8021X) {
     dictionary.SetBoolean("certNeeded", true);
     dictionary.SetString("ident", network->identity());
     dictionary.SetString("cert", network->cert_path());
   } else {
     dictionary.SetBoolean("certNeeded", false);
   }
   dom_ui_->CallJavascriptFunction(
       L"options.InternetOptions.showPasswordEntry", dictionary);
 }
 
 void InternetOptionsHandler::LoginCallback(const ListValue* args) {
-
   std::string service_path;
   std::string password;
 
   if (args->GetSize() != 2 ||
       !args->GetString(0, &service_path) ||
       !args->GetString(1, &password)) {
     NOTREACHED();
     return;
   }
 
   chromeos::NetworkLibrary* cros =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   chromeos::WifiNetwork* network = cros->FindWifiNetworkByPath(service_path);
   if (network) {
     cros->ConnectToWifiNetwork(
         network, password, std::string(), std::string());
   } else {
     // Network disappeared while the user is connecting to it.
     // TODO(chocobo): Display error message.
     LOG(WARNING) << "Cannot find network to connect " << service_path;
   }
 }
 
 void InternetOptionsHandler::LoginCertCallback(const ListValue* args) {
-
   std::string service_path;
   std::string identity;
   std::string certpath;
   if (args->GetSize() < 3 ||
       !args->GetString(0, &service_path) ||
       !args->GetString(1, &certpath) ||
       !args->GetString(2, &identity)) {
     return;
   }
   chromeos::NetworkLibrary* cros =
@@ skipping 220 matching lines @@
         false,
         chromeos::ACTIVATION_STATE_UNKNOWN));
   }
 
   const chromeos::CellularNetworkVector cellular_networks =
       cros->cellular_networks();
   for (chromeos::CellularNetworkVector::const_iterator it =
       cellular_networks.begin(); it != cellular_networks.end(); ++it) {
     SkBitmap icon = chromeos::NetworkMenu::IconForNetworkStrength(
         (*it)->strength(), true);
-    SkBitmap badge = *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_3G);
+    SkBitmap badge = chromeos::NetworkMenu::BadgeForNetworkTechnology(*it);
     icon = chromeos::NetworkMenu::IconForDisplay(icon, badge);
     list->Append(GetNetwork(
         (*it)->service_path(),
         icon,
         (*it)->name(),
         (*it)->connecting(),
         (*it)->connected(),
         chromeos::TYPE_CELLULAR,
         false,
         (*it)->activation_state()));
@@ skipping 35 matching lines @@
         icon,
         (*it)->name(),
         (*it)->connecting(),
         (*it)->connected(),
         chromeos::TYPE_WIFI,
         true,
         chromeos::ACTIVATION_STATE_UNKNOWN));
   }
   return list;
 }