Introduce ExclusiveStreamReader.

Source/core/streams/ReadableStream.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 ReadableStream_h
 #define ReadableStream_h
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseProperty.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "core/dom/ActiveDOMObject.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Forward.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 class DOMException;
 class ExceptionState;
+class ExclusiveStreamReader;
 class UnderlyingSource;
 
 class ReadableStream : public GarbageCollectedFinalized<ReadableStream>, public ScriptWrappable, public ActiveDOMObject {
     DEFINE_WRAPPERTYPEINFO();
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(ReadableStream);
 public:
     enum State {
         Readable,
         Waiting,
         Closed,
         Errored,
     };
 
     // After ReadableStream construction, |didSourceStart| must be called when
     // |source| initialization succeeds and |error| must be called when
     // |source| initialization fails.
     ReadableStream(ExecutionContext*, UnderlyingSource* /* source */);
     virtual ~ReadableStream();
 
     bool isStarted() const { return m_isStarted; }
     bool isDraining() const { return m_isDraining; }
     bool isPulling() const { return m_isPulling; }
-    State state() const { return m_state; }
+    State stateInternal() const { return m_state; }
+    DOMException* storedException() { return m_exception.get(); }
+
+    // |stateString|, |read| and |ready| are affected by an exclusive lock. Use
+    // |stateInternal|, |readInternal| and |readyInternal| if you want to avoid
+    // that.
     String stateString() const;
-
-    virtual ScriptValue read(ScriptState*, ExceptionState&) = 0;
+    ScriptValue read(ScriptState*, ExceptionState&);
     ScriptPromise ready(ScriptState*);
     ScriptPromise cancel(ScriptState*, ScriptValue reason);
     ScriptPromise closed(ScriptState*);
 
+    virtual ScriptValue readInternal(ScriptState*, ExceptionState&) = 0;
+    ScriptPromise readyInternal(ScriptState*);
+
     void close();
     void error(PassRefPtrWillBeRawPtr<DOMException>);
 
     void didSourceStart();
 
+    // This function is not a getter. It creates an ExclusiveStreamReader and
+    // returns it.
+    ExclusiveStreamReader* getReader(ExceptionState&);
+    // Only ExclusiveStreamReader methods should call this function.
+    void setReader(ExclusiveStreamReader*);
+    bool isLockedTo(const ExclusiveStreamReader* reader) const { return m_reader == reader; }
+
     bool hasPendingActivity() const override;
-    virtual void trace(Visitor*) override;
+    void trace(Visitor*) override;
+
+    // Returns the string representation of the given State.
+    static String toString(State);

[tyoshino (SeeGerritForStatus), 2015/02/02 04:24:11]

give a name from it we understand immediately that this is for formatting the
State, not for dumping the whole Stream object

e.g. formatStateToString

[yhirano, 2015/02/02 06:05:37]

Done.

 
 protected:
     bool enqueuePreliminaryCheck();
     bool enqueuePostAction();
-    void readPreliminaryCheck(ExceptionState&);
-    void readPostAction();
+    void readInternalPreliminaryCheck(ExceptionState&);
+    void readInternalPostAction();
 
 private:
-    typedef ScriptPromiseProperty<Member<ReadableStream>, ToV8UndefinedGenerator, RefPtrWillBeMember<DOMException> > WaitPromise;
-    typedef ScriptPromiseProperty<Member<ReadableStream>, ToV8UndefinedGenerator, RefPtrWillBeMember<DOMException> > ClosedPromise;
+    using WaitPromise = ScriptPromiseProperty<Member<ReadableStream>, ToV8UndefinedGenerator, RefPtrWillBeMember<DOMException>>;
+    using ClosedPromise = ScriptPromiseProperty<Member<ReadableStream>, ToV8UndefinedGenerator, RefPtrWillBeMember<DOMException>>;
 
     virtual bool isQueueEmpty() const = 0;
     virtual void clearQueue() = 0;
     // This function will call ReadableStream::error on error.
     virtual bool shouldApplyBackpressure() = 0;
 
     void callPullIfNeeded();
 
     Member<UnderlyingSource> m_source;
     bool m_isStarted;
     bool m_isDraining;
     bool m_isPulling;
     State m_state;
 
     Member<WaitPromise> m_ready;
     Member<ClosedPromise> m_closed;
+
     RefPtrWillBeMember<DOMException> m_exception;
+    Member<ExclusiveStreamReader> m_reader;
 };
 
 } // namespace blink
 
 #endif // ReadableStream_h