Don't allow connection to networks that are not connected....

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 786 matching lines @@
   chromeos::NetworkLibrary* cros =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   chromeos::CellularNetwork* cellular =
       cros->FindCellularNetworkByPath(service_path);
   if (cellular)
     cros->RefreshCellularDataPlans(cellular);
 }
 
 ListValue* InternetOptionsHandler::GetNetwork(const std::string& service_path,
     const SkBitmap& icon, const std::string& name, bool connecting,
-    bool connected, chromeos::ConnectionType connection_type, bool remembered,
-    chromeos::ActivationState activation_state, bool restricted_ip) {
-
+    bool connected, bool connectable, chromeos::ConnectionType connection_type,
+    bool remembered, chromeos::ActivationState activation_state,
+    bool restricted_ip) {
   ListValue* network = new ListValue();
 
   int connection_state = IDS_STATUSBAR_NETWORK_DEVICE_DISCONNECTED;
-  if (connecting)
+  if (!connectable)
+    connection_state = IDS_STATUSBAR_NETWORK_DEVICE_NOT_CONFIGURED;
+  else if (connecting)
     connection_state = IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING;
   else if (connected)
     connection_state = IDS_STATUSBAR_NETWORK_DEVICE_CONNECTED;
   std::string status = l10n_util::GetStringUTF8(connection_state);
   if (connection_type == chromeos::TYPE_CELLULAR) {
     if (activation_state == chromeos::ACTIVATION_STATE_ACTIVATED &&
         restricted_ip && connected) {
       status = l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_NO_PLAN_LABEL);
     } else if (activation_state != chromeos::ACTIVATION_STATE_ACTIVATED) {
       status.append(" / ");
@@ skipping 16 matching lines @@
   // icon data url
   network->Append(Value::CreateStringValue(icon.isNull() ? "" :
       dom_ui_util::GetImageDataUrl(icon)));
   // remembered
   network->Append(Value::CreateBooleanValue(remembered));
   // activation_state
   network->Append(Value::CreateIntegerValue(
                     static_cast<int>(activation_state)));
   // restricted
   network->Append(Value::CreateBooleanValue(restricted_ip));
+  // connectable
+  network->Append(Value::CreateBooleanValue(connectable));
   return network;
 }
 
 ListValue* InternetOptionsHandler::GetWiredList() {
   chromeos::NetworkLibrary* cros =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   ListValue* list = new ListValue();
 
   // If ethernet is not enabled, then don't add anything.
   if (cros->ethernet_enabled()) {
     chromeos::EthernetNetwork* ethernet_network =
         cros->ethernet_network();
     SkBitmap icon = *rb.GetBitmapNamed(IDR_STATUSBAR_WIRED_BLACK);
     if (!ethernet_network || (!ethernet_network->connecting() &&
         !ethernet_network->connected())) {
       icon = chromeos::NetworkMenu::IconForDisplay(icon,
           *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_DISCONNECTED));
     }
     if (ethernet_network) {
       list->Append(GetNetwork(
           ethernet_network->service_path(),
           icon,
           l10n_util::GetStringUTF8(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET),
           ethernet_network->connecting(),
           ethernet_network->connected(),
+          ethernet_network->connectable(),
           chromeos::TYPE_ETHERNET,
           false,
           chromeos::ACTIVATION_STATE_UNKNOWN,
           false));
     }
   }
   return list;
 }
 
 ListValue* InternetOptionsHandler::GetWirelessList() {
@@ skipping 10 matching lines @@
     if ((*it)->encrypted()) {
       icon = chromeos::NetworkMenu::IconForDisplay(icon,
           *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_SECURE));
     }
     list->Append(GetNetwork(
         (*it)->service_path(),
         icon,
         (*it)->name(),
         (*it)->connecting(),
         (*it)->connected(),
+        (*it)->connectable(),
         chromeos::TYPE_WIFI,
         false,
         chromeos::ACTIVATION_STATE_UNKNOWN,
         false));
   }
 
   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 = chromeos::NetworkMenu::BadgeForNetworkTechnology(*it);
     icon = chromeos::NetworkMenu::IconForDisplay(icon, badge);
     list->Append(GetNetwork(
         (*it)->service_path(),
         icon,
         (*it)->name(),
         (*it)->connecting(),
         (*it)->connected(),
+        (*it)->connectable(),
         chromeos::TYPE_CELLULAR,
         false,
         (*it)->activation_state(),
         (*it)->restricted_pool()));
   }
 
   // Add "Other..." if wifi is enabled.
   if (cros->wifi_enabled()) {
     list->Append(GetNetwork(
         kOtherNetworksFakePath,
         *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_BARS0_BLACK),
         l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_OTHER_NETWORKS),
         false,
         false,
+        true,
         chromeos::TYPE_WIFI,
         false,
         chromeos::ACTIVATION_STATE_UNKNOWN,
         false));
   }
 
   return list;
 }
 
 ListValue* InternetOptionsHandler::GetRememberedList() {
@@ skipping 10 matching lines @@
     if ((*it)->encrypted()) {
       icon = chromeos::NetworkMenu::IconForDisplay(icon,
           *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_SECURE));
     }
     list->Append(GetNetwork(
         (*it)->service_path(),
         icon,
         (*it)->name(),
         (*it)->connecting(),
         (*it)->connected(),
+        true,
         chromeos::TYPE_WIFI,
         true,
         chromeos::ACTIVATION_STATE_UNKNOWN,
         false));
   }
   return list;
 }