Use base::StringPiece for input parameters in Encryptor, rather than std::string

crypto/encryptor_nss.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 <cryptohi.h>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 23 matching lines @@
 
 Encryptor::Encryptor()
     : key_(NULL),
       mode_(CBC) {
   EnsureNSSInit();
 }
 
 Encryptor::~Encryptor() {
 }
 
-bool Encryptor::Init(SymmetricKey* key, Mode mode, const std::string& iv) {
+bool Encryptor::Init(SymmetricKey* key,
+                     Mode mode,
+                     const base::StringPiece& iv) {
   DCHECK(key);
   DCHECK(CBC == mode || CTR == mode) << "Unsupported mode of operation";
 
   key_ = key;
   mode_ = mode;
 
   if (mode == CBC && iv.size() != AES_BLOCK_SIZE)
     return false;
 
   slot_.reset(PK11_GetBestSlot(GetMechanism(mode), NULL));
@@ skipping 13 matching lines @@
     case CTR:
       param_.reset(PK11_ParamFromIV(GetMechanism(mode), NULL));
       break;
   }
 
   if (!param_.get())
     return false;
   return true;
 }
 
-bool Encryptor::Encrypt(const std::string& plaintext, std::string* ciphertext) {
+bool Encryptor::Encrypt(const base::StringPiece& plaintext,
+                        std::string* ciphertext) {
   ScopedPK11Context context(PK11_CreateContextBySymKey(GetMechanism(mode_),
                                                        CKA_ENCRYPT,
                                                        key_->key(),
                                                        param_.get()));
   if (!context.get())
     return false;
 
   if (mode_ == CTR)
     return CryptCTR(context.get(), plaintext, ciphertext);
   else
     return Crypt(context.get(), plaintext, ciphertext);
 }
 
-bool Encryptor::Decrypt(const std::string& ciphertext, std::string* plaintext) {
+bool Encryptor::Decrypt(const base::StringPiece& ciphertext,
+                        std::string* plaintext) {
   if (ciphertext.empty())
     return false;
 
   ScopedPK11Context context(PK11_CreateContextBySymKey(
       GetMechanism(mode_), (mode_ == CTR ? CKA_ENCRYPT : CKA_DECRYPT),
       key_->key(), param_.get()));
   if (!context.get())
     return false;
 
   if (mode_ == CTR)
     return CryptCTR(context.get(), ciphertext, plaintext);
   else
     return Crypt(context.get(), ciphertext, plaintext);
 }
 
-bool Encryptor::Crypt(PK11Context* context, const std::string& input,
+bool Encryptor::Crypt(PK11Context* context,
+                      const base::StringPiece& input,
                       std::string* output) {
   size_t output_len = input.size() + AES_BLOCK_SIZE;
   CHECK(output_len > input.size()) << "Output size overflow";
 
   output->resize(output_len);
   uint8* output_data =
       reinterpret_cast<uint8*>(const_cast<char*>(output->data()));
 
   int input_len = input.size();
   uint8* input_data =
@@ skipping 19 matching lines @@
                         output_len - op_len);
   if (SECSuccess != rv) {
     output->clear();
     return false;
   }
 
   output->resize(op_len + digest_len);
   return true;
 }
 
-bool Encryptor::CryptCTR(PK11Context* context, const std::string& input,
+bool Encryptor::CryptCTR(PK11Context* context,
+                         const base::StringPiece& input,
                          std::string* output) {
   if (!counter_.get()) {
     LOG(ERROR) << "Counter value not set in CTR mode.";
     return false;
   }
 
   size_t output_len = ((input.size() + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE) *
       AES_BLOCK_SIZE;
   CHECK(output_len >= input.size()) << "Output size overflow";
   output->resize(output_len);
@@ skipping 28 matching lines @@
 
   // Use |output_data| to mask |input|.
   MaskMessage(
       reinterpret_cast<uint8*>(const_cast<char*>(input.data())),
       input.length(), output_data, output_data);
   output->resize(input.length());
   return true;
 }
 
 }  // namespace crypto