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
|
/* -*- 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_BodyConsumer_h
#define mozilla_dom_BodyConsumer_h
#include "mozilla/GlobalFreezeObserver.h"
#include "mozilla/GlobalTeardownObserver.h"
#include "mozilla/dom/AbortFollower.h"
#include "mozilla/dom/MutableBlobStorage.h"
#include "nsIInputStreamPump.h"
class nsIThread;
namespace mozilla::dom {
class Promise;
class ThreadSafeWorkerRef;
// In order to keep alive the object all the time, we use a ThreadSafeWorkerRef,
// if created on workers.
class BodyConsumer final : public AbortFollower,
public GlobalTeardownObserver,
public GlobalFreezeObserver {
public:
NS_DECL_THREADSAFE_ISUPPORTS
enum class ConsumeType {
ArrayBuffer,
Blob,
Bytes,
FormData,
JSON,
Text,
};
/**
* Returns a promise which will be resolved when the body is completely
* consumed and converted to the wanted type (See ConsumeType).
*
* @param aGlobal the global to construct the Promise.
* @param aMainThreadEventTarget the main-thread event target. The reading
* needs to start on the main-thread because of nsIInputStreamPump.
* @param aBodyStream the stream to read.
* @param aSignalImpl an AbortSignal object. Optional.
* @param aType the consume type.
* @param aBodyBlobURISpec this is used only if the consume type is
* ConsumeType::Blob. Optional.
* @param aBodyLocalPath local path in case the blob is created from a local
* file. Used only by ConsumeType::Blob. Optional.
* @param aBodyMimeType the mime-type for blob. Used only by
* ConsumeType::Blob. Optional.
* @param aMixedCaseMimeType is needed to get mixed case multipart
* boundary value to FormDataParser.
* @param aBlobStorageType Blobs can be saved in temporary file. This is the
* type of blob storage to use. Used only by ConsumeType::Blob.
* @param aRv An ErrorResult.
*/
static already_AddRefed<Promise> Create(
nsIGlobalObject* aGlobal, nsISerialEventTarget* aMainThreadEventTarget,
nsIInputStream* aBodyStream, AbortSignalImpl* aSignalImpl,
ConsumeType aType, const nsACString& aBodyBlobURISpec,
const nsAString& aBodyLocalPath, const nsACString& aBodyMimeType,
const nsACString& aMixedCaseMimeType,
MutableBlobStorage::MutableBlobStorageType aBlobStorageType,
ErrorResult& aRv);
void ReleaseObject();
void BeginConsumeBodyMainThread(ThreadSafeWorkerRef* aWorkerRef);
void OnBlobResult(BlobImpl* aBlobImpl,
ThreadSafeWorkerRef* aWorkerRef = nullptr);
void ContinueConsumeBody(nsresult aStatus, uint32_t aResultLength,
uint8_t* aResult, bool aShuttingDown = false);
void ContinueConsumeBlobBody(BlobImpl* aBlobImpl, bool aShuttingDown = false);
void DispatchContinueConsumeBlobBody(BlobImpl* aBlobImpl,
ThreadSafeWorkerRef* aWorkerRef);
void ShutDownMainThreadConsuming();
void NullifyConsumeBodyPump() {
mShuttingDown = true;
mConsumeBodyPump = nullptr;
}
// AbortFollower
void RunAbortAlgorithm() override;
private:
BodyConsumer(nsISerialEventTarget* aMainThreadEventTarget,
nsIGlobalObject* aGlobalObject, nsIInputStream* aBodyStream,
Promise* aPromise, ConsumeType aType,
const nsACString& aBodyBlobURISpec,
const nsAString& aBodyLocalPath, const nsACString& aBodyMimeType,
const nsACString& aMixedCaseMimeType,
MutableBlobStorage::MutableBlobStorageType aBlobStorageType);
~BodyConsumer();
nsresult GetBodyLocalFile(nsIFile** aFile) const;
void AssertIsOnTargetThread() const;
void MaybeAbortConsumption();
void DisconnectFromOwner() override {
MaybeAbortConsumption();
GlobalTeardownObserver::DisconnectFromOwner();
}
void FrozenCallback(nsIGlobalObject* aGlobal) override {
// XXX: But we should not abort on window freeze, see bug 1910124
MaybeAbortConsumption();
}
nsCOMPtr<nsIThread> mTargetThread;
nsCOMPtr<nsISerialEventTarget> mMainThreadEventTarget;
// This is nullified when the consuming of the body starts.
nsCOMPtr<nsIInputStream> mBodyStream;
MutableBlobStorage::MutableBlobStorageType mBlobStorageType;
nsCString mBodyMimeType;
nsCString mMixedCaseMimeType;
nsCString mBodyBlobURISpec;
nsString mBodyLocalPath;
nsCOMPtr<nsIGlobalObject> mGlobal;
// Touched on the main-thread only.
nsCOMPtr<nsIInputStreamPump> mConsumeBodyPump;
// Only ever set once, always on target thread.
ConsumeType mConsumeType;
RefPtr<Promise> mConsumePromise;
// touched only on the target thread.
bool mBodyConsumed;
// touched only on the main-thread.
bool mShuttingDown;
};
} // namespace mozilla::dom
#endif // mozilla_dom_BodyConsumer_h
|
