Have ScriptPromiseResolver on the Oilpan heap always.

Source/core/streams/ReadableStreamImpl.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 ReadableStreamImpl_h
 #define ReadableStreamImpl_h
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 100 matching lines @@
 
     // This function is intended to be used by internal code to withdraw
     // queued data. This pulls all data from this stream's queue, but
     // ReadableStream public APIs can work with the behavior (i.e. it behaves
     // as if multiple read-one-buffer calls were made).
     void readInternal(Deque<std::pair<typename ChunkTypeTraits::HoldType, size_t>>& queue);
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_strategy);
-#if ENABLE(OILPAN)
         visitor->trace(m_pendingReads);
-#endif
         ReadableStream::trace(visitor);
     }
 
 private:
-#if ENABLE(OILPAN)
     using PendingReads = HeapDeque<Member<ScriptPromiseResolver>>;
-#else
-    using PendingReads = Deque<RefPtr<ScriptPromiseResolver>>;
-#endif
 
     // ReadableStream methods
     bool isQueueEmpty() const override { return m_queue.isEmpty(); }
     void clearQueue() override
     {
         m_queue.clear();
         m_totalQueueSize = 0;
     }
 
     void resolveAllPendingReadsAsDone() override
     {
         for (auto& resolver : m_pendingReads) {
-            ScriptState::Scope scope(resolver->scriptState());
-            resolver->resolve(v8IteratorResultDone(resolver->scriptState()));
+            ScriptState* scriptState = resolver->scriptState();
+            if (!scriptState->contextIsValid())
+                continue;
+            ScriptState::Scope scope(scriptState);
+            resolver->resolve(v8IteratorResultDone(scriptState));
         }
         m_pendingReads.clear();
     }
 
     void rejectAllPendingReads(DOMException* reason) override
     {
         for (auto& resolver : m_pendingReads)
             resolver->reject(reason);
         m_pendingReads.clear();
     }
@@ skipping 16 matching lines @@
     size_t size = m_strategy->size(chunk, this);
     if (!enqueuePreliminaryCheck())
         return false;
 
     if (m_pendingReads.isEmpty()) {
         m_queue.append(std::make_pair(chunk, size));
         m_totalQueueSize += size;
         return enqueuePostAction();
     }
 
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = m_pendingReads.takeFirst();
+    ScriptPromiseResolver* resolver = m_pendingReads.takeFirst();
     ScriptState* scriptState = resolver->scriptState();
+    if (!scriptState->contextIsValid())
+        return false;
     ScriptState::Scope scope(scriptState);
     resolver->resolve(v8IteratorResult(scriptState, chunk));
     return enqueuePostAction();
 }
 
 template <typename ChunkTypeTraits>
 ScriptPromise ReadableStreamImpl<ChunkTypeTraits>::read(ScriptState* scriptState)
 {
     ASSERT(stateInternal() == Readable);
     if (m_queue.isEmpty()) {
@@ skipping 22 matching lines @@
     ASSERT(queue.isEmpty());
 
     queue.swap(m_queue);
     m_totalQueueSize = 0;
     readInternalPostAction();
 }
 
 } // namespace blink
 
 #endif // ReadableStreamImpl_h