Refactor the interface for generating keys.

content/child/webcrypto/webcrypto_impl.cc

Index: content/child/webcrypto/webcrypto_impl.cc
diff --git a/content/child/webcrypto/webcrypto_impl.cc b/content/child/webcrypto/webcrypto_impl.cc
index e367ae641b011de7ad3a5c2197f8d5bb392b38ba..67e797095ad181d9732cc1a92b9701328651a2ad 100644
--- a/content/child/webcrypto/webcrypto_impl.cc
+++ b/content/child/webcrypto/webcrypto_impl.cc
@@ -217,18 +217,15 @@ struct GenerateKeyState : public BaseState {
         extractable(extractable),
         usage_mask(usage_mask),
         public_key(blink::WebCryptoKey::createNull()),
-        private_key(blink::WebCryptoKey::createNull()),
-        is_asymmetric(false) {}
+        private_key(blink::WebCryptoKey::createNull()) {}
 
   const blink::WebCryptoAlgorithm algorithm;
   const bool extractable;
   const blink::WebCryptoKeyUsageMask usage_mask;
 
-  // If |is_asymmetric| is false, then |public_key| is understood to mean the
-  // symmetric key, and |private_key| is unused.
+  // private_key may be a secret key, in which case public_key is unused.
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey private_key;
-  bool is_asymmetric;
 };
 
 struct ImportKeyState : public BaseState {
@@ -401,10 +398,10 @@ void DoGenerateKeyReply(scoped_ptr<GenerateKeyState> state) {
   if (state->status.IsError()) {
     CompleteWithError(state->status, &state->result);
   } else {
-    if (state->is_asymmetric)
-      state->result.completeWithKeyPair(state->public_key, state->private_key);
+    if (state->private_key.type() == blink::WebCryptoKeyTypeSecret)
+      state->result.completeWithKey(state->private_key);
     else
-      state->result.completeWithKey(state->public_key);
+      state->result.completeWithKeyPair(state->public_key, state->private_key);
   }
 }
 
@@ -412,37 +409,11 @@ void DoGenerateKey(scoped_ptr<GenerateKeyState> passed_state) {
   GenerateKeyState* state = passed_state.get();
   if (state->cancelled())
     return;
-  state->is_asymmetric =
-      webcrypto::IsAlgorithmAsymmetric(state->algorithm.id());
-  if (state->is_asymmetric) {
-    state->status = webcrypto::GenerateKeyPair(state->algorithm,
-                                               state->extractable,
-                                               state->usage_mask,
-                                               &state->public_key,
-                                               &state->private_key);
-
-    if (state->status.IsSuccess()) {
-      DCHECK(state->public_key.handle());
-      DCHECK(state->private_key.handle());
-      DCHECK_EQ(state->algorithm.id(), state->public_key.algorithm().id());
-      DCHECK_EQ(state->algorithm.id(), state->private_key.algorithm().id());
-      DCHECK_EQ(true, state->public_key.extractable());
-      DCHECK_EQ(state->extractable, state->private_key.extractable());
-    }
-  } else {
-    blink::WebCryptoKey* key = &state->public_key;
-
-    state->status = webcrypto::GenerateSecretKey(
-        state->algorithm, state->extractable, state->usage_mask, key);
-
-    if (state->status.IsSuccess()) {
-      DCHECK(key->handle());
-      DCHECK_EQ(state->algorithm.id(), key->algorithm().id());
-      DCHECK_EQ(state->extractable, key->extractable());
-      DCHECK_EQ(state->usage_mask, key->usages());
-    }
-  }
-
+  state->status = webcrypto::GenerateKey(state->algorithm,
+                                         state->extractable,
+                                         state->usage_mask,
+                                         &state->public_key,
+                                         &state->private_key);
   state->origin_thread->PostTask(
       FROM_HERE, base::Bind(DoGenerateKeyReply, Passed(&passed_state)));
 }