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
@@ skipping 30 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();

[haraken, 2015/07/17 01:40:35]

Not related to this CL, we should have:

  if (!scriptState->contextIsValid())
    return false;

[sof, 2015/07/17 09:43:26]

Done, here & in resolveAllPendingReadsAsDone()

yhirano@: ptal ?

[yhirano, 2015/07/17 13:53:41]

haraken@: Is it guaranteed that the document is stopped when
scriptState->contextIsValid() returns false? Otherwise an assertion in the
ScriptPromiseResolver fails and we should modify there as well.

[haraken, 2015/07/18 07:10:27]

It is guaranteed for a document that is associated with a frame. It is not
guaranteed for some documents that don't have a frame, but that's an edge case
(e.g., XSLT documents).

     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