Skip to content

Commit a36ac0a

Browse files
davidbenBoringssl LUCI CQ
davidben
authored and
Boringssl LUCI CQ
committed
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 <[email protected]> Commit-Queue: David Benjamin <[email protected]>
1 parent 417069f commit a36ac0a

File tree

22 files changed

+63
-64
lines changed

22 files changed

+63
-64
lines changed

‎crypto/chacha/chacha_test.cc

+3-3
Original file line numberDiff line numberDiff line change
@@ -320,7 +320,7 @@ TEST(ChaChaTest, TestVector) {
320320
for (size_t len = 0; len <= sizeof(kInput); len++) {
321321
SCOPED_TRACE(len);
322322

323-
std::unique_ptr<uint8_t[]> buf(new uint8_t[len]);
323+
auto buf = std::make_unique<uint8_t[]>(len);
324324
CRYPTO_chacha_20(buf.get(), kInput, len, kKey, kNonce, kCounter);
325325
EXPECT_EQ(Bytes(kOutput, len), Bytes(buf.get(), len));
326326

@@ -336,7 +336,7 @@ TEST(ChaChaTest, CounterOverflow) {
336336
for (size_t len = 0; len <= sizeof(kInput); len++) {
337337
SCOPED_TRACE(len);
338338

339-
std::unique_ptr<uint8_t[]> buf(new uint8_t[len]);
339+
auto buf = std::make_unique<uint8_t[]>(len);
340340
CRYPTO_chacha_20(buf.get(), kInput, len, kKey, kNonce, kOverflowCounter);
341341
EXPECT_EQ(Bytes(kOverflowOutput, len), Bytes(buf.get(), len));
342342

@@ -354,7 +354,7 @@ TEST(ChaChaTest, ABI) {
354354

355355
static const uint32_t kCounterNonce[4] = {0};
356356

357-
std::unique_ptr<uint8_t[]> buf(new uint8_t[sizeof(kInput)]);
357+
auto buf = std::make_unique<uint8_t[]>(sizeof(kInput));
358358
for (size_t len = 0; len <= 32; len++) {
359359
SCOPED_TRACE(len);
360360
CHECK_ABI(ChaCha20_ctr32, buf.get(), kInput, len, key, kCounterNonce);

‎crypto/cipher_extra/aead_test.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -821,7 +821,7 @@ TEST(ChaChaPoly1305Test, ABI) {
821821
return;
822822
}
823823

824-
std::unique_ptr<uint8_t[]> buf(new uint8_t[1024]);
824+
auto buf = std::make_unique<uint8_t[]>(1024);
825825
for (size_t len = 0; len <= 1024; len += 5) {
826826
SCOPED_TRACE(len);
827827
union chacha20_poly1305_open_data open_ctx = {};

‎crypto/digest_extra/digest_test.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -167,7 +167,7 @@ static void TestDigest(const DigestTestVector *test) {
167167
for (size_t i = 0; i < test->repeat; i++) {
168168
ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), test->input, strlen(test->input)));
169169
}
170-
std::unique_ptr<uint8_t[]> digest(new uint8_t[EVP_MD_size(test->md.func())]);
170+
auto digest = std::make_unique<uint8_t[]>(EVP_MD_size(test->md.func()));
171171
unsigned digest_len;
172172
ASSERT_TRUE(EVP_DigestFinal_ex(ctx.get(), digest.get(), &digest_len));
173173
CompareDigest(test, digest.get(), digest_len);

‎crypto/fipsmodule/aes/aes_test.cc

+4-4
Original file line numberDiff line numberDiff line change
@@ -89,7 +89,7 @@ static void TestKeyWrap(FileTest *t) {
8989
ASSERT_EQ(0, AES_set_encrypt_key(key.data(), 8 * key.size(), &aes_key));
9090

9191
// Test with implicit IV.
92-
std::unique_ptr<uint8_t[]> buf(new uint8_t[ciphertext.size()]);
92+
auto buf = std::make_unique<uint8_t[]>(ciphertext.size());
9393
int len = AES_wrap_key(&aes_key, nullptr /* iv */, buf.get(),
9494
plaintext.data(), plaintext.size());
9595
ASSERT_GE(len, 0);
@@ -106,7 +106,7 @@ static void TestKeyWrap(FileTest *t) {
106106
ASSERT_EQ(0, AES_set_decrypt_key(key.data(), 8 * key.size(), &aes_key));
107107

108108
// Test with implicit IV.
109-
buf.reset(new uint8_t[plaintext.size()]);
109+
buf = std::make_unique<uint8_t[]>(plaintext.size());
110110
len = AES_unwrap_key(&aes_key, nullptr /* iv */, buf.get(), ciphertext.data(),
111111
ciphertext.size());
112112
ASSERT_GE(len, 0);
@@ -133,7 +133,7 @@ static void TestKeyWrapWithPadding(FileTest *t) {
133133
// Test encryption.
134134
AES_KEY aes_key;
135135
ASSERT_EQ(0, AES_set_encrypt_key(key.data(), 8 * key.size(), &aes_key));
136-
std::unique_ptr<uint8_t[]> buf(new uint8_t[plaintext.size() + 15]);
136+
auto buf = std::make_unique<uint8_t[]>(plaintext.size() + 15);
137137
size_t len;
138138
ASSERT_TRUE(AES_wrap_key_padded(&aes_key, buf.get(), &len,
139139
plaintext.size() + 15, plaintext.data(),
@@ -142,7 +142,7 @@ static void TestKeyWrapWithPadding(FileTest *t) {
142142

143143
// Test decryption
144144
ASSERT_EQ(0, AES_set_decrypt_key(key.data(), 8 * key.size(), &aes_key));
145-
buf.reset(new uint8_t[ciphertext.size() - 8]);
145+
buf = std::make_unique<uint8_t[]>(ciphertext.size() - 8);
146146
ASSERT_TRUE(AES_unwrap_key_padded(&aes_key, buf.get(), &len,
147147
ciphertext.size() - 8, ciphertext.data(),
148148
ciphertext.size()));

‎crypto/fipsmodule/bn/bn_test.cc

+14-11
Original file line numberDiff line numberDiff line change
@@ -458,8 +458,8 @@ static void TestSquare(BIGNUMFileTest *t, BN_CTX *ctx) {
458458
SCOPED_TRACE(num_a);
459459
size_t num_r = 2 * num_a;
460460
// Use newly-allocated buffers so ASan will catch out-of-bounds writes.
461-
std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[num_a]),
462-
r_words(new BN_ULONG[num_r]);
461+
auto a_words = std::make_unique<BN_ULONG[]>(num_a);
462+
auto r_words = std::make_unique<BN_ULONG[]>(num_r);
463463
ASSERT_TRUE(bn_copy_words(a_words.get(), num_a, a.get()));
464464

465465
bn_mul_small(r_words.get(), num_r, a_words.get(), num_a, a_words.get(),
@@ -525,8 +525,9 @@ static void TestProduct(BIGNUMFileTest *t, BN_CTX *ctx) {
525525
SCOPED_TRACE(num_b);
526526
size_t num_r = num_a + num_b;
527527
// Use newly-allocated buffers so ASan will catch out-of-bounds writes.
528-
std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[num_a]),
529-
b_words(new BN_ULONG[num_b]), r_words(new BN_ULONG[num_r]);
528+
auto a_words = std::make_unique<BN_ULONG[]>(num_a);
529+
auto b_words = std::make_unique<BN_ULONG[]>(num_b);
530+
auto r_words = std::make_unique<BN_ULONG[]>(num_r);
530531
ASSERT_TRUE(bn_copy_words(a_words.get(), num_a, a.get()));
531532
ASSERT_TRUE(bn_copy_words(b_words.get(), num_b, b.get()));
532533

@@ -672,8 +673,9 @@ static void TestModMul(BIGNUMFileTest *t, BN_CTX *ctx) {
672673
#if !defined(BORINGSSL_SHARED_LIBRARY)
673674
size_t m_width = static_cast<size_t>(bn_minimal_width(m.get()));
674675
if (m_width <= BN_SMALL_MAX_WORDS) {
675-
std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[m_width]),
676-
b_words(new BN_ULONG[m_width]), r_words(new BN_ULONG[m_width]);
676+
auto a_words = std::make_unique<BN_ULONG[]>(m_width);
677+
auto b_words = std::make_unique<BN_ULONG[]>(m_width);
678+
auto r_words = std::make_unique<BN_ULONG[]>(m_width);
677679
ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get()));
678680
ASSERT_TRUE(bn_copy_words(b_words.get(), m_width, b.get()));
679681
bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get());
@@ -691,7 +693,7 @@ static void TestModMul(BIGNUMFileTest *t, BN_CTX *ctx) {
691693
// inputs. Test this by running |bn_from_montgomery_small| on the result
692694
// of a product. Note |a_words| * |b_words| has an extra factor of R^2, so
693695
// we must reduce twice.
694-
std::unique_ptr<BN_ULONG[]> prod_words(new BN_ULONG[m_width * 2]);
696+
auto prod_words = std::make_unique<BN_ULONG[]>(m_width * 2);
695697
bn_mul_small(prod_words.get(), m_width * 2, a_words.get(), m_width,
696698
b_words.get(), m_width);
697699
bn_from_montgomery_small(r_words.get(), m_width, prod_words.get(),
@@ -752,8 +754,9 @@ static void TestModSquare(BIGNUMFileTest *t, BN_CTX *ctx) {
752754
#if !defined(BORINGSSL_SHARED_LIBRARY)
753755
size_t m_width = static_cast<size_t>(bn_minimal_width(m.get()));
754756
if (m_width <= BN_SMALL_MAX_WORDS) {
755-
std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[m_width]),
756-
a_copy_words(new BN_ULONG[m_width]), r_words(new BN_ULONG[m_width]);
757+
auto a_words = std::make_unique<BN_ULONG[]>(m_width);
758+
auto a_copy_words = std::make_unique<BN_ULONG[]>(m_width);
759+
auto r_words = std::make_unique<BN_ULONG[]>(m_width);
757760
ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get()));
758761
bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get());
759762
bn_mod_mul_montgomery_small(r_words.get(), a_words.get(), a_words.get(),
@@ -815,8 +818,8 @@ static void TestModExp(BIGNUMFileTest *t, BN_CTX *ctx) {
815818
bssl::UniquePtr<BN_MONT_CTX> mont(
816819
BN_MONT_CTX_new_for_modulus(m.get(), ctx));
817820
ASSERT_TRUE(mont.get());
818-
std::unique_ptr<BN_ULONG[]> r_words(new BN_ULONG[m_width]),
819-
a_words(new BN_ULONG[m_width]);
821+
auto r_words = std::make_unique<BN_ULONG[]>(m_width);
822+
auto a_words = std::make_unique<BN_ULONG[]>(m_width);
820823
ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get()));
821824
bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get());
822825
bn_mod_exp_mont_small(r_words.get(), a_words.get(), m_width, e->d,

‎crypto/fipsmodule/rand/ctrdrbg_test.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -76,7 +76,7 @@ TEST(CTRDRBGTest, Large) {
7676
CTR_DRBG_STATE drbg;
7777
ASSERT_TRUE(CTR_DRBG_init(&drbg, kSeed, nullptr, 0));
7878

79-
std::unique_ptr<uint8_t[]> buf(new uint8_t[CTR_DRBG_MAX_GENERATE_LENGTH]);
79+
auto buf = std::make_unique<uint8_t[]>(CTR_DRBG_MAX_GENERATE_LENGTH);
8080
ASSERT_TRUE(CTR_DRBG_generate(&drbg, buf.get(), CTR_DRBG_MAX_GENERATE_LENGTH,
8181
nullptr, 0));
8282

‎crypto/hmac_extra/hmac_test.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,7 @@ TEST(HMACTest, TestVectors) {
9999
ASSERT_EQ(EVP_MD_size(digest), output.size());
100100

101101
// Test using the one-shot API.
102-
std::unique_ptr<uint8_t[]> mac(new uint8_t[EVP_MD_size(digest)]);
102+
auto mac = std::make_unique<uint8_t[]>(EVP_MD_size(digest));
103103
unsigned mac_len;
104104
ASSERT_TRUE(HMAC(digest, key.data(), key.size(), input.data(), input.size(),
105105
mac.get(), &mac_len));

‎crypto/lhash/lhash_test.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ DEFINE_LHASH_OF(char)
3636

3737
static std::unique_ptr<char[]> RandString(void) {
3838
unsigned len = 1 + (rand() % 3);
39-
std::unique_ptr<char[]> ret(new char[len + 1]);
39+
auto ret = std::make_unique<char[]>(len + 1);
4040

4141
for (unsigned i = 0; i < len; i++) {
4242
ret[i] = '0' + (rand() & 7);

‎crypto/test/file_test.cc

+2-3
Original file line numberDiff line numberDiff line change
@@ -98,7 +98,7 @@ FileTest::ReadResult FileTest::ReadNext() {
9898
ClearTest();
9999

100100
static const size_t kBufLen = 8192 * 4;
101-
std::unique_ptr<char[]> buf(new char[kBufLen]);
101+
auto buf = std::make_unique<char[]>(kBufLen);
102102

103103
bool in_instruction_block = false;
104104
is_at_new_instruction_block_ = false;
@@ -409,8 +409,7 @@ int FileTestMain(FileTestFunc run_test, void *arg, const char *path) {
409409
}
410410

411411
int FileTestMain(const FileTest::Options &opts) {
412-
std::unique_ptr<FileLineReader> reader(
413-
new FileLineReader(opts.path));
412+
auto reader = std::make_unique<FileLineReader>(opts.path);
414413
if (!reader->is_open()) {
415414
fprintf(stderr, "Could not open file %s: %s.\n", opts.path,
416415
strerror(errno));

‎crypto/test/file_test_gtest.cc

+2-3
Original file line numberDiff line numberDiff line change
@@ -66,9 +66,8 @@ class StringLineReader : public FileTest::LineReader {
6666
};
6767

6868
void FileTestGTest(const char *path, std::function<void(FileTest *)> run_test) {
69-
std::unique_ptr<StringLineReader> reader(
70-
new StringLineReader(GetTestData(path)));
71-
FileTest t(std::move(reader), nullptr, false);
69+
FileTest t(std::make_unique<StringLineReader>(GetTestData(path)), nullptr,
70+
false);
7271

7372
while (true) {
7473
switch (t.ReadNext()) {

‎crypto/x509/x509_test.cc

+2-2
Original file line numberDiff line numberDiff line change
@@ -2335,7 +2335,7 @@ TEST(X509Test, TestFromBufferWithTrailingData) {
23352335
bssl::UniquePtr<uint8_t> data;
23362336
ASSERT_TRUE(PEMToDER(&data, &data_len, kRootCAPEM));
23372337

2338-
std::unique_ptr<uint8_t[]> trailing_data(new uint8_t[data_len + 1]);
2338+
auto trailing_data = std::make_unique<uint8_t[]>(data_len + 1);
23392339
OPENSSL_memcpy(trailing_data.get(), data.get(), data_len);
23402340

23412341
bssl::UniquePtr<CRYPTO_BUFFER> buf_trailing_data(
@@ -2438,7 +2438,7 @@ TEST(X509Test, TestFailedParseFromBuffer) {
24382438
bssl::UniquePtr<uint8_t> data;
24392439
ASSERT_TRUE(PEMToDER(&data, &data_len, kRootCAPEM));
24402440

2441-
std::unique_ptr<uint8_t[]> data_with_trailing_byte(new uint8_t[data_len + 1]);
2441+
auto data_with_trailing_byte = std::make_unique<uint8_t[]>(data_len + 1);
24422442
OPENSSL_memcpy(data_with_trailing_byte.get(), data.get(), data_len);
24432443
data_with_trailing_byte[data_len] = 0;
24442444

‎decrepit/cfb/cfb_test.cc

+2-2
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@ TEST(CFBTest, TestVectors) {
8787
SCOPED_TRACE(test_num);
8888

8989
const size_t input_len = sizeof(test.plaintext);
90-
std::unique_ptr<uint8_t[]> out(new uint8_t[input_len]);
90+
auto out = std::make_unique<uint8_t[]>(input_len);
9191

9292
for (size_t stride = 1; stride <= input_len; stride++) {
9393
bssl::ScopedEVP_CIPHER_CTX ctx;
@@ -134,7 +134,7 @@ TEST(CFBTest, TestVectors) {
134134
nullptr, test.key, test.iv));
135135
}
136136

137-
std::unique_ptr<uint8_t[]> plaintext(new uint8_t[input_len]);
137+
auto plaintext = std::make_unique<uint8_t[]>(input_len);
138138
int num_bytes;
139139
ASSERT_TRUE(EVP_DecryptUpdate(decrypt_ctx.get(), plaintext.get(),
140140
&num_bytes, out.get(), input_len));

‎decrepit/ripemd/ripemd_test.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,7 @@ TEST(RIPEMDTest, RunTest) {
9090
}
9191

9292
static const size_t kLargeBufSize = 1000000;
93-
std::unique_ptr<uint8_t[]> buf(new uint8_t[kLargeBufSize]);
93+
auto buf = std::make_unique<uint8_t[]>(kLargeBufSize);
9494
OPENSSL_memset(buf.get(), 'a', kLargeBufSize);
9595
uint8_t digest[RIPEMD160_DIGEST_LENGTH];
9696
RIPEMD160(buf.get(), kLargeBufSize, digest);

‎ssl/ssl_test.cc

+2-2
Original file line numberDiff line numberDiff line change
@@ -3522,7 +3522,7 @@ static bool GetServerTicketTime(long *out, const SSL_SESSION *session) {
35223522

35233523
const uint8_t *ciphertext = ticket + 16 + 16;
35243524
size_t len = ticket_len - 16 - 16 - SHA256_DIGEST_LENGTH;
3525-
std::unique_ptr<uint8_t[]> plaintext(new uint8_t[len]);
3525+
auto plaintext = std::make_unique<uint8_t[]>(len);
35263526

35273527
#if defined(BORINGSSL_UNSAFE_FUZZER_MODE)
35283528
// Fuzzer-mode tickets are unencrypted.
@@ -6299,7 +6299,7 @@ class QUICMethodTest : public testing::Test {
62996299
SSL_set_connect_state(client_.get());
63006300
SSL_set_accept_state(server_.get());
63016301

6302-
transport_.reset(new MockQUICTransportPair);
6302+
transport_ = std::make_unique<MockQUICTransportPair>();
63036303
if (!ex_data_.Set(client_.get(), transport_->client()) ||
63046304
!ex_data_.Set(server_.get(), transport_->server())) {
63056305
return false;

‎ssl/test/bssl_shim.cc

+7-7
Original file line numberDiff line numberDiff line change
@@ -243,7 +243,7 @@ static int DoRead(SSL *ssl, uint8_t *out, size_t max_out) {
243243
} while (RetryAsync(ssl, ret));
244244

245245
if (config->peek_then_read && ret > 0) {
246-
std::unique_ptr<uint8_t[]> buf(new uint8_t[static_cast<size_t>(ret)]);
246+
auto buf = std::make_unique<uint8_t[]>(static_cast<size_t>(ret));
247247

248248
// SSL_peek should synchronously return the same data.
249249
int ret2 = SSL_peek(ssl, buf.get(), ret);
@@ -790,8 +790,8 @@ static bool DoConnection(bssl::UniquePtr<SSL_SESSION> *out_session,
790790
SSL_CTX *ssl_ctx, const TestConfig *config,
791791
const TestConfig *retry_config, bool is_resume,
792792
SSL_SESSION *session, SettingsWriter *writer) {
793-
bssl::UniquePtr<SSL> ssl = config->NewSSL(
794-
ssl_ctx, session, std::unique_ptr<TestState>(new TestState));
793+
bssl::UniquePtr<SSL> ssl =
794+
config->NewSSL(ssl_ctx, session, std::make_unique<TestState>());
795795
if (!ssl) {
796796
return false;
797797
}
@@ -858,8 +858,8 @@ static bool DoConnection(bssl::UniquePtr<SSL_SESSION> *out_session,
858858
bio = std::move(async_scoped);
859859
}
860860
if (config->is_quic) {
861-
GetTestState(ssl.get())->quic_transport.reset(
862-
new MockQuicTransport(std::move(bio), ssl.get()));
861+
GetTestState(ssl.get())->quic_transport =
862+
std::make_unique<MockQuicTransport>(std::move(bio), ssl.get());
863863
} else {
864864
SSL_set_bio(ssl.get(), bio.get(), bio.get());
865865
bio.release(); // SSL_set_bio takes ownership.
@@ -1144,7 +1144,7 @@ static bool DoExchange(bssl::UniquePtr<SSL_SESSION> *out_session,
11441144
// This mode writes a number of different record sizes in an attempt to
11451145
// trip up the CBC record splitting code.
11461146
static const size_t kBufLen = 32769;
1147-
std::unique_ptr<uint8_t[]> buf(new uint8_t[kBufLen]);
1147+
auto buf = std::make_unique<uint8_t[]>(kBufLen);
11481148
OPENSSL_memset(buf.get(), 0x42, kBufLen);
11491149
static const size_t kRecordSizes[] = {
11501150
0, 1, 255, 256, 257, 16383, 16384, 16385, 32767, 32768, 32769};
@@ -1194,7 +1194,7 @@ static bool DoExchange(bssl::UniquePtr<SSL_SESSION> *out_session,
11941194
if (config->read_size > 0) {
11951195
read_size = config->read_size;
11961196
}
1197-
std::unique_ptr<uint8_t[]> buf(new uint8_t[read_size]);
1197+
auto buf = std::make_unique<uint8_t[]>(read_size);
11981198

11991199
int n = DoRead(ssl, buf.get(), read_size);
12001200
int err = SSL_get_error(ssl, n);

‎ssl/test/handshaker.cc

+2-3
Original file line numberDiff line numberDiff line change
@@ -153,9 +153,8 @@ bool GenerateHandshakeHint(const TestConfig *config,
153153
return false;
154154
}
155155

156-
UniquePtr<SSL> ssl =
157-
config->NewSSL(ctx.get(), /*session=*/nullptr,
158-
std::unique_ptr<TestState>(new TestState));
156+
UniquePtr<SSL> ssl = config->NewSSL(ctx.get(), /*session=*/nullptr,
157+
std::make_unique<TestState>());
159158
if (!ssl) {
160159
fprintf(stderr, "Error creating SSL object in handshaker.\n");
161160
ERR_print_errors_fp(stderr);

‎ssl/test/test_config.cc

+3-3
Original file line numberDiff line numberDiff line change
@@ -139,7 +139,7 @@ Flag OptionalStringFlag(const char *name,
139139
bool skip_handshaker = false) {
140140
return Flag{name, true, skip_handshaker,
141141
[=](TestConfig *config, const char *param) -> bool {
142-
(config->*field).reset(new std::string(param));
142+
(config->*field) = std::make_unique<std::string>(param);
143143
return true;
144144
}};
145145
}
@@ -972,7 +972,7 @@ static bool HexDecode(std::string *out, const std::string &in) {
972972
return false;
973973
}
974974

975-
std::unique_ptr<uint8_t[]> buf(new uint8_t[in.size() / 2]);
975+
auto buf = std::make_unique<uint8_t[]>(in.size() / 2);
976976
for (size_t i = 0; i < in.size() / 2; i++) {
977977
uint8_t high, low;
978978
if (!OPENSSL_fromxdigit(&high, in[i * 2]) ||
@@ -1584,7 +1584,7 @@ bssl::UniquePtr<SSL_CTX> TestConfig::SetupCtx(SSL_CTX *old_ctx) const {
15841584
if (uncompressed_len != 2 + in_len) {
15851585
return 0;
15861586
}
1587-
std::unique_ptr<uint8_t[]> buf(new uint8_t[2 + in_len]);
1587+
auto buf = std::make_unique<uint8_t[]>(2 + in_len);
15881588
buf[0] = 0;
15891589
buf[1] = 0;
15901590
OPENSSL_memcpy(&buf[2], in, in_len);

‎tool/digest.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -115,7 +115,7 @@ static bool SumFile(std::string *out_hex, const EVP_MD *md,
115115
}
116116

117117
static const size_t kBufSize = 8192;
118-
std::unique_ptr<uint8_t[]> buf(new uint8_t[kBufSize]);
118+
auto buf = std::make_unique<uint8_t[]>(kBufSize);
119119

120120
bssl::ScopedEVP_MD_CTX ctx;
121121
if (!EVP_DigestInit_ex(ctx.get(), md, NULL)) {

‎tool/pkcs12.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ bool DoPKCS12(const std::vector<std::string> &args) {
7272
}
7373
const size_t size = st.st_size;
7474

75-
std::unique_ptr<uint8_t[]> contents(new uint8_t[size]);
75+
auto contents = std::make_unique<uint8_t[]>(size);
7676
size_t off = 0;
7777
while (off < size) {
7878
size_t bytes_read;

‎tool/sign.cc

+1-1
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ bool Sign(const std::vector<std::string> &args) {
6868
}
6969

7070
size_t sig_len = EVP_PKEY_size(key.get());
71-
std::unique_ptr<uint8_t[]> sig(new uint8_t[sig_len]);
71+
auto sig = std::make_unique<uint8_t[]>(sig_len);
7272
if (!EVP_DigestSign(ctx.get(), sig.get(), &sig_len, data.data(),
7373
data.size())) {
7474
return false;

0 commit comments

Comments
 (0)