Remove ParsedCertificate::unparsed_extensions().

net/cert/internal/parsed_certificate_unittest.cc

 // Copyright 2017 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 "net/cert/internal/parsed_certificate.h"
 
 #include "net/cert/internal/cert_errors.h"
 #include "net/cert/internal/parse_certificate.h"
 #include "net/cert/internal/test_helpers.h"
 #include "net/der/input.h"
@@ skipping 50 matching lines @@
 }
 
 // Parses an Extension whose critical field is true (255).
 TEST(ParsedCertificateTest, ExtensionCritical) {
   scoped_refptr<ParsedCertificate> cert =
       ParseCertificateFromFile("extension_critical.pem");
   ASSERT_TRUE(cert);
 
   const uint8_t kExpectedValue[] = {0x30, 0x00};
 
-  auto it = cert->unparsed_extensions().find(DavidBenOid());
-  ASSERT_NE(cert->unparsed_extensions().end(), it);
-  const auto& extension = it->second;
+  ParsedExtension extension;
+  ASSERT_TRUE(cert->GetExtension(DavidBenOid(), &extension));
 
   EXPECT_TRUE(extension.critical);
   EXPECT_EQ(DavidBenOid(), extension.oid);
   EXPECT_EQ(der::Input(kExpectedValue), extension.value);
 }
 
 // Parses an Extension whose critical field is false (omitted).
 TEST(ParsedCertificateTest, ExtensionNotCritical) {
   scoped_refptr<ParsedCertificate> cert =
       ParseCertificateFromFile("extension_not_critical.pem");
   ASSERT_TRUE(cert);
 
   const uint8_t kExpectedValue[] = {0x30, 0x00};
 
-  auto it = cert->unparsed_extensions().find(DavidBenOid());
-  ASSERT_NE(cert->unparsed_extensions().end(), it);
-  const auto& extension = it->second;
+  ParsedExtension extension;
+  ASSERT_TRUE(cert->GetExtension(DavidBenOid(), &extension));
 
   EXPECT_FALSE(extension.critical);
   EXPECT_EQ(DavidBenOid(), extension.oid);
   EXPECT_EQ(der::Input(kExpectedValue), extension.value);
 }
 
 // Parses an Extension whose critical field is 0. This is in one sense FALSE,
 // however because critical has DEFAULT of false this is in fact invalid
 // DER-encoding.
 TEST(ParsedCertificateTest, ExtensionCritical0) {
@@ skipping 26 matching lines @@
 TEST(ParsedCertificateTest, ExtensionsDuplicateKeyUsage) {
   ASSERT_FALSE(ParseCertificateFromFile("extensions_duplicate_key_usage.pem"));
 }
 
 // Parses an Extensions that contains an extended key usages.
 TEST(ParsedCertificateTest, ExtendedKeyUsage) {
   scoped_refptr<ParsedCertificate> cert =
       ParseCertificateFromFile("extended_key_usage.pem");
   ASSERT_TRUE(cert);
 
-  const auto& extensions = cert->unparsed_extensions();
-  ASSERT_EQ(3u, extensions.size());
+  ASSERT_EQ(4u, cert->extensions().size());
 
-  auto iter = extensions.find(ExtKeyUsageOid());
-  ASSERT_TRUE(iter != extensions.end());
-  EXPECT_FALSE(iter->second.critical);
-  EXPECT_EQ(45u, iter->second.value.Length());
+  ParsedExtension extension;
+  ASSERT_TRUE(cert->GetExtension(ExtKeyUsageOid(), &extension));
+
+  EXPECT_FALSE(extension.critical);
+  EXPECT_EQ(45u, extension.value.Length());
+
+  EXPECT_TRUE(cert->has_extended_key_usage());
+  EXPECT_EQ(4u, cert->extended_key_usage().size());
 }
 
 // Parses an Extensions that contains a key usage.
 TEST(ParsedCertificateTest, KeyUsage) {
   scoped_refptr<ParsedCertificate> cert =
       ParseCertificateFromFile("key_usage.pem");
   ASSERT_TRUE(cert);
 
   ASSERT_TRUE(cert->has_key_usage());
 
   EXPECT_EQ(5u, cert->key_usage().unused_bits());
   const uint8_t kExpectedBytes[] = {0xA0};
   EXPECT_EQ(der::Input(kExpectedBytes), cert->key_usage().bytes());
 
   EXPECT_TRUE(cert->key_usage().AssertsBit(0));
   EXPECT_FALSE(cert->key_usage().AssertsBit(1));
   EXPECT_TRUE(cert->key_usage().AssertsBit(2));
 }
 
 // Parses an Extensions that contains a policies extension.
 TEST(ParsedCertificateTest, Policies) {
   scoped_refptr<ParsedCertificate> cert =
       ParseCertificateFromFile("policies.pem");
   ASSERT_TRUE(cert);
 
-  const auto& extensions = cert->unparsed_extensions();
-  ASSERT_EQ(3u, extensions.size());
+  ASSERT_EQ(4u, cert->extensions().size());
 
-  auto iter = extensions.find(CertificatePoliciesOid());
-  ASSERT_TRUE(iter != extensions.end());
-  EXPECT_FALSE(iter->second.critical);
-  EXPECT_EQ(95u, iter->second.value.Length());
+  ParsedExtension extension;
+  ASSERT_TRUE(cert->GetExtension(CertificatePoliciesOid(), &extension));
+
+  EXPECT_FALSE(extension.critical);
+  EXPECT_EQ(95u, extension.value.Length());
+
+  EXPECT_TRUE(cert->has_policy_oids());
+  EXPECT_EQ(2u, cert->policy_oids().size());
 }
 
 // Parses an Extensions that contains a subjectaltname extension.
 TEST(ParsedCertificateTest, SubjectAltName) {
   scoped_refptr<ParsedCertificate> cert =
       ParseCertificateFromFile("subject_alt_name.pem");
   ASSERT_TRUE(cert);
 
   ASSERT_TRUE(cert->has_subject_alt_names());
 }
 
 // Parses an Extensions that contains multiple extensions, sourced from a
 // real-world certificate.
 TEST(ParsedCertificateTest, ExtensionsReal) {
   scoped_refptr<ParsedCertificate> cert =
       ParseCertificateFromFile("extensions_real.pem");
   ASSERT_TRUE(cert);
 
-  const auto& extensions = cert->unparsed_extensions();
-  ASSERT_EQ(4u, extensions.size());
+  ASSERT_EQ(7u, cert->extensions().size());
 
   EXPECT_TRUE(cert->has_key_usage());
   EXPECT_TRUE(cert->has_basic_constraints());
+  EXPECT_TRUE(cert->has_policy_oids());
 
-  auto iter = extensions.find(CertificatePoliciesOid());
-  ASSERT_TRUE(iter != extensions.end());
-  EXPECT_FALSE(iter->second.critical);
-  EXPECT_EQ(16u, iter->second.value.Length());
+  ParsedExtension extension;
+  ASSERT_TRUE(cert->GetExtension(CertificatePoliciesOid(), &extension));
+
+  EXPECT_FALSE(extension.critical);
+  EXPECT_EQ(16u, extension.value.Length());
 
   // TODO(eroman): Verify the other 4 extensions' values.
 }
 
 // Parses a BasicConstraints with no CA or pathlen.
 TEST(ParsedCertificateTest, BasicConstraintsNotCa) {
   scoped_refptr<ParsedCertificate> cert =
       ParseCertificateFromFile("basic_constraints_not_ca.pem");
   ASSERT_TRUE(cert);
 
@@ skipping 83 matching lines @@
 
   EXPECT_TRUE(cert->has_basic_constraints());
   EXPECT_FALSE(cert->basic_constraints().is_ca);
   EXPECT_TRUE(cert->basic_constraints().has_path_len);
   EXPECT_EQ(1u, cert->basic_constraints().path_len);
 }
 
 }  // namespace
 
 }  // namespace net