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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 js_StreamConsumer_h
#define js_StreamConsumer_h
#include "mozilla/Attributes.h"
#include "mozilla/RefCountType.h"
#include <stddef.h>
#include <stdint.h>
#include "jstypes.h"
#include "js/AllocPolicy.h"
#include "js/TypeDecls.h"
#include "js/UniquePtr.h"
#include "js/Vector.h"
namespace JS {
/**
* The ConsumeStreamCallback is called from an active JSContext, passing a
* StreamConsumer that wishes to consume the given host object as a stream of
* bytes with the given MIME type. On failure, the embedding must report the
* appropriate error on 'cx'. On success, the embedding must call
* consumer->consumeChunk() repeatedly on any thread until exactly one of:
* - consumeChunk() returns false
* - the embedding calls consumer->streamEnd()
* - the embedding calls consumer->streamError()
* before JS_DestroyContext(cx) or JS::ShutdownAsyncTasks(cx) is called.
*
* Note: consumeChunk(), streamEnd() and streamError() may be called
* synchronously by ConsumeStreamCallback.
*
* When streamEnd() is called, the embedding may optionally pass an
* OptimizedEncodingListener*, indicating that there is a cache entry associated
* with this stream that can store an optimized encoding of the bytes that were
* just streamed at some point in the future by having SpiderMonkey call
* storeOptimizedEncoding(). Until the optimized encoding is ready, SpiderMonkey
* will hold an outstanding refcount to keep the listener alive.
*
* After storeOptimizedEncoding() is called, on cache hit, the embedding
* may call consumeOptimizedEncoding() instead of consumeChunk()/streamEnd().
* The embedding must ensure that the GetOptimizedEncodingBuildId() (see
* js/BuildId.h) at the time when an optimized encoding is created is the same
* as when it is later consumed.
*/
class OptimizedEncodingListener {
protected:
virtual ~OptimizedEncodingListener() = default;
public:
// SpiderMonkey will hold an outstanding reference count as long as it holds
// a pointer to OptimizedEncodingListener.
virtual MozExternalRefCountType MOZ_XPCOM_ABI AddRef() = 0;
virtual MozExternalRefCountType MOZ_XPCOM_ABI Release() = 0;
// SpiderMonkey may optionally call storeOptimizedEncoding() after it has
// finished processing a streamed resource.
virtual void storeOptimizedEncoding(const uint8_t* bytes, size_t length) = 0;
};
class JS_PUBLIC_API StreamConsumer {
protected:
// AsyncStreamConsumers are created and destroyed by SpiderMonkey.
StreamConsumer() = default;
virtual ~StreamConsumer() = default;
public:
// Called by the embedding as each chunk of bytes becomes available.
// If this function returns 'false', the stream must drop all pointers to
// this StreamConsumer.
virtual bool consumeChunk(const uint8_t* begin, size_t length) = 0;
// Called by the embedding when the stream reaches end-of-file, passing the
// listener described above.
virtual void streamEnd(OptimizedEncodingListener* listener = nullptr) = 0;
// Called by the embedding when there is an error during streaming. The
// given error code should be passed to the ReportStreamErrorCallback on the
// main thread to produce the semantically-correct rejection value.
virtual void streamError(size_t errorCode) = 0;
// Called by the embedding *instead of* consumeChunk()/streamEnd() if an
// optimized encoding is available from a previous streaming of the same
// contents with the same optimized build id.
virtual void consumeOptimizedEncoding(const uint8_t* begin,
size_t length) = 0;
// Provides optional stream attributes such as base or source mapping URLs.
// Necessarily called before consumeChunk(), streamEnd(), streamError() or
// consumeOptimizedEncoding(). The caller retains ownership of the strings.
virtual void noteResponseURLs(const char* maybeUrl,
const char* maybeSourceMapUrl) = 0;
};
enum class MimeType { Wasm };
using ConsumeStreamCallback = bool (*)(JSContext*, JS::HandleObject, MimeType,
StreamConsumer*);
using ReportStreamErrorCallback = void (*)(JSContext*, size_t);
extern JS_PUBLIC_API void InitConsumeStreamCallback(
JSContext* cx, ConsumeStreamCallback consume,
ReportStreamErrorCallback report);
} // namespace JS
#endif // js_StreamConsumer_h
|
