Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1206)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: Source/modules/crypto/NormalizeAlgorithm.cpp

Issue 243853004: [webcrypto] Reject failed operations with a DOMException rather than null. (Closed) Base URL: svn://svn.chromium.org/blink/trunk
Patch Set: Fix compile warning Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « Source/modules/crypto/Key.cpp ('k') | Source/modules/crypto/SubtleCrypto.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: Source/modules/crypto/NormalizeAlgorithm.cpp
diff --git a/Source/modules/crypto/NormalizeAlgorithm.cpp b/Source/modules/crypto/NormalizeAlgorithm.cpp
index 4d799e7b3b6c554de036dfa04073da7b0c43973f..19965eeb8aab1e51759a8bcca196f5b11a9bfd2d 100644
--- a/Source/modules/crypto/NormalizeAlgorithm.cpp
+++ b/Source/modules/crypto/NormalizeAlgorithm.cpp
@@ -396,6 +396,21 @@ const AlgorithmInfo* lookupAlgorithmInfo(blink::WebCryptoAlgorithmId id)
return &algorithmIdToInfo[id];
}
+void completeWithSyntaxError(const String& message, CryptoResult* result)
+{
+ result->completeWithError(blink::WebCryptoErrorTypeSyntax, message);
+}
+
+void completeWithNotSupportedError(const String& message, CryptoResult* result)
+{
+ result->completeWithError(blink::WebCryptoErrorTypeNotSupported, message);
+}
+
+void completeWithDataError(const String& message, CryptoResult* result)
+{
+ result->completeWithError(blink::WebCryptoErrorTypeData, message);
+}
+
// ErrorContext holds a stack of string literals which describe what was
// happening at the time the error occurred. This is helpful because
// parsing of the algorithm dictionary can be recursive and it is difficult to
@@ -407,6 +422,11 @@ public:
m_messages.append(message);
}
+ void removeLast()
+ {
+ m_messages.removeLast();
+ }
+
// Join all of the string literals into a single String.
String toString() const
{
@@ -456,7 +476,7 @@ private:
// typedef (ArrayBuffer or ArrayBufferView) CryptoOperationData;
//
// FIXME: Currently only supports ArrayBufferView.
-bool getOptionalCryptoOperationData(const Dictionary& raw, const char* propertyName, bool& hasProperty, RefPtr<ArrayBufferView>& buffer, const ErrorContext& context, String& errorDetails)
+bool getOptionalCryptoOperationData(const Dictionary& raw, const char* propertyName, bool& hasProperty, RefPtr<ArrayBufferView>& buffer, const ErrorContext& context, CryptoResult* result)
{
if (!raw.get(propertyName, buffer)) {
hasProperty = false;
@@ -466,7 +486,7 @@ bool getOptionalCryptoOperationData(const Dictionary& raw, const char* propertyN
hasProperty = true;
if (!buffer) {
- errorDetails = context.toString(propertyName, "Not an ArrayBufferView");
+ completeWithSyntaxError(context.toString(propertyName, "Not an ArrayBufferView"), result);
return false;
}
@@ -478,21 +498,21 @@ bool getOptionalCryptoOperationData(const Dictionary& raw, const char* propertyN
// typedef (ArrayBuffer or ArrayBufferView) CryptoOperationData;
//
// FIXME: Currently only supports ArrayBufferView.
-bool getCryptoOperationData(const Dictionary& raw, const char* propertyName, RefPtr<ArrayBufferView>& buffer, const ErrorContext& context, String& errorDetails)
+bool getCryptoOperationData(const Dictionary& raw, const char* propertyName, RefPtr<ArrayBufferView>& buffer, const ErrorContext& context, CryptoResult* result)
{
bool hasProperty;
- bool ok = getOptionalCryptoOperationData(raw, propertyName, hasProperty, buffer, context, errorDetails);
+ bool ok = getOptionalCryptoOperationData(raw, propertyName, hasProperty, buffer, context, result);
if (!hasProperty) {
- errorDetails = context.toString(propertyName, "Missing required property");
+ completeWithSyntaxError(context.toString(propertyName, "Missing required property"), result);
return false;
}
return ok;
}
-bool getUint8Array(const Dictionary& raw, const char* propertyName, RefPtr<Uint8Array>& array, const ErrorContext& context, String& errorDetails)
+bool getUint8Array(const Dictionary& raw, const char* propertyName, RefPtr<Uint8Array>& array, const ErrorContext& context, CryptoResult* result)
{
if (!raw.get(propertyName, array) || !array) {
- errorDetails = context.toString(propertyName, "Missing or not a Uint8Array");
+ completeWithSyntaxError(context.toString(propertyName, "Missing or not a Uint8Array"), result);
return false;
}
return true;
@@ -501,25 +521,25 @@ bool getUint8Array(const Dictionary& raw, const char* propertyName, RefPtr<Uint8
// Defined by the WebCrypto spec as:
//
// typedef Uint8Array BigInteger;
-bool getBigInteger(const Dictionary& raw, const char* propertyName, RefPtr<Uint8Array>& array, const ErrorContext& context, String& errorDetails)
+bool getBigInteger(const Dictionary& raw, const char* propertyName, RefPtr<Uint8Array>& array, const ErrorContext& context, CryptoResult* result)
{
- if (!getUint8Array(raw, propertyName, array, context, errorDetails))
+ if (!getUint8Array(raw, propertyName, array, context, result))
return false;
if (!array->byteLength()) {
- errorDetails = context.toString(propertyName, "BigInteger should not be empty");
+ completeWithSyntaxError(context.toString(propertyName, "BigInteger should not be empty"), result);
return false;
}
if (!raw.get(propertyName, array) || !array) {
- errorDetails = context.toString(propertyName, "Missing or not a Uint8Array");
+ completeWithSyntaxError(context.toString(propertyName, "Missing or not a Uint8Array"), result);
return false;
}
return true;
}
// Gets an integer according to WebIDL's [EnforceRange].
-bool getOptionalInteger(const Dictionary& raw, const char* propertyName, bool& hasProperty, double& value, double minValue, double maxValue, const ErrorContext& context, String& errorDetails)
+bool getOptionalInteger(const Dictionary& raw, const char* propertyName, bool& hasProperty, double& value, double minValue, double maxValue, const ErrorContext& context, CryptoResult* result)
{
double number;
bool ok = raw.get(propertyName, number, hasProperty);
@@ -528,14 +548,14 @@ bool getOptionalInteger(const Dictionary& raw, const char* propertyName, bool& h
return true;
if (!ok || std::isnan(number)) {
- errorDetails = context.toString(propertyName, "Is not a number");
+ completeWithSyntaxError(context.toString(propertyName, "Is not a number"), result);
return false;
}
number = trunc(number);
if (std::isinf(number) || number < minValue || number > maxValue) {
- errorDetails = context.toString(propertyName, "Outside of numeric range");
+ completeWithSyntaxError(context.toString(propertyName, "Outside of numeric range"), result);
return false;
}
@@ -543,51 +563,51 @@ bool getOptionalInteger(const Dictionary& raw, const char* propertyName, bool& h
return true;
}
-bool getInteger(const Dictionary& raw, const char* propertyName, double& value, double minValue, double maxValue, const ErrorContext& context, String& errorDetails)
+bool getInteger(const Dictionary& raw, const char* propertyName, double& value, double minValue, double maxValue, const ErrorContext& context, CryptoResult* result)
{
bool hasProperty;
- if (!getOptionalInteger(raw, propertyName, hasProperty, value, minValue, maxValue, context, errorDetails))
+ if (!getOptionalInteger(raw, propertyName, hasProperty, value, minValue, maxValue, context, result))
return false;
if (!hasProperty) {
- errorDetails = context.toString(propertyName, "Missing required property");
+ completeWithSyntaxError(context.toString(propertyName, "Missing required property"), result);
return false;
}
return true;
}
-bool getUint32(const Dictionary& raw, const char* propertyName, uint32_t& value, const ErrorContext& context, String& errorDetails)
+bool getUint32(const Dictionary& raw, const char* propertyName, uint32_t& value, const ErrorContext& context, CryptoResult* result)
{
double number;
- if (!getInteger(raw, propertyName, number, 0, 0xFFFFFFFF, context, errorDetails))
+ if (!getInteger(raw, propertyName, number, 0, 0xFFFFFFFF, context, result))
return false;
value = number;
return true;
}
-bool getUint16(const Dictionary& raw, const char* propertyName, uint16_t& value, const ErrorContext& context, String& errorDetails)
+bool getUint16(const Dictionary& raw, const char* propertyName, uint16_t& value, const ErrorContext& context, CryptoResult* result)
{
double number;
- if (!getInteger(raw, propertyName, number, 0, 0xFFFF, context, errorDetails))
+ if (!getInteger(raw, propertyName, number, 0, 0xFFFF, context, result))
return false;
value = number;
return true;
}
-bool getUint8(const Dictionary& raw, const char* propertyName, uint8_t& value, const ErrorContext& context, String& errorDetails)
+bool getUint8(const Dictionary& raw, const char* propertyName, uint8_t& value, const ErrorContext& context, CryptoResult* result)
{
double number;
- if (!getInteger(raw, propertyName, number, 0, 0xFF, context, errorDetails))
+ if (!getInteger(raw, propertyName, number, 0, 0xFF, context, result))
return false;
value = number;
return true;
}
-bool getOptionalUint32(const Dictionary& raw, const char* propertyName, bool& hasValue, uint32_t& value, const ErrorContext& context, String& errorDetails)
+bool getOptionalUint32(const Dictionary& raw, const char* propertyName, bool& hasValue, uint32_t& value, const ErrorContext& context, CryptoResult* result)
{
double number;
- if (!getOptionalInteger(raw, propertyName, hasValue, number, 0, 0xFFFFFFFF, context, errorDetails))
+ if (!getOptionalInteger(raw, propertyName, hasValue, number, 0, 0xFFFFFFFF, context, result))
return false;
if (hasValue)
value = number;
@@ -599,14 +619,14 @@ bool getOptionalUint32(const Dictionary& raw, const char* propertyName, bool& ha
// dictionary AesCbcParams : Algorithm {
// CryptoOperationData iv;
// };
-bool parseAesCbcParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseAesCbcParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
RefPtr<ArrayBufferView> iv;
- if (!getCryptoOperationData(raw, "iv", iv, context, errorDetails))
+ if (!getCryptoOperationData(raw, "iv", iv, context, result))
return false;
if (iv->byteLength() != 16) {
- errorDetails = context.toString("iv", "Must be 16 bytes");
+ completeWithDataError(context.toString("iv", "Must be 16 bytes"), result);
return false;
}
@@ -619,28 +639,28 @@ bool parseAesCbcParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmPa
// dictionary AesKeyGenParams : Algorithm {
// [EnforceRange] unsigned short length;
// };
-bool parseAesKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseAesKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
uint16_t length;
- if (!getUint16(raw, "length", length, context, errorDetails))
+ if (!getUint16(raw, "length", length, context, result))
return false;
params = adoptPtr(new blink::WebCryptoAesKeyGenParams(length));
return true;
}
-bool parseAlgorithm(const Dictionary&, AlgorithmOperation, blink::WebCryptoAlgorithm&, ErrorContext, String&);
+bool parseAlgorithm(const Dictionary&, AlgorithmOperation, blink::WebCryptoAlgorithm&, ErrorContext, CryptoResult*);
-bool parseHash(const Dictionary& raw, blink::WebCryptoAlgorithm& hash, ErrorContext context, String& errorDetails)
+bool parseHash(const Dictionary& raw, blink::WebCryptoAlgorithm& hash, ErrorContext context, CryptoResult* result)
{
Dictionary rawHash;
if (!raw.get("hash", rawHash)) {
- errorDetails = context.toString("hash", "Missing or not a dictionary");
+ completeWithSyntaxError(context.toString("hash", "Missing or not a dictionary"), result);
return false;
}
context.add("hash");
- return parseAlgorithm(rawHash, Digest, hash, context, errorDetails);
+ return parseAlgorithm(rawHash, Digest, hash, context, result);
}
// Defined by the WebCrypto spec as:
@@ -648,10 +668,10 @@ bool parseHash(const Dictionary& raw, blink::WebCryptoAlgorithm& hash, ErrorCont
// dictionary HmacImportParams : Algorithm {
// AlgorithmIdentifier hash;
// };
-bool parseHmacImportParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseHmacImportParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
blink::WebCryptoAlgorithm hash;
- if (!parseHash(raw, hash, context, errorDetails))
+ if (!parseHash(raw, hash, context, result))
return false;
params = adoptPtr(new blink::WebCryptoHmacImportParams(hash));
@@ -667,15 +687,15 @@ bool parseHmacImportParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorit
// // size.
// unsigned long length;
// };
-bool parseHmacKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseHmacKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
blink::WebCryptoAlgorithm hash;
- if (!parseHash(raw, hash, context, errorDetails))
+ if (!parseHash(raw, hash, context, result))
return false;
bool hasLength;
uint32_t length = 0;
- if (!getOptionalUint32(raw, "length", hasLength, length, context, errorDetails))
+ if (!getOptionalUint32(raw, "length", hasLength, length, context, result))
return false;
params = adoptPtr(new blink::WebCryptoHmacKeyGenParams(hash, hasLength, length));
@@ -687,10 +707,10 @@ bool parseHmacKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorit
// dictionary RsaHashedImportParams {
// AlgorithmIdentifier hash;
// };
-bool parseRsaHashedImportParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseRsaHashedImportParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
blink::WebCryptoAlgorithm hash;
- if (!parseHash(raw, hash, context, errorDetails))
+ if (!parseHash(raw, hash, context, result))
return false;
params = adoptPtr(new blink::WebCryptoRsaHashedImportParams(hash));
@@ -703,22 +723,22 @@ bool parseRsaHashedImportParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAl
// unsigned long modulusLength;
// BigInteger publicExponent;
// };
-bool parseRsaKeyGenParams(const Dictionary& raw, uint32_t& modulusLength, RefPtr<Uint8Array>& publicExponent, const ErrorContext& context, String& errorDetails)
+bool parseRsaKeyGenParams(const Dictionary& raw, uint32_t& modulusLength, RefPtr<Uint8Array>& publicExponent, const ErrorContext& context, CryptoResult* result)
{
- if (!getUint32(raw, "modulusLength", modulusLength, context, errorDetails))
+ if (!getUint32(raw, "modulusLength", modulusLength, context, result))
return false;
- if (!getBigInteger(raw, "publicExponent", publicExponent, context, errorDetails))
+ if (!getBigInteger(raw, "publicExponent", publicExponent, context, result))
return false;
return true;
}
-bool parseRsaKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseRsaKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
uint32_t modulusLength;
RefPtr<Uint8Array> publicExponent;
- if (!parseRsaKeyGenParams(raw, modulusLength, publicExponent, context, errorDetails))
+ if (!parseRsaKeyGenParams(raw, modulusLength, publicExponent, context, result))
return false;
params = adoptPtr(new blink::WebCryptoRsaKeyGenParams(modulusLength, static_cast<const unsigned char*>(publicExponent->baseAddress()), publicExponent->byteLength()));
@@ -730,15 +750,15 @@ bool parseRsaKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorith
// dictionary RsaHashedKeyGenParams : RsaKeyGenParams {
// AlgorithmIdentifier hash;
// };
-bool parseRsaHashedKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseRsaHashedKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
uint32_t modulusLength;
RefPtr<Uint8Array> publicExponent;
- if (!parseRsaKeyGenParams(raw, modulusLength, publicExponent, context, errorDetails))
+ if (!parseRsaKeyGenParams(raw, modulusLength, publicExponent, context, result))
return false;
blink::WebCryptoAlgorithm hash;
- if (!parseHash(raw, hash, context, errorDetails))
+ if (!parseHash(raw, hash, context, result))
return false;
params = adoptPtr(new blink::WebCryptoRsaHashedKeyGenParams(hash, modulusLength, static_cast<const unsigned char*>(publicExponent->baseAddress()), publicExponent->byteLength()));
@@ -751,14 +771,14 @@ bool parseRsaHashedKeyGenParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAl
// CryptoOperationData counter;
// [EnforceRange] octet length;
// };
-bool parseAesCtrParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseAesCtrParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
RefPtr<ArrayBufferView> counter;
- if (!getCryptoOperationData(raw, "counter", counter, context, errorDetails))
+ if (!getCryptoOperationData(raw, "counter", counter, context, result))
return false;
uint8_t length;
- if (!getUint8(raw, "length", length, context, errorDetails))
+ if (!getUint8(raw, "length", length, context, result))
return false;
params = adoptPtr(new blink::WebCryptoAesCtrParams(length, static_cast<const unsigned char*>(counter->baseAddress()), counter->byteLength()));
@@ -772,20 +792,20 @@ bool parseAesCtrParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmPa
// CryptoOperationData? additionalData;
// [EnforceRange] octet? tagLength; // May be 0-128
// }
-bool parseAesGcmParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, String& errorDetails)
+bool parseAesGcmParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmParams>& params, const ErrorContext& context, CryptoResult* result)
{
RefPtr<ArrayBufferView> iv;
- if (!getCryptoOperationData(raw, "iv", iv, context, errorDetails))
+ if (!getCryptoOperationData(raw, "iv", iv, context, result))
return false;
bool hasAdditionalData;
RefPtr<ArrayBufferView> additionalData;
- if (!getOptionalCryptoOperationData(raw, "additionalData", hasAdditionalData, additionalData, context, errorDetails))
+ if (!getOptionalCryptoOperationData(raw, "additionalData", hasAdditionalData, additionalData, context, result))
return false;
double tagLength;
bool hasTagLength;
- if (!getOptionalInteger(raw, "tagLength", hasTagLength, tagLength, 0, 128, context, errorDetails))
+ if (!getOptionalInteger(raw, "tagLength", hasTagLength, tagLength, 0, 128, context, result))
return false;
const unsigned char* ivStart = static_cast<const unsigned char*>(iv->baseAddress());
@@ -798,38 +818,38 @@ bool parseAesGcmParams(const Dictionary& raw, OwnPtr<blink::WebCryptoAlgorithmPa
return true;
}
-bool parseAlgorithmParams(const Dictionary& raw, blink::WebCryptoAlgorithmParamsType type, OwnPtr<blink::WebCryptoAlgorithmParams>& params, ErrorContext& context, String& errorDetails)
+bool parseAlgorithmParams(const Dictionary& raw, blink::WebCryptoAlgorithmParamsType type, OwnPtr<blink::WebCryptoAlgorithmParams>& params, ErrorContext& context, CryptoResult* result)
{
switch (type) {
case blink::WebCryptoAlgorithmParamsTypeNone:
return true;
case blink::WebCryptoAlgorithmParamsTypeAesCbcParams:
context.add("AesCbcParams");
- return parseAesCbcParams(raw, params, context, errorDetails);
+ return parseAesCbcParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeAesKeyGenParams:
context.add("AesKeyGenParams");
- return parseAesKeyGenParams(raw, params, context, errorDetails);
+ return parseAesKeyGenParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeHmacImportParams:
context.add("HmacImportParams");
- return parseHmacImportParams(raw, params, context, errorDetails);
+ return parseHmacImportParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeHmacKeyGenParams:
context.add("HmacKeyGenParams");
- return parseHmacKeyGenParams(raw, params, context, errorDetails);
+ return parseHmacKeyGenParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams:
context.add("RsaHashedKeyGenParams");
- return parseRsaHashedKeyGenParams(raw, params, context, errorDetails);
+ return parseRsaHashedKeyGenParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeRsaHashedImportParams:
context.add("RsaHashedImportParams");
- return parseRsaHashedImportParams(raw, params, context, errorDetails);
+ return parseRsaHashedImportParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams:
context.add("RsaKeyGenParams");
- return parseRsaKeyGenParams(raw, params, context, errorDetails);
+ return parseRsaKeyGenParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeAesCtrParams:
context.add("AesCtrParams");
- return parseAesCtrParams(raw, params, context, errorDetails);
+ return parseAesCtrParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeAesGcmParams:
context.add("AesGcmParams");
- return parseAesGcmParams(raw, params, context, errorDetails);
+ return parseAesGcmParams(raw, params, context, result);
case blink::WebCryptoAlgorithmParamsTypeRsaOaepParams:
// TODO
notImplemented();
@@ -839,39 +859,73 @@ bool parseAlgorithmParams(const Dictionary& raw, blink::WebCryptoAlgorithmParams
return false;
}
-bool parseAlgorithm(const Dictionary& raw, AlgorithmOperation op, blink::WebCryptoAlgorithm& algorithm, ErrorContext context, String& errorDetails)
+const char* operationToString(AlgorithmOperation op)
+{
+ switch (op) {
+ case Encrypt:
+ return "encrypt";
+ case Decrypt:
+ return "decrypt";
+ case Sign:
+ return "sign";
+ case Verify:
+ return "verify";
+ case Digest:
+ return "digest";
+ case GenerateKey:
+ return "generateKey";
+ case ImportKey:
+ return "importKey";
+ case DeriveKey:
+ return "deriveKey";
+ case DeriveBits:
+ return "deriveBits";
+ case WrapKey:
+ return "wrapKey";
+ case UnwrapKey:
+ return "unwrapKey";
+ }
+ return 0;
+}
+
+bool parseAlgorithm(const Dictionary& raw, AlgorithmOperation op, blink::WebCryptoAlgorithm& algorithm, ErrorContext context, CryptoResult* result)
{
context.add("Algorithm");
if (!raw.isObject()) {
- errorDetails = context.toString("Not an object");
+ completeWithSyntaxError(context.toString("Not an object"), result);
return false;
}
String algorithmName;
if (!raw.get("name", algorithmName)) {
- errorDetails = context.toString("name", "Missing or not a string");
+ completeWithSyntaxError(context.toString("name", "Missing or not a string"), result);
return false;
}
blink::WebCryptoAlgorithmId algorithmId;
if (!lookupAlgorithmIdByName(algorithmName, algorithmId)) {
- errorDetails = context.toString("Unrecognized algorithm name");
+ // FIXME: The spec says to return a SyntaxError if the input contains
+ // any non-ASCII characters.
+ completeWithNotSupportedError(context.toString("Unrecognized name"), result);
return false;
}
+ // Remove the "Algorithm:" prefix for all subsequent errors.
+ context.removeLast();
+
const AlgorithmInfo* algorithmInfo = lookupAlgorithmInfo(algorithmId);
- context.add(algorithmInfo->name);
if (algorithmInfo->operationToParamsType[op] == Undefined) {
- errorDetails = context.toString("Unsupported operation");
+ context.add(algorithmIdToName(algorithmId));
+ completeWithNotSupportedError(context.toString("Unsupported operation", operationToString(op)), result);
return false;
}
blink::WebCryptoAlgorithmParamsType paramsType = static_cast<blink::WebCryptoAlgorithmParamsType>(algorithmInfo->operationToParamsType[op]);
OwnPtr<blink::WebCryptoAlgorithmParams> params;
- if (!parseAlgorithmParams(raw, paramsType, params, context, errorDetails))
+ if (!parseAlgorithmParams(raw, paramsType, params, context, result))
return false;
algorithm = blink::WebCryptoAlgorithm(algorithmId, params.release());
@@ -882,12 +936,7 @@ bool parseAlgorithm(const Dictionary& raw, AlgorithmOperation op, blink::WebCryp
bool parseAlgorithm(const Dictionary& raw, AlgorithmOperation op, blink::WebCryptoAlgorithm& algorithm, CryptoResult* result)
{
- String errorDetails;
- if (!parseAlgorithm(raw, op, algorithm, ErrorContext(), errorDetails)) {
- result->completeWithError(errorDetails);
- return false;
- }
- return true;
+ return parseAlgorithm(raw, op, algorithm, ErrorContext(), result);
}
const char* algorithmIdToName(blink::WebCryptoAlgorithmId id)
« no previous file with comments | « Source/modules/crypto/Key.cpp ('k') | Source/modules/crypto/SubtleCrypto.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698