Have ScriptPromiseResolver on the Oilpan heap always.

Source/bindings/core/v8/ScriptPromiseResolverTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 62 matching lines @@
 
 TEST_F(ScriptPromiseResolverTest, construct)
 {
     ASSERT_FALSE(executionContext()->activeDOMObjectsAreStopped());
     ScriptState::Scope scope(scriptState());
     ScriptPromiseResolver::create(scriptState());
 }
 
 TEST_F(ScriptPromiseResolverTest, resolve)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = nullptr;
+    ScriptPromiseResolver* resolver = nullptr;
     ScriptPromise promise;
     {
         ScriptState::Scope scope(scriptState());
         resolver = ScriptPromiseResolver::create(scriptState());
         promise = resolver->promise();
     }
 
     String onFulfilled, onRejected;
     ASSERT_FALSE(promise.isEmpty());
     {
@@ skipping 27 matching lines @@
     resolver->resolve("bye");
     resolver->reject("bye");
     isolate()->RunMicrotasks();
 
     EXPECT_EQ("hello", onFulfilled);
     EXPECT_EQ(String(), onRejected);
 }
 
 TEST_F(ScriptPromiseResolverTest, reject)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = nullptr;
+    ScriptPromiseResolver* resolver = nullptr;
     ScriptPromise promise;
     {
         ScriptState::Scope scope(scriptState());
         resolver = ScriptPromiseResolver::create(scriptState());
         promise = resolver->promise();
     }
 
     String onFulfilled, onRejected;
     ASSERT_FALSE(promise.isEmpty());
     {
@@ skipping 27 matching lines @@
     resolver->resolve("bye");
     resolver->reject("bye");
     isolate()->RunMicrotasks();
 
     EXPECT_EQ(String(), onFulfilled);
     EXPECT_EQ("hello", onRejected);
 }
 
 TEST_F(ScriptPromiseResolverTest, stop)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = nullptr;
+    ScriptPromiseResolver* resolver = nullptr;
     ScriptPromise promise;
     {
         ScriptState::Scope scope(scriptState());
         resolver = ScriptPromiseResolver::create(scriptState());
         promise = resolver->promise();
     }
 
     String onFulfilled, onRejected;
     ASSERT_FALSE(promise.isEmpty());
     {
         ScriptState::Scope scope(scriptState());
         promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
     }
 
     executionContext()->stopActiveDOMObjects();
     {
         ScriptState::Scope scope(scriptState());
         EXPECT_TRUE(resolver->promise().isEmpty());
     }
 
     resolver->resolve("hello");
     isolate()->RunMicrotasks();
 
     EXPECT_EQ(String(), onFulfilled);
     EXPECT_EQ(String(), onRejected);
 }
 
-#if !ENABLE(OILPAN)
+class ScriptPromiseResolverKeepAlive : public ScriptPromiseResolver {
+public:
+    static ScriptPromiseResolverKeepAlive* create(ScriptState* scriptState)
+    {
+        ScriptPromiseResolverKeepAlive* resolver = new ScriptPromiseResolverKeepAlive(scriptState);
+        resolver->suspendIfNeeded();
+        return resolver;
+    }
+
+    ~ScriptPromiseResolverKeepAlive() override
+    {
+        s_destructorCalls++;
+    }
+
+    static void reset() { s_destructorCalls = 0; }
+    static bool isAlive() { return !s_destructorCalls; }
+
+    static int s_destructorCalls;
+
+private:
+    explicit ScriptPromiseResolverKeepAlive(ScriptState* scriptState)
+        : ScriptPromiseResolver(scriptState)
+    {
+    }
+};
+
+int ScriptPromiseResolverKeepAlive::s_destructorCalls = 0;
+
 TEST_F(ScriptPromiseResolverTest, keepAliveUntilResolved)
 {
-    RefPtr<ScriptPromiseResolver> resolver;
+    ScriptPromiseResolverKeepAlive::reset();
+    ScriptPromiseResolver* resolver = nullptr;
     {
         ScriptState::Scope scope(scriptState());
-        resolver = ScriptPromiseResolver::create(scriptState());
+        resolver = ScriptPromiseResolverKeepAlive::create(scriptState());
     }
-    EXPECT_EQ(1, resolver->refCount());
     resolver->keepAliveWhilePending();
-    EXPECT_EQ(2, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    ASSERT_TRUE(ScriptPromiseResolverKeepAlive::isAlive());
 
     resolver->resolve("hello");
-    EXPECT_EQ(1, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_FALSE(ScriptPromiseResolverKeepAlive::isAlive());
 }
 
 TEST_F(ScriptPromiseResolverTest, keepAliveUntilRejected)
 {
-    RefPtr<ScriptPromiseResolver> resolver;
+    ScriptPromiseResolverKeepAlive::reset();
+    ScriptPromiseResolver* resolver = nullptr;
     {
         ScriptState::Scope scope(scriptState());
-        resolver = ScriptPromiseResolver::create(scriptState());
+        resolver = ScriptPromiseResolverKeepAlive::create(scriptState());
     }
-    EXPECT_EQ(1, resolver->refCount());
     resolver->keepAliveWhilePending();
-    EXPECT_EQ(2, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    ASSERT_TRUE(ScriptPromiseResolverKeepAlive::isAlive());
 
     resolver->reject("hello");
-    EXPECT_EQ(1, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_FALSE(ScriptPromiseResolverKeepAlive::isAlive());
 }
 
 TEST_F(ScriptPromiseResolverTest, keepAliveUntilStopped)
 {
-    RefPtr<ScriptPromiseResolver> resolver;
+    ScriptPromiseResolverKeepAlive::reset();
+    ScriptPromiseResolver* resolver = nullptr;
     {
         ScriptState::Scope scope(scriptState());
-        resolver = ScriptPromiseResolver::create(scriptState());
+        resolver = ScriptPromiseResolverKeepAlive::create(scriptState());
     }
-    EXPECT_EQ(1, resolver->refCount());
     resolver->keepAliveWhilePending();
-    EXPECT_EQ(2, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_TRUE(ScriptPromiseResolverKeepAlive::isAlive());
 
     executionContext()->stopActiveDOMObjects();
-    EXPECT_EQ(1, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_FALSE(ScriptPromiseResolverKeepAlive::isAlive());
 }
 
 TEST_F(ScriptPromiseResolverTest, suspend)
 {
-    RefPtr<ScriptPromiseResolver> resolver;
+    ScriptPromiseResolverKeepAlive::reset();
+    ScriptPromiseResolver* resolver = nullptr;
     {
         ScriptState::Scope scope(scriptState());
-        resolver = ScriptPromiseResolver::create(scriptState());
+        resolver = ScriptPromiseResolverKeepAlive::create(scriptState());
     }
-    EXPECT_EQ(1, resolver->refCount());
     resolver->keepAliveWhilePending();
-    EXPECT_EQ(2, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    ASSERT_TRUE(ScriptPromiseResolverKeepAlive::isAlive());
+
     executionContext()->suspendActiveDOMObjects();
     resolver->resolve("hello");
-    EXPECT_EQ(3, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_TRUE(ScriptPromiseResolverKeepAlive::isAlive());
 
     executionContext()->stopActiveDOMObjects();
-    EXPECT_EQ(1, resolver->refCount());
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_FALSE(ScriptPromiseResolverKeepAlive::isAlive());
 }
-#endif
 
 TEST_F(ScriptPromiseResolverTest, resolveVoid)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = nullptr;
+    ScriptPromiseResolver* resolver = nullptr;
     ScriptPromise promise;
     {
         ScriptState::Scope scope(scriptState());
         resolver = ScriptPromiseResolver::create(scriptState());
         promise = resolver->promise();
     }
 
     String onFulfilled, onRejected;
     ASSERT_FALSE(promise.isEmpty());
     {
         ScriptState::Scope scope(scriptState());
         promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
     }
 
     resolver->resolve();
     isolate()->RunMicrotasks();
 
     EXPECT_EQ("undefined", onFulfilled);
     EXPECT_EQ(String(), onRejected);
 }
 
 TEST_F(ScriptPromiseResolverTest, rejectVoid)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = nullptr;
+    ScriptPromiseResolver* resolver = nullptr;
     ScriptPromise promise;
     {
         ScriptState::Scope scope(scriptState());
         resolver = ScriptPromiseResolver::create(scriptState());
         promise = resolver->promise();
     }
 
     String onFulfilled, onRejected;
     ASSERT_FALSE(promise.isEmpty());
     {
         ScriptState::Scope scope(scriptState());
         promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
     }
 
     resolver->reject();
     isolate()->RunMicrotasks();
 
     EXPECT_EQ(String(), onFulfilled);
     EXPECT_EQ("undefined", onRejected);
 }
 
 } // namespace
 
 } // namespace blink