[refactor] Change ordering of wrapkey parameters

content/child/webcrypto/shared_crypto_unittest.cc

 // Copyright 2014 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 "content/child/webcrypto/shared_crypto.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 2746 matching lines @@
     // Import the key to be wrapped.
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
         blink::WebCryptoKeyUsageEncrypt);
 
     // Wrap the key and verify the ciphertext result against the known answer.
     std::vector<uint8> wrapped_key;
     ASSERT_EQ(Status::Success(),
               WrapKey(blink::WebCryptoKeyFormatRaw,
+                      key,
                       wrapping_key,
-                      key,
                       wrapping_algorithm,
                       &wrapped_key));
     EXPECT_BYTES_EQ(test_ciphertext, wrapped_key);
 
     // Unwrap the known ciphertext to get a new test_key.
     blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
     ASSERT_EQ(
         Status::Success(),
         UnwrapKey(blink::WebCryptoKeyFormatRaw,
                   CryptoData(test_ciphertext),
@@ skipping 321 matching lines @@
                       CryptoData(cleartext),
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 
   // Wrap the symmetric key with raw format.
   std::vector<uint8> wrapped_key;
   ASSERT_EQ(Status::Success(),
             WrapKey(blink::WebCryptoKeyFormatRaw,
+                    key,
                     public_key,
-                    key,
                     algorithm,
                     &wrapped_key));
 
   // Unwrap the wrapped key.
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(wrapped_key),
                       private_key,
                       algorithm,
@@ skipping 55 matching lines @@
                       CryptoData(data),
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 
   // Wrapping with a private key should fail.
   std::vector<uint8> wrapped_key;
   EXPECT_EQ(Status::ErrorUnexpectedKeyType(),
             WrapKey(blink::WebCryptoKeyFormatRaw,
+                    key,
                     private_key,
-                    key,
                     wrapping_algorithm,
                     &wrapped_key));
 
   // Wrapping a key whose raw keying material is too large for the wrapping key
   // should fail.
   // RSAES can encrypt data up to length of k - 11 bytes, where k is the octet
   // length of the RSA modulus, and can decrypt data up to length k. Fabricate a
   // big piece of data here that fails both of these criteria, so it can be used
   // for both wrap and unwrap negative tests below.
   const std::vector<uint8> big_data(kModulusLengthBits / 8 + 1, 0);
   blink::WebCryptoKey big_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(big_data),
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &big_key));
   EXPECT_EQ(Status::ErrorDataTooLarge(),
             WrapKey(blink::WebCryptoKeyFormatRaw,
+                    big_key,
                     public_key,
-                    big_key,
                     wrapping_algorithm,
                     &wrapped_key));
 
   // Unwrapping with a public key should fail.
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   EXPECT_EQ(Status::ErrorUnexpectedKeyType(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(data),
                       public_key,
                       wrapping_algorithm,
@@ skipping 99 matching lines @@
       wrapping_algorithm,
       false,
       blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey,
       &public_wrapping_key,
       &private_wrapping_key);
 
   // Wrap the symkey in JWK format, using the public wrapping key.
   std::vector<uint8> wrapped_data;
   ASSERT_EQ(Status::Success(),
             WrapKey(blink::WebCryptoKeyFormatJwk,
+                    key_to_wrap,
                     public_wrapping_key,
-                    key_to_wrap,
                     wrapping_algorithm,
                     &wrapped_data));
 
   // Unwrap the key using the private wrapping key.
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatJwk,
                       CryptoData(wrapped_data),
                       private_wrapping_key,
                       wrapping_algorithm,
@@ skipping 77 matching lines @@
                       algorithm,
                       CreateAesCbcAlgorithm(std::vector<uint8>(0, 16)),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content