Have ScriptPromiseResolver on the Oilpan heap always.

Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 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 993 matching lines @@
         if (m_object)
             m_object->dispose();
     }
 
     void clear() { m_object.clear(); }
 
 private:
     Member<T> m_object;
 };
 
+// SelfKeepAlive<Object> is the idiom to use for objects that have to keep
+// themselves temporarily alive and cannot rely on there being some
+// external reference in that interval:
+//
+//  class Opener {
+//  public:
+//     ...
+//     void open()
+//     {
+//         // Retain a self-reference while in an open()ed state:
+//         m_keepAlive = this;
+//         ....
+//     }
+//
+//     void close()
+//     {
+//         // Clear self-reference that ensured we were kept alive while opened.
+//         m_keepAlive.clear();
+//         ....
+//     }
+//
+//  private:
+//     ...
+//     SelfKeepAlive m_keepAlive;
+//  };
+//
+// The responsibility to call clear() in a timely fashion resides with the implementation
+// of the object.
+//
+//
+template<typename Self>
+class SelfKeepAlive {

[haraken, 2015/07/30 11:41:21]

Can we land this (with some HeapTests) ahead of the time?

We want to use the SelfKeepAlive handle in
https://codereview.chromium.org/1257653007/ :)

+public:
+    SelfKeepAlive& operator=(Self* self)
+    {
+        ASSERT(!m_keepAlive || m_keepAlive.get() == self);
+        m_keepAlive = self;
+        return *this;
+    }
+
+    void clear()
+    {
+        m_keepAlive = nullptr;
+    }
+
+    typedef Persistent<Self> (SelfKeepAlive::*UnspecifiedBoolType);
+    operator UnspecifiedBoolType() const { return m_keepAlive ? &SelfKeepAlive::m_keepAlive : 0; }
+
+private:
+    GC_PLUGIN_IGNORE("420515")
+    Persistent<Self> m_keepAlive;
+};
+
 } // namespace blink
 
 namespace WTF {
 
 template <typename T> struct VectorTraits<blink::Member<T>> : VectorTraitsBase<blink::Member<T>> {
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
@@ skipping 189 matching lines @@
 struct ParamStorageTraits<RawPtr<T>> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
     static_assert(sizeof(T), "T must be fully defined");
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif