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
|
/**
* Test for the "alternative data stream" stored withing a cache entry.
*
* - we load a URL with preference for an alt data (check what we get is the raw data,
* since there was nothing previously cached)
* - we write a big chunk of alt-data to the output stream
* - we load the URL again, expecting to get alt-data
* - we check that the alt-data is streamed. We should get the first chunk, then
* the rest of the alt-data is written, and we check that it is received in
* the proper order.
*
*/
"use strict";
const { HttpServer } = ChromeUtils.importESModule(
"resource://testing-common/httpd.sys.mjs"
);
ChromeUtils.defineLazyGetter(this, "URL", function () {
return "http://localhost:" + httpServer.identity.primaryPort + "/content";
});
var httpServer = null;
function make_channel(url) {
return NetUtil.newChannel({ uri: url, loadUsingSystemPrincipal: true });
}
const responseContent = "response body";
// We need a large content in order to make sure that the IPDL stream is cut
// into several different chunks.
// We fill each chunk with a different character for easy debugging.
const altContent =
"a".repeat(128 * 1024) +
"b".repeat(128 * 1024) +
"c".repeat(128 * 1024) +
"d".repeat(128 * 1024) +
"e".repeat(128 * 1024) +
"f".repeat(128 * 1024) +
"g".repeat(128 * 1024) +
"h".repeat(128 * 1024) +
"i".repeat(13); // Just so the chunk size doesn't match exactly.
const firstChunkSize = Math.floor(altContent.length / 4);
const altContentType = "text/binary";
function contentHandler(metadata, response) {
response.setHeader("Content-Type", "text/plain");
response.setHeader("Cache-Control", "max-age=86400");
response.bodyOutputStream.write(responseContent, responseContent.length);
}
function run_test() {
do_get_profile();
httpServer = new HttpServer();
httpServer.registerPathHandler("/content", contentHandler);
httpServer.start(-1);
var chan = make_channel(URL);
var cc = chan.QueryInterface(Ci.nsICacheInfoChannel);
cc.preferAlternativeDataType(
altContentType,
"",
Ci.nsICacheInfoChannel.ASYNC
);
chan.asyncOpen(new ChannelListener(readServerContent, null));
do_test_pending();
}
// Output stream used to write alt-data to the cache entry.
var os;
function readServerContent(request, buffer) {
var cc = request.QueryInterface(Ci.nsICacheInfoChannel);
Assert.equal(buffer, responseContent);
Assert.equal(cc.alternativeDataType, "");
executeSoon(() => {
os = cc.openAlternativeOutputStream(altContentType, altContent.length);
// Write a quarter of the alt data content
os.write(altContent, firstChunkSize);
executeSoon(openAltChannel);
});
}
function openAltChannel() {
var chan = make_channel(URL);
var cc = chan.QueryInterface(Ci.nsICacheInfoChannel);
cc.preferAlternativeDataType(
altContentType,
"",
Ci.nsICacheInfoChannel.ASYNC
);
chan.asyncOpen(altDataListener);
}
var altDataListener = {
buffer: "",
onStartRequest() {},
onDataAvailable(request, stream, offset, count) {
let string = NetUtil.readInputStreamToString(stream, count);
this.buffer += string;
// XXX: this condition might be a bit volatile. If this test times out,
// it probably means that for some reason, the listener didn't get all the
// data in the first chunk.
if (this.buffer.length == firstChunkSize) {
// write the rest of the content
os.write(
altContent.substring(firstChunkSize, altContent.length),
altContent.length - firstChunkSize
);
os.close();
}
},
onStopRequest(request) {
var cc = request.QueryInterface(Ci.nsICacheInfoChannel);
Assert.equal(cc.alternativeDataType, altContentType);
Assert.equal(this.buffer.length, altContent.length);
Assert.equal(this.buffer, altContent);
openAltChannelWithOriginalContent();
},
};
function openAltChannelWithOriginalContent() {
var chan = make_channel(URL);
var cc = chan.QueryInterface(Ci.nsICacheInfoChannel);
cc.preferAlternativeDataType(
altContentType,
"",
Ci.nsICacheInfoChannel.SERIALIZE
);
chan.asyncOpen(originalListener);
}
var originalListener = {
buffer: "",
onStartRequest() {},
onDataAvailable(request, stream, offset, count) {
let string = NetUtil.readInputStreamToString(stream, count);
this.buffer += string;
},
onStopRequest(request) {
var cc = request.QueryInterface(Ci.nsICacheInfoChannel);
Assert.equal(cc.alternativeDataType, altContentType);
Assert.equal(this.buffer.length, responseContent.length);
Assert.equal(this.buffer, responseContent);
testAltDataStream(cc);
},
};
function testAltDataStream(cc) {
Assert.ok(!!cc.alternativeDataInputStream);
httpServer.stop(do_test_finished);
}
|
