Use std::make_unique when possible
We've required C++14 for a while now. As we're mostly C with a little
C++, this is less helpful, but may as well avoid bare new where
possible.
Change-Id: Icf3386e3f3b6f2092bb0089ed874cc50985f1a40
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/61429
Reviewed-by: Bob Beck <bbe@google.com>
Commit-Queue: David Benjamin <davidben@google.com>
diff --git a/crypto/chacha/chacha_test.cc b/crypto/chacha/chacha_test.cc
index 00683ce..d4e5332 100644
--- a/crypto/chacha/chacha_test.cc
+++ b/crypto/chacha/chacha_test.cc
@@ -320,7 +320,7 @@
for (size_t len = 0; len <= sizeof(kInput); len++) {
SCOPED_TRACE(len);
- std::unique_ptr<uint8_t[]> buf(new uint8_t[len]);
+ auto buf = std::make_unique<uint8_t[]>(len);
CRYPTO_chacha_20(buf.get(), kInput, len, kKey, kNonce, kCounter);
EXPECT_EQ(Bytes(kOutput, len), Bytes(buf.get(), len));
@@ -336,7 +336,7 @@
for (size_t len = 0; len <= sizeof(kInput); len++) {
SCOPED_TRACE(len);
- std::unique_ptr<uint8_t[]> buf(new uint8_t[len]);
+ auto buf = std::make_unique<uint8_t[]>(len);
CRYPTO_chacha_20(buf.get(), kInput, len, kKey, kNonce, kOverflowCounter);
EXPECT_EQ(Bytes(kOverflowOutput, len), Bytes(buf.get(), len));
@@ -354,7 +354,7 @@
static const uint32_t kCounterNonce[4] = {0};
- std::unique_ptr<uint8_t[]> buf(new uint8_t[sizeof(kInput)]);
+ auto buf = std::make_unique<uint8_t[]>(sizeof(kInput));
for (size_t len = 0; len <= 32; len++) {
SCOPED_TRACE(len);
CHECK_ABI(ChaCha20_ctr32, buf.get(), kInput, len, key, kCounterNonce);
diff --git a/crypto/cipher_extra/aead_test.cc b/crypto/cipher_extra/aead_test.cc
index a8d2dbd..64c65e9 100644
--- a/crypto/cipher_extra/aead_test.cc
+++ b/crypto/cipher_extra/aead_test.cc
@@ -821,7 +821,7 @@
return;
}
- std::unique_ptr<uint8_t[]> buf(new uint8_t[1024]);
+ auto buf = std::make_unique<uint8_t[]>(1024);
for (size_t len = 0; len <= 1024; len += 5) {
SCOPED_TRACE(len);
union chacha20_poly1305_open_data open_ctx = {};
diff --git a/crypto/digest_extra/digest_test.cc b/crypto/digest_extra/digest_test.cc
index 12858e2..d15e4d1 100644
--- a/crypto/digest_extra/digest_test.cc
+++ b/crypto/digest_extra/digest_test.cc
@@ -167,7 +167,7 @@
for (size_t i = 0; i < test->repeat; i++) {
ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), test->input, strlen(test->input)));
}
- std::unique_ptr<uint8_t[]> digest(new uint8_t[EVP_MD_size(test->md.func())]);
+ auto digest = std::make_unique<uint8_t[]>(EVP_MD_size(test->md.func()));
unsigned digest_len;
ASSERT_TRUE(EVP_DigestFinal_ex(ctx.get(), digest.get(), &digest_len));
CompareDigest(test, digest.get(), digest_len);
diff --git a/crypto/fipsmodule/aes/aes_test.cc b/crypto/fipsmodule/aes/aes_test.cc
index dd3b374..75a5aed 100644
--- a/crypto/fipsmodule/aes/aes_test.cc
+++ b/crypto/fipsmodule/aes/aes_test.cc
@@ -89,7 +89,7 @@
ASSERT_EQ(0, AES_set_encrypt_key(key.data(), 8 * key.size(), &aes_key));
// Test with implicit IV.
- std::unique_ptr<uint8_t[]> buf(new uint8_t[ciphertext.size()]);
+ auto buf = std::make_unique<uint8_t[]>(ciphertext.size());
int len = AES_wrap_key(&aes_key, nullptr /* iv */, buf.get(),
plaintext.data(), plaintext.size());
ASSERT_GE(len, 0);
@@ -106,7 +106,7 @@
ASSERT_EQ(0, AES_set_decrypt_key(key.data(), 8 * key.size(), &aes_key));
// Test with implicit IV.
- buf.reset(new uint8_t[plaintext.size()]);
+ buf = std::make_unique<uint8_t[]>(plaintext.size());
len = AES_unwrap_key(&aes_key, nullptr /* iv */, buf.get(), ciphertext.data(),
ciphertext.size());
ASSERT_GE(len, 0);
@@ -133,7 +133,7 @@
// Test encryption.
AES_KEY aes_key;
ASSERT_EQ(0, AES_set_encrypt_key(key.data(), 8 * key.size(), &aes_key));
- std::unique_ptr<uint8_t[]> buf(new uint8_t[plaintext.size() + 15]);
+ auto buf = std::make_unique<uint8_t[]>(plaintext.size() + 15);
size_t len;
ASSERT_TRUE(AES_wrap_key_padded(&aes_key, buf.get(), &len,
plaintext.size() + 15, plaintext.data(),
@@ -142,7 +142,7 @@
// Test decryption
ASSERT_EQ(0, AES_set_decrypt_key(key.data(), 8 * key.size(), &aes_key));
- buf.reset(new uint8_t[ciphertext.size() - 8]);
+ buf = std::make_unique<uint8_t[]>(ciphertext.size() - 8);
ASSERT_TRUE(AES_unwrap_key_padded(&aes_key, buf.get(), &len,
ciphertext.size() - 8, ciphertext.data(),
ciphertext.size()));
diff --git a/crypto/fipsmodule/bn/bn_test.cc b/crypto/fipsmodule/bn/bn_test.cc
index 92da5f2..5bf2e13 100644
--- a/crypto/fipsmodule/bn/bn_test.cc
+++ b/crypto/fipsmodule/bn/bn_test.cc
@@ -458,8 +458,8 @@
SCOPED_TRACE(num_a);
size_t num_r = 2 * num_a;
// Use newly-allocated buffers so ASan will catch out-of-bounds writes.
- std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[num_a]),
- r_words(new BN_ULONG[num_r]);
+ auto a_words = std::make_unique<BN_ULONG[]>(num_a);
+ auto r_words = std::make_unique<BN_ULONG[]>(num_r);
ASSERT_TRUE(bn_copy_words(a_words.get(), num_a, a.get()));
bn_mul_small(r_words.get(), num_r, a_words.get(), num_a, a_words.get(),
@@ -525,8 +525,9 @@
SCOPED_TRACE(num_b);
size_t num_r = num_a + num_b;
// Use newly-allocated buffers so ASan will catch out-of-bounds writes.
- std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[num_a]),
- b_words(new BN_ULONG[num_b]), r_words(new BN_ULONG[num_r]);
+ auto a_words = std::make_unique<BN_ULONG[]>(num_a);
+ auto b_words = std::make_unique<BN_ULONG[]>(num_b);
+ auto r_words = std::make_unique<BN_ULONG[]>(num_r);
ASSERT_TRUE(bn_copy_words(a_words.get(), num_a, a.get()));
ASSERT_TRUE(bn_copy_words(b_words.get(), num_b, b.get()));
@@ -672,8 +673,9 @@
#if !defined(BORINGSSL_SHARED_LIBRARY)
size_t m_width = static_cast<size_t>(bn_minimal_width(m.get()));
if (m_width <= BN_SMALL_MAX_WORDS) {
- std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[m_width]),
- b_words(new BN_ULONG[m_width]), r_words(new BN_ULONG[m_width]);
+ auto a_words = std::make_unique<BN_ULONG[]>(m_width);
+ auto b_words = std::make_unique<BN_ULONG[]>(m_width);
+ auto r_words = std::make_unique<BN_ULONG[]>(m_width);
ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get()));
ASSERT_TRUE(bn_copy_words(b_words.get(), m_width, b.get()));
bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get());
@@ -691,7 +693,7 @@
// inputs. Test this by running |bn_from_montgomery_small| on the result
// of a product. Note |a_words| * |b_words| has an extra factor of R^2, so
// we must reduce twice.
- std::unique_ptr<BN_ULONG[]> prod_words(new BN_ULONG[m_width * 2]);
+ auto prod_words = std::make_unique<BN_ULONG[]>(m_width * 2);
bn_mul_small(prod_words.get(), m_width * 2, a_words.get(), m_width,
b_words.get(), m_width);
bn_from_montgomery_small(r_words.get(), m_width, prod_words.get(),
@@ -752,8 +754,9 @@
#if !defined(BORINGSSL_SHARED_LIBRARY)
size_t m_width = static_cast<size_t>(bn_minimal_width(m.get()));
if (m_width <= BN_SMALL_MAX_WORDS) {
- std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[m_width]),
- a_copy_words(new BN_ULONG[m_width]), r_words(new BN_ULONG[m_width]);
+ auto a_words = std::make_unique<BN_ULONG[]>(m_width);
+ auto a_copy_words = std::make_unique<BN_ULONG[]>(m_width);
+ auto r_words = std::make_unique<BN_ULONG[]>(m_width);
ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get()));
bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get());
bn_mod_mul_montgomery_small(r_words.get(), a_words.get(), a_words.get(),
@@ -815,8 +818,8 @@
bssl::UniquePtr<BN_MONT_CTX> mont(
BN_MONT_CTX_new_for_modulus(m.get(), ctx));
ASSERT_TRUE(mont.get());
- std::unique_ptr<BN_ULONG[]> r_words(new BN_ULONG[m_width]),
- a_words(new BN_ULONG[m_width]);
+ auto r_words = std::make_unique<BN_ULONG[]>(m_width);
+ auto a_words = std::make_unique<BN_ULONG[]>(m_width);
ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get()));
bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get());
bn_mod_exp_mont_small(r_words.get(), a_words.get(), m_width, e->d,
diff --git a/crypto/fipsmodule/rand/ctrdrbg_test.cc b/crypto/fipsmodule/rand/ctrdrbg_test.cc
index 50f4297..deed19f 100644
--- a/crypto/fipsmodule/rand/ctrdrbg_test.cc
+++ b/crypto/fipsmodule/rand/ctrdrbg_test.cc
@@ -76,7 +76,7 @@
CTR_DRBG_STATE drbg;
ASSERT_TRUE(CTR_DRBG_init(&drbg, kSeed, nullptr, 0));
- std::unique_ptr<uint8_t[]> buf(new uint8_t[CTR_DRBG_MAX_GENERATE_LENGTH]);
+ auto buf = std::make_unique<uint8_t[]>(CTR_DRBG_MAX_GENERATE_LENGTH);
ASSERT_TRUE(CTR_DRBG_generate(&drbg, buf.get(), CTR_DRBG_MAX_GENERATE_LENGTH,
nullptr, 0));
diff --git a/crypto/hmac_extra/hmac_test.cc b/crypto/hmac_extra/hmac_test.cc
index e65cd6a..4c0d2a1 100644
--- a/crypto/hmac_extra/hmac_test.cc
+++ b/crypto/hmac_extra/hmac_test.cc
@@ -99,7 +99,7 @@
ASSERT_EQ(EVP_MD_size(digest), output.size());
// Test using the one-shot API.
- std::unique_ptr<uint8_t[]> mac(new uint8_t[EVP_MD_size(digest)]);
+ auto mac = std::make_unique<uint8_t[]>(EVP_MD_size(digest));
unsigned mac_len;
ASSERT_TRUE(HMAC(digest, key.data(), key.size(), input.data(), input.size(),
mac.get(), &mac_len));
diff --git a/crypto/lhash/lhash_test.cc b/crypto/lhash/lhash_test.cc
index 6b4bfad..8514fd2 100644
--- a/crypto/lhash/lhash_test.cc
+++ b/crypto/lhash/lhash_test.cc
@@ -36,7 +36,7 @@
static std::unique_ptr<char[]> RandString(void) {
unsigned len = 1 + (rand() % 3);
- std::unique_ptr<char[]> ret(new char[len + 1]);
+ auto ret = std::make_unique<char[]>(len + 1);
for (unsigned i = 0; i < len; i++) {
ret[i] = '0' + (rand() & 7);
diff --git a/crypto/test/file_test.cc b/crypto/test/file_test.cc
index d7ef951..7362e4b 100644
--- a/crypto/test/file_test.cc
+++ b/crypto/test/file_test.cc
@@ -98,7 +98,7 @@
ClearTest();
static const size_t kBufLen = 8192 * 4;
- std::unique_ptr<char[]> buf(new char[kBufLen]);
+ auto buf = std::make_unique<char[]>(kBufLen);
bool in_instruction_block = false;
is_at_new_instruction_block_ = false;
@@ -409,8 +409,7 @@
}
int FileTestMain(const FileTest::Options &opts) {
- std::unique_ptr<FileLineReader> reader(
- new FileLineReader(opts.path));
+ auto reader = std::make_unique<FileLineReader>(opts.path);
if (!reader->is_open()) {
fprintf(stderr, "Could not open file %s: %s.\n", opts.path,
strerror(errno));
diff --git a/crypto/test/file_test_gtest.cc b/crypto/test/file_test_gtest.cc
index 8ff7a2b..2cb0896 100644
--- a/crypto/test/file_test_gtest.cc
+++ b/crypto/test/file_test_gtest.cc
@@ -66,9 +66,8 @@
};
void FileTestGTest(const char *path, std::function<void(FileTest *)> run_test) {
- std::unique_ptr<StringLineReader> reader(
- new StringLineReader(GetTestData(path)));
- FileTest t(std::move(reader), nullptr, false);
+ FileTest t(std::make_unique<StringLineReader>(GetTestData(path)), nullptr,
+ false);
while (true) {
switch (t.ReadNext()) {
diff --git a/crypto/x509/x509_test.cc b/crypto/x509/x509_test.cc
index 404ce5b..68d75d5 100644
--- a/crypto/x509/x509_test.cc
+++ b/crypto/x509/x509_test.cc
@@ -2335,7 +2335,7 @@
bssl::UniquePtr<uint8_t> data;
ASSERT_TRUE(PEMToDER(&data, &data_len, kRootCAPEM));
- std::unique_ptr<uint8_t[]> trailing_data(new uint8_t[data_len + 1]);
+ auto trailing_data = std::make_unique<uint8_t[]>(data_len + 1);
OPENSSL_memcpy(trailing_data.get(), data.get(), data_len);
bssl::UniquePtr<CRYPTO_BUFFER> buf_trailing_data(
@@ -2438,7 +2438,7 @@
bssl::UniquePtr<uint8_t> data;
ASSERT_TRUE(PEMToDER(&data, &data_len, kRootCAPEM));
- std::unique_ptr<uint8_t[]> data_with_trailing_byte(new uint8_t[data_len + 1]);
+ auto data_with_trailing_byte = std::make_unique<uint8_t[]>(data_len + 1);
OPENSSL_memcpy(data_with_trailing_byte.get(), data.get(), data_len);
data_with_trailing_byte[data_len] = 0;
diff --git a/decrepit/cfb/cfb_test.cc b/decrepit/cfb/cfb_test.cc
index da9681e..67904c2 100644
--- a/decrepit/cfb/cfb_test.cc
+++ b/decrepit/cfb/cfb_test.cc
@@ -87,7 +87,7 @@
SCOPED_TRACE(test_num);
const size_t input_len = sizeof(test.plaintext);
- std::unique_ptr<uint8_t[]> out(new uint8_t[input_len]);
+ auto out = std::make_unique<uint8_t[]>(input_len);
for (size_t stride = 1; stride <= input_len; stride++) {
bssl::ScopedEVP_CIPHER_CTX ctx;
@@ -134,7 +134,7 @@
nullptr, test.key, test.iv));
}
- std::unique_ptr<uint8_t[]> plaintext(new uint8_t[input_len]);
+ auto plaintext = std::make_unique<uint8_t[]>(input_len);
int num_bytes;
ASSERT_TRUE(EVP_DecryptUpdate(decrypt_ctx.get(), plaintext.get(),
&num_bytes, out.get(), input_len));
diff --git a/decrepit/ripemd/ripemd_test.cc b/decrepit/ripemd/ripemd_test.cc
index 6338fec..a52e743 100644
--- a/decrepit/ripemd/ripemd_test.cc
+++ b/decrepit/ripemd/ripemd_test.cc
@@ -90,7 +90,7 @@
}
static const size_t kLargeBufSize = 1000000;
- std::unique_ptr<uint8_t[]> buf(new uint8_t[kLargeBufSize]);
+ auto buf = std::make_unique<uint8_t[]>(kLargeBufSize);
OPENSSL_memset(buf.get(), 'a', kLargeBufSize);
uint8_t digest[RIPEMD160_DIGEST_LENGTH];
RIPEMD160(buf.get(), kLargeBufSize, digest);
diff --git a/ssl/ssl_test.cc b/ssl/ssl_test.cc
index b791fc3..73963c9 100644
--- a/ssl/ssl_test.cc
+++ b/ssl/ssl_test.cc
@@ -3522,7 +3522,7 @@
const uint8_t *ciphertext = ticket + 16 + 16;
size_t len = ticket_len - 16 - 16 - SHA256_DIGEST_LENGTH;
- std::unique_ptr<uint8_t[]> plaintext(new uint8_t[len]);
+ auto plaintext = std::make_unique<uint8_t[]>(len);
#if defined(BORINGSSL_UNSAFE_FUZZER_MODE)
// Fuzzer-mode tickets are unencrypted.
@@ -6299,7 +6299,7 @@
SSL_set_connect_state(client_.get());
SSL_set_accept_state(server_.get());
- transport_.reset(new MockQUICTransportPair);
+ transport_ = std::make_unique<MockQUICTransportPair>();
if (!ex_data_.Set(client_.get(), transport_->client()) ||
!ex_data_.Set(server_.get(), transport_->server())) {
return false;
diff --git a/ssl/test/bssl_shim.cc b/ssl/test/bssl_shim.cc
index 73aa5c6..19b838a 100644
--- a/ssl/test/bssl_shim.cc
+++ b/ssl/test/bssl_shim.cc
@@ -243,7 +243,7 @@
} while (RetryAsync(ssl, ret));
if (config->peek_then_read && ret > 0) {
- std::unique_ptr<uint8_t[]> buf(new uint8_t[static_cast<size_t>(ret)]);
+ auto buf = std::make_unique<uint8_t[]>(static_cast<size_t>(ret));
// SSL_peek should synchronously return the same data.
int ret2 = SSL_peek(ssl, buf.get(), ret);
@@ -790,8 +790,8 @@
SSL_CTX *ssl_ctx, const TestConfig *config,
const TestConfig *retry_config, bool is_resume,
SSL_SESSION *session, SettingsWriter *writer) {
- bssl::UniquePtr<SSL> ssl = config->NewSSL(
- ssl_ctx, session, std::unique_ptr<TestState>(new TestState));
+ bssl::UniquePtr<SSL> ssl =
+ config->NewSSL(ssl_ctx, session, std::make_unique<TestState>());
if (!ssl) {
return false;
}
@@ -858,8 +858,8 @@
bio = std::move(async_scoped);
}
if (config->is_quic) {
- GetTestState(ssl.get())->quic_transport.reset(
- new MockQuicTransport(std::move(bio), ssl.get()));
+ GetTestState(ssl.get())->quic_transport =
+ std::make_unique<MockQuicTransport>(std::move(bio), ssl.get());
} else {
SSL_set_bio(ssl.get(), bio.get(), bio.get());
bio.release(); // SSL_set_bio takes ownership.
@@ -1144,7 +1144,7 @@
// This mode writes a number of different record sizes in an attempt to
// trip up the CBC record splitting code.
static const size_t kBufLen = 32769;
- std::unique_ptr<uint8_t[]> buf(new uint8_t[kBufLen]);
+ auto buf = std::make_unique<uint8_t[]>(kBufLen);
OPENSSL_memset(buf.get(), 0x42, kBufLen);
static const size_t kRecordSizes[] = {
0, 1, 255, 256, 257, 16383, 16384, 16385, 32767, 32768, 32769};
@@ -1194,7 +1194,7 @@
if (config->read_size > 0) {
read_size = config->read_size;
}
- std::unique_ptr<uint8_t[]> buf(new uint8_t[read_size]);
+ auto buf = std::make_unique<uint8_t[]>(read_size);
int n = DoRead(ssl, buf.get(), read_size);
int err = SSL_get_error(ssl, n);
diff --git a/ssl/test/handshaker.cc b/ssl/test/handshaker.cc
index 72aaaa8..acdfe72 100644
--- a/ssl/test/handshaker.cc
+++ b/ssl/test/handshaker.cc
@@ -153,9 +153,8 @@
return false;
}
- UniquePtr<SSL> ssl =
- config->NewSSL(ctx.get(), /*session=*/nullptr,
- std::unique_ptr<TestState>(new TestState));
+ UniquePtr<SSL> ssl = config->NewSSL(ctx.get(), /*session=*/nullptr,
+ std::make_unique<TestState>());
if (!ssl) {
fprintf(stderr, "Error creating SSL object in handshaker.\n");
ERR_print_errors_fp(stderr);
diff --git a/ssl/test/test_config.cc b/ssl/test/test_config.cc
index baff66b..7a188f6 100644
--- a/ssl/test/test_config.cc
+++ b/ssl/test/test_config.cc
@@ -139,7 +139,7 @@
bool skip_handshaker = false) {
return Flag{name, true, skip_handshaker,
[=](TestConfig *config, const char *param) -> bool {
- (config->*field).reset(new std::string(param));
+ (config->*field) = std::make_unique<std::string>(param);
return true;
}};
}
@@ -972,7 +972,7 @@
return false;
}
- std::unique_ptr<uint8_t[]> buf(new uint8_t[in.size() / 2]);
+ auto buf = std::make_unique<uint8_t[]>(in.size() / 2);
for (size_t i = 0; i < in.size() / 2; i++) {
uint8_t high, low;
if (!OPENSSL_fromxdigit(&high, in[i * 2]) ||
@@ -1584,7 +1584,7 @@
if (uncompressed_len != 2 + in_len) {
return 0;
}
- std::unique_ptr<uint8_t[]> buf(new uint8_t[2 + in_len]);
+ auto buf = std::make_unique<uint8_t[]>(2 + in_len);
buf[0] = 0;
buf[1] = 0;
OPENSSL_memcpy(&buf[2], in, in_len);
diff --git a/tool/digest.cc b/tool/digest.cc
index d810928..e66f013 100644
--- a/tool/digest.cc
+++ b/tool/digest.cc
@@ -115,7 +115,7 @@
}
static const size_t kBufSize = 8192;
- std::unique_ptr<uint8_t[]> buf(new uint8_t[kBufSize]);
+ auto buf = std::make_unique<uint8_t[]>(kBufSize);
bssl::ScopedEVP_MD_CTX ctx;
if (!EVP_DigestInit_ex(ctx.get(), md, NULL)) {
diff --git a/tool/pkcs12.cc b/tool/pkcs12.cc
index 3d8a1cd..c19fd3a 100644
--- a/tool/pkcs12.cc
+++ b/tool/pkcs12.cc
@@ -72,7 +72,7 @@
}
const size_t size = st.st_size;
- std::unique_ptr<uint8_t[]> contents(new uint8_t[size]);
+ auto contents = std::make_unique<uint8_t[]>(size);
size_t off = 0;
while (off < size) {
size_t bytes_read;
diff --git a/tool/sign.cc b/tool/sign.cc
index a511e8d..038d853 100644
--- a/tool/sign.cc
+++ b/tool/sign.cc
@@ -68,7 +68,7 @@
}
size_t sig_len = EVP_PKEY_size(key.get());
- std::unique_ptr<uint8_t[]> sig(new uint8_t[sig_len]);
+ auto sig = std::make_unique<uint8_t[]>(sig_len);
if (!EVP_DigestSign(ctx.get(), sig.get(), &sig_len, data.data(),
data.size())) {
return false;
diff --git a/tool/speed.cc b/tool/speed.cc
index 8b4b13c..089a460 100644
--- a/tool/speed.cc
+++ b/tool/speed.cc
@@ -476,22 +476,21 @@
const size_t nonce_len = EVP_AEAD_nonce_length(aead);
const size_t overhead_len = EVP_AEAD_max_overhead(aead);
- std::unique_ptr<uint8_t[]> key(new uint8_t[key_len]);
+ auto key = std::make_unique<uint8_t[]>(key_len);
OPENSSL_memset(key.get(), 0, key_len);
- std::unique_ptr<uint8_t[]> nonce(new uint8_t[nonce_len]);
+ auto nonce = std::make_unique<uint8_t[]>(nonce_len);
OPENSSL_memset(nonce.get(), 0, nonce_len);
- std::unique_ptr<uint8_t[]> in_storage(new uint8_t[chunk_len + kAlignment]);
+ auto in_storage = std::make_unique<uint8_t[]>(chunk_len + kAlignment);
// N.B. for EVP_AEAD_CTX_seal_scatter the input and output buffers may be the
// same size. However, in the direction == evp_aead_open case we still use
// non-scattering seal, hence we add overhead_len to the size of this buffer.
- std::unique_ptr<uint8_t[]> out_storage(
- new uint8_t[chunk_len + overhead_len + kAlignment]);
- std::unique_ptr<uint8_t[]> in2_storage(
- new uint8_t[chunk_len + overhead_len + kAlignment]);
- std::unique_ptr<uint8_t[]> ad(new uint8_t[ad_len]);
+ auto out_storage =
+ std::make_unique<uint8_t[]>(chunk_len + overhead_len + kAlignment);
+ auto in2_storage =
+ std::make_unique<uint8_t[]>(chunk_len + overhead_len + kAlignment);
+ auto ad = std::make_unique<uint8_t[]>(ad_len);
OPENSSL_memset(ad.get(), 0, ad_len);
- std::unique_ptr<uint8_t[]> tag_storage(
- new uint8_t[overhead_len + kAlignment]);
+ auto tag_storage = std::make_unique<uint8_t[]>(overhead_len + kAlignment);
uint8_t *const in =
@@ -760,7 +759,7 @@
if (peer_value_len == 0) {
return false;
}
- std::unique_ptr<uint8_t[]> peer_value(new uint8_t[peer_value_len]);
+ auto peer_value = std::make_unique<uint8_t[]>(peer_value_len);
peer_value_len = EC_POINT_point2oct(
EC_KEY_get0_group(peer_key.get()), EC_KEY_get0_public_key(peer_key.get()),
POINT_CONVERSION_UNCOMPRESSED, peer_value.get(), peer_value_len, nullptr);
diff --git a/util/fipstools/acvp/modulewrapper/modulewrapper.cc b/util/fipstools/acvp/modulewrapper/modulewrapper.cc
index 0c1359e..5274598 100644
--- a/util/fipstools/acvp/modulewrapper/modulewrapper.cc
+++ b/util/fipstools/acvp/modulewrapper/modulewrapper.cc
@@ -75,7 +75,7 @@
// static
std::unique_ptr<RequestBuffer> RequestBuffer::New() {
- return std::unique_ptr<RequestBuffer>(new RequestBufferImpl);
+ return std::make_unique<RequestBufferImpl>();
}
static bool ReadAll(int fd, void *in_data, size_t data_len) {
