Remove GCMMessageCryptographer::Label

components/gcm_driver/crypto/gcm_message_cryptographer_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_message_cryptographer.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 120 matching lines @@
 
     std::string local_public_key, peer_public_key;
     ASSERT_TRUE(base::Base64UrlDecode(
         kLocalPublicKeyCommon, base::Base64UrlDecodePolicy::IGNORE_PADDING,
         &local_public_key));
     ASSERT_TRUE(base::Base64UrlDecode(
         kPeerPublicKeyCommon, base::Base64UrlDecodePolicy::IGNORE_PADDING,
         &peer_public_key));
 
     cryptographer_.reset(
-        new GCMMessageCryptographer(GCMMessageCryptographer::Label::P256,
-                                    local_public_key, peer_public_key,
+        new GCMMessageCryptographer(local_public_key, peer_public_key,
                                     kAuthSecretCommon));
   }
 
  protected:
   // Generates a cryptographically secure random salt of 16-octets in size, the
   // required length as expected by the HKDF.
   std::string GenerateRandomSalt() {
     const size_t kSaltSize = 16;
 
     std::string salt;
@@ skipping 193 matching lines @@
 
 TEST_F(GCMMessageCryptographerTest, AuthSecretAffectsIKM) {
   std::string public_key;
   ASSERT_TRUE(base::Base64UrlDecode(
       kLocalPublicKeyCommon, base::Base64UrlDecodePolicy::IGNORE_PADDING,
       &public_key));
 
   // Fake IKM to use in the DerivePseudoRandomKey calls.
   const char kFakeIKM[] = "HelloWorld";
 
-  GCMMessageCryptographer hello_cryptographer(
-      GCMMessageCryptographer::Label::P256, public_key, public_key, "Hello");
+  GCMMessageCryptographer hello_cryptographer(public_key, public_key, "Hello");
 
-  GCMMessageCryptographer world_cryptographer(
-      GCMMessageCryptographer::Label::P256, public_key, public_key, "World");
+  GCMMessageCryptographer world_cryptographer(public_key, public_key, "World");
 
   ASSERT_NE(hello_cryptographer.DerivePseudoRandomKey(kFakeIKM), kFakeIKM);
   ASSERT_NE(world_cryptographer.DerivePseudoRandomKey(kFakeIKM), kFakeIKM);
 
   ASSERT_NE(hello_cryptographer.DerivePseudoRandomKey(kFakeIKM),
             world_cryptographer.DerivePseudoRandomKey(kFakeIKM));
 
   std::string salt = GenerateRandomSalt();
 
   // Verify that the IKM actually gets used by the transformations.
@@ skipping 68 matching lines @@
         encoded_sender_public_key,
         base::Base64UrlDecodePolicy::IGNORE_PADDING, &sender_public_key));
 
     if (encoded_auth_secret) {
       ASSERT_TRUE(base::Base64UrlDecode(
           encoded_auth_secret,
           base::Base64UrlDecodePolicy::IGNORE_PADDING, &auth_secret));
     }
 
     std::unique_ptr<GCMMessageCryptographer> instance(
-        new GCMMessageCryptographer(GCMMessageCryptographer::Label::P256,
-                                    receiver_public_key, sender_public_key,
+        new GCMMessageCryptographer(receiver_public_key, sender_public_key,
                                     auth_secret));
 
     if (auth_secret.empty())
       instance->set_allow_empty_auth_secret_for_tests(true);
 
     cryptographer->swap(instance);
   }
 };
 
 TEST_F(GCMMessageCryptographerReferenceTest, WithAuthSecret) {
@@ skipping 139 matching lines @@
                         &encoded_ciphertext);
   ASSERT_EQ(kCiphertext, encoded_ciphertext);
 
   // Verify that decrypting |kCiphertext| yields the expected |kPlaintext|.
   ASSERT_TRUE(cryptographer->Decrypt(ciphertext, sender_shared_secret, salt,
                                      record_size, &plaintext));
   ASSERT_EQ(kPlaintext, plaintext);
 }
 
 }  // namespace gcm