Resolve certificate references in ONC by PEM.

chrome/browser/chromeos/cros/network_library_unittest.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 <pk11pub.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 159 matching lines @@
     onc_blob->GetListWithoutPathExpansion(
         onc::toplevel_config::kNetworkConfigurations,
         &onc_network_configs);
     ASSERT_TRUE(onc_network_configs);
 
     scoped_ptr<base::Value> expected_value =
         google_apis::test_util::LoadJSONFile(shill_json);
     base::DictionaryValue* expected_configs;
     expected_value->GetAsDictionary(&expected_configs);
 
-    cros_->LoadOncNetworks(*onc_network_configs, source);
+    cros_->LoadOncNetworks(*onc_network_configs, source,
+                           base::Bind(&onc::test_utils::FakeFingerprintToPEM));
 
     const std::map<std::string, base::DictionaryValue*>& configs =
         cros_->GetConfigurations();
 
     EXPECT_EQ(expected_configs->size(), configs.size());
 
     for (base::DictionaryValue::Iterator it(*expected_configs); !it.IsAtEnd();
          it.Advance()) {
       const base::DictionaryValue* expected_config;
       it.value().GetAsDictionary(&expected_config);
@@ skipping 93 matching lines @@
   EXPECT_TRUE(wifi1->connected());
   cros_->DisconnectFromNetwork(wifi1);
   EXPECT_FALSE(wifi1->connected());
   EXPECT_TRUE(cros_->CanConnectToNetwork(wifi1));
   cros_->ConnectToWifiNetwork(wifi1);
   EXPECT_TRUE(wifi1->connected());
 }
 
 TEST_F(NetworkLibraryStubTest, NetworkConnectWifiWithCertPattern) {
   scoped_ptr<base::DictionaryValue> onc_root =
-      onc::test_utils::ReadTestDictionary("toplevel_wifi_eap_clientcert.onc");
+      onc::test_utils::ReadTestDictionary("certificate-client.onc");
   base::ListValue* certificates;
   onc_root->GetListWithoutPathExpansion(onc::toplevel_config::kCertificates,
                                         &certificates);
 
   onc::CertificateImporter importer(true /* allow trust imports */);
   ASSERT_EQ(onc::CertificateImporter::IMPORT_OK,
-            importer.ParseAndStoreCertificates(*certificates, NULL));
+            importer.ParseAndStoreCertificates(*certificates, NULL, NULL));
 
   WifiNetwork* wifi = cros_->FindWifiNetworkByPath("wifi_cert_pattern");
 
   StubEnrollmentDelegate* enrollment_delegate = new StubEnrollmentDelegate();
   wifi->SetEnrollmentDelegate(enrollment_delegate);
   EXPECT_FALSE(enrollment_delegate->did_enroll);
   EXPECT_FALSE(enrollment_delegate->correct_args);
 
   ASSERT_NE(static_cast<const WifiNetwork*>(NULL), wifi);
   EXPECT_FALSE(wifi->connected());
   EXPECT_TRUE(cros_->CanConnectToNetwork(wifi));
   EXPECT_FALSE(wifi->connected());
   wifi->AttemptConnection(
       base::Bind(&WifiNetworkConnectCallback, cros_, wifi));
   EXPECT_TRUE(wifi->connected());
   EXPECT_TRUE(enrollment_delegate->did_enroll);
   EXPECT_TRUE(enrollment_delegate->correct_args);
 }
 
 TEST_F(NetworkLibraryStubTest, NetworkConnectVPNWithCertPattern) {
   scoped_ptr<base::DictionaryValue> onc_root =
-      onc::test_utils::ReadTestDictionary("toplevel_openvpn_clientcert.onc");
+      onc::test_utils::ReadTestDictionary("certificate-client.onc");
   base::ListValue* certificates;
   onc_root->GetListWithoutPathExpansion(onc::toplevel_config::kCertificates,
                                         &certificates);
 
   onc::CertificateImporter importer(true /* allow trust imports */);
   ASSERT_EQ(onc::CertificateImporter::IMPORT_OK,
-            importer.ParseAndStoreCertificates(*certificates, NULL));
+            importer.ParseAndStoreCertificates(*certificates, NULL, NULL));
 
   VirtualNetwork* vpn = cros_->FindVirtualNetworkByPath("vpn_cert_pattern");
 
   StubEnrollmentDelegate* enrollment_delegate = new StubEnrollmentDelegate();
   vpn->SetEnrollmentDelegate(enrollment_delegate);
   EXPECT_FALSE(enrollment_delegate->did_enroll);
   EXPECT_FALSE(enrollment_delegate->correct_args);
 
   ASSERT_NE(static_cast<const VirtualNetwork*>(NULL), vpn);
   EXPECT_FALSE(vpn->connected());
@@ skipping 61 matching lines @@
                            GetParam().expect_import_result);
 }
 
 INSTANTIATE_TEST_CASE_P(
     LoadOncNetworksTest,
     LoadOncNetworksTest,
     ::testing::Values(
          ImportParams("managed_toplevel1_normalized.onc",
                       "chromeos/net/shill_for_managed_toplevel1.json",
                       onc::ONC_SOURCE_USER_POLICY),
-         ImportParams("managed_toplevel2.onc",
+         ImportParams("managed_toplevel2_with_cert_fingerprints.onc",
                       "chromeos/net/shill_for_managed_toplevel2.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("managed_toplevel_l2tpipsec.onc",
                       "chromeos/net/shill_for_managed_toplevel_l2tpipsec.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("managed_toplevel_wifi_peap.onc",
                       "chromeos/net/shill_for_managed_toplevel_wifi_peap.json",
                       onc::ONC_SOURCE_DEVICE_POLICY),
          ImportParams("toplevel_wifi_open.onc",
                       "chromeos/net/shill_for_toplevel_wifi_open.json",
                       onc::ONC_SOURCE_DEVICE_POLICY),
          ImportParams("toplevel_wifi_wep_proxy.onc",
                       "chromeos/net/shill_for_toplevel_wifi_wep_proxy.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("toplevel_wifi_wpa_psk.onc",
                       "chromeos/net/shill_for_toplevel_wifi_wpa_psk.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("toplevel_wifi_leap.onc",
                       "chromeos/net/shill_for_toplevel_wifi_leap.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams(
-            "toplevel_wifi_eap_clientcert.onc",
+            "toplevel_wifi_eap_clientcert_with_cert_fingerprints.onc",
             "chromeos/net/shill_for_toplevel_wifi_eap_clientcert.json",
             onc::ONC_SOURCE_USER_POLICY),
-         ImportParams("toplevel_openvpn_clientcert.onc",
+         ImportParams("toplevel_openvpn_clientcert_with_cert_fingerprints.onc",
                       "chromeos/net/shill_for_toplevel_openvpn_clientcert.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("toplevel_wifi_remove.onc",
                       "chromeos/net/shill_for_toplevel_wifi_remove.json",
                       onc::ONC_SOURCE_USER_POLICY)));
 
 // TODO(stevenjb): Test remembered networks.
 
 // TODO(stevenjb): Test network profiles.
 
 // TODO(stevenjb): Test network devices.
 
 // TODO(stevenjb): Test data plans.
 
 // TODO(stevenjb): Test monitor network / device.
 
 }  // namespace chromeos