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

Source/modules/crypto/CryptoResultImpl.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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/crypto/CryptoResultImpl.h"
 
 #include "bindings/v8/NewScriptState.h"
 #include "bindings/v8/ScriptPromiseResolverWithContext.h"
 #include "core/dom/ContextLifecycleObserver.h"
+#include "core/dom/DOMError.h"
+#include "core/dom/DOMException.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/crypto/Key.h"
 #include "modules/crypto/KeyPair.h"
 #include "modules/crypto/NormalizeAlgorithm.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebArrayBuffer.h"
 #include "public/platform/WebCryptoAlgorithm.h"
 #include "wtf/ArrayBufferView.h"
 
 namespace WebCore {
 
+namespace {
+
+ExceptionCode toExceptionCode(blink::WebCryptoErrorType errorType)
+{
+    switch (errorType) {
+    case blink::WebCryptoErrorTypeNotSupported:
+        return NotSupportedError;
+    case blink::WebCryptoErrorTypeSyntax:
+        return SyntaxError;
+    case blink::WebCryptoErrorTypeInvalidState:
+        return InvalidStateError;
+    case blink::WebCryptoErrorTypeInvalidAccess:
+        return InvalidAccessError;
+    case blink::WebCryptoErrorTypeUnknown:
+        return UnknownError;
+    case blink::WebCryptoErrorTypeData:
+        return DataError;
+    case blink::WebCryptoErrorTypeOperation:
+        // FIXME: This exception type is new to WebCrypto and not yet defined.
+        // Use a placeholder for now.
+        return InvalidStateError;
+    case blink::WebCryptoErrorTypeType:
+        // FIXME: This should construct a TypeError instead. For now do
+        //        something to facilitate refactor, but this will need to be
+        //        revisited.
+        return DataError;
+    }
+
+    ASSERT_NOT_REACHED();
+    return 0;
+}
+
+} // namespace
+
 // The PromiseState class contains all the state which is tied to an
 // ExecutionContext. Whereas CryptoResultImpl can be deleted from any thread,
 // PromiseState is not thread safe and must only be accessed and deleted from
 // the blink thread.
 //
 // This is achieved by making CryptoResultImpl hold a WeakPtr to the PromiseState.
 // The PromiseState deletes itself after being notified of completion.
 // Additionally the PromiseState deletes itself when the ExecutionContext is
 // destroyed (necessary to avoid leaks when dealing with WebWorker threads,
 // which may die before the operation is completed).
@@ skipping 10 matching lines @@
     {
         ContextLifecycleObserver::contextDestroyed();
         delete this;
     }
 
     ScriptPromise promise()
     {
         return m_promiseResolver->promise();
     }
 
-    void completeWithError(const blink::WebString& errorDetails)
+    void completeWithError(blink::WebCryptoErrorType errorType, const blink::WebString& errorDetails)
     {
-        if (!errorDetails.isEmpty()) {
-            // FIXME: Include the line number which started the crypto operation.
-            executionContext()->addConsoleMessage(JSMessageSource, ErrorMessageLevel, errorDetails);
-        }
-        m_promiseResolver->reject(V8NullType());
+        m_promiseResolver->reject(DOMException::create(toExceptionCode(errorType), errorDetails));
         delete this;
     }
 
-    void completeWithError()
-    {
-        completeWithError(blink::WebString());
-    }
-
     void completeWithBuffer(const blink::WebArrayBuffer& buffer)
     {
         m_promiseResolver->resolve(PassRefPtr<ArrayBuffer>(buffer));
         delete this;
     }
 
     void completeWithBoolean(bool b)
     {
         m_promiseResolver->resolve(b);
         delete this;
@@ skipping 25 matching lines @@
 
 CryptoResultImpl::~CryptoResultImpl()
 {
 }
 
 PassRefPtr<CryptoResultImpl> CryptoResultImpl::create()
 {
     return adoptRef(new CryptoResultImpl(callingExecutionContext(v8::Isolate::GetCurrent())));
 }
 
-void CryptoResultImpl::completeWithError(const blink::WebString& errorDetails)
+void CryptoResultImpl::completeWithError(blink::WebCryptoErrorType errorType, const blink::WebString& errorDetails)
 {
     if (m_promiseState)
-        m_promiseState->completeWithError(errorDetails);
-}
-
-void CryptoResultImpl::completeWithError()
-{
-    completeWithError(blink::WebString());
+        m_promiseState->completeWithError(errorType, errorDetails);
 }
 
 void CryptoResultImpl::completeWithBuffer(const blink::WebArrayBuffer& buffer)
 {
     if (m_promiseState)
         m_promiseState->completeWithBuffer(buffer);
 }
 
 void CryptoResultImpl::completeWithBoolean(bool b)
 {
@@ skipping 17 matching lines @@
     : m_promiseState(PromiseState::create(context))
 {
 }
 
 ScriptPromise CryptoResultImpl::promise()
 {
     return m_promiseState->promise();
 }
 
 } // namespace WebCore