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
206
207
208
209
210
211
212
213
214
215
216
217
218
|
/* 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/. */
/**
* Test that we emit network markers accordingly.
* In this file we'll test the case of a service worker that has no fetch
* handlers. In this case, a fetch is done to the network. There may be
* shortcuts in our code in this case, that's why it's important to test it
* separately.
*/
const serviceWorkerFileName = "serviceworker_no_fetch_handler.js";
registerCleanupFunction(() => SpecialPowers.removeAllServiceWorkerData());
add_task(async function test_network_markers_service_worker_setup() {
// Disabling cache makes the result more predictable. Also this makes things
// simpler when dealing with service workers.
await SpecialPowers.pushPrefEnv({
set: [
["browser.cache.disk.enable", false],
["browser.cache.memory.enable", false],
],
});
});
add_task(async function test_network_markers_service_worker_register() {
// In this first step, we request an HTML page that will register a service
// worker. We'll wait until the service worker is fully installed before
// checking various things.
const url = `${BASE_URL_HTTPS}serviceworkers/serviceworker_register.html`;
await BrowserTestUtils.withNewTab(url, async contentBrowser => {
await SpecialPowers.spawn(
contentBrowser,
[serviceWorkerFileName],
async function (serviceWorkerFileName) {
await content.wrappedJSObject.registerServiceWorkerAndWait(
serviceWorkerFileName
);
}
);
// Let's make sure we actually have a registered service workers.
const workers = await SpecialPowers.registeredServiceWorkers();
Assert.equal(
workers.length,
1,
"One service worker should be properly registered."
);
});
});
add_task(async function test_network_markers_service_worker_use() {
Assert.ok(
!Services.profiler.IsActive(),
"The profiler is not currently active"
);
startProfilerForMarkerTests();
const url = `${BASE_URL_HTTPS}serviceworkers/serviceworker_page.html`;
await BrowserTestUtils.withNewTab(url, async contentBrowser => {
const contentPid = await SpecialPowers.spawn(
contentBrowser,
[],
() => Services.appinfo.processID
);
const { parentThread, contentThread } = await stopProfilerNowAndGetThreads(
contentPid
);
// By logging a few information about the threads we make debugging easier.
logInformationForThread("parentThread information", parentThread);
logInformationForThread("contentThread information", contentThread);
const parentNetworkMarkers = getInflatedNetworkMarkers(parentThread)
// When we load a page, Firefox will check the service worker freshness
// after a few seconds. So when the test lasts a long time (with some test
// environments) we might see spurious markers about that that we're not
// interesting in in this part of the test. They're only present in the
// parent process.
.filter(marker => !marker.data.URI.includes(serviceWorkerFileName));
const contentNetworkMarkers = getInflatedNetworkMarkers(contentThread);
// Here are some logs to ease debugging.
info(
"Parent network markers:" + JSON.stringify(parentNetworkMarkers, null, 2)
);
info(
"Content network markers:" +
JSON.stringify(contentNetworkMarkers, null, 2)
);
const parentPairs = getPairsOfNetworkMarkers(parentNetworkMarkers);
const contentPairs = getPairsOfNetworkMarkers(contentNetworkMarkers);
// First, make sure we properly matched all start with stop markers. This
// means that both arrays should contain only arrays of 2 elements.
parentPairs.forEach(pair =>
Assert.equal(
pair.length,
2,
`For the URL ${pair[0].data.URI} we should get 2 markers in the parent process.`
)
);
contentPairs.forEach(pair =>
Assert.equal(
pair.length,
2,
`For the URL ${pair[0].data.URI} we should get 2 markers in the content process.`
)
);
// Let's look at all pairs and make sure we requested all expected files.
const parentStopMarkers = parentPairs.map(([_, stopMarker]) => stopMarker);
const contentStopMarkers = contentPairs.map(
([_, stopMarker]) => stopMarker
);
// These are the files requested by the page.
// We should see markers for the parent thread and the content thread.
const expectedFiles = [
// Please take care that the first element is the top level navigation, as
// this is special-cased below.
"serviceworker_page.html",
"firefox-logo-nightly.svg",
].map(filename => `${BASE_URL_HTTPS}serviceworkers/${filename}`);
Assert.equal(
parentStopMarkers.length,
expectedFiles.length,
"There should be as many stop markers in the parent process as requested files."
);
Assert.equal(
contentStopMarkers.length,
expectedFiles.length,
"There should be as many stop markers in the content process as requested files."
);
for (const [i, expectedFile] of expectedFiles.entries()) {
info(
`Checking if "${expectedFile}" if present in the network markers in both processes.`
);
const parentMarker = parentStopMarkers.find(
marker => marker.data.URI === expectedFile
);
const contentMarker = contentStopMarkers.find(
marker => marker.data.URI === expectedFile
);
const commonProperties = {
name: Expect.stringMatches(
`Load \\d+:.*${escapeStringRegexp(expectedFile)}`
),
};
Assert.objectContains(parentMarker, commonProperties);
Assert.objectContains(contentMarker, commonProperties);
// We get the full set of properties in this case, because we do an actual
// fetch to the network.
const commonDataProperties = {
type: "Network",
status: "STATUS_STOP",
URI: expectedFile,
requestMethod: "GET",
contentType: Expect.stringMatches(/^(text\/html|image\/svg\+xml)$/),
startTime: Expect.number(),
endTime: Expect.number(),
id: Expect.number(),
pri: Expect.number(),
count: Expect.number(),
domainLookupStart: Expect.number(),
domainLookupEnd: Expect.number(),
connectStart: Expect.number(),
tcpConnectEnd: Expect.number(),
connectEnd: Expect.number(),
requestStart: Expect.number(),
responseStart: Expect.number(),
responseEnd: Expect.number(),
};
if (i === 0) {
// The first marker is special cased: this is the top level navigation
// serviceworker_page.html,
// and in this case we don't have all the same properties. Especially
// the innerWindowID information is missing.
Assert.objectContainsOnly(parentMarker.data, {
...commonDataProperties,
// Note that the parent process has the "cache" information, but not the content
// process. See Bug 1544821.
// Also because the request races with the cache, these 2 values are valid:
// "Missed" when the cache answered before we get a result from the network.
// "Unresolved" when we got a response from the network before the cache subsystem.
cache: Expect.stringMatches(/^(Missed|Unresolved)$/),
});
Assert.objectContainsOnly(contentMarker.data, commonDataProperties);
} else {
// This is the other file firefox-logo-nightly.svg.
Assert.objectContainsOnly(parentMarker.data, {
...commonDataProperties,
// Because the request races with the cache, these 2 values are valid:
// "Missed" when the cache answered before we get a result from the network.
// "Unresolved" when we got a response from the network before the cache subsystem.
cache: Expect.stringMatches(/^(Missed|Unresolved)$/),
innerWindowID: Expect.number(),
});
Assert.objectContainsOnly(contentMarker.data, {
...commonDataProperties,
innerWindowID: Expect.number(),
});
}
}
});
});
|
