[refactor] Change ordering of wrapkey parameters

content/child/webcrypto/platform_crypto_nss.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/platform_crypto.h"
 
 #include <cryptohi.h>
 #include <pk11pub.h>
 #include <secerr.h>
 #include <sechash.h>
@@ skipping 1473 matching lines @@
     return status;
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
-Status WrapSymKeyAesKw(SymKey* wrapping_key,
-                       SymKey* key,
+Status WrapSymKeyAesKw(SymKey* key,
+                       SymKey* wrapping_key,
                        std::vector<uint8>* buffer) {
   // The data size must be at least 16 bytes and a multiple of 8 bytes.
   // RFC 3394 does not specify a maximum allowed data length, but since only
   // keys are being wrapped in this application (which are small), a reasonable
   // max limit is whatever will fit into an unsigned. For the max size test,
   // note that AES Key Wrap always adds 8 bytes to the input data size.
   const unsigned int input_length = PK11_GetKeyLength(key->key());
   if (input_length < 16)
     return Status::ErrorDataTooSmall();
   if (input_length > UINT_MAX - 8)
@@ skipping 78 matching lines @@
   if (PK11_ExtractKeyValue(decrypted.get()) != SECSuccess)
     return Status::OperationError();
   const SECItem* const key_data = PK11_GetKeyData(decrypted.get());
   if (!key_data)
     return Status::OperationError();
   buffer->assign(key_data->data, key_data->data + key_data->len);
 
   return Status::Success();
 }
 
-Status WrapSymKeyRsaEs(PublicKey* wrapping_key,
-                       SymKey* key,
+Status WrapSymKeyRsaEs(SymKey* key,
+                       PublicKey* wrapping_key,
                        std::vector<uint8>* buffer) {
   // Check the raw length of the key to be wrapped against the max size allowed
   // by the RSA wrapping key. With PKCS#1 v1.5 padding used in this function,
   // the maximum data length that can be encrypted is the wrapping_key's modulus
   // byte length minus eleven bytes.
   const unsigned int input_length_bytes = PK11_GetKeyLength(key->key());
   const unsigned int modulus_length_bytes =
       SECKEY_PublicKeyStrength(wrapping_key->key());
   if (modulus_length_bytes < 11 ||
       modulus_length_bytes - 11 < input_length_bytes)
@@ skipping 66 matching lines @@
                                      key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content