Use ScriptPromiseProperty::reset in ReadableStream.

Source/core/streams/ReadableStream.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 "core/streams/ReadableStream.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 53 matching lines @@
 
 bool ReadableStream::enqueuePostAction(size_t totalQueueSize)
 {
     m_isPulling = false;
 
     // FIXME: Set needsMore correctly.
     bool needsMore = true;
 
     if (m_state == Waiting) {
         m_state = Readable;
-        if (m_wait->state() == m_wait->Pending)
-            m_wait->resolve(V8UndefinedType());
+        m_wait->resolve(V8UndefinedType());
     }
 
     return needsMore;
 }
 
 void ReadableStream::close()
 {
     if (m_state == Waiting) {
-        if (m_wait->state() == m_wait->Pending)
-            m_wait->resolve(V8UndefinedType());
+        m_wait->resolve(V8UndefinedType());
         m_closed->resolve(V8UndefinedType());
         m_state = Closed;
     } else if (m_state == Readable) {
         m_isDraining = true;
     }
 }
 
 void ReadableStream::readPreliminaryCheck(ExceptionState* exceptionState)
 {
     if (m_state == Waiting) {
         exceptionState->throwTypeError("read is called while state is waiting");
         return;
     }
     if (m_state == Closed) {
         exceptionState->throwTypeError("read is called while state is closed");
         return;
     }
     if (m_state == Errored) {
         exceptionState->throwDOMException(m_exception->code(), m_exception->message());
         return;
     }
 }
 
 void ReadableStream::readPostAction()
 {
     ASSERT(m_state == Readable);
     if (isQueueEmpty()) {
         if (m_isDraining) {
             m_state = Closed;
-            // FIXME: Use reset.
-            // m_wait->reset();
-            if (m_wait->state() == m_wait->Pending)
-                m_wait->resolve(V8UndefinedType());
+            m_wait->reset();
+            m_wait->resolve(V8UndefinedType());
             m_closed->resolve(V8UndefinedType());
         } else {
             m_state = Waiting;
-            // FIXME: Use reset.
-            // m_wait->reset();
+            m_wait->reset();
             callOrSchedulePull();
         }
     }
 }
 
 ScriptPromise ReadableStream::wait(ScriptState* scriptState)
 {
     if (m_state == Waiting)
         callOrSchedulePull();
     return m_wait->promise(scriptState->world());
 }
 
 ScriptPromise ReadableStream::cancel(ScriptState* scriptState, ScriptValue reason)
 {
     if (m_state == Errored) {
         RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
         ScriptPromise promise = resolver->promise();
         resolver->reject(m_exception);
         return promise;
     }
     if (m_state == Closed)
         return ScriptPromise::cast(scriptState, v8::Undefined(scriptState->isolate()));
 
     if (m_state == Waiting) {
-        if (m_wait->state() == m_wait->Pending)
-            m_wait->resolve(V8UndefinedType());
+        m_wait->resolve(V8UndefinedType());
     } else {
         ASSERT(m_state == Readable);
-        // FIXME: Use reset here.
-        // m_wait->reset();
-        if (m_wait->state() == m_wait->Pending)
-            m_wait->resolve(V8UndefinedType());
+        m_wait->reset();
+        m_wait->resolve(V8UndefinedType());
     }
 
     clearQueue();
     m_state = Closed;
     m_closed->resolve(V8UndefinedType());
     return m_source->cancelSource(scriptState, reason);
 }
 
 ScriptPromise ReadableStream::closed(ScriptState* scriptState)
 {
     return m_closed->promise(scriptState->world());
 }
 
 void ReadableStream::error(PassRefPtrWillBeRawPtr<DOMException> exception)
 {
     if (m_state == Readable) {
         clearQueue();
-        // FIXME: Use reset here.
-        // m_wait->reset();
+        m_wait->reset();
     }
 
     if (m_state == Waiting || m_state == Readable) {
         m_state = Errored;
         m_exception = exception;
         if (m_wait->state() == m_wait->Pending)
             m_wait->reject(m_exception);
         m_closed->reject(m_exception);
     }
 }
@@ skipping 19 matching lines @@
 void ReadableStream::trace(Visitor* visitor)
 {
     visitor->trace(m_source);
     visitor->trace(m_wait);
     visitor->trace(m_closed);
     visitor->trace(m_exception);
 }
 
 } // namespace blink