chromeos networking: move from security to securityclass property

chromeos/network/network_connection_handler.cc

 // Copyright (c) 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/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 73 matching lines @@
     NET_LOG_EVENT("VPN Is Configured", service_path);
   }
   return false;
 }
 
 std::string GetDefaultUserProfilePath(const NetworkState* network) {
   if (!NetworkHandler::IsInitialized() ||
       (LoginState::IsInitialized() &&
        !LoginState::Get()->UserHasNetworkProfile()) ||
       (network && network->type() == shill::kTypeWifi &&
-       network->security() == shill::kSecurityNone)) {
+       network->security_class() == shill::kSecurityNone)) {
     return NetworkProfileHandler::GetSharedProfilePath();
   }
   const NetworkProfile* profile  =
       NetworkHandler::Get()->network_profile_handler()->GetDefaultUserProfile();
   return profile ? profile->path
                  : NetworkProfileHandler::GetSharedProfilePath();
 }
 
 }  // namespace
 
@@ skipping 255 matching lines @@
   // If 'passphrase_required' is still true, then the 'Passphrase' property
   // has not been set to a minimum length value.
   bool passphrase_required = false;
   service_properties.GetBooleanWithoutPathExpansion(
       shill::kPassphraseRequiredProperty, &passphrase_required);
   if (passphrase_required) {
     ErrorCallbackForPendingRequest(service_path, kErrorPassphraseRequired);
     return;
   }
 
-  std::string type, security;
+  std::string type, security_class;
   service_properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type);
   service_properties.GetStringWithoutPathExpansion(
-      shill::kSecurityProperty, &security);
+      shill::kSecurityClassProperty, &security_class);
   bool connectable = false;
   service_properties.GetBooleanWithoutPathExpansion(
       shill::kConnectableProperty, &connectable);
 
   // In case NetworkState was not available in ConnectToNetwork (e.g. it had
   // been recently configured), we need to check Connectable again.
   if (connectable && type != shill::kTypeVPN) {
     // TODO(stevenjb): Shill needs to properly set Connectable for VPN.
     CallShillConnect(service_path);
     return;
@@ skipping 45 matching lines @@
       // TODO(benchan): Modify shill to specify the authentication type via
       // the kL2tpIpsecAuthenticationType property, so that Chrome doesn't need
       // to deduce the authentication type based on the
       // kL2tpIpsecClientCertIdProperty here (and also in VPNConfigView).
       if (!vpn_client_cert_id.empty() ||
           cert_config_from_policy.client_cert_type !=
               onc::client_cert::kClientCertTypeNone) {
         client_cert_type = client_cert::CONFIG_TYPE_IPSEC;
       }
     }
-  } else if (type == shill::kTypeWifi && security == shill::kSecurity8021x) {
+  } else if (type == shill::kTypeWifi &&
+             security_class == shill::kSecurity8021x) {
     client_cert_type = client_cert::CONFIG_TYPE_EAP;
   }
 
   base::DictionaryValue config_properties;
   if (client_cert_type != client_cert::CONFIG_TYPE_NONE) {
     // Note: if we get here then a certificate *may* be required, so we want
     // to ensure that certificates have loaded successfully before attempting
     // to connect.
 
     // User must be logged in to connect to a network requiring a certificate.
@@ skipping 297 matching lines @@
 
 void NetworkConnectionHandler::HandleShillDisconnectSuccess(
     const std::string& service_path,
     const base::Closure& success_callback) {
   NET_LOG_EVENT("Disconnect Request Sent", service_path);
   if (!success_callback.is_null())
     success_callback.Run();
 }
 
 }  // namespace chromeos