[webcrypto] Allow crypto operations to be cancelled by the platform implementation.

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 29 matching lines @@
 #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 {
-
-class WeakResolver : public ScriptPromiseResolverWithContext {
+class CryptoResultImpl::WeakResolver : public ScriptPromiseResolverWithContext {
 public:
-    static WeakPtr<ScriptPromiseResolverWithContext> create(ScriptState* scriptState)
+    static WeakPtr<ScriptPromiseResolverWithContext> create(ScriptState* scriptState, CryptoResultImpl* result)
     {
-        RefPtr<WeakResolver> p = adoptRef(new WeakResolver(scriptState));
+        RefPtr<WeakResolver> p = adoptRef(new WeakResolver(scriptState, result));
         p->suspendIfNeeded();
         p->keepAliveWhilePending();
         return p->m_weakPtrFactory.createWeakPtr();
     }
 
+    virtual ~WeakResolver()
+    {
+        m_result->cancel();
+    }
+
 private:
-    explicit WeakResolver(ScriptState* scriptState)
+    WeakResolver(ScriptState* scriptState, CryptoResultImpl* result)
         : ScriptPromiseResolverWithContext(scriptState)
-        , m_weakPtrFactory(this) { }
+        , m_weakPtrFactory(this)
+        , m_result(result) { }
     WeakPtrFactory<ScriptPromiseResolverWithContext> m_weakPtrFactory;
+    RefPtr<CryptoResultImpl> m_result;
 };
 
-} // namespace
-
 ExceptionCode webCryptoErrorToExceptionCode(blink::WebCryptoErrorType errorType)
 {
     switch (errorType) {
     case blink::WebCryptoErrorTypeNotSupported:
         return NotSupportedError;
     case blink::WebCryptoErrorTypeSyntax:
         return SyntaxError;
     case blink::WebCryptoErrorTypeInvalidState:
         return InvalidStateError;
     case blink::WebCryptoErrorTypeInvalidAccess:
@@ skipping 67 matching lines @@
     if (m_resolver)
         m_resolver->resolve(Key::create(key));
 }
 
 void CryptoResultImpl::completeWithKeyPair(const blink::WebCryptoKey& publicKey, const blink::WebCryptoKey& privateKey)
 {
     if (m_resolver)
         m_resolver->resolve(KeyPair::create(publicKey, privateKey));
 }
 
+bool CryptoResultImpl::cancelled() const
+{
+    return acquireLoad(&m_cancelled);
+}
+
+void CryptoResultImpl::cancel()
+{
+    releaseStore(&m_cancelled, 1);
+}
+
 CryptoResultImpl::CryptoResultImpl(ScriptState* scriptState)
-    : m_resolver(WeakResolver::create(scriptState))
+    : m_resolver(WeakResolver::create(scriptState, this))
+    , m_cancelled(0)
 {
 }
 
 ScriptPromise CryptoResultImpl::promise()
 {
     return m_resolver->promise();
 }
 
 } // namespace WebCore