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

chrome/browser/chromeos/cros/network_library.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/cros/network_library.h"
 
 #include <algorithm>
 #include <map>
 
 #include "app/l10n_util.h"
@@ skipping 17 matching lines @@
 
 }  // namespace
 
 namespace chromeos {
 
 namespace {
 // TODO(ers) These string constants and Parse functions are copied
 // straight out of libcros:chromeos_network.cc. Fix this by moving
 // all handling of properties into libcros.
 // Network service properties we are interested in monitoring
+static const char* kConnectableProperty = "Connectable";
 static const char* kIsActiveProperty = "IsActive";
 static const char* kStateProperty = "State";
 static const char* kSignalStrengthProperty = "Strength";
 static const char* kActivationStateProperty = "Cellular.ActivationState";
 static const char* kNetworkTechnologyProperty = "Cellular.NetworkTechnology";
 static const char* kPaymentURLProperty = "Cellular.OlpUrl";
 static const char* kRestrictedPoolProperty = "Cellular.RestrictedPool";
 static const char* kRoamingStateProperty = "Cellular.RoamingState";
 
 // Connman state options.
@@ skipping 164 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Network
 
 Network::Network(const Network& network) {
   service_path_ = network.service_path();
   device_path_ = network.device_path();
   ip_address_ = network.ip_address();
   type_ = network.type();
   state_ = network.state();
   error_ = network.error();
+  connectable_ = network.connectable();
+  is_active_ = network.is_active();
 }
 
 void Network::Clear() {
-  state_ = STATE_UNKNOWN;
-  error_ = ERROR_UNKNOWN;
   service_path_.clear();
   device_path_.clear();
   ip_address_.clear();
+  type_ = TYPE_UNKNOWN;
+  state_ = STATE_UNKNOWN;
+  error_ = ERROR_UNKNOWN;
+  connectable_ = true;
   is_active_ = false;
 }
 
 Network::Network(const ServiceInfo* service) {
   type_ = service->type;
   state_ = service->state;
   error_ = service->error;
   service_path_ = SafeString(service->service_path);
   device_path_ = SafeString(service->device_path);
+  connectable_ = service->connectable;
   is_active_ = service->is_active;
   ip_address_.clear();
   // If connected, get ip config.
   if (EnsureCrosLoaded() && connected() && service->device_path) {
     IPConfigStatus* ipconfig_status = ListIPConfigs(service->device_path);
     if (ipconfig_status) {
       for (int i = 0; i < ipconfig_status->size; i++) {
         IPConfig ipconfig = ipconfig_status->ips[i];
         if (strlen(ipconfig.address) > 0)
           ip_address_ = ipconfig.address;
@@ skipping 1168 matching lines @@
     wifi2->set_strength(70);
     wifi2->set_connected(true);
     wifi2->set_encryption(SECURITY_WEP);
     wifi_networks_.push_back(wifi2);
 
     WifiNetwork* wifi3 = new WifiNetwork();
     wifi3->set_service_path("fw3");
     wifi3->set_name("Fake Wifi 3");
     wifi3->set_strength(50);
     wifi3->set_connected(false);
-    wifi3->set_encryption(SECURITY_WEP);
+    wifi3->set_encryption(SECURITY_8021X);
+    wifi3->set_connectable(false);
     wifi_networks_.push_back(wifi3);
 
     wifi_ = wifi2;
 
     STLDeleteElements(&cellular_networks_);
     cellular_networks_.clear();
 
     CellularNetwork* cellular1 = new CellularNetwork();
     cellular1->set_service_path("fc1");
     cellular1->set_name("Fake Cellular 1");
@@ skipping 196 matching lines @@
           if (value->GetAsString(&stringval))
             cellular->set_network_technology(
                 ParseNetworkTechnology(stringval));
         } else if (strcmp(key, kRoamingStateProperty) == 0) {
           if (value->GetAsString(&stringval))
             cellular->set_roaming_state(ParseRoamingState(stringval));
         }
       }
       network = wireless;
     }
-    if (strcmp(key, kIsActiveProperty) == 0) {
+    if (strcmp(key, kConnectableProperty) == 0) {
+      if (value->GetAsBoolean(&boolval))
+        network->set_connectable(boolval);
+    } else if (strcmp(key, kIsActiveProperty) == 0) {
       if (value->GetAsBoolean(&boolval))
         network->set_active(boolval);
     } else if (strcmp(key, kStateProperty) == 0) {
       if (value->GetAsString(&stringval))
         network->set_state(ParseState(stringval));
     }
     NotifyNetworkChanged(network);
   }
 
   void UpdateCellularDataPlan(const CellularDataPlanList* data_plans) {
@@ skipping 184 matching lines @@
     return new NetworkLibraryStubImpl();
   else
     return new NetworkLibraryImpl();
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImpl);