Make ScriptPromiseResolver RefCountedWillBeRefCountedGarbageCollected.

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 44 matching lines @@
     if (!resolver->executionContext() || resolver->executionContext()->activeDOMObjectsAreStopped())
         return;
 
     ScriptState::Scope scope(resolver->scriptState());
     v8::Isolate* isolate = resolver->scriptState()->isolate();
     resolver->reject(v8::Exception::TypeError(v8String(isolate, errorDetails)));
 }
 
 class CryptoResultImpl::Resolver final : public ScriptPromiseResolver {
 public:
-    static PassRefPtr<ScriptPromiseResolver> create(ScriptState* scriptState, CryptoResultImpl* result)
+    static PassRefPtrWillBeRawPtr<ScriptPromiseResolver> create(ScriptState* scriptState, CryptoResultImpl* result)
     {
-        RefPtr<Resolver> resolver = adoptRef(new Resolver(scriptState, result));
+        RefPtrWillBeRawPtr<Resolver> resolver = adoptRefWillBeNoop(new Resolver(scriptState, result));
         resolver->suspendIfNeeded();
         resolver->keepAliveWhilePending();
         return resolver.release();
     }
 
     virtual void stop() override
     {
         m_result->cancel();
         m_result->clearResolver();
         m_result = nullptr;
         ScriptPromiseResolver::stop();
     }
 
+    virtual void trace(Visitor* visitor)

[haraken, 2014/12/16 09:43:29]

Add override.

The same comment for other overridden trace methods.

[tasak, 2014/12/16 11:54:28]

Done.

+    {
+        ScriptPromiseResolver::trace(visitor);
+    }
+
 private:
     Resolver(ScriptState* scriptState, CryptoResultImpl* result)
         : ScriptPromiseResolver(scriptState)
         , m_result(result) { }
     RefPtr<CryptoResultImpl> m_result;
 };
 
 ExceptionCode webCryptoErrorToExceptionCode(WebCryptoErrorType errorType)
 {
     switch (errorType) {
@@ skipping 15 matching lines @@
     return 0;
 }
 
 CryptoResultImpl::~CryptoResultImpl()
 {
     ASSERT(!m_resolver);
 }
 
 void CryptoResultImpl::clearResolver()
 {
+#if ENABLE(OILPAN)
+    m_resolver.clear();
+#else
     m_resolver = nullptr;
+#endif
 }
 
-PassRefPtr<CryptoResultImpl> CryptoResultImpl::create(ScriptState* scriptState)
+ScriptPromiseResolver* CryptoResultImpl::resolver()
 {
-    return adoptRef(new CryptoResultImpl(scriptState));
+#if ENABLE(OILPAN)
+    return m_resolver ? m_resolver.get()->get() : nullptr;
+#else
+    return m_resolver;
+#endif
+}
+
+PassRefPtrWillBeRawPtr<CryptoResultImpl> CryptoResultImpl::create(ScriptState* scriptState)
+{
+    return adoptRefWillBeNoop(new CryptoResultImpl(scriptState));
 }
 
 void CryptoResultImpl::completeWithError(WebCryptoErrorType errorType, const WebString& errorDetails)
 {
-    if (m_resolver) {
+    if (resolver()) {
+        ScriptPromiseResolver* scriptPromiseResolver = resolver();
         ExceptionCode ec = webCryptoErrorToExceptionCode(errorType);
 
         // Handle TypeError separately, as it cannot be created using
         // DOMException.
         if (ec == V8TypeError)
-            rejectWithTypeError(errorDetails, m_resolver);
+            rejectWithTypeError(errorDetails, scriptPromiseResolver);
         else
-            m_resolver->reject(DOMException::create(ec, errorDetails));
+            scriptPromiseResolver->reject(DOMException::create(ec, 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;
-        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);
 
         v8::TryCatch exceptionCatcher;
         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());
 
         v8::Handle<v8::Value> publicKeyValue = toV8(CryptoKey::create(publicKey), scriptState->context()->Global(), scriptState->isolate());
         v8::Handle<v8::Value> privateKeyValue = toV8(CryptoKey::create(privateKey), scriptState->context()->Global(), scriptState->isolate());
 
         keyPair.set("publicKey", publicKeyValue);
         keyPair.set("privateKey", privateKeyValue);
 
-        m_resolver->resolve(keyPair.v8Value());
+        resolver()->resolve(keyPair.v8Value());
     }
     clearResolver();
 }
 
 bool CryptoResultImpl::cancelled() const
 {
     return acquireLoad(&m_cancelled);
 }
 
 void CryptoResultImpl::cancel()
 {
     releaseStore(&m_cancelled, 1);
 }
 
 CryptoResultImpl::CryptoResultImpl(ScriptState* scriptState)
     : m_cancelled(0)
 {
     ASSERT(scriptState->contextIsValid());
     if (scriptState->executionContext()->activeDOMObjectsAreStopped()) {
         // If active dom objects have been stopped, avoid creating
         // CryptoResultResolver.
         m_resolver = nullptr;
     } else {
+#if ENABLE(OILPAN)
+        if (!m_resolver)
+            m_resolver = adoptPtr(new Persistent<ScriptPromiseResolver>());
+        *m_resolver = Persistent<ScriptPromiseResolver>(Resolver::create(scriptState, this));
+#else
         m_resolver = Resolver::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