Refactor the interface for generating keys.

content/child/webcrypto/nss/rsa_key_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/nss/rsa_key_nss.h"
 
 #include "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
+#include "content/child/webcrypto/generate_key_result.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/nss/key_nss.h"
 #include "content/child/webcrypto/nss/util_nss.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/webcrypto_util.h"
 #include "crypto/scoped_nss_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace content {
@@ skipping 479 matching lines @@
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 }  // namespace
 
-Status RsaHashedAlgorithm::VerifyKeyUsagesBeforeGenerateKeyPair(
+Status RsaHashedAlgorithm::GenerateKey(
+    const blink::WebCryptoAlgorithm& algorithm,
+    bool extractable,
     blink::WebCryptoKeyUsageMask combined_usage_mask,
-    blink::WebCryptoKeyUsageMask* public_usage_mask,
-    blink::WebCryptoKeyUsageMask* private_usage_mask) const {
+    GenerateKeyResult* result) const {
   Status status = CheckKeyCreationUsages(
       all_public_key_usages_ | all_private_key_usages_, combined_usage_mask);
   if (status.IsError())
     return status;
 
-  *public_usage_mask = combined_usage_mask & all_public_key_usages_;
-  *private_usage_mask = combined_usage_mask & all_private_key_usages_;
+  const blink::WebCryptoKeyUsageMask public_usage_mask =
+      combined_usage_mask & all_public_key_usages_;
+  const blink::WebCryptoKeyUsageMask private_usage_mask =
+      combined_usage_mask & all_private_key_usages_;
 
-  return Status::Success();
-}
-
-Status RsaHashedAlgorithm::GenerateKeyPair(
-    const blink::WebCryptoAlgorithm& algorithm,
-    bool extractable,
-    blink::WebCryptoKeyUsageMask public_usage_mask,
-    blink::WebCryptoKeyUsageMask private_usage_mask,
-    blink::WebCryptoKey* public_key,
-    blink::WebCryptoKey* private_key) const {
   unsigned int public_exponent = 0;
   unsigned int modulus_length_bits = 0;
-  Status status = GetRsaKeyGenParameters(algorithm.rsaHashedKeyGenParams(),
-                                         &public_exponent,
-                                         &modulus_length_bits);
+  status = GetRsaKeyGenParameters(algorithm.rsaHashedKeyGenParams(),
+                                  &public_exponent,
+                                  &modulus_length_bits);
   if (status.IsError())
     return status;
 
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::OperationError();
 
   PK11RSAGenParams rsa_gen_params;
   rsa_gen_params.keySizeInBits = modulus_length_bits;
   rsa_gen_params.pe = public_exponent;
@@ skipping 39 matching lines @@
       crypto::ScopedSECKEYPublicKey(sec_public_key), CryptoData(spki_data)));
 
   std::vector<uint8_t> pkcs8_data;
   status = ExportKeyPkcs8Nss(scoped_sec_private_key.get(), &pkcs8_data);
   if (status.IsError())
     return status;
 
   scoped_ptr<PrivateKeyNss> private_key_handle(
       new PrivateKeyNss(scoped_sec_private_key.Pass(), CryptoData(pkcs8_data)));
 
-  *public_key = blink::WebCryptoKey::create(public_key_handle.release(),
-                                            blink::WebCryptoKeyTypePublic,
-                                            true,
-                                            key_algorithm,
-                                            public_usage_mask);
-  *private_key = blink::WebCryptoKey::create(private_key_handle.release(),
-                                             blink::WebCryptoKeyTypePrivate,
-                                             extractable,
-                                             key_algorithm,
-                                             private_usage_mask);
+  blink::WebCryptoKey public_key =
+      blink::WebCryptoKey::create(public_key_handle.release(),
+                                  blink::WebCryptoKeyTypePublic,
+                                  true,
+                                  key_algorithm,
+                                  public_usage_mask);
 
+  blink::WebCryptoKey private_key =
+      blink::WebCryptoKey::create(private_key_handle.release(),
+                                  blink::WebCryptoKeyTypePrivate,
+                                  extractable,
+                                  key_algorithm,
+                                  private_usage_mask);
+
+  result->AssignKeyPair(public_key, private_key);
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::VerifyKeyUsagesBeforeImportKey(
     blink::WebCryptoKeyFormat format,
     blink::WebCryptoKeyUsageMask usage_mask) const {
   switch (format) {
     case blink::WebCryptoKeyFormatSpki:
       return CheckKeyCreationUsages(all_public_key_usages_, usage_mask);
     case blink::WebCryptoKeyFormatPkcs8:
@@ skipping 222 matching lines @@
       return Status::Success();
     }
     default:
       return Status::ErrorUnexpected();
   }
 }
 
 }  // namespace webcrypto
 
 }  // namespace content