[Fetch API] Introduce BytesConsumer

third_party/WebKit/Source/modules/fetch/BytesConsumerForDataConsumerHandle.cpp

Index: third_party/WebKit/Source/modules/fetch/BytesConsumerForDataConsumerHandle.cpp
diff --git a/third_party/WebKit/Source/modules/fetch/BytesConsumerForDataConsumerHandle.cpp b/third_party/WebKit/Source/modules/fetch/BytesConsumerForDataConsumerHandle.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..80b7f04e49411121ff1365b67290930d37c9343f
--- /dev/null
+++ b/third_party/WebKit/Source/modules/fetch/BytesConsumerForDataConsumerHandle.cpp
@@ -0,0 +1,167 @@
+// Copyright 2016 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/BytesConsumerForDataConsumerHandle.h"
+
+#include <algorithm>
+#include <string.h>
+
+namespace blink {
+
+BytesConsumerForDataConsumerHandle::BytesConsumerForDataConsumerHandle(PassOwnPtr<FetchDataConsumerHandle> handle)
+    : m_reader(handle->obtainReader(this))
+{
+}
+
+BytesConsumerForDataConsumerHandle::~BytesConsumerForDataConsumerHandle() {}
+
+BytesConsumer::Result BytesConsumerForDataConsumerHandle::read(char* buffer, size_t size, size_t* readSize)
+{
+    if (m_state == State::Closed)
+        return Result::Done;
+    if (m_state == State::Errored)
+        return Result::Error;
+
+    WebDataConsumerHandle::Result r = m_reader->read(buffer, size, WebDataConsumerHandle::FlagNone, readSize);
+    switch (r) {
+    case WebDataConsumerHandle::Ok:
+        return Result::Ok;
+    case WebDataConsumerHandle::ShouldWait:
+        return Result::ShouldWait;
+    case WebDataConsumerHandle::Done:
+        close();
+        return Result::Done;
+    default:
+        error();
+        return Result::Error;
+    }
+}
+
+BytesConsumer::Result BytesConsumerForDataConsumerHandle::beginRead(const char** buffer, size_t* available)
+{
+    if (m_state == State::Closed)
+        return Result::Done;
+    if (m_state == State::Errored)
+        return Result::Error;
+
+    WebDataConsumerHandle::Result r = m_reader->beginRead(reinterpret_cast<const void**>(buffer), WebDataConsumerHandle::FlagNone, available);
+    switch (r) {
+    case WebDataConsumerHandle::Ok:
+        return Result::Ok;
+    case WebDataConsumerHandle::ShouldWait:
+        return Result::ShouldWait;
+    case WebDataConsumerHandle::Done:
+        close();
+        return Result::Done;
+    default:
+        error();
+        return Result::Error;
+    }
+}
+
+BytesConsumer::Result BytesConsumerForDataConsumerHandle::endRead(size_t read)
+{
+    DCHECK(m_state == State::Readable || m_state == State::Waiting);
+    WebDataConsumerHandle::Result r = m_reader->endRead(read);
+    if (r == WebDataConsumerHandle::Ok)
+        return Result::Ok;
+    error();
+    return Result::Error;
+}
+
+PassRefPtr<BlobDataHandle> BytesConsumerForDataConsumerHandle::drainAsBlobDataHandle(BlobSizePolicy policy)
+{
+    if (!m_reader)
+        return nullptr;
+    if (policy == BlobSizePolicy::DisallowBlobWithInvalidSize)
+        return m_reader->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::DisallowBlobWithInvalidSize);
+    DCHECK_EQ(BlobSizePolicy::AllowBlobWithInvalidSize, policy);
+    return m_reader->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize);
+}
+
+PassRefPtr<EncodedFormData> BytesConsumerForDataConsumerHandle::drainAsFormData()
+{
+    if (!m_reader)
+        return nullptr;
+    return m_reader->drainAsFormData();
+}
+
+void BytesConsumerForDataConsumerHandle::setClient(BytesConsumer::Client* client)
+{
+    DCHECK(!m_client);
+    DCHECK(client);
+    m_client = client;
+}
+
+void BytesConsumerForDataConsumerHandle::clearClient()
+{
+    DCHECK(m_client);
+    m_client = nullptr;
+}
+
+void BytesConsumerForDataConsumerHandle::cancel()
+{
+    if (m_state == State::Readable || m_state == State::Waiting) {
+        // We don't want the client to be notified in this case.
+        BytesConsumer::Client* client = m_client;
+        m_client = nullptr;
+        close();
+        m_client = client;
+    }
+}
+
+void BytesConsumerForDataConsumerHandle::didGetReadable()
+{
+    DCHECK(m_state == State::Readable || m_state == State::Waiting);
+    // Perform zero-length read to call check handle's status.
+    size_t readSize;
+    WebDataConsumerHandle::Result result = m_reader->read(nullptr, 0, WebDataConsumerHandle::FlagNone, &readSize);
+    switch (result) {
+    case WebDataConsumerHandle::Ok:
+    case WebDataConsumerHandle::ShouldWait:
+        if (m_client)
+            m_client->onReadable();
+        return;
+    case WebDataConsumerHandle::Done:
+        close();
+        return;
+    case WebDataConsumerHandle::Busy:
+    case WebDataConsumerHandle::ResourceExhausted:
+    case WebDataConsumerHandle::UnexpectedError:
+        error();
+        return;
+    }
+    return;
+}
+
+DEFINE_TRACE(BytesConsumerForDataConsumerHandle)
+{
+    visitor->trace(m_client);
+    BytesConsumer::trace(visitor);
+}
+
+void BytesConsumerForDataConsumerHandle::close()
+{
+    if (m_state == State::Closed)
+        return;
+    DCHECK(m_state == State::Readable || m_state == State::Waiting);
+    m_state = State::Closed;
+    m_reader = nullptr;
+    if (m_client)
+        m_client->onClose();
+}
+
+void BytesConsumerForDataConsumerHandle::error()
+{
+    if (m_state == State::Errored)
+        return;
+    DCHECK(m_state == State::Readable || m_state == State::Waiting);
+    m_state = State::Errored;
+    m_reader = nullptr;
+    m_error = Error("error");
+    if (m_client)
+        m_client->onError(m_error);
+}
+
+} // namespace blink