Streams Implementation Update: Reader name and Stream methods

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"
 #include "bindings/core/v8/V8Binding.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
-#include "core/streams/ExclusiveStreamReader.h"
+#include "core/streams/ReadableStreamReader.h"
 #include "core/streams/UnderlyingSource.h"
 
 namespace blink {
 
 namespace {
 
 class ConstUndefined : public ScriptFunction {
 public:
     static v8::Handle<v8::Function> create(ScriptState* scriptState)
     {
@@ skipping 138 matching lines @@
             m_ready->reset();
             m_state = Waiting;
         }
     }
     callPullIfNeeded();
 }
 
 ScriptValue ReadableStream::read(ScriptState* scriptState, ExceptionState& exceptionState)
 {
     if (m_reader) {
-        exceptionState.throwTypeError("this stream is locked to an ExclusiveStreamReader");
+        exceptionState.throwTypeError("this stream is locked to an ReadableStreamReader");

[tyoshino (SeeGerritForStatus), 2015/03/17 05:14:39]

an -> a

[yhirano, 2015/03/17 05:24:16]

Done.

         return ScriptValue();
     }
     return readInternal(scriptState, exceptionState);
 }
 
 ScriptPromise ReadableStream::ready(ScriptState* scriptState)
 {
     if (m_reader) {
         return m_reader->released(scriptState).then(ResolveWithReady::create(scriptState, this));
     }
 
     if (m_state == Waiting) {
         return readyInternal(scriptState).then(ResolveWithReady::create(scriptState, this));
     }
     return readyInternal(scriptState);
 }
 
 ScriptPromise ReadableStream::readyInternal(ScriptState* scriptState)
 {
     return m_ready->promise(scriptState->world());
 }
 
 ScriptPromise ReadableStream::cancel(ScriptState* scriptState, ScriptValue reason)
 {
     if (m_reader)
-        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "this stream is locked to an ExclusiveStreamReader"));
+        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "this stream is locked to an ReadableStreamReader"));

[tyoshino (SeeGerritForStatus), 2015/03/17 05:14:40]

an -> a

[yhirano, 2015/03/17 05:24:16]

Done.

     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_ready->resolve(ToV8UndefinedGenerator());
     clearQueue();
     m_closed->resolve(ToV8UndefinedGenerator());
@@ skipping 31 matching lines @@
         break;
     }
 }
 
 void ReadableStream::didSourceStart()
 {
     m_isStarted = true;
     callPullIfNeeded();
 }
 
-ExclusiveStreamReader* ReadableStream::getReader(ExceptionState& exceptionState)
+ReadableStreamReader* ReadableStream::getReader(ExceptionState& exceptionState)
 {
     if (m_state == Closed) {
         exceptionState.throwTypeError("this stream is already closed");
         return nullptr;
     }
     if (m_state == Errored) {
         exceptionState.throwDOMException(m_exception->code(), m_exception->message());
         return nullptr;
     }
     if (m_reader) {
-        exceptionState.throwTypeError("already locked to an ExclusiveStreamReader");
+        exceptionState.throwTypeError("already locked to an ReadableStreamReader");

[tyoshino (SeeGerritForStatus), 2015/03/17 05:14:39]

an -> a

[yhirano, 2015/03/17 05:24:16]

Done.

         return nullptr;
     }
-    return new ExclusiveStreamReader(this);
+    return new ReadableStreamReader(this);
 }
 
-void ReadableStream::setReader(ExclusiveStreamReader* reader)
+void ReadableStream::setReader(ReadableStreamReader* reader)
 {
     ASSERT((reader && !m_reader) || (!reader && m_reader));
     m_reader = reader;
 }
 
 void ReadableStream::callPullIfNeeded()
 {
     if (m_isPulling || m_isDraining || !m_isStarted || m_state == Closed || m_state == Errored)
         return;
 
@@ skipping 36 matching lines @@
     case Closed:
         return "closed";
     case Errored:
         return "errored";
     }
     ASSERT(false);
     return String();
 }
 
 } // namespace blink