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 59 matching lines @@
 
   return true;
 }
 
 bool Encryptor::Encrypt(const base::StringPiece& plaintext,
                         std::string* ciphertext) {
   DWORD data_len = plaintext.size();
   DWORD total_len = data_len + block_size_;
 
   // CryptoAPI encrypts/decrypts in place.
-  std::vector<BYTE> tmp(total_len);
-  memcpy(&tmp[0], plaintext.data(), data_len);
+  plaintext.CopyToString(ciphertext);
 
-  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*>(WriteInto(ciphertext, total_len+1)),

[wtc, 2011/06/29 00:46:41]

Add spaces around '+'.

It is safer to do things in this order:

1. Call WriteInto(ciphertext, total_len + 1) to get a pointer
to an output buffer of the right size.

2. Copy plaintext into the output buffer.

3. Pass the output buffer to CryptEncrypt.

The reason to call WriteInto before copying is that I
am not sure if WriteInto preserves the existing data in
the std::string.

I prefer ciphertext->clear() to ciphertext->resize(0).

+      &data_len, total_len);
+  if (!ok) {
+    ciphertext->resize(0);
     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.
+  ciphertext.CopyToString(plaintext);
 
-  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*>(WriteInto(plaintext, data_len+1)),
+      &data_len);
+  if (!ok) {
+    plaintext->resize(0);
     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