Add NetworkConnectionHandler class

chromeos/network/network_state.cc

 // Copyright (c) 2012 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 "chromeos/network/network_state.h"
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 41 matching lines @@
 }  // namespace
 
 namespace chromeos {
 
 NetworkState::NetworkState(const std::string& path)
     : ManagedState(MANAGED_TYPE_NETWORK, path),
       auto_connect_(false),
       favorite_(false),
       priority_(0),
       signal_strength_(0),
+      connectable_(false),
+      passphrase_required_(false),
       activate_over_non_cellular_networks_(false),
       cellular_out_of_credits_(false) {
 }
 
 NetworkState::~NetworkState() {
 }
 
 bool NetworkState::PropertyChanged(const std::string& key,
                                    const base::Value& value) {
   // Keep care that these properties are the same as in |GetProperties|.
   if (ManagedStatePropertyChanged(key, value))
     return true;
   if (key == flimflam::kSignalStrengthProperty) {
     return GetIntegerValue(key, value, &signal_strength_);
   } else if (key == flimflam::kStateProperty) {
     return GetStringValue(key, value, &connection_state_);
+  } else if (key == flimflam::kConnectableProperty) {
+    return GetBooleanValue(key, value, &connectable_);
+  } else if (key == flimflam::kPassphraseRequiredProperty) {
+    return GetBooleanValue(key, value, &passphrase_required_);
   } else if (key == flimflam::kErrorProperty) {
     return GetStringValue(key, value, &error_);
   } else if (key == IPConfigProperty(flimflam::kAddressProperty)) {
     return GetStringValue(key, value, &ip_address_);
   } else if (key == IPConfigProperty(flimflam::kNameServersProperty)) {
     dns_servers_.clear();
     const base::ListValue* dns_servers;
     if (value.GetAsList(&dns_servers) &&
         ConvertListValueToStringVector(*dns_servers, &dns_servers_))
       return true;
@@ skipping 35 matching lines @@
 
 void NetworkState::InitialPropertiesReceived() {
   UpdateName();
 }
 
 void NetworkState::GetProperties(base::DictionaryValue* dictionary) const {
   // Keep care that these properties are the same as in |PropertyChanged|.
   dictionary->SetStringWithoutPathExpansion(flimflam::kNameProperty, name());
   dictionary->SetStringWithoutPathExpansion(flimflam::kTypeProperty, type());
   dictionary->SetIntegerWithoutPathExpansion(flimflam::kSignalStrengthProperty,
-                                             signal_strength());
+                                             signal_strength_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kStateProperty,
-                                            connection_state());
+                                            connection_state_);
+  dictionary->SetBooleanWithoutPathExpansion(flimflam::kConnectableProperty,
+                                             connectable_);
+  dictionary->SetBooleanWithoutPathExpansion(
+      flimflam::kPassphraseRequiredProperty, passphrase_required_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kErrorProperty,
-                                            error());
+                                            error_);
   base::DictionaryValue* ipconfig_properties = new DictionaryValue;
   ipconfig_properties->SetStringWithoutPathExpansion(flimflam::kAddressProperty,
-                                                     ip_address());
+                                                     ip_address_);
   base::ListValue* name_servers = new ListValue;
-  name_servers->AppendStrings(dns_servers());
+  name_servers->AppendStrings(dns_servers_);
   ipconfig_properties->SetWithoutPathExpansion(flimflam::kNameServersProperty,
                                                name_servers);
   dictionary->SetWithoutPathExpansion(shill::kIPConfigProperty,
                                       ipconfig_properties);
 
   dictionary->SetStringWithoutPathExpansion(flimflam::kActivationStateProperty,
-                                            activation_state());
+                                            activation_state_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kRoamingStateProperty,
-                                            roaming());
+                                            roaming_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kSecurityProperty,
-                                            security());
+                                            security_);
   dictionary->SetBooleanWithoutPathExpansion(flimflam::kAutoConnectProperty,
-                                             auto_connect());
+                                             auto_connect_);
   dictionary->SetBooleanWithoutPathExpansion(flimflam::kFavoriteProperty,
-                                             favorite());
+                                             favorite_);
   dictionary->SetIntegerWithoutPathExpansion(flimflam::kPriorityProperty,
-                                             priority());
+                                             priority_);
   dictionary->SetStringWithoutPathExpansion(
       flimflam::kNetworkTechnologyProperty,
-      technology());
+      technology_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kDeviceProperty,
-                                            device_path());
-  dictionary->SetStringWithoutPathExpansion(flimflam::kGuidProperty, guid());
+                                            device_path_);
+  dictionary->SetStringWithoutPathExpansion(flimflam::kGuidProperty, guid_);
   dictionary->SetStringWithoutPathExpansion(flimflam::kProfileProperty,
-                                            profile_path());
+                                            profile_path_);
   dictionary->SetBooleanWithoutPathExpansion(
       shill::kActivateOverNonCellularNetworkProperty,
-      activate_over_non_cellular_networks());
+      activate_over_non_cellular_networks_);
   dictionary->SetBooleanWithoutPathExpansion(shill::kOutOfCreditsProperty,
-                                             cellular_out_of_credits());
+                                             cellular_out_of_credits_);
 }
 
 bool NetworkState::IsConnectedState() const {
   return StateIsConnected(connection_state_);
 }
 
 bool NetworkState::IsConnectingState() const {
   return StateIsConnecting(connection_state_);
 }
 
@@ skipping 73 matching lines @@
           connection_state == flimflam::kStateConfiguration ||
           connection_state == flimflam::kStateCarrier);
 }
 
 // static
 std::string NetworkState::IPConfigProperty(const char* key) {
   return base::StringPrintf("%s.%s", shill::kIPConfigProperty, key);
 }
 
 }  // namespace chromeos