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

chrome/browser/chromeos/cros/network_library.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 31 matching lines @@
   bool connecting() const { return state_ == STATE_ASSOCIATION ||
       state_ == STATE_CONFIGURATION || state_ == STATE_CARRIER; }
   bool configuring() const { return state_ == STATE_CONFIGURATION; }
   bool connected() const { return state_ == STATE_READY; }
   bool connecting_or_connected() const { return connecting() || connected(); }
   bool failed() const { return state_ == STATE_FAILURE; }
   bool failed_or_disconnected() const { return failed() ||
       state_ == STATE_IDLE; }
   ConnectionError error() const { return error_; }
   ConnectionState state() const { return state_; }
+  // Is this network connectable. Some networks are not yet ready to be
+  // connected. For example, an 8021X network without certificates.
+  bool connectable() const { return connectable_; }
   // Is this the active network, i.e, the one through which
   // network traffic is being routed? A network can be connected,
   // but not be carrying traffic.
   bool is_active() const { return is_active_; }
 
   // Clear the fields.
   virtual void Clear();
 
   // Return a string representation of the state code.
   std::string GetStateString() const;
 
   // Return a string representation of the error code.
   std::string GetErrorString() const;
 
  protected:
   Network()
       : type_(TYPE_UNKNOWN),
         state_(STATE_UNKNOWN),
         error_(ERROR_UNKNOWN),
+        connectable_(true),
         is_active_(false) {}
   explicit Network(const Network& network);
   explicit Network(const ServiceInfo* service);
   virtual ~Network() {}
 
   std::string service_path_;
   std::string device_path_;
   std::string ip_address_;
   ConnectionType type_;
   ConnectionState state_;
   ConnectionError error_;
+  bool connectable_;
   bool is_active_;
 
  private:
   void set_service_path(const std::string& service_path) {
       service_path_ = service_path; }
   void set_connecting(bool connecting) { state_ = (connecting ?
       STATE_ASSOCIATION : STATE_IDLE); }
   void set_connected(bool connected) { state_ = (connected ?
       STATE_READY : STATE_IDLE); }
   void set_state(ConnectionState state) { state_ = state; }
+  void set_connectable(bool connectable) { connectable_ = connectable; }
   void set_active(bool is_active) { is_active_ = is_active; }
 
   friend class NetworkLibraryImpl;
 };
 
 class EthernetNetwork : public Network {
  public:
   EthernetNetwork() : Network() {
     type_ = TYPE_ETHERNET;
   }
@@ skipping 482 matching lines @@
   virtual std::string GetHtmlInfo(int refresh) = 0;
 
   // Factory function, creates a new instance and returns ownership.
   // For normal usage, access the singleton via CrosLibrary::Get().
   static NetworkLibrary* GetImpl(bool stub);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_