[webcrypto] Reject failed operations with a DOMException rather than null.

Source/modules/crypto/SubtleCrypto.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 33 matching lines @@
 
 namespace {
 
 // Seems like the generated bindings should take care of these however it
 // currently doesn't. See also http://crbug.com/264520
 template <typename T>
 bool ensureNotNull(T* x, const char* paramName, CryptoResult* result)
 {
     if (!x) {
         String message = String("Invalid ") + paramName + String(" argument");
-        result->completeWithError(blink::WebString(message));
+        result->completeWithError(blink::WebCryptoErrorTypeType, blink::WebString(message));
         return false;
     }
     return true;
 }
 
 ScriptPromise startCryptoOperation(const Dictionary& rawAlgorithm, Key* key, AlgorithmOperation operationType, ArrayBufferView* signature, ArrayBufferView* dataBuffer)
 {
     RefPtr<CryptoResultImpl> result = CryptoResultImpl::create();
     ScriptPromise promise = result->promise();
 
@@ skipping 121 matching lines @@
     ScriptPromise promise = result->promise();
 
     if (!ensureNotNull(key, "key", result.get()))
         return promise;
 
     blink::WebCryptoKeyFormat format;
     if (!Key::parseFormat(rawFormat, format, result.get()))
         return promise;
 
     if (!key->extractable()) {
-        result->completeWithError("key is not extractable");
+        result->completeWithError(blink::WebCryptoErrorTypeInvalidAccess, "key is not extractable");
         return promise;
     }
 
     blink::Platform::current()->crypto()->exportKey(format, key->key(), result->result());
     return promise;
 }
 
 ScriptPromise SubtleCrypto::wrapKey(const String& rawFormat, Key* key, Key* wrappingKey, const Dictionary& rawWrapAlgorithm)
 {
     RefPtr<CryptoResultImpl> result = CryptoResultImpl::create();
     ScriptPromise promise = result->promise();
 
     if (!ensureNotNull(key, "key", result.get()))
         return promise;
 
     if (!ensureNotNull(wrappingKey, "wrappingKey", result.get()))
         return promise;
 
     blink::WebCryptoKeyFormat format;
     if (!Key::parseFormat(rawFormat, format, result.get()))
         return promise;
 
     blink::WebCryptoAlgorithm wrapAlgorithm;
     if (!parseAlgorithm(rawWrapAlgorithm, WrapKey, wrapAlgorithm, result.get()))
         return promise;
 
     if (!key->extractable()) {
-        result->completeWithError("key is not extractable");
+        result->completeWithError(blink::WebCryptoErrorTypeInvalidAccess, "key is not extractable");
         return promise;
     }
 
     if (!wrappingKey->canBeUsedForAlgorithm(wrapAlgorithm, WrapKey, result.get()))
         return promise;
 
     blink::Platform::current()->crypto()->wrapKey(format, key->key(), wrappingKey->key(), wrapAlgorithm, result->result());
     return promise;
 }
 
@@ skipping 27 matching lines @@
         return promise;
 
     const unsigned char* wrappedKeyData = static_cast<const unsigned char*>(wrappedKey->baseAddress());
     unsigned wrappedKeyDataSize = wrappedKey->byteLength();
 
     blink::Platform::current()->crypto()->unwrapKey(format, wrappedKeyData, wrappedKeyDataSize, unwrappingKey->key(), unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages, result->result());
     return promise;
 }
 
 } // namespace WebCore