Make ScriptPromiseResolver RefCountedWillBeRefCountedGarbageCollected.

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..25cb2fa31fd920f0d2c49cb27d88b0b722f0cfea 100644
--- a/Source/modules/crypto/CryptoResultImpl.cpp
+++ b/Source/modules/crypto/CryptoResultImpl.cpp
@@ -50,26 +50,32 @@ namespace blink {
 
 class CryptoResultImpl::WeakResolver : public ScriptPromiseResolver {
 public:
-    static WeakPtr<ScriptPromiseResolver> create(ScriptState* scriptState, CryptoResultImpl* result)
+    static PassRefPtrWillBeRawPtr<ScriptPromiseResolver> create(ScriptState* scriptState, CryptoResultImpl* result)
     {
-        RefPtr<WeakResolver> p = adoptRef(new WeakResolver(scriptState, result));
+        RefPtrWillBeRawPtr<WeakResolver> p = adoptRefWillBeNoop(new WeakResolver(scriptState, result));
         p->suspendIfNeeded();
         p->keepAliveWhilePending();
-        return p->m_weakPtrFactory.createWeakPtr();
+        return p.release();
     }
 
-    virtual ~WeakResolver()
+    virtual void stop() override
     {
         m_result->cancel();
+        m_result->clearResolver();
+        ScriptPromiseResolver::stop();
+    }
+
+
+    virtual void trace(Visitor* visitor)
+    {
+        ScriptPromiseResolver::trace(visitor);
     }
 
 private:
     WeakResolver(ScriptState* scriptState, CryptoResultImpl* result)
         : ScriptPromiseResolver(scriptState)
-        , m_weakPtrFactory(this)
         , m_result(result) { }
-    WeakPtrFactory<ScriptPromiseResolver> m_weakPtrFactory;
-    RefPtr<CryptoResultImpl> m_result;
+    RawPtr<CryptoResultImpl> m_result;

[tasak, 2014/12/09 10:38:28]

Since CryptResultImpl has a persistent member: m_resolver, which points 
WeakResolver, RawPtr.

 

 };
 
 ExceptionCode webCryptoErrorToExceptionCode(WebCryptoErrorType errorType)
@@ -102,30 +108,53 @@ ExceptionCode webCryptoErrorToExceptionCode(WebCryptoErrorType errorType)
 
 CryptoResultImpl::~CryptoResultImpl()
 {
+#if ENABLE(OILPAN)
+    ASSERT(!m_resolver);
+#endif
+}
+
+void CryptoResultImpl::clearResolver()
+{
+#if ENABLE(OILPAN)
+    m_resolver.clear();
+#else
+    m_resolver = nullptr;
+#endif
+}
+
+ScriptPromiseResolver* CryptoResultImpl::resolver()
+{
+#if ENABLE(OILPAN)
+    return m_resolver ? m_resolver.get()->get() : nullptr;
+#else
+    return m_resolver.get();
+#endif
 }
 
-PassRefPtr<CryptoResultImpl> CryptoResultImpl::create(ScriptState* scriptState)
+PassRefPtrWillBeRawPtr<CryptoResultImpl> CryptoResultImpl::create(ScriptState* scriptState)
 {
-    return adoptRef(new CryptoResultImpl(scriptState));
+    return adoptRefWillBeNoop(new CryptoResultImpl(scriptState));
 }
 
 void CryptoResultImpl::completeWithError(WebCryptoErrorType errorType, const WebString& errorDetails)
 {
-    if (m_resolver)
-        m_resolver->reject(DOMException::create(webCryptoErrorToExceptionCode(errorType), errorDetails));
+    if (resolver())
+        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));
+    if (resolver())
+        resolver()->resolve(DOMArrayBuffer::create(bytes, bytesSize));
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithJson(const char* utf8Data, unsigned length)
 {
-    if (m_resolver) {
-        ScriptPromiseResolver* resolver = m_resolver.get();
-        ScriptState* scriptState = resolver->scriptState();
+    if (resolver()) {
+        ScriptPromiseResolver* scriptPromiseResolver = resolver();
+        ScriptState* scriptState = scriptPromiseResolver->scriptState();
         ScriptState::Scope scope(scriptState);
 
         v8::Handle<v8::String> jsonString = v8::String::NewFromUtf8(scriptState->isolate(), utf8Data, v8::String::kInternalizedString, length);
@@ -134,29 +163,32 @@ void CryptoResultImpl::completeWithJson(const char* utf8Data, unsigned length)
         v8::Handle<v8::Value> jsonDictionary = v8::JSON::Parse(jsonString);
         if (exceptionCatcher.HasCaught() || jsonDictionary.IsEmpty()) {
             ASSERT_NOT_REACHED();
-            resolver->reject(DOMException::create(OperationError, "Failed inflating JWK JSON to object"));
+            scriptPromiseResolver->reject(DOMException::create(OperationError, "Failed inflating JWK JSON to object"));
         } else {
-            resolver->resolve(jsonDictionary);
+            scriptPromiseResolver->resolve(jsonDictionary);
         }
     }
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithBoolean(bool b)
 {
-    if (m_resolver)
-        m_resolver->resolve(b);
+    if (resolver())
+        resolver()->resolve(b);
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithKey(const WebCryptoKey& key)
 {
-    if (m_resolver)
-        m_resolver->resolve(CryptoKey::create(key));
+    if (resolver())
+        resolver()->resolve(CryptoKey::create(key));
+    clearResolver();
 }
 
 void CryptoResultImpl::completeWithKeyPair(const WebCryptoKey& publicKey, const WebCryptoKey& privateKey)
 {
-    if (m_resolver) {
-        ScriptState* scriptState = m_resolver->scriptState();
+    if (resolver()) {
+        ScriptState* scriptState = resolver()->scriptState();
         ScriptState::Scope scope(scriptState);
 
         Dictionary keyPair = Dictionary::createEmpty(scriptState->isolate());
@@ -167,8 +199,9 @@ void CryptoResultImpl::completeWithKeyPair(const WebCryptoKey& publicKey, const
         keyPair.set("publicKey", publicKeyValue);
         keyPair.set("privateKey", privateKeyValue);
 
-        m_resolver->resolve(keyPair.v8Value());
+        resolver()->resolve(keyPair.v8Value());
     }
+    clearResolver();
 }
 
 bool CryptoResultImpl::cancelled() const
@@ -186,12 +219,20 @@ CryptoResultImpl::CryptoResultImpl(ScriptState* scriptState)
 {
     // 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);
+#if ENABLE(OILPAN)
+    if (!m_resolver)
+        m_resolver = adoptPtr(new Persistent<ScriptPromiseResolver>());
+    *m_resolver = Persistent<ScriptPromiseResolver>(WeakResolver::create(scriptState, this));
+#else
+    m_resolver = WeakResolver::create(scriptState, this).get();
+#endif
 }
 
 ScriptPromise CryptoResultImpl::promise()
 {
-    return m_resolver ? m_resolver->promise() : ScriptPromise();
+    if (ScriptPromiseResolver* scriptPromiseResolver = resolver())
+        return scriptPromiseResolver->promise();
+    return ScriptPromise();
 }
 
 } // namespace blink