WebCrypto: Add interfaces for importKey().

Source/modules/crypto/Key.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 35 matching lines @@
         return "public";
     case WebKit::WebCryptoKeyTypePrivate:
         return "private";
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 const char* keyUsageToString(WebKit::WebCryptoKeyUsage usage)
 {
+    // NOTE: Keep this in sync with keyUsageStringToMask() below.
     switch (usage) {
     case WebKit::WebCryptoKeyUsageEncrypt:
         return "encrypt";
     case WebKit::WebCryptoKeyUsageDecrypt:
         return "decrypt";
     case WebKit::WebCryptoKeyUsageSign:
         return "sign";
     case WebKit::WebCryptoKeyUsageVerify:
         return "verify";
     case WebKit::WebCryptoKeyUsageDeriveKey:
         return "deriveKey";
     case WebKit::WebCryptoKeyUsageWrapKey:
         return "wrapKey";
     case WebKit::WebCryptoKeyUsageUnwrapKey:
         return "unwrapKey";
     case WebKit::EndOfWebCryptoKeyUsage:
         break;
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
+WebKit::WebCryptoKeyUsageMask keyUsageStringToMask(const String& usageString)
+{
+    // There are few enough values that testing serially is fast enough.
+    if (usageString == "encrypt")
+        return WebKit::WebCryptoKeyUsageEncrypt;
+    if (usageString == "decrypt")
+        return WebKit::WebCryptoKeyUsageDecrypt;
+    if (usageString == "sign")
+        return WebKit::WebCryptoKeyUsageSign;
+    if (usageString == "verify")
+        return WebKit::WebCryptoKeyUsageVerify;
+    if (usageString == "deriveKey")
+        return WebKit::WebCryptoKeyUsageDeriveKey;
+    if (usageString == "wrapKey")
+        return WebKit::WebCryptoKeyUsageWrapKey;
+    if (usageString == "unwrapKey")
+        return WebKit::WebCryptoKeyUsageUnwrapKey;

[abarth-chromium, 2013/07/23 06:22:07]

Maybe use a single table to drive both?  The table is small, so the reverse
lookup should be fast.  That seems less fragile than having to keep these two
functions in sync.

[eroman, 2013/07/23 23:29:02]

Done.

+
+    return 0;
+}
+
 } // namespace
 
 Key::Key(const WebKit::WebCryptoKey& key)
     : m_key(key)
 {
     ScriptWrappable::init(this);
 }
 
 String Key::type() const
 {
@@ skipping 22 matching lines @@
 
     // The WebCryptoKeyUsage values are consecutive powers of 2. Test each one in order.
     for (int i = 0; (1 << i) < WebKit::EndOfWebCryptoKeyUsage; ++i) {
         WebKit::WebCryptoKeyUsage usage = static_cast<WebKit::WebCryptoKeyUsage>(1 << i);
         if (m_key.usages() & usage)
             result.append(ASCIILiteral(keyUsageToString(usage)));
     }
     return result;
 }
 
+bool Key::parseFormat(const String& formatString, WebKit::WebCryptoKeyFormat& format)
+{
+    // There are few enough values that testing serially is fast enough.
+    if (formatString == "raw") {
+        format = WebKit::WebCryptoKeyFormatRaw;
+        return true;
+    }
+    if (formatString == "pkcs8") {
+        format = WebKit::WebCryptoKeyFormatPkcs8;
+        return true;
+    }
+    if (formatString == "spki") {
+        format = WebKit::WebCryptoKeyFormatSpki;
+        return true;
+    }
+    if (formatString == "jwk") {
+        format = WebKit::WebCryptoKeyFormatJwk;
+        return true;
+    }
+
+    return false;
+}
+
+bool Key::parseUsageMask(const Vector<String>& usages, WebKit::WebCryptoKeyUsageMask& mask)
+{
+    mask = 0;
+    for (size_t i = 0; i < usages.size(); ++i) {
+        WebKit::WebCryptoKeyUsageMask usage = keyUsageStringToMask(usages[i]);
+        if (!usage)
+            return false;
+        mask |= usage;
+    }
+    return true;
+}
+
 } // namespace WebCore