Oilpan: prefer eager finalization over prefinalizers.

Source/bindings/core/v8/ScriptPromiseResolver.h

 // 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.
 
 #ifndef ScriptPromiseResolver_h
 #define ScriptPromiseResolver_h
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 10 matching lines @@
 // This class wraps v8::Promise::Resolver and provides the following
 // functionalities.
 //  - A ScriptPromiseResolver retains a ScriptState. A caller
 //    can call resolve or reject from outside of a V8 context.
 //  - This class is an ActiveDOMObject and keeps track of the associated
 //    ExecutionContext state. When the ExecutionContext is suspended,
 //    resolve or reject will be delayed. When it is stopped, resolve or reject
 //    will be ignored.
 class CORE_EXPORT ScriptPromiseResolver : public RefCountedWillBeRefCountedGarbageCollected<ScriptPromiseResolver>, public ActiveDOMObject {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(ScriptPromiseResolver);
-#if ENABLE(ASSERT)
-    WILL_BE_USING_PRE_FINALIZER(ScriptPromiseResolver, assertNotPending);
-#endif
     WTF_MAKE_NONCOPYABLE(ScriptPromiseResolver);
 public:
     static PassRefPtrWillBeRawPtr<ScriptPromiseResolver> create(ScriptState* scriptState)
     {
         RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = adoptRefWillBeNoop(new ScriptPromiseResolver(scriptState));
         resolver->suspendIfNeeded();
         return resolver.release();
     }
 
-#if !ENABLE(OILPAN) && ENABLE(ASSERT)
+#if ENABLE(ASSERT)
+    // Eagerly finalized so as to ensure valid access to executionContext()
+    // from the destructor's assert.
+    EAGERLY_FINALIZE();
+
     ~ScriptPromiseResolver() override
     {
-        assertNotPending();
+        // This assertion fails if:
+        //  - promise() is called at least once and
+        //  - this resolver is destructed before it is resolved, rejected or
+        //    the associated ExecutionContext is stopped.
+        ASSERT(m_state == ResolvedOrRejected || !m_isPromiseCalled || !executionContext() || executionContext()->activeDOMObjectsAreStopped());
     }
 #endif
 
     // Anything that can be passed to toV8 can be passed to this function.
     template<typename T>
     void resolve(T value)
     {
         resolveOrReject(value, Resolving);
     }
 
@@ skipping 43 matching lines @@
         Pending,
         Resolving,
         Rejecting,
         ResolvedOrRejected,
     };
     enum LifetimeMode {
         Default,
         KeepAliveWhilePending,
     };
 
-#if ENABLE(ASSERT)
-    void assertNotPending()
-    {
-        // This assertion fails if:
-        //  - promise() is called at least once and
-        //  - this resolver is destructed before it is resolved, rejected or
-        //    the associated ExecutionContext is stopped.
-        // This function cannot be run in the destructor if
-        // ScriptPromiseResolver is on-heap.
-        ASSERT(m_state == ResolvedOrRejected || !m_isPromiseCalled || !executionContext() || executionContext()->activeDOMObjectsAreStopped());
-    }
-#endif
-
     template<typename T>
     void resolveOrReject(T value, ResolutionState newState)
     {
         if (m_state != Pending || !executionContext() || executionContext()->activeDOMObjectsAreStopped())
             return;
         ASSERT(newState == Resolving || newState == Rejecting);
         m_state = newState;
         // Retain this object until it is actually resolved or rejected.
         // |deref| will be called in |clear|.
         ref();
@@ skipping 18 matching lines @@
     ScopedPersistent<v8::Value> m_value;
 #if ENABLE(ASSERT)
     // True if promise() is called.
     bool m_isPromiseCalled;
 #endif
 };
 
 } // namespace blink
 
 #endif // ScriptPromiseResolver_h