Refactor the client certificate code in chromeos/network/.

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/certificate_pattern_matcher.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 "dbus/object_path.h"
 #include "net/cert/x509_certificate.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
@@ skipping 388 matching lines @@
     if (!CertificateIsConfigured(ui_data.get(), &pkcs11_id)) {
       ErrorCallbackForPendingRequest(service_path, kErrorCertificateRequired);
       return;
     }
 
     // The network may not be 'Connectable' because the certificate data is
     // not set up, so configure tpm slot/pin and pkcs11_id before connecting.
     // TODO(stevenjb): Remove this code once NetworkConfigurationHandler
     // handles this.
     NET_LOG_EVENT("Configuring Network", service_path);
-    const std::string& tpm_slot = cert_loader_->tpm_token_slot();
-    const std::string& tpm_pin = cert_loader_->tpm_user_pin();
     base::DictionaryValue config_properties;
     // 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::kSecurityProperty,
                              &config_properties);
     CopyStringFromDictionary(service_properties, flimflam::kGuidProperty,
                              &config_properties);
 
+    client_cert::ConfigType client_cert_type =
+        client_cert::CONFIG_TYPE_OPENVPN;      // Initialize to arbitrary
+                                               // value.

[stevenjb, 2013/08/07 19:24:47]

nit: Only 2 spaces before cpmment, and maybe use "Init" to fit trailing comment
on one line

[pneubeck (no reviews), 2013/08/08 11:28:29]

Done.

     if (type == flimflam::kTypeVPN) {
       // VPN Provider values are read from the "Provider" dictionary, not the
       // "Provider.Type", etc keys (which are used only to set the values).
       std::string provider_type;
-      const base::DictionaryValue* provider_properties;
-      if (service_properties.GetDictionaryWithoutPathExpansion(
-              flimflam::kProviderProperty, &provider_properties)) {
+      const base::DictionaryValue* provider_properties = NULL;
+      service_properties.GetDictionaryWithoutPathExpansion(
+          flimflam::kProviderProperty, &provider_properties);
+      if (provider_properties) {
         provider_properties->GetStringWithoutPathExpansion(
             flimflam::kTypeProperty, &provider_type);
       }
       if (provider_type.empty()) {
         ErrorCallbackForPendingRequest(service_path, kErrorMissingProviderType);
         return;
       }
-      if (provider_type == flimflam::kProviderOpenVpn) {
-        config_properties.SetStringWithoutPathExpansion(
-            flimflam::kOpenVPNClientCertSlotProperty, tpm_slot);
-        config_properties.SetStringWithoutPathExpansion(
-            flimflam::kOpenVPNPinProperty, tpm_pin);
-        config_properties.SetStringWithoutPathExpansion(
-            flimflam::kOpenVPNClientCertIdProperty, pkcs11_id);
-      } else {
-        config_properties.SetStringWithoutPathExpansion(
-            flimflam::kL2tpIpsecClientCertSlotProperty, tpm_slot);
-        config_properties.SetStringWithoutPathExpansion(
-            flimflam::kL2tpIpsecPinProperty, tpm_pin);
-        config_properties.SetStringWithoutPathExpansion(
-            flimflam::kL2tpIpsecClientCertIdProperty, pkcs11_id);
-      }
+      if (provider_type == flimflam::kProviderOpenVpn)
+        client_cert_type = client_cert::CONFIG_TYPE_OPENVPN;
+      else
+        client_cert_type = client_cert::CONFIG_TYPE_IPSEC;
     } else if (type == flimflam::kTypeWifi) {
-      config_properties.SetStringWithoutPathExpansion(
-          flimflam::kEapPinProperty, cert_loader_->tpm_user_pin());
-      config_properties.SetStringWithoutPathExpansion(
-          flimflam::kEapCertIdProperty, pkcs11_id);
-      config_properties.SetStringWithoutPathExpansion(
-          flimflam::kEapKeyIdProperty, pkcs11_id);
+      client_cert_type = client_cert::CONFIG_TYPE_EAP;
     }
+    client_cert::SetShillProperties(client_cert_type,
+                                    cert_loader_->tpm_token_slot(),
+                                    cert_loader_->tpm_user_pin(),
+                                    pkcs11_id,
+                                    &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;
   }
 
@@ skipping 107 matching lines @@
   }
 }
 
 bool NetworkConnectionHandler::CertificateIsConfigured(NetworkUIData* ui_data,
                                                        std::string* pkcs11_id) {
   if (ui_data->certificate_pattern().Empty())
     return false;
 
   // Find the matching certificate.
   scoped_refptr<net::X509Certificate> matching_cert =
-      certificate_pattern::GetCertificateMatch(ui_data->certificate_pattern());
+      client_cert::GetCertificateMatch(ui_data->certificate_pattern());
   if (!matching_cert.get())
     return false;
-  *pkcs11_id = cert_loader_->GetPkcs11IdForCert(*matching_cert.get());
+  if (cert_loader_->IsHardwareBacked())
+    *pkcs11_id = CertLoader::GetPkcs11IdForCert(*matching_cert.get());
   return true;
 }
 
 void NetworkConnectionHandler::ErrorCallbackForPendingRequest(
     const std::string& service_path,
     const std::string& error_name) {
   ConnectRequest* request = pending_request(service_path);
   DCHECK(request);
   // Remove the entry before invoking the callback in case it triggers a retry.
   network_handler::ErrorCallback error_callback = request->error_callback;
@@ skipping 18 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