Make //crypto factories return std::unique_ptr<>s

crypto/encryptor.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "crypto/encryptor.h"
 
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "crypto/openssl_util.h"
 #include "crypto/symmetric_key.h"
 
 namespace crypto {
 
 namespace {
 
 const EVP_CIPHER* GetCipherForKey(SymmetricKey* key) {
   switch (key->key().length()) {
     case 16: return EVP_aes_128_cbc();
     case 32: return EVP_aes_256_cbc();
-    default: return NULL;
+    default:
+      return nullptr;
   }
 }
 
 // On destruction this class will cleanup the ctx, and also clear the OpenSSL
 // ERR stack as a convenience.
 class ScopedCipherCTX {
  public:
   explicit ScopedCipherCTX() {
     EVP_CIPHER_CTX_init(&ctx_);
   }
@@ skipping 40 matching lines @@
   memcpy(buf_ptr, &counter_, sizeof(counter_));
 }
 
 size_t Encryptor::Counter::GetLengthInBytes() const {
   return sizeof(counter_);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Encryptor Implementation.
 
-Encryptor::Encryptor()
-    : key_(NULL),
-      mode_(CBC) {
-}
+Encryptor::Encryptor() : key_(nullptr), mode_(CBC) {}
 
 Encryptor::~Encryptor() {
 }
 
 bool Encryptor::Init(SymmetricKey* key,
                      Mode mode,
                      const base::StringPiece& iv) {
   DCHECK(key);
   DCHECK(mode == CBC || mode == CTR);
 
   EnsureOpenSSLInit();
   if (mode == CBC && iv.size() != AES_BLOCK_SIZE)
     return false;
 
-  if (GetCipherForKey(key) == NULL)
+  if (GetCipherForKey(key) == nullptr)
     return false;
 
   key_ = key;
   mode_ = mode;
   iv.CopyToString(&iv_);
   return true;
 }
 
 bool Encryptor::Encrypt(const base::StringPiece& plaintext,
                         std::string* ciphertext) {
@@ skipping 68 matching lines @@
   output->clear();
 
   const EVP_CIPHER* cipher = GetCipherForKey(key_);
   DCHECK(cipher);  // Already handled in Init();
 
   const std::string& key = key_->key();
   DCHECK_EQ(EVP_CIPHER_iv_length(cipher), iv_.length());
   DCHECK_EQ(EVP_CIPHER_key_length(cipher), key.length());
 
   ScopedCipherCTX ctx;
-  if (!EVP_CipherInit_ex(
-          ctx.get(), cipher, NULL, reinterpret_cast<const uint8_t*>(key.data()),
-          reinterpret_cast<const uint8_t*>(iv_.data()), do_encrypt))
+  if (!EVP_CipherInit_ex(ctx.get(), cipher, nullptr,
+                         reinterpret_cast<const uint8_t*>(key.data()),
+                         reinterpret_cast<const uint8_t*>(iv_.data()),
+                         do_encrypt))
     return false;
 
   // When encrypting, add another block size of space to allow for any padding.
   const size_t output_size = input.size() + (do_encrypt ? iv_.size() : 0);
   CHECK_GT(output_size, 0u);
   CHECK_GT(output_size + 1, input.size());
   uint8_t* out_ptr =
       reinterpret_cast<uint8_t*>(base::WriteInto(&result, output_size + 1));
   int out_len;
   if (!EVP_CipherUpdate(ctx.get(), out_ptr, &out_len,
@@ skipping 48 matching lines @@
 
   // AES_ctr128_encrypt() updates |ivec|. Update the |counter_| here.
   SetCounter(base::StringPiece(reinterpret_cast<const char*>(ivec),
                                AES_BLOCK_SIZE));
 
   output->swap(result);
   return true;
 }
 
 }  // namespace crypto