chromeos networking: move from security to securityclass property

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/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_profile_handler.h"
@@ skipping 88 matching lines @@
   } else if (key == shill::kActivationStateProperty) {
     return GetStringValue(key, value, &activation_state_);
   } else if (key == shill::kRoamingStateProperty) {
     return GetStringValue(key, value, &roaming_);
   } else if (key == shill::kPaymentPortalProperty) {
     const base::DictionaryValue* olp;
     if (!value.GetAsDictionary(&olp))
       return false;
     return olp->GetStringWithoutPathExpansion(shill::kPaymentPortalURL,
                                               &payment_url_);
-  } else if (key == shill::kSecurityProperty) {
-    return GetStringValue(key, value, &security_);
+  } else if (key == shill::kSecurityClassProperty) {
+    return GetStringValue(key, value, &security_class_);
   } else if (key == shill::kEapMethodProperty) {
     return GetStringValue(key, value, &eap_method_);
   } else if (key == shill::kNetworkTechnologyProperty) {
     return GetStringValue(key, value, &network_technology_);
   } else if (key == shill::kDeviceProperty) {
     return GetStringValue(key, value, &device_path_);
   } else if (key == shill::kGuidProperty) {
     return GetStringValue(key, value, &guid_);
   } else if (key == shill::kProfileProperty) {
     return GetStringValue(key, value, &profile_path_);
@@ skipping 58 matching lines @@
   }
 
   return changed;
 }
 
 void NetworkState::GetStateProperties(base::DictionaryValue* dictionary) const {
   ManagedState::GetStateProperties(dictionary);
 
   // Properties shared by all types.
   dictionary->SetStringWithoutPathExpansion(shill::kGuidProperty, guid());
-  dictionary->SetStringWithoutPathExpansion(shill::kSecurityProperty,
-                                            security());
+  dictionary->SetStringWithoutPathExpansion(shill::kSecurityClassProperty,
+                                            security_class());
 
   if (visible()) {
     if (!error().empty())
       dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty, error());
     dictionary->SetStringWithoutPathExpansion(shill::kStateProperty,
                                               connection_state());
   }
 
   // Wireless properties
   if (!NetworkTypePattern::Wireless().MatchesType(type()))
@@ skipping 110 matching lines @@
 std::string NetworkState::GetNetmask() const {
   return network_util::PrefixLengthToNetmask(prefix_length_);
 }
 
 std::string NetworkState::GetSpecifier() const {
   if (!update_received()) {
     NET_LOG_ERROR("GetSpecifier called before update", path());
     return std::string();
   }
   if (type() == shill::kTypeWifi)
-    return name() + "_" + security_;
+    return name() + "_" + security_class_;
   if (!name().empty())
     return name();
   return type();  // For unnamed networks such as ethernet.
 }
 
 void NetworkState::SetGuid(const std::string& guid) {
   guid_ = guid;
 }
 
 bool NetworkState::UpdateName(const base::DictionaryValue& properties) {
@@ skipping 20 matching lines @@
           connection_state == shill::kStateCarrier);
 }
 
 // static
 bool NetworkState::ErrorIsValid(const std::string& error) {
   // Shill uses "Unknown" to indicate an unset or cleared error state.
   return !error.empty() && error != kErrorUnknown;
 }
 
 }  // namespace chromeos