chromeos networking: move from security to securityclass property

chromeos/network/shill_property_util.cc

 // Copyright 2013 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/shill_property_util.h"
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 39 matching lines @@
                               base::DictionaryValue* dest) {
   std::string string_value;
   if (!source.GetStringWithoutPathExpansion(key, &string_value) ||
       string_value.empty()) {
     return false;
   }
   dest->SetStringWithoutPathExpansion(key, string_value);
   return true;
 }
 
-// This is the same normalization that Shill applies to security types for the
-// sake of comparing/identifying WiFi networks. See Shill's
-// WiFiService::GetSecurityClass.
-std::string GetSecurityClass(const std::string& security) {
-  if (security == shill::kSecurityRsn || security == shill::kSecurityWpa)
-    return shill::kSecurityPsk;
-  else
-    return security;
-}
-
 }  // namespace
 
 void SetSSID(const std::string ssid, base::DictionaryValue* properties) {
   std::string hex_ssid = base::HexEncode(ssid.c_str(), ssid.size());
   properties->SetStringWithoutPathExpansion(shill::kWifiHexSsid, hex_ssid);
 }
 
 std::string GetSSIDFromProperties(const base::DictionaryValue& properties,
                                   bool* unknown_encoding) {
   bool verbose_logging = false;
@@ skipping 168 matching lines @@
   bool success = true;
 
   // GUID is optional.
   CopyStringFromDictionary(service_properties, shill::kGuidProperty, dest);
 
   std::string type;
   service_properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type);
   success &= !type.empty();
   dest->SetStringWithoutPathExpansion(shill::kTypeProperty, type);
   if (type == shill::kTypeWifi) {
-    std::string security;
-    service_properties.GetStringWithoutPathExpansion(shill::kSecurityProperty,
-                                                     &security);
-    if (security.empty()) {
+    std::string security_class;
+    service_properties.GetStringWithoutPathExpansion(
+        shill::kSecurityClassProperty, &security_class);
+    if (security_class.empty()) {
       success = false;
     } else {
-      dest->SetStringWithoutPathExpansion(shill::kSecurityProperty,
-                                          GetSecurityClass(security));
+      dest->SetStringWithoutPathExpansion(shill::kSecurityClassProperty,
+                                          security_class);
     }
     success &=
         CopyStringFromDictionary(service_properties, shill::kWifiHexSsid, dest);
     success &= CopyStringFromDictionary(
         service_properties, shill::kModeProperty, dest);
   } else if (type == shill::kTypeVPN) {
     success &= CopyStringFromDictionary(
         service_properties, shill::kNameProperty, dest);
 
     // VPN Provider values are read from the "Provider" dictionary, but written
@@ skipping 95 matching lines @@
     LOG(WARNING)
         << "Provider name and country not defined, using code instead: "
         << *home_provider_id;
   }
   return true;
 }
 
 }  // namespace shill_property_util
 
 }  // namespace chromeos