Make CryptoResultImpl not to use WeakPtr.

Source/modules/crypto/CryptoResultImpl.cpp

Index: Source/modules/crypto/CryptoResultImpl.cpp
diff --git a/Source/modules/crypto/CryptoResultImpl.cpp b/Source/modules/crypto/CryptoResultImpl.cpp
index 18f45f92f91164f107de07d2b54f144feaee3bcf..63464b3abf09be91044fedc66900f1108de06d68 100644
--- a/Source/modules/crypto/CryptoResultImpl.cpp
+++ b/Source/modules/crypto/CryptoResultImpl.cpp
@@ -48,30 +48,40 @@
 
 namespace blink {
 
-class CryptoResultImpl::WeakResolver : public ScriptPromiseResolver {
+class CryptoResultResolver : public ScriptPromiseResolver {

[haraken, 2014/12/12 00:04:10]

Add final.

[tasak, 2014/12/12 07:56:50]

Done.

 public:
-    static WeakPtr<ScriptPromiseResolver> create(ScriptState* scriptState, CryptoResultImpl* result)
+    static PassRefPtr<ScriptPromiseResolver> create(ScriptState* scriptState, CryptoResultImpl* result)
     {
-        RefPtr<WeakResolver> p = adoptRef(new WeakResolver(scriptState, result));
+        RefPtr<CryptoResultResolver> p = adoptRef(new CryptoResultResolver(scriptState, result));

[haraken, 2014/12/12 00:04:10]

p => resolver

[tasak, 2014/12/12 07:56:51]

Done.

         p->suspendIfNeeded();
         p->keepAliveWhilePending();
-        return p->m_weakPtrFactory.createWeakPtr();
+        return p.release();
     }
 
-    virtual ~WeakResolver()
+    virtual void stop() override
     {
-        m_result->cancel();
+        if (m_result) {
+            m_result->cancel();
+            m_result->clearResolver();
+            m_result = nullptr;
+        }
+        ScriptPromiseResolver::stop();
+    }
+
+    void clearCryptoResult()
+    {
+        m_result = nullptr;
     }
 
 private:
-    WeakResolver(ScriptState* scriptState, CryptoResultImpl* result)
+    CryptoResultResolver(ScriptState* scriptState, CryptoResultImpl* result)
         : ScriptPromiseResolver(scriptState)
-        , m_weakPtrFactory(this)
         , m_result(result) { }
-    WeakPtrFactory<ScriptPromiseResolver> m_weakPtrFactory;
-    RefPtr<CryptoResultImpl> m_result;
+    CryptoResultImpl* m_result;

[haraken, 2014/12/12 00:04:10]

Help me understand: Why can't this a RefPtr?

[tasak, 2014/12/12 07:56:50]

As far as I investigated, CryptoResultImpl should live longer than this
Resolver.
So Resolver don't need to use RefPtr to hold CryptoResultImpl. Instead, we
should carefully clear m_result.

 };
 
+DEFINE_TYPE_CASTS(CryptoResultResolver, ScriptPromiseResolver, resolver, true, true);
+
 ExceptionCode webCryptoErrorToExceptionCode(WebCryptoErrorType errorType)
 {
     switch (errorType) {
@@ -104,6 +114,13 @@ CryptoResultImpl::~CryptoResultImpl()
 {

[haraken, 2014/12/12 00:04:10]

Add ASSERT(!m_resolver) to verify that the resolver is cleared before the
CryptoResultImpl is destructed.

 }
 
+void CryptoResultImpl::clearResolver()
+{
+    if (m_resolver)
+        toCryptoResultResolver(m_resolver)->clearCryptoResult();
+    m_resolver = nullptr;
+}
+
 PassRefPtr<CryptoResultImpl> CryptoResultImpl::create(ScriptState* scriptState)
 {
     return adoptRef(new CryptoResultImpl(scriptState));
@@ -113,12 +130,14 @@ void CryptoResultImpl::completeWithError(WebCryptoErrorType errorType, const Web
 {
     if (m_resolver)
         m_resolver->reject(DOMException::create(webCryptoErrorToExceptionCode(errorType), errorDetails));
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithBuffer(const void* bytes, unsigned bytesSize)
 {
     if (m_resolver)
         m_resolver->resolve(DOMArrayBuffer::create(bytes, bytesSize));
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithJson(const char* utf8Data, unsigned length)
@@ -139,18 +158,21 @@ void CryptoResultImpl::completeWithJson(const char* utf8Data, unsigned length)
             resolver->resolve(jsonDictionary);
         }
     }
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithBoolean(bool b)
 {
     if (m_resolver)
         m_resolver->resolve(b);
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithKey(const WebCryptoKey& key)
 {
     if (m_resolver)
         m_resolver->resolve(CryptoKey::create(key));
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithKeyPair(const WebCryptoKey& publicKey, const WebCryptoKey& privateKey)
@@ -169,6 +191,7 @@ void CryptoResultImpl::completeWithKeyPair(const WebCryptoKey& publicKey, const
 
         m_resolver->resolve(keyPair.v8Value());
     }
+    clearResolver();
 }
 
 bool CryptoResultImpl::cancelled() const
@@ -184,9 +207,14 @@ void CryptoResultImpl::cancel()
 CryptoResultImpl::CryptoResultImpl(ScriptState* scriptState)
     : m_cancelled(0)
 {
-    // Creating the WeakResolver may return nullptr if active dom objects have
-    // been stopped. And in the process set m_cancelled to 1.
-    m_resolver = WeakResolver::create(scriptState, this);
+    ASSERT(scriptState);

[haraken, 2014/12/12 00:04:10]

scriptState should never be 0. Instead you should check if
scriptState->contextIsValid().

+    if (scriptState->executionContext()->activeDOMObjectsAreStopped()) {
+        // If active dom objects have been stopped, avoid creating
+        // CryptoResultResolver.
+        m_resolver = nullptr;
+    } else {
+        m_resolver = CryptoResultResolver::create(scriptState, this).get();
+    }
 }
 
 ScriptPromise CryptoResultImpl::promise()