Introduce ExclusiveStreamReader.

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/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/streams/ReadableStream.h"
 #include "wtf/Deque.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
 #include <utility>
 
 namespace blink {
 
+class ExclusiveStreamReader;
 // We define the default ChunkTypeTraits for frequently used types.
 template<typename ChunkType>
 class ReadableStreamChunkTypeTraits { };
 
 template<>
 class ReadableStreamChunkTypeTraits<String> {
 public:
     typedef String HoldType;
     typedef const String& PassType;
 
@@ skipping 43 matching lines @@
 
     ReadableStreamImpl(ExecutionContext* executionContext, UnderlyingSource* source)
         : ReadableStreamImpl(executionContext, source, new DefaultStrategy) { }
     ReadableStreamImpl(ExecutionContext* executionContext, UnderlyingSource* source, Strategy* strategy)
         : ReadableStream(executionContext, source)
         , m_strategy(strategy)
         , m_totalQueueSize(0) { }
     ~ReadableStreamImpl() override { }
 
     // ReadableStream methods
-    ScriptValue read(ScriptState*, ExceptionState&) override;
+    ScriptValue readInternal(ScriptState*, ExceptionState&) override;
 
     bool enqueue(typename ChunkTypeTraits::PassType);
 
     // 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 read(Deque<std::pair<typename ChunkTypeTraits::HoldType, size_t>>& queue);
+    void readInternal(Deque<std::pair<typename ChunkTypeTraits::HoldType, size_t>>& queue);
 
     void trace(Visitor* visitor) override
     {
         visitor->trace(m_strategy);
         ReadableStream::trace(visitor);
     }
 
 private:
     // ReadableStream methods
     bool isQueueEmpty() const override { return m_queue.isEmpty(); }
@@ skipping 17 matching lines @@
 {
     size_t size = m_strategy->size(chunk, this);
     if (!enqueuePreliminaryCheck())
         return false;
     m_queue.append(std::make_pair(chunk, size));
     m_totalQueueSize += size;
     return enqueuePostAction();
 }
 
 template <typename ChunkTypeTraits>
-ScriptValue ReadableStreamImpl<ChunkTypeTraits>::read(ScriptState* scriptState, ExceptionState& exceptionState)
+ScriptValue ReadableStreamImpl<ChunkTypeTraits>::readInternal(ScriptState* scriptState, ExceptionState& exceptionState)
 {
-    readPreliminaryCheck(exceptionState);
+    readInternalPreliminaryCheck(exceptionState);
     if (exceptionState.hadException())
         return ScriptValue();
-    ASSERT(state() == Readable);
+    ASSERT(stateInternal() == Readable);
     ASSERT(!m_queue.isEmpty());
     auto pair = m_queue.takeFirst();
     typename ChunkTypeTraits::HoldType chunk = pair.first;
     size_t size = pair.second;
     ASSERT(m_totalQueueSize >= size);
     m_totalQueueSize -= size;
-    readPostAction();
+    readInternalPostAction();
     return ChunkTypeTraits::toScriptValue(scriptState, chunk);
 }
 
 template <typename ChunkTypeTraits>
-void ReadableStreamImpl<ChunkTypeTraits>::read(Deque<std::pair<typename ChunkTypeTraits::HoldType, size_t>>& queue)
+void ReadableStreamImpl<ChunkTypeTraits>::readInternal(Deque<std::pair<typename ChunkTypeTraits::HoldType, size_t>>& queue)
 {
     // We omit the preliminary check. Check it by yourself.
-    ASSERT(state() == Readable);
+    ASSERT(stateInternal() == Readable);
     ASSERT(!m_queue.isEmpty());
     ASSERT(queue.isEmpty());
 
     queue.swap(m_queue);
     m_totalQueueSize = 0;
-    readPostAction();
+    readInternalPostAction();
 }
 
 } // namespace blink
 
 #endif // ReadableStreamImpl_h