Replace Scoped* heap types with bssl::UniquePtr.

Unlike the Scoped* types, bssl::UniquePtr is available to C++ users, and
offered for a large variety of types.  The 'extern "C++"' trick is used
to make the C++ bits digestible to C callers that wrap header files in
'extern "C"'.

Change-Id: Ifbca4c2997d6628e33028c7d7620c72aff0f862e
Reviewed-on: https://boringssl-review.googlesource.com/10521
Reviewed-by: David Benjamin <davidben@google.com>
Commit-Queue: David Benjamin <davidben@google.com>
CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>

22 files changed, 311 insertions, 453 deletions

diff --git a/crypto/asn1/asn1_test.cc b/crypto/asn1/asn1_test.cc
index 8b024427..77a1ee0d 100644
--- a/crypto/asn1/asn1_test.cc
+++ b/crypto/asn1/asn1_test.cc
@@ -18,8 +18,6 @@
 #include <openssl/crypto.h>
 #include <openssl/err.h>
 
-#include "../test/scoped_types.h"
-
 
 // kTag128 is an ASN.1 structure with a universal tag with number 128.
 static const uint8_t kTag128[] = {
@@ -42,7 +40,7 @@ static const uint8_t kTagOverflow[] = {
 
 static bool TestLargeTags() {
   const uint8_t *p = kTag258;
-  ScopedASN1_TYPE obj(d2i_ASN1_TYPE(NULL, &p, sizeof(kTag258)));
+  bssl::UniquePtr<ASN1_TYPE> obj(d2i_ASN1_TYPE(NULL, &p, sizeof(kTag258)));
   if (obj) {
     fprintf(stderr, "Parsed value with illegal tag (type = %d).\n", obj->type);
     return false;
diff --git a/crypto/bio/bio_test.cc b/crypto/bio/bio_test.cc
index d7be884e..cbc4fde8 100644
--- a/crypto/bio/bio_test.cc
+++ b/crypto/bio/bio_test.cc
@@ -41,7 +41,6 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
 #include <algorithm>
 
 #include "../internal.h"
-#include "../test/scoped_types.h"
 
 
 #if !defined(OPENSSL_WINDOWS)
@@ -104,7 +103,7 @@ static bool TestSocketConnect() {
   char hostname[80];
   BIO_snprintf(hostname, sizeof(hostname), "%s:%d", "127.0.0.1",
                ntohs(sin.sin_port));
-  ScopedBIO bio(BIO_new_connect(hostname));
+  bssl::UniquePtr<BIO> bio(BIO_new_connect(hostname));
   if (!bio) {
     fprintf(stderr, "BIO_new_connect failed.\n");
     return false;
@@ -216,8 +215,8 @@ static bool TestZeroCopyBioPairs() {
       if (!BIO_new_bio_pair(&bio1, kBufferSize, &bio2, kBufferSize)) {
         return false;
       }
-      ScopedBIO bio1_scoper(bio1);
-      ScopedBIO bio2_scoper(bio2);
+      bssl::UniquePtr<BIO> bio1_scoper(bio1);
+      bssl::UniquePtr<BIO> bio2_scoper(bio2);
 
       total_write += BioWriteZeroCopyWrapper(
           bio1, bio1_application_send_buffer, kLengths[i]);
@@ -287,7 +286,7 @@ static bool TestPrintf() {
   // 256 (the size of the buffer) to ensure edge cases are correct.
   static const size_t kLengths[] = { 5, 250, 251, 252, 253, 254, 1023 };
 
-  ScopedBIO bio(BIO_new(BIO_s_mem()));
+  bssl::UniquePtr<BIO> bio(BIO_new(BIO_s_mem()));
   if (!bio) {
     fprintf(stderr, "BIO_new failed\n");
     return false;
@@ -331,7 +330,7 @@ static bool TestPrintf() {
 
 static bool ReadASN1(bool should_succeed, const uint8_t *data, size_t data_len,
                      size_t expected_len, size_t max_len) {
-  ScopedBIO bio(BIO_new_mem_buf(data, data_len));
+  bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(data, data_len));
 
   uint8_t *out;
   size_t out_len;
@@ -339,7 +338,7 @@ static bool ReadASN1(bool should_succeed, const uint8_t *data, size_t data_len,
   if (!ok) {
     out = nullptr;
   }
-  ScopedOpenSSLBytes out_storage(out);
+  bssl::UniquePtr<uint8_t> out_storage(out);
 
   if (should_succeed != (ok == 1)) {
     return false;
@@ -369,7 +368,7 @@ static bool TestASN1() {
   static const size_t kLargePayloadLen = 8000;
   static const uint8_t kLargePrefix[] = {0x30, 0x82, kLargePayloadLen >> 8,
                                          kLargePayloadLen & 0xff};
-  ScopedOpenSSLBytes large(reinterpret_cast<uint8_t *>(
+  bssl::UniquePtr<uint8_t> large(reinterpret_cast<uint8_t *>(
       OPENSSL_malloc(sizeof(kLargePrefix) + kLargePayloadLen)));
   if (!large) {
     return false;
diff --git a/crypto/bn/bn_test.cc b/crypto/bn/bn_test.cc
index bb83a407..0867dec2 100644
--- a/crypto/bn/bn_test.cc
+++ b/crypto/bn/bn_test.cc
@@ -81,30 +81,30 @@
 #include <utility>
 
 #include <openssl/bn.h>
+#include <openssl/bytestring.h>
 #include <openssl/crypto.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
 #include "../internal.h"
 #include "../test/file_test.h"
-#include "../test/scoped_types.h"
 #include "../test/test_util.h"
 
 
-static int HexToBIGNUM(ScopedBIGNUM *out, const char *in) {
+static int HexToBIGNUM(bssl::UniquePtr<BIGNUM> *out, const char *in) {
   BIGNUM *raw = NULL;
   int ret = BN_hex2bn(&raw, in);
   out->reset(raw);
   return ret;
 }
 
-static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *attribute) {
+static bssl::UniquePtr<BIGNUM> GetBIGNUM(FileTest *t, const char *attribute) {
   std::string hex;
   if (!t->GetAttribute(&hex, attribute)) {
     return nullptr;
   }
 
-  ScopedBIGNUM ret;
+  bssl::UniquePtr<BIGNUM> ret;
   if (HexToBIGNUM(&ret, hex.c_str()) != static_cast<int>(hex.size())) {
     t->PrintLine("Could not decode '%s'.", hex.c_str());
     return nullptr;
@@ -113,7 +113,7 @@ static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *attribute) {
 }
 
 static bool GetInt(FileTest *t, int *out, const char *attribute) {
-  ScopedBIGNUM ret = GetBIGNUM(t, attribute);
+  bssl::UniquePtr<BIGNUM> ret = GetBIGNUM(t, attribute);
   if (!ret) {
     return false;
   }
@@ -133,8 +133,8 @@ static bool ExpectBIGNUMsEqual(FileTest *t, const char *operation,
     return true;
   }
 
-  ScopedOpenSSLString expected_str(BN_bn2hex(expected));
-  ScopedOpenSSLString actual_str(BN_bn2hex(actual));
+  bssl::UniquePtr<char> expected_str(BN_bn2hex(expected));
+  bssl::UniquePtr<char> actual_str(BN_bn2hex(actual));
   if (!expected_str || !actual_str) {
     return false;
   }
@@ -147,14 +147,14 @@ static bool ExpectBIGNUMsEqual(FileTest *t, const char *operation,
 }
 
 static bool TestSum(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM b = GetBIGNUM(t, "B");
-  ScopedBIGNUM sum = GetBIGNUM(t, "Sum");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> b = GetBIGNUM(t, "B");
+  bssl::UniquePtr<BIGNUM> sum = GetBIGNUM(t, "Sum");
   if (!a || !b || !sum) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new());
   if (!ret ||
       !BN_add(ret.get(), a.get(), b.get()) ||
       !ExpectBIGNUMsEqual(t, "A + B", sum.get(), ret.get()) ||
@@ -246,16 +246,16 @@ static bool TestSum(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestLShift1(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM lshift1 = GetBIGNUM(t, "LShift1");
-  ScopedBIGNUM zero(BN_new());
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> lshift1 = GetBIGNUM(t, "LShift1");
+  bssl::UniquePtr<BIGNUM> zero(BN_new());
   if (!a || !lshift1 || !zero) {
     return false;
   }
 
   BN_zero(zero.get());
 
-  ScopedBIGNUM ret(BN_new()), two(BN_new()), remainder(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new()), two(BN_new()), remainder(BN_new());
   if (!ret || !two || !remainder ||
       !BN_set_word(two.get(), 2) ||
       !BN_add(ret.get(), a.get(), a.get()) ||
@@ -287,14 +287,14 @@ static bool TestLShift1(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestLShift(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM lshift = GetBIGNUM(t, "LShift");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> lshift = GetBIGNUM(t, "LShift");
   int n = 0;
   if (!a || !lshift || !GetInt(t, &n, "N")) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new());
   if (!ret ||
       !BN_lshift(ret.get(), a.get(), n) ||
       !ExpectBIGNUMsEqual(t, "A << N", lshift.get(), ret.get()) ||
@@ -307,14 +307,14 @@ static bool TestLShift(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestRShift(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM rshift = GetBIGNUM(t, "RShift");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> rshift = GetBIGNUM(t, "RShift");
   int n = 0;
   if (!a || !rshift || !GetInt(t, &n, "N")) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new());
   if (!ret ||
       !BN_rshift(ret.get(), a.get(), n) ||
       !ExpectBIGNUMsEqual(t, "A >> N", rshift.get(), ret.get())) {
@@ -325,16 +325,16 @@ static bool TestRShift(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestSquare(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM square = GetBIGNUM(t, "Square");
-  ScopedBIGNUM zero(BN_new());
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> square = GetBIGNUM(t, "Square");
+  bssl::UniquePtr<BIGNUM> zero(BN_new());
   if (!a || !square || !zero) {
     return false;
   }
 
   BN_zero(zero.get());
 
-  ScopedBIGNUM ret(BN_new()), remainder(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new()), remainder(BN_new());
   if (!ret ||
       !BN_sqr(ret.get(), a.get(), ctx) ||
       !ExpectBIGNUMsEqual(t, "A^2", square.get(), ret.get()) ||
@@ -354,7 +354,7 @@ static bool TestSquare(FileTest *t, BN_CTX *ctx) {
 
   // BN_sqrt should fail on non-squares and negative numbers.
   if (!BN_is_zero(square.get())) {
-    ScopedBIGNUM tmp(BN_new());
+    bssl::UniquePtr<BIGNUM> tmp(BN_new());
     if (!tmp || !BN_copy(tmp.get(), square.get())) {
       return false;
     }
@@ -381,17 +381,17 @@ static bool TestSquare(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestProduct(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM b = GetBIGNUM(t, "B");
-  ScopedBIGNUM product = GetBIGNUM(t, "Product");
-  ScopedBIGNUM zero(BN_new());
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> b = GetBIGNUM(t, "B");
+  bssl::UniquePtr<BIGNUM> product = GetBIGNUM(t, "Product");
+  bssl::UniquePtr<BIGNUM> zero(BN_new());
   if (!a || !b || !product || !zero) {
     return false;
   }
 
   BN_zero(zero.get());
 
-  ScopedBIGNUM ret(BN_new()), remainder(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new()), remainder(BN_new());
   if (!ret || !remainder ||
       !BN_mul(ret.get(), a.get(), b.get(), ctx) ||
       !ExpectBIGNUMsEqual(t, "A * B", product.get(), ret.get()) ||
@@ -408,15 +408,15 @@ static bool TestProduct(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestQuotient(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM b = GetBIGNUM(t, "B");
-  ScopedBIGNUM quotient = GetBIGNUM(t, "Quotient");
-  ScopedBIGNUM remainder = GetBIGNUM(t, "Remainder");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> b = GetBIGNUM(t, "B");
+  bssl::UniquePtr<BIGNUM> quotient = GetBIGNUM(t, "Quotient");
+  bssl::UniquePtr<BIGNUM> remainder = GetBIGNUM(t, "Remainder");
   if (!a || !b || !quotient || !remainder) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new()), ret2(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new()), ret2(BN_new());
   if (!ret || !ret2 ||
       !BN_div(ret.get(), ret2.get(), a.get(), b.get(), ctx) ||
       !ExpectBIGNUMsEqual(t, "A / B", quotient.get(), ret.get()) ||
@@ -457,7 +457,7 @@ static bool TestQuotient(FileTest *t, BN_CTX *ctx) {
 
   // Test BN_nnmod.
   if (!BN_is_negative(b.get())) {
-    ScopedBIGNUM nnmod(BN_new());
+    bssl::UniquePtr<BIGNUM> nnmod(BN_new());
     if (!nnmod ||
         !BN_copy(nnmod.get(), remainder.get()) ||
         (BN_is_negative(nnmod.get()) &&
@@ -473,15 +473,15 @@ static bool TestQuotient(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestModMul(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM b = GetBIGNUM(t, "B");
-  ScopedBIGNUM m = GetBIGNUM(t, "M");
-  ScopedBIGNUM mod_mul = GetBIGNUM(t, "ModMul");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> b = GetBIGNUM(t, "B");
+  bssl::UniquePtr<BIGNUM> m = GetBIGNUM(t, "M");
+  bssl::UniquePtr<BIGNUM> mod_mul = GetBIGNUM(t, "ModMul");
   if (!a || !b || !m || !mod_mul) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new());
   if (!ret ||
       !BN_mod_mul(ret.get(), a.get(), b.get(), m.get(), ctx) ||
       !ExpectBIGNUMsEqual(t, "A * B (mod M)", mod_mul.get(), ret.get())) {
@@ -490,8 +490,8 @@ static bool TestModMul(FileTest *t, BN_CTX *ctx) {
 
   if (BN_is_odd(m.get())) {
     // Reduce |a| and |b| and test the Montgomery version.
-    ScopedBN_MONT_CTX mont(BN_MONT_CTX_new());
-    ScopedBIGNUM a_tmp(BN_new()), b_tmp(BN_new());
+    bssl::UniquePtr<BN_MONT_CTX> mont(BN_MONT_CTX_new());
+    bssl::UniquePtr<BIGNUM> a_tmp(BN_new()), b_tmp(BN_new());
     if (!mont || !a_tmp || !b_tmp ||
         !BN_MONT_CTX_set(mont.get(), m.get(), ctx) ||
         !BN_nnmod(a_tmp.get(), a.get(), m.get(), ctx) ||
@@ -511,15 +511,15 @@ static bool TestModMul(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestModExp(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM e = GetBIGNUM(t, "E");
-  ScopedBIGNUM m = GetBIGNUM(t, "M");
-  ScopedBIGNUM mod_exp = GetBIGNUM(t, "ModExp");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> e = GetBIGNUM(t, "E");
+  bssl::UniquePtr<BIGNUM> m = GetBIGNUM(t, "M");
+  bssl::UniquePtr<BIGNUM> mod_exp = GetBIGNUM(t, "ModExp");
   if (!a || !e || !m || !mod_exp) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new());
   if (!ret ||
       !BN_mod_exp(ret.get(), a.get(), e.get(), m.get(), ctx) ||
       !ExpectBIGNUMsEqual(t, "A ^ E (mod M)", mod_exp.get(), ret.get())) {
@@ -542,14 +542,14 @@ static bool TestModExp(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestExp(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM e = GetBIGNUM(t, "E");
-  ScopedBIGNUM exp = GetBIGNUM(t, "Exp");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> e = GetBIGNUM(t, "E");
+  bssl::UniquePtr<BIGNUM> exp = GetBIGNUM(t, "Exp");
   if (!a || !e || !exp) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new());
   if (!ret ||
       !BN_exp(ret.get(), a.get(), e.get(), ctx) ||
       !ExpectBIGNUMsEqual(t, "A ^ E", exp.get(), ret.get())) {
@@ -560,15 +560,15 @@ static bool TestExp(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestModSqrt(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM p = GetBIGNUM(t, "P");
-  ScopedBIGNUM mod_sqrt = GetBIGNUM(t, "ModSqrt");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> p = GetBIGNUM(t, "P");
+  bssl::UniquePtr<BIGNUM> mod_sqrt = GetBIGNUM(t, "ModSqrt");
   if (!a || !p || !mod_sqrt) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new());
-  ScopedBIGNUM ret2(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new());
+  bssl::UniquePtr<BIGNUM> ret2(BN_new());
   if (!ret ||
       !ret2 ||
       !BN_mod_sqrt(ret.get(), a.get(), p.get(), ctx) ||
@@ -586,14 +586,14 @@ static bool TestModSqrt(FileTest *t, BN_CTX *ctx) {
 }
 
 static bool TestModInv(FileTest *t, BN_CTX *ctx) {
-  ScopedBIGNUM a = GetBIGNUM(t, "A");
-  ScopedBIGNUM m = GetBIGNUM(t, "M");
-  ScopedBIGNUM mod_inv = GetBIGNUM(t, "ModInv");
+  bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A");
+  bssl::UniquePtr<BIGNUM> m = GetBIGNUM(t, "M");
+  bssl::UniquePtr<BIGNUM> mod_inv = GetBIGNUM(t, "ModInv");
   if (!a || !m || !mod_inv) {
     return false;
   }
 
-  ScopedBIGNUM ret(BN_new());
+  bssl::UniquePtr<BIGNUM> ret(BN_new());
   if (!ret ||
       !BN_mod_inverse(ret.get(), a.get(), m.get(), ctx) ||
       !ExpectBIGNUMsEqual(t, "inv(A) (mod M)", mod_inv.get(), ret.get())) {
@@ -650,7 +650,7 @@ static bool TestBN2BinPadded(BN_CTX *ctx) {
   memset(zeros, 0, sizeof(zeros));
 
   // Test edge case at 0.
-  ScopedBIGNUM n(BN_new());
+  bssl::UniquePtr<BIGNUM> n(BN_new());
   if (!n || !BN_bn2bin_padded(NULL, 0, n.get())) {
     fprintf(stderr,
             "BN_bn2bin_padded failed to encode 0 in an empty buffer.\n");
@@ -713,7 +713,7 @@ static bool TestBN2BinPadded(BN_CTX *ctx) {
   return true;
 }
 
-static int DecimalToBIGNUM(ScopedBIGNUM *out, const char *in) {
+static int DecimalToBIGNUM(bssl::UniquePtr<BIGNUM> *out, const char *in) {
   BIGNUM *raw = NULL;
   int ret = BN_dec2bn(&raw, in);
   out->reset(raw);
@@ -721,7 +721,7 @@ static int DecimalToBIGNUM(ScopedBIGNUM *out, const char *in) {
 }
 
 static bool TestDec2BN(BN_CTX *ctx) {
-  ScopedBIGNUM bn;
+  bssl::UniquePtr<BIGNUM> bn;
   int ret = DecimalToBIGNUM(&bn, "0");
   if (ret != 1 || !BN_is_zero(bn.get()) || BN_is_negative(bn.get())) {
     fprintf(stderr, "BN_dec2bn gave a bad result.\n");
@@ -756,7 +756,7 @@ static bool TestDec2BN(BN_CTX *ctx) {
 }
 
 static bool TestHex2BN(BN_CTX *ctx) {
-  ScopedBIGNUM bn;
+  bssl::UniquePtr<BIGNUM> bn;
   int ret = HexToBIGNUM(&bn, "0");
   if (ret != 1 || !BN_is_zero(bn.get()) || BN_is_negative(bn.get())) {
     fprintf(stderr, "BN_hex2bn gave a bad result.\n");
@@ -790,16 +790,16 @@ static bool TestHex2BN(BN_CTX *ctx) {
   return true;
 }
 
-static ScopedBIGNUM ASCIIToBIGNUM(const char *in) {
+static bssl::UniquePtr<BIGNUM> ASCIIToBIGNUM(const char *in) {
   BIGNUM *raw = NULL;
   if (!BN_asc2bn(&raw, in)) {
     return nullptr;
   }
-  return ScopedBIGNUM(raw);
+  return bssl::UniquePtr<BIGNUM>(raw);
 }
 
 static bool TestASC2BN(BN_CTX *ctx) {
-  ScopedBIGNUM bn = ASCIIToBIGNUM("0");
+  bssl::UniquePtr<BIGNUM> bn = ASCIIToBIGNUM("0");
   if (!bn || !BN_is_zero(bn.get()) || BN_is_negative(bn.get())) {
     fprintf(stderr, "BN_asc2bn gave a bad result.\n");
     return false;
@@ -870,7 +870,7 @@ static bool TestMPI() {
 
   for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kMPITests); i++) {
     const MPITest &test = kMPITests[i];
-    ScopedBIGNUM bn(ASCIIToBIGNUM(test.base10));
+    bssl::UniquePtr<BIGNUM> bn(ASCIIToBIGNUM(test.base10));
     const size_t mpi_len = BN_bn2mpi(bn.get(), NULL);
     if (mpi_len > sizeof(scratch)) {
       fprintf(stderr, "MPI test #%u: MPI size is too large to test.\n",
@@ -892,7 +892,7 @@ static bool TestMPI() {
       return false;
     }
 
-    ScopedBIGNUM bn2(BN_mpi2bn(scratch, mpi_len, NULL));
+    bssl::UniquePtr<BIGNUM> bn2(BN_mpi2bn(scratch, mpi_len, NULL));
     if (bn2.get() == nullptr) {
       fprintf(stderr, "MPI test #%u: failed to parse\n", (unsigned)i);
       return false;
@@ -908,7 +908,7 @@ static bool TestMPI() {
 }
 
 static bool TestRand() {
-  ScopedBIGNUM bn(BN_new());
+  bssl::UniquePtr<BIGNUM> bn(BN_new());
   if (!bn) {
     return false;
   }
@@ -993,13 +993,13 @@ static const ASN1Test kASN1BuggyTests[] = {
 
 static bool TestASN1() {
   for (const ASN1Test &test : kASN1Tests) {
-    ScopedBIGNUM bn = ASCIIToBIGNUM(test.value_ascii);
+    bssl::UniquePtr<BIGNUM> bn = ASCIIToBIGNUM(test.value_ascii);
     if (!bn) {
       return false;
     }
 
     // Test that the input is correctly parsed.
-    ScopedBIGNUM bn2(BN_new());
+    bssl::UniquePtr<BIGNUM> bn2(BN_new());
     if (!bn2) {
       return false;
     }
@@ -1025,7 +1025,7 @@ static bool TestASN1() {
       CBB_cleanup(&cbb);
       return false;
     }
-    ScopedOpenSSLBytes delete_der(der);
+    bssl::UniquePtr<uint8_t> delete_der(der);
     if (der_len != test.der_len ||
         memcmp(der, reinterpret_cast<const uint8_t*>(test.der), der_len) != 0) {
       fprintf(stderr, "Bad serialization.\n");
@@ -1045,7 +1045,7 @@ static bool TestASN1() {
   }
 
   for (const ASN1InvalidTest &test : kASN1InvalidTests) {
-    ScopedBIGNUM bn(BN_new());
+    bssl::UniquePtr<BIGNUM> bn(BN_new());
     if (!bn) {
       return false;
     }
@@ -1069,7 +1069,7 @@ static bool TestASN1() {
 
   for (const ASN1Test &test : kASN1BuggyTests) {
     // These broken encodings are rejected by |BN_parse_asn1_unsigned|.
-    ScopedBIGNUM bn(BN_new());
+    bssl::UniquePtr<BIGNUM> bn(BN_new());
     if (!bn) {
       return false;
     }
@@ -1083,7 +1083,7 @@ static bool TestASN1() {
     ERR_clear_error();
 
     // However |BN_parse_asn1_unsigned_buggy| accepts them.
-    ScopedBIGNUM bn2 = ASCIIToBIGNUM(test.value_ascii);
+    bssl::UniquePtr<BIGNUM> bn2 = ASCIIToBIGNUM(test.value_ascii);
     if (!bn2) {
       return false;
     }
@@ -1101,7 +1101,7 @@ static bool TestASN1() {
   }
 
   // Serializing negative numbers is not supported.
-  ScopedBIGNUM bn = ASCIIToBIGNUM("-1");
+  bssl::UniquePtr<BIGNUM> bn = ASCIIToBIGNUM("-1");
   if (!bn) {
     return false;
   }
@@ -1120,9 +1120,9 @@ static bool TestASN1() {
 }
 
 static bool TestNegativeZero(BN_CTX *ctx) {
-  ScopedBIGNUM a(BN_new());
-  ScopedBIGNUM b(BN_new());
-  ScopedBIGNUM c(BN_new());
+  bssl::UniquePtr<BIGNUM> a(BN_new());
+  bssl::UniquePtr<BIGNUM> b(BN_new());
+  bssl::UniquePtr<BIGNUM> c(BN_new());
   if (!a || !b || !c) {
     return false;
   }
@@ -1142,7 +1142,7 @@ static bool TestNegativeZero(BN_CTX *ctx) {
   }
 
   for (int consttime = 0; consttime < 2; consttime++) {
-    ScopedBIGNUM numerator(BN_new()), denominator(BN_new());
+    bssl::UniquePtr<BIGNUM> numerator(BN_new()), denominator(BN_new());
     if (!numerator || !denominator) {
       return false;
     }
@@ -1190,8 +1190,8 @@ static bool TestNegativeZero(BN_CTX *ctx) {
   // Test that forcibly creating a negative zero does not break |BN_bn2hex| or
   // |BN_bn2dec|.
   a->neg = 1;
-  ScopedOpenSSLString dec(BN_bn2dec(a.get()));
-  ScopedOpenSSLString hex(BN_bn2hex(a.get()));
+  bssl::UniquePtr<char> dec(BN_bn2dec(a.get()));
+  bssl::UniquePtr<char> hex(BN_bn2hex(a.get()));
   if (!dec || !hex ||
       strcmp(dec.get(), "-0") != 0 ||
       strcmp(hex.get(), "-0") != 0) {
@@ -1203,10 +1203,10 @@ static bool TestNegativeZero(BN_CTX *ctx) {
 }
 
 static bool TestBadModulus(BN_CTX *ctx) {
-  ScopedBIGNUM a(BN_new());
-  ScopedBIGNUM b(BN_new());
-  ScopedBIGNUM zero(BN_new());
-  ScopedBN_MONT_CTX mont(BN_MONT_CTX_new());
+  bssl::UniquePtr<BIGNUM> a(BN_new());
+  bssl::UniquePtr<BIGNUM> b(BN_new());
+  bssl::UniquePtr<BIGNUM> zero(BN_new());
+  bssl::UniquePtr<BN_MONT_CTX> mont(BN_MONT_CTX_new());
   if (!a || !b || !zero || !mont) {
     return false;
   }
@@ -1290,7 +1290,7 @@ static bool TestBadModulus(BN_CTX *ctx) {
 
 // TestExpModZero tests that 1**0 mod 1 == 0.
 static bool TestExpModZero() {
-  ScopedBIGNUM zero(BN_new()), a(BN_new()), r(BN_new());
+  bssl::UniquePtr<BIGNUM> zero(BN_new()), a(BN_new()), r(BN_new());
   if (!zero || !a || !r ||
       !BN_rand(a.get(), 1024, BN_RAND_TOP_ONE, BN_RAND_BOTTOM_ANY)) {
     return false;
@@ -1317,7 +1317,7 @@ static bool TestExpModZero() {
 static bool TestSmallPrime(BN_CTX *ctx) {
   static const unsigned kBits = 10;
 
-  ScopedBIGNUM r(BN_new());
+  bssl::UniquePtr<BIGNUM> r(BN_new());
   if (!r || !BN_generate_prime_ex(r.get(), static_cast<int>(kBits), 0, NULL,
                                   NULL, NULL)) {
     return false;
@@ -1334,7 +1334,7 @@ static bool TestSmallPrime(BN_CTX *ctx) {
 static bool TestCmpWord() {
   static const BN_ULONG kMaxWord = (BN_ULONG)-1;
 
-  ScopedBIGNUM r(BN_new());
+  bssl::UniquePtr<BIGNUM> r(BN_new());
   if (!r ||
       !BN_set_word(r.get(), 0)) {
     return false;
@@ -1416,13 +1416,13 @@ static bool TestBN2Dec() {
   };
 
   for (const char *test : kBN2DecTests) {
-    ScopedBIGNUM bn;
+    bssl::UniquePtr<BIGNUM> bn;
     int ret = DecimalToBIGNUM(&bn, test);
     if (ret == 0) {
       return false;
     }
 
-    ScopedOpenSSLString dec(BN_bn2dec(bn.get()));
+    bssl::UniquePtr<char> dec(BN_bn2dec(bn.get()));
     if (!dec) {
       fprintf(stderr, "BN_bn2dec failed on %s.\n", test);
       return false;
@@ -1445,7 +1445,7 @@ int main(int argc, char *argv[]) {
     return 1;
   }
 
-  ScopedBN_CTX ctx(BN_CTX_new());
+  bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new());
   if (!ctx) {
     return 1;
   }
diff --git a/crypto/bytestring/bytestring_test.cc b/crypto/bytestring/bytestring_test.cc
index f567fd0c..45a2335a 100644
--- a/crypto/bytestring/bytestring_test.cc
+++ b/crypto/bytestring/bytestring_test.cc
@@ -27,7 +27,6 @@
 
 #include "internal.h"
 #include "../internal.h"
-#include "../test/scoped_types.h"
 
 namespace bssl {
 
@@ -294,7 +293,7 @@ static bool TestCBBBasic() {
     return false;
   }
 
-  ScopedOpenSSLBytes scoper(buf);
+  bssl::UniquePtr<uint8_t> scoper(buf);
   return buf_len == sizeof(kExpected) && memcmp(buf, kExpected, buf_len) == 0;
 }
 
@@ -345,7 +344,7 @@ static bool TestCBBFinishChild() {
     CBB_cleanup(&cbb);
     return false;
   }
-  ScopedOpenSSLBytes scoper(out_buf);
+  bssl::UniquePtr<uint8_t> scoper(out_buf);
   return out_size == 1 && out_buf[0] == 0;
 }
 
@@ -378,7 +377,7 @@ static bool TestCBBPrefixed() {
     return false;
   }
 
-  ScopedOpenSSLBytes scoper(buf);
+  bssl::UniquePtr<uint8_t> scoper(buf);
   return buf_len == sizeof(kExpected) && memcmp(buf, kExpected, buf_len) == 0;
 }
 
@@ -418,7 +417,7 @@ static bool TestCBBDiscardChild() {
   if (!CBB_finish(cbb.get(), &buf, &buf_len)) {
     return false;
   }
-  ScopedOpenSSLBytes scoper(buf);
+  bssl::UniquePtr<uint8_t> scoper(buf);
 
   static const uint8_t kExpected[] = {
         0xaa,
@@ -464,7 +463,7 @@ static bool TestCBBMisuse() {
     CBB_cleanup(&cbb);
     return false;
   }
-  ScopedOpenSSLBytes scoper(buf);
+  bssl::UniquePtr<uint8_t> scoper(buf);
 
   if (buf_len != 3 ||
       memcmp(buf, "\x01\x01\x02", 3) != 0) {
@@ -488,7 +487,7 @@ static bool TestCBBASN1() {
     CBB_cleanup(&cbb);
     return false;
   }
-  ScopedOpenSSLBytes scoper(buf);
+  bssl::UniquePtr<uint8_t> scoper(buf);
 
   if (buf_len != sizeof(kExpected) || memcmp(buf, kExpected, buf_len) != 0) {
     return false;
@@ -563,7 +562,7 @@ static bool DoBerConvert(const char *name,
     fprintf(stderr, "%s: CBS_asn1_ber_to_der failed.\n", name);
     return false;
   }
-  ScopedOpenSSLBytes scoper(out);
+  bssl::UniquePtr<uint8_t> scoper(out);
 
   if (out == NULL) {
     if (ber_len != der_len ||
@@ -676,7 +675,7 @@ static bool TestImplicitString() {
     int ok = CBS_get_asn1_implicit_string(&in, &out, &storage,
                                           CBS_ASN1_CONTEXT_SPECIFIC | 0,
                                           CBS_ASN1_OCTETSTRING);
-    ScopedOpenSSLBytes scoper(storage);
+    bssl::UniquePtr<uint8_t> scoper(storage);
 
     if (static_cast<bool>(ok) != test.ok) {
       fprintf(stderr, "CBS_get_asn1_implicit_string unexpectedly %s\n",
@@ -754,7 +753,7 @@ static bool TestASN1Uint64() {
       CBB_cleanup(&cbb);
       return false;
     }
-    ScopedOpenSSLBytes scoper(out);
+    bssl::UniquePtr<uint8_t> scoper(out);
     if (len != test->encoding_len || memcmp(out, test->encoding, len) != 0) {
       return false;
     }
diff --git a/crypto/cmac/cmac_test.cc b/crypto/cmac/cmac_test.cc
index 2496f2a9..7cb1df50 100644
--- a/crypto/cmac/cmac_test.cc
+++ b/crypto/cmac/cmac_test.cc
@@ -16,9 +16,10 @@
 
 #include <algorithm>
 
+#include <openssl/cipher.h>
 #include <openssl/cmac.h>
+#include <openssl/mem.h>
 
-#include "../test/scoped_types.h"
 #include "../test/test_util.h"
 
 
@@ -43,7 +44,7 @@ static int test(const char *name, const uint8_t *key, size_t key_len,
     return 0;
   }
 
-  ScopedCMAC_CTX ctx(CMAC_CTX_new());
+  bssl::UniquePtr<CMAC_CTX> ctx(CMAC_CTX_new());
   if (!ctx || !CMAC_Init(ctx.get(), key, key_len, EVP_aes_128_cbc(), NULL)) {
     fprintf(stderr, "%s: CMAC_Init failed.\n", name);
     return 0;
diff --git a/crypto/curve25519/spake25519_test.cc b/crypto/curve25519/spake25519_test.cc
index d97a8602..363b60ca 100644
--- a/crypto/curve25519/spake25519_test.cc
+++ b/crypto/curve25519/spake25519_test.cc
@@ -19,18 +19,17 @@
 #include <string.h>
 
 #include <openssl/curve25519.h>
-#include "../test/scoped_types.h"
 
 
 struct SPAKE2Run {
   bool Run() {
-    ScopedSPAKE2_CTX alice(SPAKE2_CTX_new(
+    bssl::UniquePtr<SPAKE2_CTX> alice(SPAKE2_CTX_new(
         spake2_role_alice,
         reinterpret_cast<const uint8_t *>(alice_names.first.data()),
         alice_names.first.size(),
         reinterpret_cast<const uint8_t *>(alice_names.second.data()),
         alice_names.second.size()));
-    ScopedSPAKE2_CTX bob(SPAKE2_CTX_new(
+    bssl::UniquePtr<SPAKE2_CTX> bob(SPAKE2_CTX_new(
         spake2_role_bob,
         reinterpret_cast<const uint8_t *>(bob_names.first.data()),
         bob_names.first.size(),
diff --git a/crypto/dh/dh_test.cc b/crypto/dh/dh_test.cc
index b8bfe46e..12984e64 100644
--- a/crypto/dh/dh_test.cc
+++ b/crypto/dh/dh_test.cc
@@ -64,11 +64,10 @@
 #include <openssl/bn.h>
 #include <openssl/c++/bytestring.h>
 #include <openssl/crypto.h>
+#include <openssl/dh.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "../test/scoped_types.h"
-
 namespace bssl {
 
 static bool RunBasicTests();
@@ -115,7 +114,7 @@ static int GenerateCallback(int p, int n, BN_GENCB *arg) {
 static bool RunBasicTests() {
   BN_GENCB cb;
   BN_GENCB_set(&cb, &GenerateCallback, stdout);
-  ScopedDH a(DH_new());
+  bssl::UniquePtr<DH> a(DH_new());
   if (!a || !DH_generate_parameters_ex(a.get(), 64, DH_GENERATOR_5, &cb)) {
     return false;
   }
@@ -143,7 +142,7 @@ static bool RunBasicTests() {
   BN_print_fp(stdout, a->g);
   printf("\n");
 
-  ScopedDH b(DH_new());
+  bssl::UniquePtr<DH> b(DH_new());
   if (!b) {
     return false;
   }
@@ -437,8 +436,8 @@ static bool RunRFC5114Tests() {
   for (unsigned i = 0; i < sizeof(kRFCTestData) / sizeof(RFC5114TestData); i++) {
     const RFC5114TestData *td = kRFCTestData + i;
     /* Set up DH structures setting key components */
-    ScopedDH dhA(td->get_param(nullptr));
-    ScopedDH dhB(td->get_param(nullptr));
+    bssl::UniquePtr<DH> dhA(td->get_param(nullptr));
+    bssl::UniquePtr<DH> dhB(td->get_param(nullptr));
     if (!dhA || !dhB) {
       fprintf(stderr, "Initialisation error RFC5114 set %u\n", i + 1);
       return false;
@@ -513,8 +512,8 @@ static const uint8_t kRFC5114_2048_224BadY[] = {
 };
 
 static bool TestBadY() {
-  ScopedDH dh(DH_get_2048_224(nullptr));
-  ScopedBIGNUM pub_key(
+  bssl::UniquePtr<DH> dh(DH_get_2048_224(nullptr));
+  bssl::UniquePtr<BIGNUM> pub_key(
       BN_bin2bn(kRFC5114_2048_224BadY, sizeof(kRFC5114_2048_224BadY), nullptr));
   if (!dh || !pub_key || !DH_generate_key(dh.get())) {
     return false;
@@ -544,7 +543,7 @@ static bool BIGNUMEqualsHex(const BIGNUM *bn, const char *hex) {
   if (!BN_hex2bn(&hex_bn, hex)) {
     return false;
   }
-  ScopedBIGNUM free_hex_bn(hex_bn);
+  bssl::UniquePtr<BIGNUM> free_hex_bn(hex_bn);
   return BN_cmp(bn, hex_bn) == 0;
 }
 
@@ -560,7 +559,7 @@ static bool TestASN1() {
 
   CBS cbs;
   CBS_init(&cbs, kParams, sizeof(kParams));
-  ScopedDH dh(DH_parse_parameters(&cbs));
+  bssl::UniquePtr<DH> dh(DH_parse_parameters(&cbs));
   if (!dh || CBS_len(&cbs) != 0 ||
       !BIGNUMEqualsHex(
           dh->p,
@@ -577,7 +576,7 @@ static bool TestASN1() {
       !CBB_finish(cbb.get(), &der, &der_len)) {
     return false;
   }
-  ScopedOpenSSLBytes free_der(der);
+  bssl::UniquePtr<uint8_t> free_der(der);
   if (der_len != sizeof(kParams) || memcmp(der, kParams, der_len) != 0) {
     return false;
   }
@@ -619,7 +618,7 @@ static bool TestASN1() {
       !CBB_finish(cbb.get(), &der, &der_len)) {
     return false;
   }
-  ScopedOpenSSLBytes free_der2(der);
+  bssl::UniquePtr<uint8_t> free_der2(der);
   if (der_len != sizeof(kParamsDSA) || memcmp(der, kParamsDSA, der_len) != 0) {
     return false;
   }
@@ -628,7 +627,7 @@ static bool TestASN1() {
 }
 
 static bool TestRFC3526() {
-  ScopedBIGNUM bn(BN_get_rfc3526_prime_1536(nullptr));
+  bssl::UniquePtr<BIGNUM> bn(BN_get_rfc3526_prime_1536(nullptr));
   if (!bn) {
     return false;
   }
diff --git a/crypto/ec/ec_test.cc b/crypto/ec/ec_test.cc
index ca0e1401..9648d57d 100644
--- a/crypto/ec/ec_test.cc
+++ b/crypto/ec/ec_test.cc
@@ -18,12 +18,13 @@
 #include <vector>
 
 #include <openssl/c++/bytestring.h>
+#include <openssl/bn.h>
 #include <openssl/crypto.h>
 #include <openssl/ec_key.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>
+#include <openssl/nid.h>
 
-#include "../test/scoped_types.h"
 
 namespace bssl {
 
@@ -97,10 +98,11 @@ static const uint8_t kECKeyWithZeros[] = {
 
 // DecodeECPrivateKey decodes |in| as an ECPrivateKey structure and returns the
 // result or nullptr on error.
-static ScopedEC_KEY DecodeECPrivateKey(const uint8_t *in, size_t in_len) {
+static bssl::UniquePtr<EC_KEY> DecodeECPrivateKey(const uint8_t *in,
+                                                  size_t in_len) {
   CBS cbs;
   CBS_init(&cbs, in, in_len);
-  ScopedEC_KEY ret(EC_KEY_parse_private_key(&cbs, NULL));
+  bssl::UniquePtr<EC_KEY> ret(EC_KEY_parse_private_key(&cbs, NULL));
   if (!ret || CBS_len(&cbs) != 0) {
     return nullptr;
   }
@@ -124,7 +126,7 @@ static bool EncodeECPrivateKey(std::vector<uint8_t> *out, const EC_KEY *key) {
 }
 
 static bool Testd2i_ECPrivateKey() {
-  ScopedEC_KEY key = DecodeECPrivateKey(kECKeyWithoutPublic,
+  bssl::UniquePtr<EC_KEY> key = DecodeECPrivateKey(kECKeyWithoutPublic,
                                         sizeof(kECKeyWithoutPublic));
   if (!key) {
     fprintf(stderr, "Failed to parse private key.\n");
@@ -152,8 +154,8 @@ static bool Testd2i_ECPrivateKey() {
     return false;
   }
 
-  ScopedBIGNUM x(BN_new());
-  ScopedBIGNUM y(BN_new());
+  bssl::UniquePtr<BIGNUM> x(BN_new());
+  bssl::UniquePtr<BIGNUM> y(BN_new());
   if (!x || !y) {
     return false;
   }
@@ -162,8 +164,8 @@ static bool Testd2i_ECPrivateKey() {
     fprintf(stderr, "Failed to get public key in affine coordinates.\n");
     return false;
   }
-  ScopedOpenSSLString x_hex(BN_bn2hex(x.get()));
-  ScopedOpenSSLString y_hex(BN_bn2hex(y.get()));
+  bssl::UniquePtr<char> x_hex(BN_bn2hex(x.get()));
+  bssl::UniquePtr<char> y_hex(BN_bn2hex(y.get()));
   if (!x_hex || !y_hex) {
     return false;
   }
@@ -182,7 +184,7 @@ static bool Testd2i_ECPrivateKey() {
 
 static bool TestZeroPadding() {
   // Check that the correct encoding round-trips.
-  ScopedEC_KEY key = DecodeECPrivateKey(kECKeyWithZeros,
+  bssl::UniquePtr<EC_KEY> key = DecodeECPrivateKey(kECKeyWithZeros,
                                         sizeof(kECKeyWithZeros));
   std::vector<uint8_t> out;
   if (!key || !EncodeECPrivateKey(&out, key.get())) {
@@ -214,7 +216,7 @@ static bool TestZeroPadding() {
 
 static bool TestSpecifiedCurve() {
   // Test keys with specified curves may be decoded.
-  ScopedEC_KEY key =
+  bssl::UniquePtr<EC_KEY> key =
       DecodeECPrivateKey(kECKeySpecifiedCurve, sizeof(kECKeySpecifiedCurve));
   if (!key) {
     ERR_print_errors_fp(stderr);
@@ -245,7 +247,7 @@ static bool TestSpecifiedCurve() {
 }
 
 static bool TestSetAffine(const int nid) {
-  ScopedEC_KEY key(EC_KEY_new_by_curve_name(nid));
+  bssl::UniquePtr<EC_KEY> key(EC_KEY_new_by_curve_name(nid));
   if (!key) {
     return false;
   }
@@ -265,8 +267,8 @@ static bool TestSetAffine(const int nid) {
     return false;
   }
 
-  ScopedBIGNUM x(BN_new());
-  ScopedBIGNUM y(BN_new());
+  bssl::UniquePtr<BIGNUM> x(BN_new());
+  bssl::UniquePtr<BIGNUM> y(BN_new());
   if (!EC_POINT_get_affine_coordinates_GFp(group,
                                            EC_KEY_get0_public_key(key.get()),
                                            x.get(), y.get(), nullptr)) {
@@ -276,7 +278,7 @@ static bool TestSetAffine(const int nid) {
     return false;
   }
 
-  ScopedEC_POINT point(EC_POINT_new(group));
+  auto point = bssl::UniquePtr<EC_POINT>(EC_POINT_new(group));
   if (!point) {
     return false;
   }
@@ -294,7 +296,7 @@ static bool TestSetAffine(const int nid) {
     return false;
   }
 
-  ScopedEC_POINT invalid_point(EC_POINT_new(group));
+  bssl::UniquePtr<EC_POINT> invalid_point(EC_POINT_new(group));
   if (!invalid_point) {
     return false;
   }
@@ -314,7 +316,7 @@ static bool TestSetAffine(const int nid) {
 
 static bool TestArbitraryCurve() {
   // Make a P-256 key and extract the affine coordinates.
-  ScopedEC_KEY key(EC_KEY_new_by_curve_name(NID_X9_62_prime256v1));
+  bssl::UniquePtr<EC_KEY> key(EC_KEY_new_by_curve_name(NID_X9_62_prime256v1));
   if (!key || !EC_KEY_generate_key(key.get())) {
     return false;
   }
@@ -350,25 +352,25 @@ static bool TestArbitraryCurve() {
       0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0xe6, 0xfa, 0xad, 0xa7, 0x17,
       0x9e, 0x84, 0xf3, 0xb9, 0xca, 0xc2, 0xfc, 0x63, 0x25, 0x51,
   };
-  ScopedBN_CTX ctx(BN_CTX_new());
-  ScopedBIGNUM p(BN_bin2bn(kP, sizeof(kP), nullptr));
-  ScopedBIGNUM a(BN_bin2bn(kA, sizeof(kA), nullptr));
-  ScopedBIGNUM b(BN_bin2bn(kB, sizeof(kB), nullptr));
-  ScopedBIGNUM gx(BN_bin2bn(kX, sizeof(kX), nullptr));
-  ScopedBIGNUM gy(BN_bin2bn(kY, sizeof(kY), nullptr));
-  ScopedBIGNUM order(BN_bin2bn(kOrder, sizeof(kOrder), nullptr));
-  ScopedBIGNUM cofactor(BN_new());
+  bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new());
+  bssl::UniquePtr<BIGNUM> p(BN_bin2bn(kP, sizeof(kP), nullptr));
+  bssl::UniquePtr<BIGNUM> a(BN_bin2bn(kA, sizeof(kA), nullptr));
+  bssl::UniquePtr<BIGNUM> b(BN_bin2bn(kB, sizeof(kB), nullptr));
+  bssl::UniquePtr<BIGNUM> gx(BN_bin2bn(kX, sizeof(kX), nullptr));
+  bssl::UniquePtr<BIGNUM> gy(BN_bin2bn(kY, sizeof(kY), nullptr));
+  bssl::UniquePtr<BIGNUM> order(BN_bin2bn(kOrder, sizeof(kOrder), nullptr));
+  bssl::UniquePtr<BIGNUM> cofactor(BN_new());
   if (!ctx || !p || !a || !b || !gx || !gy || !order || !cofactor ||
       !BN_set_word(cofactor.get(), 1)) {
     return false;
   }
 
-  ScopedEC_GROUP group(
+  bssl::UniquePtr<EC_GROUP> group(
       EC_GROUP_new_curve_GFp(p.get(), a.get(), b.get(), ctx.get()));
   if (!group) {
     return false;
   }
-  ScopedEC_POINT generator(EC_POINT_new(group.get()));
+  bssl::UniquePtr<EC_POINT> generator(EC_POINT_new(group.get()));
   if (!generator ||
       !EC_POINT_set_affine_coordinates_GFp(group.get(), generator.get(),
                                            gx.get(), gy.get(), ctx.get()) ||
@@ -383,9 +385,9 @@ static bool TestArbitraryCurve() {
   }
 
   // Copy |key| to |key2| using |group|.
-  ScopedEC_KEY key2(EC_KEY_new());
-  ScopedEC_POINT point(EC_POINT_new(group.get()));
-  ScopedBIGNUM x(BN_new()), y(BN_new());
+  bssl::UniquePtr<EC_KEY> key2(EC_KEY_new());
+  bssl::UniquePtr<EC_POINT> point(EC_POINT_new(group.get()));
+  bssl::UniquePtr<BIGNUM> x(BN_new()), y(BN_new());
   if (!key2 || !point || !x || !y ||
       !EC_KEY_set_group(key2.get(), group.get()) ||
       !EC_KEY_set_private_key(key2.get(), EC_KEY_get0_private_key(key.get())) ||
@@ -409,7 +411,7 @@ static bool TestArbitraryCurve() {
 }
 
 static bool TestAddingEqualPoints(int nid) {
-  ScopedEC_KEY key(EC_KEY_new_by_curve_name(nid));
+  bssl::UniquePtr<EC_KEY> key(EC_KEY_new_by_curve_name(nid));
   if (!key) {
     return false;
   }
@@ -422,10 +424,10 @@ static bool TestAddingEqualPoints(int nid) {
     return false;
   }
 
-  ScopedEC_POINT p1(EC_POINT_new(group));
-  ScopedEC_POINT p2(EC_POINT_new(group));
-  ScopedEC_POINT double_p1(EC_POINT_new(group));
-  ScopedEC_POINT p1_plus_p2(EC_POINT_new(group));
+  bssl::UniquePtr<EC_POINT> p1(EC_POINT_new(group));
+  bssl::UniquePtr<EC_POINT> p2(EC_POINT_new(group));
+  bssl::UniquePtr<EC_POINT> double_p1(EC_POINT_new(group));
+  bssl::UniquePtr<EC_POINT> p1_plus_p2(EC_POINT_new(group));
   if (!p1 || !p2 || !double_p1 || !p1_plus_p2) {
     return false;
   }
@@ -437,7 +439,7 @@ static bool TestAddingEqualPoints(int nid) {
     return false;
   }
 
-  ScopedBN_CTX ctx(BN_CTX_new());
+  bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new());
   if (!ctx) {
     return false;
   }
diff --git a/crypto/ecdh/ecdh_test.cc b/crypto/ecdh/ecdh_test.cc
index 95f14023..a02fd22f 100644
--- a/crypto/ecdh/ecdh_test.cc
+++ b/crypto/ecdh/ecdh_test.cc
@@ -21,59 +21,60 @@
 #include <openssl/ec.h>
 #include <openssl/ec_key.h>
 #include <openssl/ecdh.h>
+#include <openssl/nid.h>
 
 #include "../test/file_test.h"
-#include "../test/scoped_types.h"
 
 
-static ScopedEC_GROUP GetCurve(FileTest *t, const char *key) {
+static bssl::UniquePtr<EC_GROUP> GetCurve(FileTest *t, const char *key) {
   std::string curve_name;
   if (!t->GetAttribute(&curve_name, key)) {
     return nullptr;
   }
 
   if (curve_name == "P-224") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp224r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp224r1));
   }
   if (curve_name == "P-256") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(
+        NID_X9_62_prime256v1));
   }
   if (curve_name == "P-384") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp384r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp384r1));
   }
   if (curve_name == "P-521") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp521r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp521r1));
   }
 
   t->PrintLine("Unknown curve '%s'", curve_name.c_str());
   return nullptr;
 }
 
-static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *key) {
+static bssl::UniquePtr<BIGNUM> GetBIGNUM(FileTest *t, const char *key) {
   std::vector<uint8_t> bytes;
   if (!t->GetBytes(&bytes, key)) {
     return nullptr;
   }
 
-  return ScopedBIGNUM(BN_bin2bn(bytes.data(), bytes.size(), nullptr));
+  return bssl::UniquePtr<BIGNUM>(BN_bin2bn(bytes.data(), bytes.size(), nullptr));
 }
 
 static bool TestECDH(FileTest *t, void *arg) {
-  ScopedEC_GROUP group = GetCurve(t, "Curve");
-  ScopedBIGNUM priv_key = GetBIGNUM(t, "Private");
-  ScopedBIGNUM x = GetBIGNUM(t, "X");
-  ScopedBIGNUM y = GetBIGNUM(t, "Y");
-  ScopedBIGNUM peer_x = GetBIGNUM(t, "PeerX");
-  ScopedBIGNUM peer_y = GetBIGNUM(t, "PeerY");
+  bssl::UniquePtr<EC_GROUP> group = GetCurve(t, "Curve");
+  bssl::UniquePtr<BIGNUM> priv_key = GetBIGNUM(t, "Private");
+  bssl::UniquePtr<BIGNUM> x = GetBIGNUM(t, "X");
+  bssl::UniquePtr<BIGNUM> y = GetBIGNUM(t, "Y");
+  bssl::UniquePtr<BIGNUM> peer_x = GetBIGNUM(t, "PeerX");
+  bssl::UniquePtr<BIGNUM> peer_y = GetBIGNUM(t, "PeerY");
   std::vector<uint8_t> z;
   if (!group || !priv_key || !x || !y || !peer_x || !peer_y ||
       !t->GetBytes(&z, "Z")) {
     return false;
   }
 
-  ScopedEC_KEY key(EC_KEY_new());
-  ScopedEC_POINT pub_key(EC_POINT_new(group.get()));
-  ScopedEC_POINT peer_pub_key(EC_POINT_new(group.get()));
+  bssl::UniquePtr<EC_KEY> key(EC_KEY_new());
+  bssl::UniquePtr<EC_POINT> pub_key(EC_POINT_new(group.get()));
+  bssl::UniquePtr<EC_POINT> peer_pub_key(EC_POINT_new(group.get()));
   if (!key || !pub_key || !peer_pub_key ||
       !EC_KEY_set_group(key.get(), group.get()) ||
       !EC_KEY_set_private_key(key.get(), priv_key.get()) ||
diff --git a/crypto/ecdsa/ecdsa_sign_test.cc b/crypto/ecdsa/ecdsa_sign_test.cc
index 683f0f05..ee95773c 100644
--- a/crypto/ecdsa/ecdsa_sign_test.cc
+++ b/crypto/ecdsa/ecdsa_sign_test.cc
@@ -21,59 +21,60 @@
 #include <openssl/ec.h>
 #include <openssl/ec_key.h>
 #include <openssl/ecdsa.h>
+#include <openssl/nid.h>
 
 #include "../test/file_test.h"
-#include "../test/scoped_types.h"
 
 
-static ScopedEC_GROUP GetCurve(FileTest *t, const char *key) {
+static bssl::UniquePtr<EC_GROUP> GetCurve(FileTest *t, const char *key) {
   std::string curve_name;
   if (!t->GetAttribute(&curve_name, key)) {
     return nullptr;
   }
 
   if (curve_name == "P-224") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp224r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp224r1));
   }
   if (curve_name == "P-256") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
+    return bssl::UniquePtr<EC_GROUP>(
+        EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
   }
   if (curve_name == "P-384") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp384r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp384r1));
   }
   if (curve_name == "P-521") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp521r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp521r1));
   }
 
   t->PrintLine("Unknown curve '%s'", curve_name.c_str());
   return nullptr;
 }
 
-static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *key) {
+static bssl::UniquePtr<BIGNUM> GetBIGNUM(FileTest *t, const char *key) {
   std::vector<uint8_t> bytes;
   if (!t->GetBytes(&bytes, key)) {
     return nullptr;
   }
 
-  return ScopedBIGNUM(BN_bin2bn(bytes.data(), bytes.size(), nullptr));
+  return bssl::UniquePtr<BIGNUM>(BN_bin2bn(bytes.data(), bytes.size(), nullptr));
 }
 
 static bool TestECDSASign(FileTest *t, void *arg) {
-  ScopedEC_GROUP group = GetCurve(t, "Curve");
-  ScopedBIGNUM priv_key = GetBIGNUM(t, "Private");
-  ScopedBIGNUM x = GetBIGNUM(t, "X");
-  ScopedBIGNUM y = GetBIGNUM(t, "Y");
-  ScopedBIGNUM k = GetBIGNUM(t, "K");
-  ScopedBIGNUM r = GetBIGNUM(t, "R");
-  ScopedBIGNUM s = GetBIGNUM(t, "S");
+  bssl::UniquePtr<EC_GROUP> group = GetCurve(t, "Curve");
+  bssl::UniquePtr<BIGNUM> priv_key = GetBIGNUM(t, "Private");
+  bssl::UniquePtr<BIGNUM> x = GetBIGNUM(t, "X");
+  bssl::UniquePtr<BIGNUM> y = GetBIGNUM(t, "Y");
+  bssl::UniquePtr<BIGNUM> k = GetBIGNUM(t, "K");
+  bssl::UniquePtr<BIGNUM> r = GetBIGNUM(t, "R");
+  bssl::UniquePtr<BIGNUM> s = GetBIGNUM(t, "S");
   std::vector<uint8_t> digest;
   if (!group || !priv_key || !x || !y || !k || !r || !s ||
       !t->GetBytes(&digest, "Digest")) {
     return false;
   }
 
-  ScopedEC_KEY key(EC_KEY_new());
-  ScopedEC_POINT pub_key(EC_POINT_new(group.get()));
+  bssl::UniquePtr<EC_KEY> key(EC_KEY_new());
+  bssl::UniquePtr<EC_POINT> pub_key(EC_POINT_new(group.get()));
   if (!key || !pub_key ||
       !EC_KEY_set_group(key.get(), group.get()) ||
       !EC_KEY_set_private_key(key.get(), priv_key.get()) ||
@@ -85,15 +86,15 @@ static bool TestECDSASign(FileTest *t, void *arg) {
   }
 
   // |ECDSA_do_sign_ex| expects |k| to already be inverted.
-  ScopedBN_CTX ctx(BN_CTX_new());
+  bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new());
   if (!ctx ||
       !BN_mod_inverse(k.get(), k.get(), EC_GROUP_get0_order(group.get()),
                       ctx.get())) {
     return false;
   }
 
-  ScopedECDSA_SIG sig(ECDSA_do_sign_ex(digest.data(), digest.size(), k.get(),
-                                       r.get(), key.get()));
+  bssl::UniquePtr<ECDSA_SIG> sig(ECDSA_do_sign_ex(digest.data(), digest.size(), k.get(),
+                                 r.get(), key.get()));
   if (!sig) {
     return false;
   }
diff --git a/crypto/ecdsa/ecdsa_test.cc b/crypto/ecdsa/ecdsa_test.cc
index 8d7827df..7c68de44 100644
--- a/crypto/ecdsa/ecdsa_test.cc
+++ b/crypto/ecdsa/ecdsa_test.cc
@@ -62,8 +62,6 @@
 #include <openssl/nid.h>
 #include <openssl/rand.h>
 
-#include "../test/scoped_types.h"
-
 enum Api {
   kEncodedApi,
   kRawApi,
@@ -82,7 +80,7 @@ static bool VerifyECDSASig(Api api, const uint8_t *digest,
       if (!ECDSA_SIG_to_bytes(&der, &der_len, ecdsa_sig)) {
         return false;
       }
-      ScopedOpenSSLBytes delete_der(der);
+      bssl::UniquePtr<uint8_t> delete_der(der);
       actual_result = ECDSA_verify(0, digest, digest_len, der, der_len, eckey);
       break;
     }
@@ -171,7 +169,7 @@ static bool TestBuiltin(FILE *out) {
     fprintf(out, "%s: ", kCurves[n].name);
 
     int nid = kCurves[n].nid;
-    ScopedEC_GROUP group(EC_GROUP_new_by_curve_name(nid));
+    bssl::UniquePtr<EC_GROUP> group(EC_GROUP_new_by_curve_name(nid));
     if (!group) {
       fprintf(out, " failed\n");
       return false;
@@ -184,14 +182,14 @@ static bool TestBuiltin(FILE *out) {
     }
 
     // Create a new ECDSA key.
-    ScopedEC_KEY eckey(EC_KEY_new());
+    bssl::UniquePtr<EC_KEY> eckey(EC_KEY_new());
     if (!eckey || !EC_KEY_set_group(eckey.get(), group.get()) ||
         !EC_KEY_generate_key(eckey.get())) {
       fprintf(out, " failed\n");
       return false;
     }
     // Create a second key.
-    ScopedEC_KEY wrong_eckey(EC_KEY_new());
+    bssl::UniquePtr<EC_KEY> wrong_eckey(EC_KEY_new());
     if (!wrong_eckey || !EC_KEY_set_group(wrong_eckey.get(), group.get()) ||
         !EC_KEY_generate_key(wrong_eckey.get())) {
       fprintf(out, " failed\n");
@@ -253,7 +251,7 @@ static bool TestBuiltin(FILE *out) {
     fprintf(out, ".");
     fflush(out);
     // Verify a tampered signature.
-    ScopedECDSA_SIG ecdsa_sig(ECDSA_SIG_from_bytes(
+    bssl::UniquePtr<ECDSA_SIG> ecdsa_sig(ECDSA_SIG_from_bytes(
         signature.data(), signature.size()));
     if (!ecdsa_sig ||
         !TestTamperedSig(out, kEncodedApi, digest, 20, ecdsa_sig.get(),
@@ -313,7 +311,7 @@ static bool TestBuiltin(FILE *out) {
 
 static bool TestECDSA_SIG_max_len(size_t order_len) {
   /* Create the largest possible |ECDSA_SIG| of the given constraints. */
-  ScopedECDSA_SIG sig(ECDSA_SIG_new());
+  bssl::UniquePtr<ECDSA_SIG> sig(ECDSA_SIG_new());
   if (!sig) {
     return false;
   }
@@ -328,7 +326,7 @@ static bool TestECDSA_SIG_max_len(size_t order_len) {
   if (!ECDSA_SIG_to_bytes(&der, &der_len, sig.get())) {
     return false;
   }
-  ScopedOpenSSLBytes delete_der(der);
+  bssl::UniquePtr<uint8_t> delete_der(der);
 
   size_t max_len = ECDSA_SIG_max_len(order_len);
   if (max_len != der_len) {
diff --git a/crypto/ecdsa/ecdsa_verify_test.cc b/crypto/ecdsa/ecdsa_verify_test.cc
index 7ef2d29f..18340e2b 100644
--- a/crypto/ecdsa/ecdsa_verify_test.cc
+++ b/crypto/ecdsa/ecdsa_verify_test.cc
@@ -21,58 +21,59 @@
 #include <openssl/ec.h>
 #include <openssl/ec_key.h>
 #include <openssl/ecdsa.h>
+#include <openssl/nid.h>
 
 #include "../test/file_test.h"
-#include "../test/scoped_types.h"
 
 
-static ScopedEC_GROUP GetCurve(FileTest *t, const char *key) {
+static bssl::UniquePtr<EC_GROUP> GetCurve(FileTest *t, const char *key) {
   std::string curve_name;
   if (!t->GetAttribute(&curve_name, key)) {
     return nullptr;
   }
 
   if (curve_name == "P-224") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp224r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp224r1));
   }
   if (curve_name == "P-256") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
+    return bssl::UniquePtr<EC_GROUP>(
+        EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
   }
   if (curve_name == "P-384") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp384r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp384r1));
   }
   if (curve_name == "P-521") {
-    return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp521r1));
+    return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp521r1));
   }
 
   t->PrintLine("Unknown curve '%s'", curve_name.c_str());
   return nullptr;
 }
 
-static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *key) {
+static bssl::UniquePtr<BIGNUM> GetBIGNUM(FileTest *t, const char *key) {
   std::vector<uint8_t> bytes;
   if (!t->GetBytes(&bytes, key)) {
     return nullptr;
   }
 
-  return ScopedBIGNUM(BN_bin2bn(bytes.data(), bytes.size(), nullptr));
+  return bssl::UniquePtr<BIGNUM>(BN_bin2bn(bytes.data(), bytes.size(), nullptr));
 }
 
 static bool TestECDSASign(FileTest *t, void *arg) {
-  ScopedEC_GROUP group = GetCurve(t, "Curve");
-  ScopedBIGNUM x = GetBIGNUM(t, "X");
-  ScopedBIGNUM y = GetBIGNUM(t, "Y");
-  ScopedBIGNUM r = GetBIGNUM(t, "R");
-  ScopedBIGNUM s = GetBIGNUM(t, "S");
+  bssl::UniquePtr<EC_GROUP> group = GetCurve(t, "Curve");
+  bssl::UniquePtr<BIGNUM> x = GetBIGNUM(t, "X");
+  bssl::UniquePtr<BIGNUM> y = GetBIGNUM(t, "Y");
+  bssl::UniquePtr<BIGNUM> r = GetBIGNUM(t, "R");
+  bssl::UniquePtr<BIGNUM> s = GetBIGNUM(t, "S");
   std::vector<uint8_t> digest;
   if (!group || !x || !y || !r || !s ||
       !t->GetBytes(&digest, "Digest")) {
     return false;
   }
 
-  ScopedEC_KEY key(EC_KEY_new());
-  ScopedEC_POINT pub_key(EC_POINT_new(group.get()));
-  ScopedECDSA_SIG sig(ECDSA_SIG_new());
+  bssl::UniquePtr<EC_KEY> key(EC_KEY_new());
+  bssl::UniquePtr<EC_POINT> pub_key(EC_POINT_new(group.get()));
+  bssl::UniquePtr<ECDSA_SIG> sig(ECDSA_SIG_new());
   if (!key || !pub_key || !sig ||
       !EC_KEY_set_group(key.get(), group.get()) ||
       !EC_POINT_set_affine_coordinates_GFp(group.get(), pub_key.get(), x.get(),
diff --git a/crypto/evp/evp_extra_test.cc b/crypto/evp/evp_extra_test.cc
index b2c519eb..125dc032 100644
--- a/crypto/evp/evp_extra_test.cc
+++ b/crypto/evp/evp_extra_test.cc
@@ -24,10 +24,9 @@
 #include <openssl/c++/digest.h>
 #include <openssl/crypto.h>
 #include <openssl/err.h>
+#include <openssl/pkcs8.h>
 #include <openssl/rsa.h>
 
-#include "../test/scoped_types.h"
-
 namespace bssl {
 
 // kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
@@ -357,13 +356,13 @@ static const uint8_t kInvalidPrivateKey[] = {
     0x48, 0x30, 0x01, 0xaa, 0x02, 0x86, 0xc0, 0x30, 0xdf, 0xe9, 0x80,
 };
 
-static ScopedEVP_PKEY LoadExampleRSAKey() {
-  ScopedRSA rsa(RSA_private_key_from_bytes(kExampleRSAKeyDER,
+static bssl::UniquePtr<EVP_PKEY> LoadExampleRSAKey() {
+  bssl::UniquePtr<RSA> rsa(RSA_private_key_from_bytes(kExampleRSAKeyDER,
                                            sizeof(kExampleRSAKeyDER)));
   if (!rsa) {
     return nullptr;
   }
-  ScopedEVP_PKEY pkey(EVP_PKEY_new());
+  bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_RSA(pkey.get(), rsa.get())) {
     return nullptr;
   }
@@ -371,7 +370,7 @@ static ScopedEVP_PKEY LoadExampleRSAKey() {
 }
 
 static bool TestEVP_DigestSignInit(void) {
-  ScopedEVP_PKEY pkey = LoadExampleRSAKey();
+  bssl::UniquePtr<EVP_PKEY> pkey = LoadExampleRSAKey();
   ScopedEVP_MD_CTX md_ctx;
   if (!pkey ||
       !EVP_DigestSignInit(md_ctx.get(), NULL, EVP_sha256(), NULL, pkey.get()) ||
@@ -409,7 +408,7 @@ static bool TestEVP_DigestSignInit(void) {
 }
 
 static bool TestEVP_DigestVerifyInit(void) {
-  ScopedEVP_PKEY pkey = LoadExampleRSAKey();
+  bssl::UniquePtr<EVP_PKEY> pkey = LoadExampleRSAKey();
   ScopedEVP_MD_CTX md_ctx;
   if (!pkey ||
       !EVP_DigestVerifyInit(md_ctx.get(), NULL, EVP_sha256(), NULL,
@@ -422,12 +421,12 @@ static bool TestEVP_DigestVerifyInit(void) {
 }
 
 static bool TestVerifyRecover() {
-  ScopedEVP_PKEY pkey = LoadExampleRSAKey();
+  bssl::UniquePtr<EVP_PKEY> pkey = LoadExampleRSAKey();
   if (!pkey) {
     return false;
   }
 
-  ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey.get()));
+  bssl::UniquePtr<RSA> rsa(EVP_PKEY_get1_RSA(pkey.get()));
   if (!rsa) {
     return false;
   }
@@ -444,7 +443,7 @@ static bool TestVerifyRecover() {
   }
 
   size_t out_len;
-  ScopedEVP_PKEY_CTX ctx(EVP_PKEY_CTX_new(pkey.get(), nullptr));
+  bssl::UniquePtr<EVP_PKEY_CTX> ctx(EVP_PKEY_CTX_new(pkey.get(), nullptr));
   if (!EVP_PKEY_verify_recover_init(ctx.get()) ||
       !EVP_PKEY_CTX_set_rsa_padding(ctx.get(), RSA_PKCS1_PADDING) ||
       !EVP_PKEY_CTX_set_signature_md(ctx.get(), EVP_sha256()) ||
@@ -502,7 +501,7 @@ static bool TestVerifyRecover() {
 static bool TestValidPrivateKey(const uint8_t *input, size_t input_len,
                                 int expected_id) {
   const uint8_t *p = input;
-  ScopedEVP_PKEY pkey(d2i_AutoPrivateKey(NULL, &p, input_len));
+  bssl::UniquePtr<EVP_PKEY> pkey(d2i_AutoPrivateKey(NULL, &p, input_len));
   if (!pkey || p != input + input_len) {
     fprintf(stderr, "d2i_AutoPrivateKey failed\n");
     return false;
@@ -556,7 +555,7 @@ static bool Testd2i_AutoPrivateKey() {
   }
 
   const uint8_t *p = kInvalidPrivateKey;
-  ScopedEVP_PKEY pkey(d2i_AutoPrivateKey(NULL, &p, sizeof(kInvalidPrivateKey)));
+  bssl::UniquePtr<EVP_PKEY> pkey(d2i_AutoPrivateKey(NULL, &p, sizeof(kInvalidPrivateKey)));
   if (pkey) {
     fprintf(stderr, "Parsed invalid private key\n");
     return false;
@@ -569,14 +568,14 @@ static bool Testd2i_AutoPrivateKey() {
 // TestEVP_PKCS82PKEY tests loading a bad key in PKCS8 format.
 static bool TestEVP_PKCS82PKEY(void) {
   const uint8_t *derp = kExampleBadECKeyDER;
-  ScopedPKCS8_PRIV_KEY_INFO p8inf(
+  bssl::UniquePtr<PKCS8_PRIV_KEY_INFO> p8inf(
       d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, sizeof(kExampleBadECKeyDER)));
   if (!p8inf || derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) {
     fprintf(stderr, "Failed to parse key\n");
     return false;
   }
 
-  ScopedEVP_PKEY pkey(EVP_PKCS82PKEY(p8inf.get()));
+  bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKCS82PKEY(p8inf.get()));
   if (pkey) {
     fprintf(stderr, "Imported invalid EC key\n");
     return false;
@@ -588,7 +587,7 @@ static bool TestEVP_PKCS82PKEY(void) {
 
 // TestEVPMarshalEmptyPublicKey tests |EVP_marshal_public_key| on an empty key.
 static bool TestEVPMarshalEmptyPublicKey(void) {
-  ScopedEVP_PKEY empty(EVP_PKEY_new());
+  bssl::UniquePtr<EVP_PKEY> empty(EVP_PKEY_new());
   if (!empty) {
     return false;
   }
@@ -608,7 +607,7 @@ static bool TestEVPMarshalEmptyPublicKey(void) {
 // Testd2i_PrivateKey tests |d2i_PrivateKey|.
 static bool Testd2i_PrivateKey(void) {
   const uint8_t *derp = kExampleRSAKeyDER;
-  ScopedEVP_PKEY pkey(d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &derp,
+  bssl::UniquePtr<EVP_PKEY> pkey(d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &derp,
                                      sizeof(kExampleRSAKeyDER)));
   if (!pkey || derp != kExampleRSAKeyDER + sizeof(kExampleRSAKeyDER)) {
     fprintf(stderr, "Failed to import raw RSA key.\n");
diff --git a/crypto/evp/evp_test.cc b/crypto/evp/evp_test.cc
index 9c8735b4..58d3ebda 100644
--- a/crypto/evp/evp_test.cc
+++ b/crypto/evp/evp_test.cc
@@ -74,7 +74,6 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
 #include <openssl/err.h>
 
 #include "../test/file_test.h"
-#include "../test/scoped_types.h"
 
 namespace bssl {
 
@@ -115,7 +114,7 @@ static int GetKeyType(FileTest *t, const std::string &name) {
   return EVP_PKEY_NONE;
 }
 
-using KeyMap = std::map<std::string, ScopedEVP_PKEY>;
+using KeyMap = std::map<std::string, bssl::UniquePtr<EVP_PKEY>>;
 
 static bool ImportKey(FileTest *t, KeyMap *key_map,
                       EVP_PKEY *(*parse_func)(CBS *cbs),
@@ -127,7 +126,7 @@ static bool ImportKey(FileTest *t, KeyMap *key_map,
 
   CBS cbs;
   CBS_init(&cbs, input.data(), input.size());
-  ScopedEVP_PKEY pkey(parse_func(&cbs));
+  bssl::UniquePtr<EVP_PKEY> pkey(parse_func(&cbs));
   if (!pkey) {
     return false;
   }
@@ -150,7 +149,7 @@ static bool ImportKey(FileTest *t, KeyMap *key_map,
       !CBB_finish(cbb.get(), &der, &der_len)) {
     return false;
   }
-  ScopedOpenSSLBytes free_der(der);
+  bssl::UniquePtr<uint8_t> free_der(der);
 
   std::vector<uint8_t> output = input;
   if (t->HasAttribute("Output") &&
@@ -215,7 +214,7 @@ static bool TestEVP(FileTest *t, void *arg) {
   }
 
   // Set up the EVP_PKEY_CTX.
-  ScopedEVP_PKEY_CTX ctx(EVP_PKEY_CTX_new(key, nullptr));
+  bssl::UniquePtr<EVP_PKEY_CTX> ctx(EVP_PKEY_CTX_new(key, nullptr));
   if (!ctx || !key_op_init(ctx.get())) {
     return false;
   }
diff --git a/crypto/newhope/newhope_statistical_test.cc b/crypto/newhope/newhope_statistical_test.cc
index 44fac48a..3ca6d78d 100644
--- a/crypto/newhope/newhope_statistical_test.cc
+++ b/crypto/newhope/newhope_statistical_test.cc
@@ -19,9 +19,9 @@
 #include <string.h>
 
 #include <openssl/crypto.h>
+#include <openssl/newhope.h>
 #include <openssl/rand.h>
 
-#include "../test/scoped_types.h"
 #include "internal.h"
 
 
@@ -108,7 +108,7 @@ static bool TestKeys(void) {
   uint8_t key[NEWHOPE_KEY_LENGTH];
   uint8_t offermsg[NEWHOPE_OFFERMSG_LENGTH];
 
-  ScopedNEWHOPE_POLY sk(NEWHOPE_POLY_new()), pk(NEWHOPE_POLY_new()),
+  bssl::UniquePtr<NEWHOPE_POLY> sk(NEWHOPE_POLY_new()), pk(NEWHOPE_POLY_new()),
       sp(NEWHOPE_POLY_new()), ep(NEWHOPE_POLY_new()), epp(NEWHOPE_POLY_new()),
       a(NEWHOPE_POLY_new()), bp(NEWHOPE_POLY_new()), rec(NEWHOPE_POLY_new());
 
diff --git a/crypto/newhope/newhope_test.cc b/crypto/newhope/newhope_test.cc
index 6637393f..a5907214 100644
--- a/crypto/newhope/newhope_test.cc
+++ b/crypto/newhope/newhope_test.cc
@@ -19,7 +19,6 @@
 #include <openssl/crypto.h>
 #include <openssl/rand.h>
 
-#include "../test/scoped_types.h"
 #include "internal.h"
 
 
@@ -28,7 +27,7 @@ static const int kNumTests = 10;
 
 static bool TestKeys(void) {
   // Alice generates a public key.
-  ScopedNEWHOPE_POLY sk(NEWHOPE_POLY_new());
+  bssl::UniquePtr<NEWHOPE_POLY> sk(NEWHOPE_POLY_new());
   uint8_t offer_msg[NEWHOPE_OFFERMSG_LENGTH];
   NEWHOPE_offer(offer_msg, sk.get());
 
@@ -58,7 +57,7 @@ static bool TestKeys(void) {
 static bool TestInvalidSK(void) {
   // Alice generates a public key.
   uint8_t offer_msg[NEWHOPE_OFFERMSG_LENGTH];
-  ScopedNEWHOPE_POLY sk(NEWHOPE_POLY_new());
+  bssl::UniquePtr<NEWHOPE_POLY> sk(NEWHOPE_POLY_new());
   NEWHOPE_offer(offer_msg, sk.get());
 
   // Bob derives a secret key and creates a response.
@@ -93,7 +92,7 @@ static bool TestInvalidSK(void) {
 
 static bool TestInvalidAcceptMsg(void) {
   // Alice generates a public key.
-  ScopedNEWHOPE_POLY sk(NEWHOPE_POLY_new());
+  bssl::UniquePtr<NEWHOPE_POLY> sk(NEWHOPE_POLY_new());
   uint8_t offer_msg[NEWHOPE_OFFERMSG_LENGTH];
   NEWHOPE_offer(offer_msg, sk.get());
 
diff --git a/crypto/newhope/newhope_vectors_test.cc b/crypto/newhope/newhope_vectors_test.cc
index fe84cd4b..64aa0bbc 100644
--- a/crypto/newhope/newhope_vectors_test.cc
+++ b/crypto/newhope/newhope_vectors_test.cc
@@ -20,17 +20,16 @@
 #include <openssl/rand.h>
 
 #include "../test/file_test.h"
-#include "../test/scoped_types.h"
 #include "internal.h"
 
 
 static bool TestNewhope(FileTest *t, void *arg) {
-  ScopedNEWHOPE_POLY a(NEWHOPE_POLY_new());
-  ScopedNEWHOPE_POLY s(NEWHOPE_POLY_new()), sp(NEWHOPE_POLY_new());
-  ScopedNEWHOPE_POLY e(NEWHOPE_POLY_new()), ep(NEWHOPE_POLY_new()),
+  bssl::UniquePtr<NEWHOPE_POLY> a(NEWHOPE_POLY_new());
+  bssl::UniquePtr<NEWHOPE_POLY> s(NEWHOPE_POLY_new()), sp(NEWHOPE_POLY_new());
+  bssl::UniquePtr<NEWHOPE_POLY> e(NEWHOPE_POLY_new()), ep(NEWHOPE_POLY_new()),
       epp(NEWHOPE_POLY_new());
-  ScopedNEWHOPE_POLY in_pk(NEWHOPE_POLY_new());
-  ScopedNEWHOPE_POLY in_rec(NEWHOPE_POLY_new());
+  bssl::UniquePtr<NEWHOPE_POLY> in_pk(NEWHOPE_POLY_new());
+  bssl::UniquePtr<NEWHOPE_POLY> in_rec(NEWHOPE_POLY_new());
 
   if (t->GetType() == "InRandA") {
     std::vector<uint8_t> a_bytes, s_bytes, e_bytes, expected_pk;
diff --git a/crypto/pkcs8/pkcs12_test.cc b/crypto/pkcs8/pkcs12_test.cc
index 17bcd273..5c1a1b48 100644
--- a/crypto/pkcs8/pkcs12_test.cc
+++ b/crypto/pkcs8/pkcs12_test.cc
@@ -23,8 +23,6 @@
 #include <openssl/stack.h>
 #include <openssl/x509.h>
 
-#include "../test/scoped_types.h"
-
 
 /* kPKCS12DER contains sample PKCS#12 data generated by OpenSSL with:
  * openssl pkcs12 -export -inkey key.pem -in cacert.pem */
@@ -684,7 +682,7 @@ static const uint8_t kWindows[] = {
 static const char kPassword[] = "foo";
 
 static bool Test(const char *name, const uint8_t *der, size_t der_len) {
-  ScopedX509Stack certs(sk_X509_new_null());
+  bssl::UniquePtr<STACK_OF(X509)> certs(sk_X509_new_null());
   if (!certs) {
     return false;
   }
@@ -697,7 +695,7 @@ static bool Test(const char *name, const uint8_t *der, size_t der_len) {
     ERR_print_errors_fp(stderr);
     return false;
   }
-  ScopedEVP_PKEY delete_key(key);
+  bssl::UniquePtr<EVP_PKEY> delete_key(key);
 
   if (sk_X509_num(certs.get()) != 1 || key == nullptr) {
     fprintf(stderr, "Bad result from %s data.\n", name);
@@ -708,12 +706,12 @@ static bool Test(const char *name, const uint8_t *der, size_t der_len) {
 }
 
 static bool TestCompat(const uint8_t *der, size_t der_len) {
-  ScopedBIO bio(BIO_new_mem_buf(der, der_len));
+  bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(der, der_len));
   if (!bio) {
     return false;
   }
 
-  ScopedPKCS12 p12(d2i_PKCS12_bio(bio.get(), nullptr));
+  bssl::UniquePtr<PKCS12> p12(d2i_PKCS12_bio(bio.get(), nullptr));
   if (!p12) {
     fprintf(stderr, "PKCS12_parse failed.\n");
     ERR_print_errors_fp(stderr);
@@ -738,9 +736,9 @@ static bool TestCompat(const uint8_t *der, size_t der_len) {
     ERR_print_errors_fp(stderr);
     return false;
   }
-  ScopedEVP_PKEY delete_key(key);
-  ScopedX509 delete_cert(cert);
-  ScopedX509Stack delete_ca_certs(ca_certs);
+  bssl::UniquePtr<EVP_PKEY> delete_key(key);
+  bssl::UniquePtr<X509> delete_cert(cert);
+  bssl::UniquePtr<STACK_OF(X509)> delete_ca_certs(ca_certs);
 
   if (key == nullptr || cert == nullptr) {
     fprintf(stderr, "Bad result from PKCS12_parse.\n");
diff --git a/crypto/pkcs8/pkcs8_test.cc b/crypto/pkcs8/pkcs8_test.cc
index 7a88ddf4..cbb20438 100644
--- a/crypto/pkcs8/pkcs8_test.cc
+++ b/crypto/pkcs8/pkcs8_test.cc
@@ -21,8 +21,6 @@
 #include <openssl/pkcs8.h>
 #include <openssl/x509.h>
 
-#include "../test/scoped_types.h"
-
 
 /* kDER is a PKCS#8 encrypted private key. It was generated with:
  *
@@ -64,14 +62,14 @@ static const uint8_t kDER[] = {
 
 static bool test(const uint8_t *der, size_t der_len) {
   const uint8_t *data = der;
-  ScopedX509_SIG sig(d2i_X509_SIG(NULL, &data, der_len));
+  bssl::UniquePtr<X509_SIG> sig(d2i_X509_SIG(NULL, &data, der_len));
   if (sig.get() == NULL || data != der + der_len) {
     fprintf(stderr, "d2i_X509_SIG failed or did not consume all bytes.\n");
     return false;
   }
 
   static const char kPassword[] = "testing";
-  ScopedPKCS8_PRIV_KEY_INFO keypair(PKCS8_decrypt(sig.get(), kPassword, -1));
+  bssl::UniquePtr<PKCS8_PRIV_KEY_INFO> keypair(PKCS8_decrypt(sig.get(), kPassword, -1));
   if (!keypair) {
     fprintf(stderr, "PKCS8_decrypt failed.\n");
     ERR_print_errors_fp(stderr);
diff --git a/crypto/rsa/rsa_test.cc b/crypto/rsa/rsa_test.cc
index 62177a4c..8c4a7871 100644
--- a/crypto/rsa/rsa_test.cc
+++ b/crypto/rsa/rsa_test.cc
@@ -65,8 +65,6 @@
 #include <openssl/err.h>
 #include <openssl/nid.h>
 
-#include "../test/scoped_types.h"
-
 
 // kPlaintext is a sample plaintext.
 static const uint8_t kPlaintext[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
@@ -526,7 +524,7 @@ static const uint8_t kExponent1RSAKey[] = {
 static bool TestRSA(const uint8_t *der, size_t der_len,
                     const uint8_t *oaep_ciphertext,
                     size_t oaep_ciphertext_len) {
-  ScopedRSA key(RSA_private_key_from_bytes(der, der_len));
+  bssl::UniquePtr<RSA> key(RSA_private_key_from_bytes(der, der_len));
   if (!key) {
     return false;
   }
@@ -612,7 +610,7 @@ static bool TestRSA(const uint8_t *der, size_t der_len,
 
 static bool TestMultiPrimeKey(int nprimes, const uint8_t *der, size_t der_size,
                               const uint8_t *enc, size_t enc_size) {
-  ScopedRSA rsa(d2i_RSAPrivateKey(nullptr, &der, der_size));
+  bssl::UniquePtr<RSA> rsa(d2i_RSAPrivateKey(nullptr, &der, der_size));
   if (!rsa) {
     fprintf(stderr, "%d-prime key failed to parse.\n", nprimes);
     ERR_print_errors_fp(stderr);
@@ -645,8 +643,8 @@ static bool TestMultiPrimeKeygen() {
   uint8_t encrypted[kBits / 8], decrypted[kBits / 8];
   size_t encrypted_len, decrypted_len;
 
-  ScopedRSA rsa(RSA_new());
-  ScopedBIGNUM e(BN_new());
+  bssl::UniquePtr<RSA> rsa(RSA_new());
+  bssl::UniquePtr<BIGNUM> e(BN_new());
   if (!rsa || !e ||
       !BN_set_word(e.get(), RSA_F4) ||
       !RSA_generate_multi_prime_key(rsa.get(), kBits, 3, e.get(), nullptr) ||
@@ -666,8 +664,8 @@ static bool TestMultiPrimeKeygen() {
 }
 
 static bool TestBadKey() {
-  ScopedRSA key(RSA_new());
-  ScopedBIGNUM e(BN_new());
+  bssl::UniquePtr<RSA> key(RSA_new());
+  bssl::UniquePtr<BIGNUM> e(BN_new());
 
   if (!key || !e || !BN_set_word(e.get(), RSA_F4)) {
     return false;
@@ -705,7 +703,7 @@ static bool TestOnlyDGiven() {
 
   uint8_t buf[64];
   unsigned buf_len = sizeof(buf);
-  ScopedRSA key(RSA_new());
+  bssl::UniquePtr<RSA> key(RSA_new());
   if (!key ||
       !BN_hex2bn(&key->n, kN) ||
       !BN_hex2bn(&key->e, kE) ||
@@ -739,7 +737,7 @@ static bool TestOnlyDGiven() {
   // Keys without the public exponent must continue to work when blinding is
   // disabled to support Java's RSAPrivateKeySpec API. See
   // https://bugs.chromium.org/p/boringssl/issues/detail?id=12.
-  ScopedRSA key2(RSA_new());
+  bssl::UniquePtr<RSA> key2(RSA_new());
   if (!key2 ||
       !BN_hex2bn(&key2->n, kN) ||
       !BN_hex2bn(&key2->d, kD)) {
@@ -772,7 +770,7 @@ static bool TestOnlyDGiven() {
 }
 
 static bool TestRecoverCRTParams() {
-  ScopedBIGNUM e(BN_new());
+  bssl::UniquePtr<BIGNUM> e(BN_new());
   if (!e || !BN_set_word(e.get(), RSA_F4)) {
     return false;
   }
@@ -780,7 +778,7 @@ static bool TestRecoverCRTParams() {
   ERR_clear_error();
 
   for (unsigned i = 0; i < 1; i++) {
-    ScopedRSA key1(RSA_new());
+    bssl::UniquePtr<RSA> key1(RSA_new());
     if (!key1 ||
         !RSA_generate_key_ex(key1.get(), 512, e.get(), nullptr)) {
       fprintf(stderr, "RSA_generate_key_ex failed.\n");
@@ -794,7 +792,7 @@ static bool TestRecoverCRTParams() {
       return false;
     }
 
-    ScopedRSA key2(RSA_new());
+    bssl::UniquePtr<RSA> key2(RSA_new());
     if (!key2) {
       return false;
     }
@@ -844,7 +842,7 @@ static bool TestRecoverCRTParams() {
 
 static bool TestASN1() {
   // Test that private keys may be decoded.
-  ScopedRSA rsa(RSA_private_key_from_bytes(kKey1, sizeof(kKey1) - 1));
+  bssl::UniquePtr<RSA> rsa(RSA_private_key_from_bytes(kKey1, sizeof(kKey1) - 1));
   if (!rsa) {
     return false;
   }
@@ -855,7 +853,7 @@ static bool TestASN1() {
   if (!RSA_private_key_to_bytes(&der, &der_len, rsa.get())) {
     return false;
   }
-  ScopedOpenSSLBytes delete_der(der);
+  bssl::UniquePtr<uint8_t> delete_der(der);
   if (der_len != sizeof(kKey1) - 1 || memcmp(der, kKey1, der_len) != 0) {
     return false;
   }
@@ -878,7 +876,7 @@ static bool TestASN1() {
   if (!RSA_public_key_to_bytes(&der2, &der2_len, rsa.get())) {
     return false;
   }
-  ScopedOpenSSLBytes delete_der2(der2);
+  bssl::UniquePtr<uint8_t> delete_der2(der2);
   if (der_len != der2_len || memcmp(der, der2, der_len) != 0) {
     return false;
   }
@@ -910,7 +908,7 @@ static bool TestASN1() {
 }
 
 static bool TestBadExponent() {
-  ScopedRSA rsa(RSA_public_key_from_bytes(kExponent1RSAKey,
+  bssl::UniquePtr<RSA> rsa(RSA_public_key_from_bytes(kExponent1RSAKey,
                                           sizeof(kExponent1RSAKey)));
 
   if (rsa) {
diff --git a/crypto/test/scoped_types.h b/crypto/test/scoped_types.h
deleted file mode 100644
index c124235d..00000000
--- a/crypto/test/scoped_types.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/* Copyright (c) 2015, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#ifndef OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H
-#define OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H
-
-#include <stdint.h>
-#include <stdio.h>
-
-#include <memory>
-
-#include <openssl/aead.h>
-#include <openssl/asn1.h>
-#include <openssl/bio.h>
-#include <openssl/bn.h>
-#include <openssl/bytestring.h>
-#include <openssl/cmac.h>
-#include <openssl/curve25519.h>
-#include <openssl/dh.h>
-#include <openssl/ecdsa.h>
-#include <openssl/ec.h>
-#include <openssl/ec_key.h>
-#include <openssl/evp.h>
-#include <openssl/hmac.h>
-#include <openssl/mem.h>
-#include <openssl/newhope.h>
-#include <openssl/pkcs8.h>
-#include <openssl/rsa.h>
-#include <openssl/stack.h>
-#include <openssl/x509.h>
-
-
-template<typename T, void (*func)(T*)>
-struct OpenSSLDeleter {
-  void operator()(T *obj) {
-    func(obj);
-  }
-};
-
-template<typename StackType, typename T, void (*func)(T*)>
-struct OpenSSLStackDeleter {
-  void operator()(StackType *obj) {
-    sk_pop_free(reinterpret_cast<_STACK*>(obj),
-                reinterpret_cast<void (*)(void *)>(func));
-  }
-};
-
-template<typename T>
-struct OpenSSLFree {
-  void operator()(T *buf) {
-    OPENSSL_free(buf);
-  }
-};
-
-struct FileCloser {
-  void operator()(FILE *file) {
-    fclose(file);
-  }
-};
-
-template<typename T, void (*func)(T*)>
-using ScopedOpenSSLType = std::unique_ptr<T, OpenSSLDeleter<T, func>>;
-
-template<typename StackType, typename T, void (*func)(T*)>
-using ScopedOpenSSLStack =
-    std::unique_ptr<StackType, OpenSSLStackDeleter<StackType, T, func>>;
-
-template<typename T, typename CleanupRet, void (*init_func)(T*),
-         CleanupRet (*cleanup_func)(T*)>
-class ScopedOpenSSLContext {
- public:
-  ScopedOpenSSLContext() {
-    init_func(&ctx_);
-  }
-  ~ScopedOpenSSLContext() {
-    cleanup_func(&ctx_);
-  }
-
-  T *get() { return &ctx_; }
-  const T *get() const { return &ctx_; }
-
-  void Reset() {
-    cleanup_func(&ctx_);
-    init_func(&ctx_);
-  }
-
- private:
-  T ctx_;
-};
-
-using ScopedASN1_TYPE = ScopedOpenSSLType<ASN1_TYPE, ASN1_TYPE_free>;
-using ScopedBIO = ScopedOpenSSLType<BIO, BIO_vfree>;
-using ScopedBIGNUM = ScopedOpenSSLType<BIGNUM, BN_free>;
-using ScopedBN_CTX = ScopedOpenSSLType<BN_CTX, BN_CTX_free>;
-using ScopedBN_MONT_CTX = ScopedOpenSSLType<BN_MONT_CTX, BN_MONT_CTX_free>;
-using ScopedCMAC_CTX = ScopedOpenSSLType<CMAC_CTX, CMAC_CTX_free>;
-using ScopedDH = ScopedOpenSSLType<DH, DH_free>;
-using ScopedECDSA_SIG = ScopedOpenSSLType<ECDSA_SIG, ECDSA_SIG_free>;
-using ScopedEC_GROUP = ScopedOpenSSLType<EC_GROUP, EC_GROUP_free>;
-using ScopedEC_KEY = ScopedOpenSSLType<EC_KEY, EC_KEY_free>;
-using ScopedEC_POINT = ScopedOpenSSLType<EC_POINT, EC_POINT_free>;
-using ScopedEVP_PKEY = ScopedOpenSSLType<EVP_PKEY, EVP_PKEY_free>;
-using ScopedEVP_PKEY_CTX = ScopedOpenSSLType<EVP_PKEY_CTX, EVP_PKEY_CTX_free>;
-using ScopedNEWHOPE_POLY = ScopedOpenSSLType<NEWHOPE_POLY, NEWHOPE_POLY_free>;
-using ScopedPKCS8_PRIV_KEY_INFO = ScopedOpenSSLType<PKCS8_PRIV_KEY_INFO,
-                                                    PKCS8_PRIV_KEY_INFO_free>;
-using ScopedPKCS12 = ScopedOpenSSLType<PKCS12, PKCS12_free>;
-using ScopedSPAKE2_CTX = ScopedOpenSSLType<SPAKE2_CTX, SPAKE2_CTX_free>;
-using ScopedRSA = ScopedOpenSSLType<RSA, RSA_free>;
-using ScopedX509 = ScopedOpenSSLType<X509, X509_free>;
-using ScopedX509_ALGOR = ScopedOpenSSLType<X509_ALGOR, X509_ALGOR_free>;
-using ScopedX509_SIG = ScopedOpenSSLType<X509_SIG, X509_SIG_free>;
-using ScopedX509_STORE_CTX = ScopedOpenSSLType<X509_STORE_CTX, X509_STORE_CTX_free>;
-
-using ScopedX509Stack = ScopedOpenSSLStack<STACK_OF(X509), X509, X509_free>;
-
-using ScopedOpenSSLBytes = std::unique_ptr<uint8_t, OpenSSLFree<uint8_t>>;
-using ScopedOpenSSLString = std::unique_ptr<char, OpenSSLFree<char>>;
-
-using ScopedFILE = std::unique_ptr<FILE, FileCloser>;
-
-#endif  // OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H
diff --git a/crypto/x509/x509_test.cc b/crypto/x509/x509_test.cc
index d1eed2a3..3c7cc636 100644
--- a/crypto/x509/x509_test.cc
+++ b/crypto/x509/x509_test.cc
@@ -23,8 +23,6 @@
 #include <openssl/pem.h>
 #include <openssl/x509.h>
 
-#include "../test/scoped_types.h"
-
 namespace bssl {
 
 static const char kCrossSigningRootPEM[] =
@@ -226,23 +224,25 @@ static const char kRSAKey[] =
 
 // CertFromPEM parses the given, NUL-terminated pem block and returns an
 // |X509*|.
-static ScopedX509 CertFromPEM(const char *pem) {
-  ScopedBIO bio(BIO_new_mem_buf(pem, strlen(pem)));
-  return ScopedX509(PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr));
+static bssl::UniquePtr<X509> CertFromPEM(const char *pem) {
+  bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(pem, strlen(pem)));
+  return bssl::UniquePtr<X509>(
+      PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr));
 }
 
 // PrivateKeyFromPEM parses the given, NUL-terminated pem block and returns an
 // |EVP_PKEY*|.
-static ScopedEVP_PKEY PrivateKeyFromPEM(const char *pem) {
-  ScopedBIO bio(BIO_new_mem_buf(const_cast<char *>(pem), strlen(pem)));
-  return ScopedEVP_PKEY(
+static bssl::UniquePtr<EVP_PKEY> PrivateKeyFromPEM(const char *pem) {
+  bssl::UniquePtr<BIO> bio(
+      BIO_new_mem_buf(const_cast<char *>(pem), strlen(pem)));
+  return bssl::UniquePtr<EVP_PKEY>(
       PEM_read_bio_PrivateKey(bio.get(), nullptr, nullptr, nullptr));
 }
 
 // CertsToStack converts a vector of |X509*| to an OpenSSL STACK_OF(X509*),
 // bumping the reference counts for each certificate in question.
 static STACK_OF(X509)* CertsToStack(const std::vector<X509*> &certs) {
-  ScopedX509Stack stack(sk_X509_new_null());
+  bssl::UniquePtr<STACK_OF(X509)> stack(sk_X509_new_null());
   if (!stack) {
     return nullptr;
   }
@@ -259,14 +259,16 @@ static STACK_OF(X509)* CertsToStack(const std::vector<X509*> &certs) {
 static bool Verify(X509 *leaf, const std::vector<X509 *> &roots,
                    const std::vector<X509 *> &intermediates,
                    unsigned long flags = 0) {
-  ScopedX509Stack roots_stack(CertsToStack(roots));
-  ScopedX509Stack intermediates_stack(CertsToStack(intermediates));
+  bssl::UniquePtr<STACK_OF(X509)> roots_stack(CertsToStack(roots));
+  bssl::UniquePtr<STACK_OF(X509)> intermediates_stack(
+      CertsToStack(intermediates));
+
   if (!roots_stack ||
       !intermediates_stack) {
     return false;
   }
 
-  ScopedX509_STORE_CTX ctx(X509_STORE_CTX_new());
+  bssl::UniquePtr<X509_STORE_CTX> ctx(X509_STORE_CTX_new());
   if (!ctx) {
     return false;
   }
@@ -293,14 +295,15 @@ static bool Verify(X509 *leaf, const std::vector<X509 *> &roots,
 }
 
 static bool TestVerify() {
-  ScopedX509 cross_signing_root(CertFromPEM(kCrossSigningRootPEM));
-  ScopedX509 root(CertFromPEM(kRootCAPEM));
-  ScopedX509 root_cross_signed(CertFromPEM(kRootCrossSignedPEM));
-  ScopedX509 intermediate(CertFromPEM(kIntermediatePEM));
-  ScopedX509 intermediate_self_signed(CertFromPEM(kIntermediateSelfSignedPEM));
-  ScopedX509 leaf(CertFromPEM(kLeafPEM));
-  ScopedX509 leaf_no_key_usage(CertFromPEM(kLeafNoKeyUsagePEM));
-  ScopedX509 forgery(CertFromPEM(kForgeryPEM));
+  bssl::UniquePtr<X509> cross_signing_root(CertFromPEM(kCrossSigningRootPEM));
+  bssl::UniquePtr<X509> root(CertFromPEM(kRootCAPEM));
+  bssl::UniquePtr<X509> root_cross_signed(CertFromPEM(kRootCrossSignedPEM));
+  bssl::UniquePtr<X509> intermediate(CertFromPEM(kIntermediatePEM));
+  bssl::UniquePtr<X509> intermediate_self_signed(
+      CertFromPEM(kIntermediateSelfSignedPEM));
+  bssl::UniquePtr<X509> leaf(CertFromPEM(kLeafPEM));
+  bssl::UniquePtr<X509> leaf_no_key_usage(CertFromPEM(kLeafNoKeyUsagePEM));
+  bssl::UniquePtr<X509> forgery(CertFromPEM(kForgeryPEM));
 
   if (!cross_signing_root ||
       !root ||
@@ -380,12 +383,12 @@ static bool TestVerify() {
 }
 
 static bool TestPSS() {
-  ScopedX509 cert(CertFromPEM(kExamplePSSCert));
+  bssl::UniquePtr<X509> cert(CertFromPEM(kExamplePSSCert));
   if (!cert) {
     return false;
   }
 
-  ScopedEVP_PKEY pkey(X509_get_pubkey(cert.get()));
+  bssl::UniquePtr<EVP_PKEY> pkey(X509_get_pubkey(cert.get()));
   if (!pkey) {
     return false;
   }
@@ -398,12 +401,12 @@ static bool TestPSS() {
 }
 
 static bool TestBadPSSParameters() {
-  ScopedX509 cert(CertFromPEM(kBadPSSCertPEM));
+  bssl::UniquePtr<X509> cert(CertFromPEM(kBadPSSCertPEM));
   if (!cert) {
     return false;
   }
 
-  ScopedEVP_PKEY pkey(X509_get_pubkey(cert.get()));
+  bssl::UniquePtr<EVP_PKEY> pkey(X509_get_pubkey(cert.get()));
   if (!pkey) {
     return false;
   }
@@ -418,7 +421,7 @@ static bool TestBadPSSParameters() {
 
 static bool SignatureRoundTrips(EVP_MD_CTX *md_ctx, EVP_PKEY *pkey) {
   // Make a certificate like signed with |md_ctx|'s settings.'
-  ScopedX509 cert(CertFromPEM(kLeafPEM));
+  bssl::UniquePtr<X509> cert(CertFromPEM(kLeafPEM));
   if (!cert || !X509_sign_ctx(cert.get(), md_ctx)) {
     return false;
   }
@@ -429,7 +432,7 @@ static bool SignatureRoundTrips(EVP_MD_CTX *md_ctx, EVP_PKEY *pkey) {
 }
 
 static bool TestSignCtx() {
-  ScopedEVP_PKEY pkey(PrivateKeyFromPEM(kRSAKey));
+  bssl::UniquePtr<EVP_PKEY> pkey(PrivateKeyFromPEM(kRSAKey));
   if (!pkey) {
     return false;
   }