[Fetch API] Add streams predicates to BodyStreamBuffer

third_party/WebKit/Source/modules/fetch/BodyStreamBuffer.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 "modules/fetch/BodyStreamBuffer.h"
 
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
@@ skipping 66 matching lines @@
     : m_handle(handle)
     , m_reader(m_handle->obtainReader(this))
     , m_stream(new ReadableByteStream(this, new ReadableByteStream::StrictStrategy))
     , m_streamNeedsMore(false)
 {
     m_stream->didSourceStart();
 }
 
 PassRefPtr<BlobDataHandle> BodyStreamBuffer::drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::BlobSizePolicy policy)
 {
-    ASSERT(!stream()->isLocked());
-    m_stream->setIsDisturbed();
-    if (ReadableStream::Closed == m_stream->stateInternal() || ReadableStream::Errored == m_stream->stateInternal())
+    ASSERT(!isStreamLocked());
+    ASSERT(!isStreamDisturbed());
+    if (isStreamClosed() || isStreamErrored())
         return nullptr;
 
     RefPtr<BlobDataHandle> blobDataHandle = m_reader->drainAsBlobDataHandle(policy);
     if (blobDataHandle) {
+        m_stream->setIsDisturbed();
         close();
         return blobDataHandle.release();
     }
     return nullptr;
 }
 
 PassRefPtr<EncodedFormData> BodyStreamBuffer::drainAsFormData()
 {
-    ASSERT(!stream()->isLocked());
-    m_stream->setIsDisturbed();
-    if (ReadableStream::Closed == m_stream->stateInternal() || ReadableStream::Errored == m_stream->stateInternal())
+    ASSERT(!isStreamLocked());
+    ASSERT(!isStreamDisturbed());
+    if (isStreamClosed() || isStreamErrored())
         return nullptr;
 
     RefPtr<EncodedFormData> formData = m_reader->drainAsFormData();
     if (formData) {
+        m_stream->setIsDisturbed();
         close();
         return formData.release();
     }
     return nullptr;
 }
 
 PassOwnPtr<FetchDataConsumerHandle> BodyStreamBuffer::releaseHandle(ExecutionContext* executionContext)
 {
-    ASSERT(!stream()->isLocked());
+    ASSERT(!isStreamLocked());
+    ASSERT(!isStreamDisturbed());
     m_reader = nullptr;
     m_stream->setIsDisturbed();
     TrackExceptionState exceptionState;
     m_stream->getBytesReader(executionContext, exceptionState);
 
-    if (ReadableStream::Closed == m_stream->stateInternal())
+    if (isStreamClosed())
         return createFetchDataConsumerHandleFromWebHandle(createDoneDataConsumerHandle());
-    if (ReadableStream::Errored == m_stream->stateInternal())
+    if (isStreamErrored())
         return createFetchDataConsumerHandleFromWebHandle(createUnexpectedErrorDataConsumerHandle());
 
     ASSERT(m_handle);
     OwnPtr<FetchDataConsumerHandle> handle = m_handle.release();
     close();
     return handle.release();
 }
 
 void BodyStreamBuffer::startLoading(ExecutionContext* executionContext, FetchDataLoader* loader, FetchDataLoader::Client* client)
 {
     ASSERT(!m_loader);
     OwnPtr<FetchDataConsumerHandle> handle = releaseHandle(executionContext);
     m_loader = loader;
     loader->start(handle.get(), new LoaderClient(executionContext, this, client));
 }
 
 bool BodyStreamBuffer::hasPendingActivity() const
 {
-    return m_loader || (m_stream->isLocked() && m_stream->stateInternal() == ReadableStream::Readable);
+    return m_loader || (isStreamLocked() && isStreamReadable());
 }
 
 void BodyStreamBuffer::stop()
 {
     m_reader = nullptr;
     m_handle = nullptr;
 }
 
 void BodyStreamBuffer::pullSource()
 {
@@ skipping 28 matching lines @@
         case WebDataConsumerHandle::ResourceExhausted:
         case WebDataConsumerHandle::UnexpectedError:
             error();
             return;
         }
         return;
     }
     processData();
 }
 
+bool BodyStreamBuffer::isStreamReadable() const
+{
+    return m_stream->stateInternal() == ReadableStream::Readable;
+}
+
+bool BodyStreamBuffer::isStreamClosed() const
+{
+    return m_stream->stateInternal() == ReadableStream::Closed;
+}
+
+bool BodyStreamBuffer::isStreamErrored() const
+{
+    return m_stream->stateInternal() == ReadableStream::Errored;
+}
+
+bool BodyStreamBuffer::isStreamLocked() const
+{
+    return m_stream->isLocked();
+}
+
+bool BodyStreamBuffer::isStreamDisturbed() const
+{
+    return m_stream->isDisturbed();
+}
+
 void BodyStreamBuffer::close()
 {
     m_reader = nullptr;
     m_stream->close();
     m_handle.clear();
 }
 
 void BodyStreamBuffer::error()
 {
     m_reader = nullptr;
@@ skipping 38 matching lines @@
 
 void BodyStreamBuffer::stopLoading()
 {
     if (!m_loader)
         return;
     m_loader->cancel();
     m_loader = nullptr;
 }
 
 } // namespace blink