Use BoringSSL scopers in //net.

net/cert/internal/verify_name_match.cc

 // Copyright 2015 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/verify_name_match.h"
 
+#include <openssl/bytestring.h>
+#include <openssl/mem.h>
+
 #include <algorithm>
 #include <vector>
 
 #include "base/strings/string_util.h"
 #include "base/tuple.h"
-#include "crypto/auto_cbb.h"
-#include "crypto/scoped_openssl_types.h"
 #include "net/cert/internal/parse_name.h"
 #include "net/der/input.h"
 #include "net/der/parser.h"
 #include "net/der/tag.h"
 
 namespace net {
 
 namespace {
 
 // RFC 5280 section A.1:
@@ skipping 263 matching lines @@
 }
 
 }  // namespace
 
 bool NormalizeName(const der::Input& name_rdn_sequence,
                    std::string* normalized_rdn_sequence) {
   // RFC 5280 section 4.1.2.4
   // RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
   der::Parser rdn_sequence_parser(name_rdn_sequence);
 
-  crypto::AutoCBB cbb;
+  bssl::ScopedCBB cbb;
   if (!CBB_init(cbb.get(), 0))
     return false;
 
   while (rdn_sequence_parser.HasMore()) {
     // RelativeDistinguishedName ::= SET SIZE (1..MAX) OF AttributeTypeAndValue
     der::Parser rdn_parser;
     if (!rdn_sequence_parser.ReadConstructed(der::kSet, &rdn_parser))
       return false;
     RelativeDistinguishedName type_and_values;
     if (!ReadRdn(&rdn_parser, &type_and_values))
       return false;
 
     // The AttributeTypeAndValue objects in the SET OF need to be sorted on
     // their DER encodings. Encode each individually and save the encoded values
     // in |encoded_attribute_type_and_values| so that it can be sorted before
     // being added to |rdn_cbb|. |scoped_encoded_attribute_type_and_values|
     // owns the |OPENSSL_malloc|ed memory referred to by
     // |encoded_attribute_type_and_values|.
     CBB rdn_cbb;
     if (!CBB_add_asn1(cbb.get(), &rdn_cbb, CBS_ASN1_SET))
       return false;
-    std::vector<crypto::ScopedOpenSSLBytes>
+    std::vector<bssl::UniquePtr<uint8_t>>
         scoped_encoded_attribute_type_and_values;
     std::vector<der::Input> encoded_attribute_type_and_values;
 
     for (const auto& type_and_value : type_and_values) {
       // A top-level CBB for encoding each individual AttributeTypeAndValue.
-      crypto::AutoCBB type_and_value_encoder_cbb;
+      bssl::ScopedCBB type_and_value_encoder_cbb;
       if (!CBB_init(type_and_value_encoder_cbb.get(), 0))
         return false;
 
       // AttributeTypeAndValue ::= SEQUENCE {
       //   type     AttributeType,
       //   value    AttributeValue }
       CBB attribute_type_and_value_cbb, type_cbb, value_cbb;
       if (!CBB_add_asn1(type_and_value_encoder_cbb.get(),
                         &attribute_type_and_value_cbb, CBS_ASN1_SEQUENCE)) {
         return false;
@@ skipping 24 matching lines @@
             !CBB_add_bytes(&value_cbb, type_and_value.value.UnsafeData(),
                            type_and_value.value.Length()))
           return false;
       }
 
       uint8_t* bytes;
       size_t len;
       if (!CBB_finish(type_and_value_encoder_cbb.get(), &bytes, &len))
         return false;
       scoped_encoded_attribute_type_and_values.push_back(
-          crypto::ScopedOpenSSLBytes(bytes));
+          bssl::UniquePtr<uint8_t>(bytes));
       encoded_attribute_type_and_values.push_back(der::Input(bytes, len));
     }
 
     std::sort(encoded_attribute_type_and_values.begin(),
               encoded_attribute_type_and_values.end());
     for (const auto& encoded_attribute_type_and_value :
          encoded_attribute_type_and_values) {
       if (!CBB_add_bytes(&rdn_cbb,
                          encoded_attribute_type_and_value.UnsafeData(),
                          encoded_attribute_type_and_value.Length())) {
@@ skipping 44 matching lines @@
         return true;
       }
     }
   }
 
   *contained_email_address = false;
   return true;
 }
 
 }  // namespace net