Added a PolicyCertVerifier that uses the trust anchors from the ONC policies.

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 <cert.h>
 #include <pk11pub.h>
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/cros/network_library_impl_stub.h"
 #include "chrome/browser/chromeos/login/mock_user_manager.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "chromeos/network/onc/onc_certificate_importer.h"
 #include "chromeos/network/onc/onc_constants.h"
 #include "chromeos/network/onc/onc_test_utils.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "crypto/nss_util.h"
 #include "net/base/crypto_module.h"
 #include "net/cert/nss_cert_database.h"
 #include "net/cert/x509_certificate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::AnyNumber;
 using ::testing::Return;
-using ::testing::AtLeast;
 
 namespace chromeos {
 
 namespace {
 
 // Have to do a stub here because MOCK can't handle closure arguments.
 class StubEnrollmentDelegate : public EnrollmentDelegate {
  public:
   explicit StubEnrollmentDelegate()
       : did_enroll(false),
@@ skipping 114 matching lines @@
   // Load the ONC from |onc_file| using NetworkLibrary::LoadOncNetworks. Check
   // that return value matches |expect_successful_import| and the configuration
   // that would be sent to Shill matches |shill_json|.
   void LoadOncAndVerifyNetworks(std::string onc_file,
                                 std::string shill_json,
                                 onc::ONCSource source,
                                 bool expect_successful_import) {
     ScopedMockUserManagerEnabler mock_user_manager;
     mock_user_manager.user_manager()->SetLoggedInUser("madmax@my.domain.com");
     EXPECT_CALL(*mock_user_manager.user_manager(), IsUserLoggedIn())
-        .Times(AtLeast(0))
+        .Times(AnyNumber())
         .WillRepeatedly(Return(true));
 
     std::string onc_blob =
         onc::test_utils::ReadTestData(onc_file);
 
     scoped_ptr<base::Value> expected_value =
         google_apis::test_util::LoadJSONFile(shill_json);
     base::DictionaryValue* expected_configs;
     expected_value->GetAsDictionary(&expected_configs);
 
+    net::CertificateList cert_list;
     EXPECT_EQ(expect_successful_import,
-              cros_->LoadOncNetworks(onc_blob, "", source, true));
+              cros_->LoadOncNetworks(onc_blob, "", source, &cert_list));
 
     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.HasNext();
          it.Advance()) {
       const base::DictionaryValue* expected_config;
       it.value().GetAsDictionary(&expected_config);
@@ skipping 123 matching lines @@
   EXPECT_TRUE(wifi1->connected());
 }
 
 TEST_F(NetworkLibraryStubTest, NetworkConnectWifiWithCertPattern) {
   scoped_ptr<base::DictionaryValue> onc_root =
       onc::test_utils::ReadTestDictionary("toplevel_wifi_eap_clientcert.onc");
   base::ListValue* certificates;
   onc_root->GetListWithoutPathExpansion(onc::toplevel_config::kCertificates,
                                         &certificates);
 
-  onc::CertificateImporter importer(true /* allow webtrust */);
+  onc::CertificateImporter importer(true /* allow trust imports */);
+  net::CertificateList cert_list;
   ASSERT_EQ(onc::CertificateImporter::IMPORT_OK,
-            importer.ParseAndStoreCertificates(*certificates));
+            importer.ParseAndStoreCertificates(*certificates, &cert_list));
 
   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");
   base::ListValue* certificates;
   onc_root->GetListWithoutPathExpansion(onc::toplevel_config::kCertificates,
                                         &certificates);
 
-  onc::CertificateImporter importer(true /* allow webtrust */);
+  onc::CertificateImporter importer(true /* allow trust imports */);
+  net::CertificateList cert_list;
   ASSERT_EQ(onc::CertificateImporter::IMPORT_OK,
-            importer.ParseAndStoreCertificates(*certificates));
+            importer.ParseAndStoreCertificates(*certificates, &cert_list));
 
   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 128 matching lines @@
 
 // TODO(stevenjb): Test network profiles.
 
 // TODO(stevenjb): Test network devices.
 
 // TODO(stevenjb): Test data plans.
 
 // TODO(stevenjb): Test monitor network / device.
 
 }  // namespace chromeos