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

content/renderer/webcrypto/webcrypto_impl.cc

 // Copyright (c) 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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
@@ skipping 22 matching lines @@
   memcpy(new_buffer.data(), buffer->data(), new_size);
   *buffer = new_buffer;
 }
 
 void WebCryptoImpl::encrypt(
     const WebKit::WebCryptoAlgorithm& algorithm,
     const WebKit::WebCryptoKey& key,
     const unsigned char* data,
     unsigned data_size,
     WebKit::WebCryptoResult result) {
+  DCHECK(!algorithm.isNull());
   WebKit::WebArrayBuffer buffer;
   if (!EncryptInternal(algorithm, key, data, data_size, &buffer)) {
     result.completeWithError();
   } else {
     result.completeWithBuffer(buffer);
   }
 }
 
 void WebCryptoImpl::decrypt(
     const WebKit::WebCryptoAlgorithm& algorithm,
     const WebKit::WebCryptoKey& key,
     const unsigned char* data,
     unsigned data_size,
     WebKit::WebCryptoResult result) {
+  DCHECK(!algorithm.isNull());
   WebKit::WebArrayBuffer buffer;
   if (!DecryptInternal(algorithm, key, data, data_size, &buffer)) {
     result.completeWithError();
   } else {
     result.completeWithBuffer(buffer);
   }
 }
 
 void WebCryptoImpl::digest(
     const WebKit::WebCryptoAlgorithm& algorithm,
     const unsigned char* data,
     unsigned data_size,
     WebKit::WebCryptoResult result) {
+  DCHECK(!algorithm.isNull());
   WebKit::WebArrayBuffer buffer;
   if (!DigestInternal(algorithm, data, data_size, &buffer)) {
     result.completeWithError();
   } else {
     result.completeWithBuffer(buffer);
   }
 }
 
+WebKit::WebCryptoKey NullKey() {
+  // TODO(eroman): Expose this in Blink instead.
+  return WebKit::WebCryptoKey::create(NULL, WebKit::WebCryptoKeyTypeSecret,
+                                      false,
+                                      WebKit::WebCryptoAlgorithm::createNull(),
+                                      0);
+}
+
 void WebCryptoImpl::generateKey(
     const WebKit::WebCryptoAlgorithm& algorithm,
-    bool exportable,
-    WebKit::WebCryptoKeyUsageMask usage,
+    bool extractable,
+    WebKit::WebCryptoKeyUsageMask usage_mask,
     WebKit::WebCryptoResult result) {
-  scoped_ptr<WebKit::WebCryptoKeyHandle> handle;
-  WebKit::WebCryptoKeyType type;
-  if (!GenerateKeyInternal(algorithm, &handle, &type)) {
-    result.completeWithError();
-  } else {
-    WebKit::WebCryptoKey key(
-        WebKit::WebCryptoKey::create(handle.release(), type, exportable,
-                                     algorithm, usage));
+  DCHECK(!algorithm.isNull());
+  WebKit::WebCryptoKey key = NullKey();
+  if (GenerateKeyInternal(algorithm, extractable, usage_mask, &key)) {
+    DCHECK(key.handle());
+    DCHECK_EQ(algorithm.id(), key.algorithm().id());
+    DCHECK_EQ(extractable, key.extractable());
+    DCHECK_EQ(usage_mask, key.usages());
     result.completeWithKey(key);
+    return;
   }
+  result.completeWithError();

[Ryan Sleevi, 2013/10/30 20:55:53]

Should you follow the normal error form here?

if (!GenerateKeyInternal(...)) {
  error
}
success

[eroman, 2013/10/30 21:26:21]

Done.

 }
 
 void WebCryptoImpl::importKey(
     WebKit::WebCryptoKeyFormat format,
     const unsigned char* key_data,
     unsigned key_data_size,
-    const WebKit::WebCryptoAlgorithm& algorithm,
+    const WebKit::WebCryptoAlgorithm& algorithm_or_null,
     bool extractable,
     WebKit::WebCryptoKeyUsageMask usage_mask,
     WebKit::WebCryptoResult result) {
-  WebKit::WebCryptoKeyType type;
-  scoped_ptr<WebKit::WebCryptoKeyHandle> handle;
-
-  if (!ImportKeyInternal(format,
-                         key_data,
-                         key_data_size,
-                         algorithm,
-                         usage_mask,
-                         &handle,
-                         &type)) {
-    result.completeWithError();
+  WebKit::WebCryptoKey key = NullKey();
+  if (ImportKeyInternal(format,
+                        key_data,
+                        key_data_size,
+                        algorithm_or_null,
+                        extractable,
+                        usage_mask,
+                        &key)) {
+    DCHECK(key.handle());
+    DCHECK(!key.algorithm().isNull());
+    DCHECK_EQ(extractable, key.extractable());
+    result.completeWithKey(key);
     return;
   }
-
-  WebKit::WebCryptoKey key(
-      WebKit::WebCryptoKey::create(
-          handle.release(), type, extractable, algorithm, usage_mask));
-
-  result.completeWithKey(key);
+  result.completeWithError();

[Ryan Sleevi, 2013/10/30 20:55:53]

ditto. Why change from the original form?

[eroman, 2013/10/30 21:26:21]

Done.

 }
 
 void WebCryptoImpl::sign(
     const WebKit::WebCryptoAlgorithm& algorithm,
     const WebKit::WebCryptoKey& key,
     const unsigned char* data,
     unsigned data_size,
     WebKit::WebCryptoResult result) {
+  DCHECK(!algorithm.isNull());
   WebKit::WebArrayBuffer buffer;
   if (!SignInternal(algorithm, key, data, data_size, &buffer)) {
     result.completeWithError();
   } else {
     result.completeWithBuffer(buffer);
   }
 }
 
 void WebCryptoImpl::verifySignature(
     const WebKit::WebCryptoAlgorithm& algorithm,
     const WebKit::WebCryptoKey& key,
     const unsigned char* signature,
     unsigned signature_size,
     const unsigned char* data,
     unsigned data_size,
     WebKit::WebCryptoResult result) {
+  DCHECK(!algorithm.isNull());
   bool signature_match = false;
   if (!VerifySignatureInternal(algorithm,
                                key,
                                signature,
                                signature_size,
                                data,
                                data_size,
                                &signature_match)) {
     result.completeWithError();
   } else {
     result.completeWithBoolean(signature_match);
   }
 }
 
 }  // namespace content