1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_dom_BodyStream_h
#define mozilla_dom_BodyStream_h
#include "jsapi.h"
#include "mozilla/AlreadyAddRefed.h"
#include "mozilla/dom/ByteStreamHelpers.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "nsIAsyncInputStream.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIObserver.h"
#include "nsISupportsImpl.h"
#include "nsNetCID.h"
#include "nsWeakReference.h"
#include "mozilla/Mutex.h"
class nsIGlobalObject;
class nsIInputStream;
namespace mozilla {
class ErrorResult;
namespace dom {
class BodyStream;
class StrongWorkerRef;
class ReadableStream;
class ReadableStreamController;
class BodyStreamUnderlyingSourceAlgorithms;
class BodyStreamHolder : public nsISupports {
friend class BodyStream;
friend class BodyStreamUnderlyingSourceAlgorithms;
friend class BodyStreamUnderlyingSourceErrorCallbackHelper;
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(BodyStreamHolder)
BodyStreamHolder();
virtual void NullifyStream() = 0;
virtual void MarkAsRead() = 0;
virtual void SetReadableStreamBody(ReadableStream* aBody) = 0;
virtual ReadableStream* GetReadableStreamBody() = 0;
protected:
virtual ~BodyStreamHolder() = default;
private:
void StoreBodyStream(BodyStream* aBodyStream);
already_AddRefed<BodyStream> TakeBodyStream() {
MOZ_ASSERT_IF(mStreamCreated, mBodyStream);
return mBodyStream.forget();
}
BodyStream* GetBodyStream() { return mBodyStream; }
RefPtr<BodyStream> mBodyStream;
#ifdef DEBUG
bool mStreamCreated = false;
#endif
};
class BodyStream final : public nsIInputStreamCallback,
public nsIObserver,
public nsSupportsWeakReference,
public SingleWriterLockOwner {
friend class BodyStreamHolder;
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSIOBSERVER
// This method creates a JS ReadableStream object and it assigns it to the
// aStreamHolder calling SetReadableStreamBody().
MOZ_CAN_RUN_SCRIPT_BOUNDARY
static void Create(JSContext* aCx, BodyStreamHolder* aStreamHolder,
nsIGlobalObject* aGlobal, nsIInputStream* aInputStream,
ErrorResult& aRv);
void Close();
bool OnWritingThread() const override {
#ifdef MOZ_THREAD_SAFETY_OWNERSHIP_CHECKS_SUPPORTED
return _mOwningThread.IsCurrentThread();
#else
return true;
#endif
}
static nsresult RetrieveInputStream(BodyStreamHolder* aStream,
nsIInputStream** aInputStream);
private:
BodyStream(nsIGlobalObject* aGlobal, BodyStreamHolder* aStreamHolder,
nsIInputStream* aInputStream);
~BodyStream() = default;
#ifdef DEBUG
void AssertIsOnOwningThread() const;
#else
void AssertIsOnOwningThread() const {}
#endif
public:
// Pull Callback
already_AddRefed<Promise> PullCallback(JSContext* aCx,
ReadableStreamController& aController,
ErrorResult& aRv);
void CloseInputAndReleaseObjects();
private:
// Fills a buffer with bytes from the stream.
void WriteIntoReadRequestBuffer(JSContext* aCx, ReadableStream* aStream,
JS::Handle<JSObject*> aBuffer,
uint32_t aLength, uint32_t* aByteWritten);
// This is a script boundary until Bug 1750605 is resolved and allows us
// to replace this with MOZ_CAN_RUN_SCRIPT.
MOZ_CAN_RUN_SCRIPT_BOUNDARY void EnqueueChunkWithSizeIntoStream(
JSContext* aCx, ReadableStream* aStream, uint64_t bytes,
ErrorResult& aRv);
void ErrorPropagation(JSContext* aCx,
const MutexSingleWriterAutoLock& aProofOfLock,
ReadableStream* aStream, nsresult aError)
MOZ_REQUIRES(mMutex);
// TODO: convert this to MOZ_CAN_RUN_SCRIPT (bug 1750605)
MOZ_CAN_RUN_SCRIPT_BOUNDARY void CloseAndReleaseObjects(
JSContext* aCx, const MutexSingleWriterAutoLock& aProofOfLock,
ReadableStream* aStream) MOZ_REQUIRES(mMutex);
class WorkerShutdown;
void ReleaseObjects(const MutexSingleWriterAutoLock& aProofOfLock)
MOZ_REQUIRES(mMutex);
void ReleaseObjects();
// Common methods
enum State {
// This is the beginning state before any reading operation.
eInitializing,
// RequestDataCallback has not been called yet. We haven't started to read
// data from the stream yet.
eWaiting,
// We are reading data in a separate I/O thread.
eReading,
// We are ready to write something in the JS Buffer.
eWriting,
// After a writing, we want to check if the stream is closed. After the
// check, we go back to eWaiting. If a reading request happens in the
// meantime, we move to eReading state.
eChecking,
// Operation completed.
eClosed,
};
// We need a mutex because JS engine can release BodyStream on a non-owning
// thread. We must be sure that the releasing of resources doesn't trigger
// race conditions.
MutexSingleWriter mMutex;
// Protected by mutex.
State mState MOZ_GUARDED_BY(mMutex); // all writes are from the owning thread
// mGlobal is set on creation, and isn't modified off the owning thread.
// It isn't set to nullptr until ReleaseObjects() runs.
nsCOMPtr<nsIGlobalObject> mGlobal;
RefPtr<BodyStreamHolder> mStreamHolder MOZ_GUARDED_BY(mMutex);
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
// This is the original inputStream received during the CTOR. It will be
// converted into an nsIAsyncInputStream and stored into mInputStream at the
// first use.
nsCOMPtr<nsIInputStream> mOriginalInputStream;
nsCOMPtr<nsIAsyncInputStream> mInputStream;
RefPtr<StrongWorkerRef> mWorkerRef;
RefPtr<StrongWorkerRef> mAsyncWaitWorkerRef;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_BodyStream_h
|
