[webcrypto] Refactor to allow for unspecified "algorithm" to importKey().

content/renderer/webcrypto/webcrypto_impl_openssl.cc

 // Copyright 2013 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/renderer/webcrypto/webcrypto_impl.h"
 
 #include <vector>
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
@@ skipping 230 matching lines @@
       static_cast<int>(hash_size) != hash_expected_size) {
     buffer->reset();
     return false;
   }
 
   return true;
 }
 
 bool WebCryptoImpl::GenerateKeyInternal(
     const WebKit::WebCryptoAlgorithm& algorithm,
-    scoped_ptr<WebKit::WebCryptoKeyHandle>* key,
-    WebKit::WebCryptoKeyType* type) {
+    bool extractable,
+    WebKit::WebCryptoKeyUsageMask usage_mask,
+    WebKit::WebCryptoKey* key) {
 
   unsigned keylen_bytes = 0;
   WebKit::WebCryptoKeyType key_type;
   switch (algorithm.id()) {
     case WebKit::WebCryptoAlgorithmIdAesCbc: {
       const WebKit::WebCryptoAesKeyGenParams* params =
           algorithm.aesKeyGenParams();
       DCHECK(params);
       if (params->length() % 8)
         return false;
@@ skipping 21 matching lines @@
     return false;
   }
 
   crypto::OpenSSLErrStackTracer(FROM_HERE);
 
   std::vector<unsigned char> random_bytes(keylen_bytes, 0);
   if (!(RAND_bytes(&random_bytes[0], keylen_bytes))) {
     return false;
   }
 
-  key->reset(new SymKeyHandle(&random_bytes[0], random_bytes.size()));
-  *type = key_type;
+  *key = WebKit::WebCryptoKey::create(
+      new SymKeyHandle(&random_bytes[0], random_bytes.size()),
+      key_type, extractable, algorithm, usage_mask);
 
   return true;
 }
 
 bool WebCryptoImpl::ImportKeyInternal(
     WebKit::WebCryptoKeyFormat format,
     const unsigned char* key_data,
     unsigned key_data_size,
-    const WebKit::WebCryptoAlgorithm& algorithm,
-    WebKit::WebCryptoKeyUsageMask /*usage_mask*/,
-    scoped_ptr<WebKit::WebCryptoKeyHandle>* handle,
-    WebKit::WebCryptoKeyType* type) {
+    const WebKit::WebCryptoAlgorithm& algorithm_or_null,
+    bool extractable,
+    WebKit::WebCryptoKeyUsageMask usage_mask,
+    WebKit::WebCryptoKey* key) {
+  // TODO(eroman): Currently expects algorithm to always be specified, as it is
+  //               required for raw format.
+  if (algorithm_or_null.isNull())
+    return false;
+  const WebKit::WebCryptoAlgorithm& algorithm = algorithm_or_null;
 
   // TODO(padolph): Support all relevant alg types and then remove this gate.
   if (algorithm.id() != WebKit::WebCryptoAlgorithmIdHmac &&
       algorithm.id() != WebKit::WebCryptoAlgorithmIdAesCbc) {
     return false;
   }
 
   // TODO(padolph): Need to split handling for symmetric (raw or jwk format) and
   // asymmetric (jwk, spki, or pkcs8 format) keys.
   // Currently only supporting symmetric.
 
   // TODO(padolph): jwk handling. Define precedence between jwk contents and
   // this method's parameters, e.g. 'alg' in jwk vs algorithm.id(). Who wins if
   // they differ? (jwk, probably)
 
   // Symmetric keys are always type secret
-  *type = WebKit::WebCryptoKeyTypeSecret;
+  WebKit::WebCryptoKeyType type = WebKit::WebCryptoKeyTypeSecret;
 
   const unsigned char* raw_key_data;
   unsigned raw_key_data_size;
   switch (format) {
     case WebKit::WebCryptoKeyFormatRaw:
       raw_key_data = key_data;
       raw_key_data_size = key_data_size;
       // The NSS implementation fails when importing a raw AES key with a length
       // incompatible with AES. The line below is to match this behavior.
       if (algorithm.id() == WebKit::WebCryptoAlgorithmIdAesCbc &&
           !GetAESCipherByKeyLength(raw_key_data_size)) {
         return false;
       }
       break;
     case WebKit::WebCryptoKeyFormatJwk:
       // TODO(padolph): Handle jwk format; need simple JSON parser.
       // break;
       return false;
     default:
       return false;
   }
 
-  handle->reset(new SymKeyHandle(raw_key_data, raw_key_data_size));
+  *key = WebKit::WebCryptoKey::create(
+      new SymKeyHandle(raw_key_data, raw_key_data_size),
+      type, extractable, algorithm, usage_mask);
 
   return true;
 }
 
 bool WebCryptoImpl::SignInternal(
     const WebKit::WebCryptoAlgorithm& algorithm,
     const WebKit::WebCryptoKey& key,
     const unsigned char* data,
     unsigned data_size,
     WebKit::WebArrayBuffer* buffer) {
@@ skipping 104 matching lines @@
 
       break;
     }
     default:
       return false;
   }
   return true;
 }
 
 }  // namespace content