Source/WebCore/Modules/streams/ReadableStream.h

   1 /*
   2  * Copyright (C) 2015 Canon Inc.
   3  * Copyright (C) 2015 Igalia S.L.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted, provided that the following conditions
   7  * are required to be met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Canon Inc. nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY CANON INC. AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL CANON INC. AND ITS CONTRIBUTORS BE LIABLE FOR
  22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  25  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  26  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #ifndef ReadableStream_h
  31 #define ReadableStream_h
  32
  33 #if ENABLE(STREAMS_API)
  34
  35 #include "ActiveDOMObject.h"
  36 #include "ScriptWrappable.h"
  37 #include <functional>
  38 #include <wtf/Deque.h>
  39 #include <wtf/Ref.h>
  40 #include <wtf/RefCounted.h>
  41
  42 namespace JSC {
  43 class JSValue;
  44 }
  45
  46 namespace WebCore {
  47
  48 class ReadableStreamReader;
  49 class ScriptExecutionContext;
  50
  51 // ReadableStream implements the core of the streams API ReadableStream functionality.
  52 // It handles in particular the backpressure according the queue size.
  53 // ReadableStream is using a ReadableStreamSource to get data in its queue.
  54 // See https://streams.spec.whatwg.org/#rs
  55 class ReadableStream : public ActiveDOMObject, public ScriptWrappable, public RefCounted<ReadableStream> {
  56 public:
  57     enum class State {
  58         Readable,
  59         Closed,
  60         Errored
  61     };
  62
  63     virtual ~ReadableStream();
  64
  65     ReadableStreamReader& getReader();
  66     const ReadableStreamReader* reader() const { return m_reader.get(); }
  67     bool isLocked() const { return !!m_reader; }
  68
  69     bool isErrored() const { return m_state == State::Errored; }
  70     bool isReadable() const { return m_state == State::Readable; }
  71     bool isCloseRequested() const { return m_closeRequested; }
  72
  73     virtual JSC::JSValue error() = 0;
  74
  75     void start();
  76     void changeStateToClosed();
  77     void changeStateToErrored();
  78
  79     typedef std::function<void(JSC::JSValue)> FailureCallback;
  80
  81     typedef std::function<void()> ClosedSuccessCallback;
  82     void closed(ClosedSuccessCallback&&, FailureCallback&&);
  83
  84     typedef std::function<void(JSC::JSValue)> ReadSuccessCallback;
  85     typedef std::function<void()> ReadEndCallback;
  86     void read(ReadSuccessCallback&&, ReadEndCallback&&, FailureCallback&&);
  87
  88 protected:
  89     explicit ReadableStream(ScriptExecutionContext&);
  90
  91     bool resolveReadCallback(JSC::JSValue);
  92     void pull();
  93
  94 private:
  95     // ActiveDOMObject API.
  96     const char* activeDOMObjectName() const override;
  97     bool canSuspendForPageCache() const override;
  98
  99     void clearCallbacks();
 100     void close();
 101
 102     virtual bool hasValue() const = 0;
 103     virtual JSC::JSValue read() = 0;
 104     virtual void doPull() = 0;
 105
 106     std::unique_ptr<ReadableStreamReader> m_reader;
 107     Vector<std::unique_ptr<ReadableStreamReader>> m_releasedReaders;
 108
 109     ClosedSuccessCallback m_closedSuccessCallback;
 110     FailureCallback m_closedFailureCallback;
 111
 112     struct ReadCallbacks {
 113         ReadSuccessCallback successCallback;
 114         ReadEndCallback endCallback;
 115         FailureCallback failureCallback;
 116     };
 117     Deque<ReadCallbacks> m_readRequests;
 118
 119     bool m_isStarted { false };
 120     bool m_closeRequested { false };
 121     State m_state { State::Readable };
 122 };
 123
 124 }
 125
 126 #endif
 127
 128 #endif // ReadableStream_h