Move Shill property utility functions to a new separate file.

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/command_line.h"
 #include "base/json/json_reader.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/client_cert_util.h"
-#include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_ui_data.h"
+#include "chromeos/network/shill_property_util.h"
 #include "dbus/object_path.h"
 #include "net/cert/x509_certificate.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 void InvokeErrorCallback(const std::string& service_path,
                          const network_handler::ErrorCallback& error_callback,
                          const std::string& error_name) {
   std::string error_msg = "Connect Error: " + error_name;
   NET_LOG_ERROR(error_msg, service_path);
   if (error_callback.is_null())
     return;
   scoped_ptr<base::DictionaryValue> error_data(
       network_handler::CreateErrorData(service_path, error_name, error_msg));
   error_callback.Run(error_name, error_data.Pass());
 }
 
 bool IsAuthenticationError(const std::string& error) {
   return (error == flimflam::kErrorBadWEPKey ||
           error == flimflam::kErrorPppAuthFailed ||
           error == shill::kErrorEapLocalTlsFailed ||
           error == shill::kErrorEapRemoteTlsFailed ||
           error == shill::kErrorEapAuthenticationFailed);
 }
 
-void CopyStringFromDictionary(const base::DictionaryValue& source,
-                              const std::string& key,
-                              base::DictionaryValue* dest) {
-  std::string string_value;
-  if (source.GetStringWithoutPathExpansion(key, &string_value))
-    dest->SetStringWithoutPathExpansion(key, string_value);
-}
-
 bool NetworkRequiresActivation(const NetworkState* network) {
   return (network->type() == flimflam::kTypeCellular &&
       ((network->activation_state() != flimflam::kActivationStateActivated &&
         network->activation_state() != flimflam::kActivationStateUnknown)));
 }
 
 bool VPNIsConfigured(const std::string& service_path,
                      const std::string& provider_type,
                      const base::DictionaryValue& provider_properties) {
   if (provider_type == flimflam::kProviderOpenVpn) {
@@ skipping 336 matching lines @@
   base::DictionaryValue config_properties;
   if (client_cert_type != client_cert::CONFIG_TYPE_NONE) {
     // If the client certificate must be configured, this will be set to a
     // non-empty string.
     std::string pkcs11_id;
 
     // Check certificate properties in kUIDataProperty if configured.
     // Note: Wifi/VPNConfigView set these properties explicitly, in which case
     //   only the TPM must be configured.
     scoped_ptr<NetworkUIData> ui_data =
-        ManagedNetworkConfigurationHandler::GetUIData(service_properties);
+        shill_property_util::GetUIDataFromShillDictionary(service_properties);
     if (ui_data && ui_data->certificate_type() == CLIENT_CERT_TYPE_PATTERN) {
       // User must be logged in to connect to a network requiring a certificate.
       if (!logged_in_ || !cert_loader_) {
         ErrorCallbackForPendingRequest(service_path, kErrorCertificateRequired);
         return;
       }
 
       // If certificates have not been loaded yet, queue the connect request.
       if (!certificates_loaded_) {
         ConnectRequest* request = GetPendingRequest(service_path);
@@ skipping 24 matching lines @@
       client_cert::SetShillProperties(client_cert_type,
                                       cert_loader_->tpm_token_slot(),
                                       cert_loader_->tpm_user_pin(),
                                       pkcs11_id.empty() ? NULL : &pkcs11_id,
                                       &config_properties);
     }
   }
 
   if (!config_properties.empty()) {
     NET_LOG_EVENT("Configuring Network", service_path);
-
-    // Set configuration properties required by Shill to identify the network.
-    config_properties.SetStringWithoutPathExpansion(
-        flimflam::kTypeProperty, type);
-    CopyStringFromDictionary(service_properties, flimflam::kNameProperty,
-                             &config_properties);
-    CopyStringFromDictionary(service_properties, flimflam::kGuidProperty,
-                             &config_properties);
-    if (type == flimflam::kTypeVPN) {
-      config_properties.SetStringWithoutPathExpansion(
-          flimflam::kProviderTypeProperty, vpn_provider_type);
-      config_properties.SetStringWithoutPathExpansion(
-          flimflam::kProviderHostProperty, vpn_provider_host);
-    } else if (type == flimflam::kTypeWifi) {
-      config_properties.SetStringWithoutPathExpansion(
-          flimflam::kSecurityProperty, security);
+    if (shill_property_util::CopyIdentifyingProperties(service_properties,
+                                                       &config_properties)) {
+      network_configuration_handler_->SetProperties(
+          service_path,
+          config_properties,
+          base::Bind(&NetworkConnectionHandler::CallShillConnect,
+                     AsWeakPtr(),
+                     service_path),
+          base::Bind(&NetworkConnectionHandler::HandleConfigurationFailure,
+                     AsWeakPtr(),
+                     service_path));
+      return;
     }
-
-    network_configuration_handler_->SetProperties(
-        service_path,
-        config_properties,
-        base::Bind(&NetworkConnectionHandler::CallShillConnect,
-                   AsWeakPtr(), service_path),
-        base::Bind(&NetworkConnectionHandler::HandleConfigurationFailure,
-                   AsWeakPtr(), service_path));
-   return;
+    NET_LOG_ERROR("Shill dictionary is missing some relevant entries",
+                  service_path);
   }
 
   // Otherwise, we probably still need to configure the network since
   // 'Connectable' is false. If |check_error_state| is true, signal an
   // error, otherwise attempt to connect to possibly gain additional error
   // state from Shill (or in case 'Connectable' is improperly unset).
   if (check_error_state)
     ErrorCallbackForPendingRequest(service_path, kErrorConfigurationRequired);
   else
     CallShillConnect(service_path);
@@ skipping 168 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