Rename ReadableStream.wait() to ReadableStream.ready.

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 24 matching lines @@
 
 } // namespace
 
 ReadableStream::ReadableStream(ExecutionContext* executionContext, UnderlyingSource* source)
     : ActiveDOMObject(executionContext)
     , m_source(source)
     , m_isStarted(false)
     , m_isDraining(false)
     , m_isPulling(false)
     , m_state(Waiting)
-    , m_wait(new WaitPromise(executionContext, this, WaitPromise::Ready))
+    , m_ready(new WaitPromise(executionContext, this, WaitPromise::Ready))
     , m_closed(new ClosedPromise(executionContext, this, ClosedPromise::Closed))
 {
     suspendIfNeeded();
 }
 
 ReadableStream::~ReadableStream()
 {
 }
 
 String ReadableStream::stateString() const
@@ skipping 28 matching lines @@
     m_isPulling = false;
 
     bool shouldApplyBackpressure = this->shouldApplyBackpressure();
     // this->shouldApplyBackpressure may call this->error().
     if (m_state == Errored)
         return false;
 
     if (m_state == Waiting) {
         // ReadableStream::hasPendingActivity return value gets false when
         // |m_state| is changed to Closed or Errored from Waiting or Readable.
-        // On the other hand, the wrappers should be kept alive when |m_wait|
+        // On the other hand, the wrappers should be kept alive when |m_ready|
         // and |m_close| resolution and rejection are called. Hence we call
         // ScriptPromiseProperty::resolve and ScriptPromiseProperty::reject
         // *before* changing state, no matter if the state change actually
         // changes hasPendingActivity return value.
-        m_wait->resolve(ToV8UndefinedGenerator());
+        m_ready->resolve(ToV8UndefinedGenerator());
         m_state = Readable;
     }
 
     return !shouldApplyBackpressure;
 }
 
 void ReadableStream::close()
 {
     if (m_state == Waiting) {
-        m_wait->resolve(ToV8UndefinedGenerator());
+        m_ready->resolve(ToV8UndefinedGenerator());
         m_closed->resolve(ToV8UndefinedGenerator());
         m_state = Closed;
     } else if (m_state == Readable) {
         m_isDraining = true;
     }
 }
 
 void ReadableStream::readPreliminaryCheck(ExceptionState& exceptionState)
 {
     if (m_state == Waiting) {
@@ skipping 11 matching lines @@
 }
 
 void ReadableStream::readPostAction()
 {
     ASSERT(m_state == Readable);
     if (isQueueEmpty()) {
         if (m_isDraining) {
             m_closed->resolve(ToV8UndefinedGenerator());
             m_state = Closed;
         } else {
-            m_wait->reset();
+            m_ready->reset();
             m_state = Waiting;
         }
     }
     callPullIfNeeded();
 }
 
-ScriptPromise ReadableStream::wait(ScriptState* scriptState)
+ScriptPromise ReadableStream::ready(ScriptState* scriptState)
 {
-    return m_wait->promise(scriptState->world());
+    return m_ready->promise(scriptState->world());
 }
 
 ScriptPromise ReadableStream::cancel(ScriptState* scriptState, ScriptValue reason)
 {
     if (m_state == Closed)
         return ScriptPromise::cast(scriptState, v8::Undefined(scriptState->isolate()));
     if (m_state == Errored)
         return ScriptPromise::rejectWithDOMException(scriptState, m_exception);
 
     ASSERT(m_state == Readable || m_state == Waiting);
     if (m_state == Waiting)
-        m_wait->resolve(ToV8UndefinedGenerator());
+        m_ready->resolve(ToV8UndefinedGenerator());
     clearQueue();
     m_closed->resolve(ToV8UndefinedGenerator());
     m_state = Closed;
     return m_source->cancelSource(scriptState, reason).then(ConstUndefined::create(scriptState));
 }
 
 ScriptPromise ReadableStream::closed(ScriptState* scriptState)
 {
     return m_closed->promise(scriptState->world());
 }
 
 void ReadableStream::error(PassRefPtrWillBeRawPtr<DOMException> exception)
 {
     switch (m_state) {
     case Waiting:
         m_exception = exception;
-        m_wait->reject(m_exception);
+        m_ready->reject(m_exception);
         m_closed->reject(m_exception);
         m_state = Errored;
         break;
     case Readable:
         clearQueue();
         m_exception = exception;
-        m_wait->reset();
-        m_wait->reject(m_exception);
+        m_ready->reset();
+        m_ready->reject(m_exception);
         m_closed->reject(m_exception);
         m_state = Errored;
         break;
     default:
         break;
     }
 }
 
 void ReadableStream::didSourceStart()
 {
@@ skipping 15 matching lines @@
 }
 
 bool ReadableStream::hasPendingActivity() const
 {
     return m_state == Waiting || m_state == Readable;
 }
 
 void ReadableStream::trace(Visitor* visitor)
 {
     visitor->trace(m_source);
-    visitor->trace(m_wait);
+    visitor->trace(m_ready);
     visitor->trace(m_closed);
     visitor->trace(m_exception);
 }
 
 } // namespace blink