Refactor the interface for generating keys.

content/child/webcrypto/algorithm_implementation.h

 // 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.
 
 #ifndef CONTENT_CHILD_WEBCRYPTO_CRYPTO_ALGORITHM_IMPLEMENTATION_H_
 #define CONTENT_CHILD_WEBCRYPTO_CRYPTO_ALGORITHM_IMPLEMENTATION_H_
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "third_party/WebKit/public/platform/WebCrypto.h"
 
 namespace content {
 
 namespace webcrypto {
 
 class CryptoData;
+class GenerateKeyResult;
 class Status;
 
 // AlgorithmImplementation is a base class for *executing* the operations of an
 // algorithm (generating keys, encrypting, signing, etc.).
 //
 // This is in contrast to blink::WebCryptoAlgorithm which instead *describes*
 // the operation and its parameters.
 //
 // AlgorithmImplementation has reasonable default implementations for all
 // methods which behave as if the operation is it is unsupported, so
@@ skipping 35 matching lines @@
                         const blink::WebCryptoKey& key,
                         const CryptoData& signature,
                         const CryptoData& data,
                         bool* signature_match) const;
 
   // This method corresponds to Web Crypto's crypto.subtle.digest().
   virtual Status Digest(const blink::WebCryptoAlgorithm& algorithm,
                         const CryptoData& data,
                         std::vector<uint8_t>* buffer) const;
 
-  // VerifyKeyUsagesBeforeGenerateKey() must be called prior to
-  // GenerateSecretKey() to validate the requested key usages.
-  virtual Status VerifyKeyUsagesBeforeGenerateKey(
-      blink::WebCryptoKeyUsageMask usage_mask) const;
-
   // This method corresponds to Web Crypto's crypto.subtle.generateKey().
-  virtual Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
-                                   bool extractable,
-                                   blink::WebCryptoKeyUsageMask usage_mask,
-                                   blink::WebCryptoKey* key) const;
-
-  // VerifyKeyUsagesBeforeGenerateKeyPair() must be called prior to
-  // GenerateKeyPair() to validate the requested key usages.
-  virtual Status VerifyKeyUsagesBeforeGenerateKeyPair(
-      blink::WebCryptoKeyUsageMask combined_usage_mask,
-      blink::WebCryptoKeyUsageMask* public_usage_mask,
-      blink::WebCryptoKeyUsageMask* private_usage_mask) const;
-
-  // This method corresponds to Web Crypto's crypto.subtle.generateKey().
-  virtual Status 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;
+  //
+  // Implementations MUST verify |usage_mask| and return an error if it is not
+  // appropriate.
+  virtual Status GenerateKey(const blink::WebCryptoAlgorithm& algorithm,
+                             bool extractable,
+                             blink::WebCryptoKeyUsageMask usage_mask,
+                             GenerateKeyResult* result) const;
 
   // -----------------------------------------------
   // Key import
   // -----------------------------------------------
 
   // VerifyKeyUsagesBeforeImportKey() must be called before either
   // importing a key, or unwrapping a key.
   //
   // Implementations should return an error if the requested usages are invalid
   // when importing for the specified format.
@@ skipping 55 matching lines @@
 
   virtual Status ExportKeyJwk(const blink::WebCryptoKey& key,
                               std::vector<uint8_t>* buffer) const;
 };
 
 }  // namespace webcrypto
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_WEBCRYPTO_CRYPTO_ALGORITHM_IMPLEMENTATION_H_