[refactor] Change ordering of wrapkey parameters

content/child/webcrypto/shared_crypto.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 "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/platform_crypto.h"
@@ skipping 357 matching lines @@
                                          algorithm,
                                          extractable,
                                          usage_mask,
                                          key);
     }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
-Status WrapKeyRaw(const blink::WebCryptoKey& wrapping_key,
-                  const blink::WebCryptoKey& key_to_wrap,
+Status WrapKeyRaw(const blink::WebCryptoKey& key_to_wrap,
+                  const blink::WebCryptoKey& wrapping_key,
                   const blink::WebCryptoAlgorithm& wrapping_algorithm,
                   std::vector<uint8>* buffer) {
   // A raw key is always a symmetric key.
   platform::SymKey* platform_key;
   Status status = ToPlatformSymKey(key_to_wrap, &platform_key);
   if (status.IsError())
     return status;
 
   // TODO(padolph): Handle other wrapping algorithms
   switch (wrapping_algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesKw: {
       platform::SymKey* platform_wrapping_key;
       status = ToPlatformSymKey(wrapping_key, &platform_wrapping_key);
       if (status.IsError())
         return status;
       return platform::WrapSymKeyAesKw(
-          platform_wrapping_key, platform_key, buffer);
+          platform_key, platform_wrapping_key, buffer);
     }
     case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5: {
       platform::PublicKey* platform_wrapping_key;
       status = ToPlatformPublicKey(wrapping_key, &platform_wrapping_key);
       if (status.IsError())
         return status;
       return platform::WrapSymKeyRsaEs(
-          platform_wrapping_key, platform_key, buffer);
+          platform_key, platform_wrapping_key, buffer);
     }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status DecryptAesKw(const blink::WebCryptoAlgorithm& algorithm,
                     const blink::WebCryptoKey& key,
                     const CryptoData& data,
                     std::vector<uint8>* buffer) {
@@ skipping 62 matching lines @@
   status = ImportKey(
       format, CryptoData(buffer), algorithm, extractable, usage_mask, key);
   // NOTE! Returning the details of any ImportKey() failure here would leak
   // information about the plaintext internals of the encrypted key. Instead,
   // collapse any error into the generic Status::OperationError().
   return status.IsError() ? Status::OperationError() : Status::Success();
 }
 
 Status WrapKeyExportAndEncrypt(
     blink::WebCryptoKeyFormat format,
+    const blink::WebCryptoKey& key_to_wrap,
     const blink::WebCryptoKey& wrapping_key,
-    const blink::WebCryptoKey& key_to_wrap,
     const blink::WebCryptoAlgorithm& wrapping_algorithm,
     std::vector<uint8>* buffer) {
   std::vector<uint8> exported_data;
   Status status = ExportKey(format, key_to_wrap, &exported_data);
   if (status.IsError())
     return status;
   return EncryptDontCheckUsage(
       wrapping_algorithm, wrapping_key, CryptoData(exported_data), buffer);
 }
 
@@ skipping 245 matching lines @@
       return VerifyHmac(algorithm, key, signature, data, signature_match);
     case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
       return VerifyRsaSsaPkcs1v1_5(
           algorithm, key, signature, data, signature_match);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WrapKey(blink::WebCryptoKeyFormat format,
+               const blink::WebCryptoKey& key_to_wrap,
                const blink::WebCryptoKey& wrapping_key,
-               const blink::WebCryptoKey& key_to_wrap,
                const blink::WebCryptoAlgorithm& wrapping_algorithm,
                std::vector<uint8>* buffer) {
   if (!KeyUsageAllows(wrapping_key, blink::WebCryptoKeyUsageWrapKey))
     return Status::ErrorUnexpected();
   if (wrapping_algorithm.id() != wrapping_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   switch (format) {
     case blink::WebCryptoKeyFormatRaw:
-      return WrapKeyRaw(wrapping_key, key_to_wrap, wrapping_algorithm, buffer);
+      return WrapKeyRaw(key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
     case blink::WebCryptoKeyFormatJwk:
       return WrapKeyExportAndEncrypt(
-          format, wrapping_key, key_to_wrap, wrapping_algorithm, buffer);
+          format, key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
     case blink::WebCryptoKeyFormatSpki:
     case blink::WebCryptoKeyFormatPkcs8:
       return Status::ErrorUnsupported();  // TODO(padolph)
     default:
       NOTREACHED();
       return Status::ErrorUnsupported();
   }
 }
 
 Status UnwrapKey(blink::WebCryptoKeyFormat format,
@@ skipping 65 matching lines @@
                             usage_mask,
                             key);
   if (status.IsError())
     return false;
   return ValidateDeserializedKey(*key, algorithm, type);
 }
 
 }  // namespace webcrypto
 
 }  // namespace content