Eliminate an extra allocation in encryptor_win when en/decrypting.

crypto/encryptor_win.cc

 // Copyright (c) 2011 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 <vector>
-
+#include "base/string_util.h"
 #include "crypto/symmetric_key.h"
 
 namespace crypto {
 
 namespace {
 
 // On success, returns the block size (in bytes) for the algorithm that |key|
 // is for. On failure, returns 0.
 DWORD GetCipherBlockSize(HCRYPTKEY key) {
   DWORD block_size_in_bits = 0;
@@ skipping 57 matching lines @@
   if (!ok)
     return false;
 
   return true;
 }
 
 bool Encryptor::Encrypt(const base::StringPiece& plaintext,
                         std::string* ciphertext) {
   DWORD data_len = plaintext.size();
   DWORD total_len = data_len + block_size_;
+  CHECK_GT(total_len, data_len);
 
   // CryptoAPI encrypts/decrypts in place.
-  std::vector<BYTE> tmp(total_len);
-  memcpy(&tmp[0], plaintext.data(), data_len);
+  char* ciphertext_data = WriteInto(ciphertext, total_len + 1);
+  plaintext.copy(ciphertext_data, plaintext.size(), 0);

[wtc, 2011/07/07 01:03:12]

Note: This comment also applies to the ciphertext.copy() call below.

plaintext.size() => data_len

Nit: it seems better to just call memcpy() here.

 
-  BOOL ok = CryptEncrypt(capi_key_.get(), NULL, TRUE, 0, &tmp[0],
-                         &data_len, total_len);
-  if (!ok)
+  BOOL ok = CryptEncrypt(capi_key_.get(), NULL, TRUE, 0,
+                         reinterpret_cast<BYTE*>(ciphertext_data), &data_len,
+                         total_len);
+  if (!ok) {
+    ciphertext->clear();
     return false;
+  }
 
-  ciphertext->assign(reinterpret_cast<char*>(&tmp[0]), data_len);
+  ciphertext->resize(data_len);
   return true;
 }
 
 bool Encryptor::Decrypt(const base::StringPiece& ciphertext,
                         std::string* plaintext) {
   DWORD data_len = ciphertext.size();
   if (data_len == 0)
     return false;
 
-  std::vector<BYTE> tmp(data_len);
-  memcpy(&tmp[0], ciphertext.data(), data_len);
+  // CryptoAPI encrypts/decrypts in place.
+  char* plaintext_data = WriteInto(plaintext, data_len + 1);
+  ciphertext.copy(plaintext_data, ciphertext.size(), 0);
 
-  BOOL ok = CryptDecrypt(capi_key_.get(), NULL, TRUE, 0, &tmp[0], &data_len);
-  if (!ok)
+  BOOL ok = CryptDecrypt(capi_key_.get(), NULL, TRUE, 0,
+                         reinterpret_cast<BYTE*>(plaintext_data), &data_len);
+  if (!ok) {
+    plaintext->clear();
     return false;
+  }
 
-  DCHECK_GT(tmp.size(), data_len);
-
-  plaintext->assign(reinterpret_cast<char*>(&tmp[0]), data_len);
+  plaintext->resize(data_len);
   return true;
 }
 
 }  // namespace crypto