Rename Encryption-Key to Crypto-Key, "key" parameter to "aesgcm128".

components/gcm_driver/crypto/gcm_encryption_provider_unittest.cc

 // Copyright 2015 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 "components/gcm_driver/crypto/gcm_encryption_provider.h"
 
 #include <sstream>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 14 matching lines @@
 namespace gcm {
 namespace {
 
 const char kExampleAppId[] = "my-app-id";
 const char kExampleMessage[] = "Hello, world, this is the GCM Driver!";
 
 const char kValidEncryptionHeader[] =
     "keyid=foo;salt=MTIzNDU2Nzg5MDEyMzQ1Ng;rs=1024";
 const char kInvalidEncryptionHeader[] = "keyid";
 
-const char kValidEncryptionKeyHeader[] =
+const char kValidCryptoKeyHeader[] =
     "keyid=foo;dh=BL_UGhfudEkXMUd4U4-D4nP5KHxKjQHsW6j88ybbehXM7fqi1OMFefDUEi0eJ"
     "vsKfyVBWYkQjH-lSPJKxjAyslg";
-const char kInvalidEncryptionKeyHeader[] = "keyid";
+const char kInvalidCryptoKeyHeader[] = "keyid";
 
 // TODO(peter): Unify the Base64Url implementations. https://crbug.com/536745.
 void Base64UrlEncode(const std::string& decoded_input,
                      std::string* encoded_output) {
   base::Base64Encode(decoded_input, encoded_output);
   base::ReplaceChars(*encoded_output, "+", "-", encoded_output);
   base::ReplaceChars(*encoded_output, "/", "_", encoded_output);
 }
 
 }  // namespace
@@ skipping 94 matching lines @@
   IncomingMessage empty_message;
   EXPECT_FALSE(encryption_provider()->IsEncryptedMessage(empty_message));
 
   IncomingMessage single_header_message;
   single_header_message.data["encryption"] = "";
   EXPECT_FALSE(encryption_provider()->IsEncryptedMessage(
                    single_header_message));
 
   IncomingMessage double_header_message;
   double_header_message.data["encryption"] = "";
-  double_header_message.data["encryption_key"] = "";
+  double_header_message.data["crypto_key"] = "";
   EXPECT_FALSE(encryption_provider()->IsEncryptedMessage(
                    double_header_message));
 
   IncomingMessage double_header_with_data_message;
   double_header_with_data_message.data["encryption"] = "";
-  double_header_with_data_message.data["encryption_key"] = "";
+  double_header_with_data_message.data["crypto_key"] = "";
   double_header_with_data_message.raw_data = "foo";
   EXPECT_TRUE(encryption_provider()->IsEncryptedMessage(
                   double_header_with_data_message));
 }
 
 TEST_F(GCMEncryptionProviderTest, VerifiesEncryptionHeaderParsing) {
   // The Encryption header must be parsable and contain valid values.
   // Note that this is more extensively tested in EncryptionHeaderParsersTest.
 
   IncomingMessage invalid_message;
   invalid_message.data["encryption"] = kInvalidEncryptionHeader;
-  invalid_message.data["encryption_key"] = kValidEncryptionKeyHeader;
+  invalid_message.data["crypto_key"] = kValidCryptoKeyHeader;
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(invalid_message));
   ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
   EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_ENCRYPTION_HEADER,
             failure_reason());
 
   IncomingMessage valid_message;
   valid_message.data["encryption"] = kValidEncryptionHeader;
-  valid_message.data["encryption_key"] = kInvalidEncryptionKeyHeader;
+  valid_message.data["crypto_key"] = kInvalidCryptoKeyHeader;
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(valid_message));
   ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
   EXPECT_NE(GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_ENCRYPTION_HEADER,
             failure_reason());
 }
 
-TEST_F(GCMEncryptionProviderTest, VerifiesEncryptionKeyHeaderParsing) {
+TEST_F(GCMEncryptionProviderTest, VerifiesCryptoKeyHeaderParsing) {
   // The Encryption-Key header must be parsable and contain valid values.
   // Note that this is more extensively tested in EncryptionHeaderParsersTest.
 
   IncomingMessage invalid_message;
   invalid_message.data["encryption"] = kValidEncryptionHeader;
-  invalid_message.data["encryption_key"] = kInvalidEncryptionKeyHeader;
+  invalid_message.data["crypto_key"] = kInvalidCryptoKeyHeader;
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(invalid_message));
   ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
-  EXPECT_EQ(
-      GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_ENCRYPTION_KEY_HEADER,
-      failure_reason());
+  EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_CRYPTO_KEY_HEADER,
+            failure_reason());
 
   IncomingMessage valid_message;
   valid_message.data["encryption"] = kInvalidEncryptionHeader;
-  valid_message.data["encryption_key"] = kValidEncryptionKeyHeader;
+  valid_message.data["crypto_key"] = kValidCryptoKeyHeader;
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(valid_message));
   ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
-  EXPECT_NE(
-      GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_ENCRYPTION_KEY_HEADER,
-      failure_reason());
+  EXPECT_NE(GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_CRYPTO_KEY_HEADER,
+            failure_reason());
 }
 
 TEST_F(GCMEncryptionProviderTest, VerifiesExistingKeys) {
   // When both headers are valid, the encryption keys still must be known to
   // the GCM key store before the message can be decrypted.
 
   IncomingMessage message;
   message.data["encryption"] = kValidEncryptionHeader;
-  message.data["encryption_key"] = kValidEncryptionKeyHeader;
+  message.data["crypto_key"] = kValidCryptoKeyHeader;
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(message));
   ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
   EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_FAILURE_NO_KEYS,
             failure_reason());
 
   std::string public_key;
   encryption_provider()->GetPublicKey(
       kExampleAppId,
       base::Bind(&GCMEncryptionProviderTest::DidGetPublicKey,
@@ skipping 64 matching lines @@
 
   // Compile the incoming GCM message, including the required headers.
   Base64UrlEncode(salt, &encoded_salt);
   Base64UrlEncode(server_pair.public_key(), &encoded_key);
 
   std::stringstream encryption_header;
   encryption_header << "rs=" << base::SizeTToString(record_size) << ";";
   encryption_header << "salt=" << encoded_salt;
 
   message.data["encryption"] = encryption_header.str();
-  message.data["encryption_key"] = "dh=" + encoded_key;
+  message.data["crypto_key"] = "dh=" + encoded_key;
 
   ASSERT_TRUE(encryption_provider()->IsEncryptedMessage(message));
 
   // Decrypt the message, and expect everything to go wonderfully well.
   ASSERT_NO_FATAL_FAILURE(Decrypt(message));
   ASSERT_EQ(DECRYPTION_SUCCEEDED, decryption_result());
 
   EXPECT_TRUE(decrypted_message().decrypted);
   EXPECT_EQ(kExampleMessage, decrypted_message().raw_data);
 }
 
 }  // namespace gcm