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
|
/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set sts=2 sw=2 et tw=80: */
"use strict";
ChromeUtils.defineESModuleGetters(this, {
AddonManager: "resource://gre/modules/AddonManager.sys.mjs",
ExtensionPreferencesManager:
"resource://gre/modules/ExtensionPreferencesManager.sys.mjs",
Management: "resource://gre/modules/Extension.sys.mjs",
Preferences: "resource://gre/modules/Preferences.sys.mjs",
});
const { createAppInfo, promiseShutdownManager, promiseStartupManager } =
AddonTestUtils;
AddonTestUtils.init(this);
createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "42");
function awaitEvent(eventName) {
return new Promise(resolve => {
let listener = (_eventName, ...args) => {
if (_eventName === eventName) {
Management.off(eventName, listener);
resolve(...args);
}
};
Management.on(eventName, listener);
});
}
function awaitPrefChange(prefName) {
return new Promise(resolve => {
let listener = args => {
Preferences.ignore(prefName, listener);
resolve();
};
Preferences.observe(prefName, listener);
});
}
add_task(async function test_disable() {
const OLD_ID = "old_id@tests.mozilla.org";
const NEW_ID = "new_id@tests.mozilla.org";
const PREF_TO_WATCH = "network.http.speculative-parallel-limit";
// Create an object to hold the values to which we will initialize the prefs.
const PREFS = {
"network.predictor.enabled": true,
"network.prefetch-next": true,
"network.http.speculative-parallel-limit": 10,
"network.dns.disablePrefetch": false,
};
// Set prefs to our initial values.
for (let pref in PREFS) {
Preferences.set(pref, PREFS[pref]);
}
registerCleanupFunction(() => {
// Reset the prefs.
for (let pref in PREFS) {
Preferences.reset(pref);
}
});
function checkPrefs(expected) {
for (let pref in PREFS) {
let msg = `${pref} set correctly.`;
let expectedValue = expected ? PREFS[pref] : !PREFS[pref];
if (pref === "network.http.speculative-parallel-limit") {
expectedValue = expected
? ExtensionPreferencesManager.getDefaultValue(pref)
: 0;
}
equal(Preferences.get(pref), expectedValue, msg);
}
}
async function background() {
browser.test.onMessage.addListener(async (msg, data) => {
await browser.privacy.network.networkPredictionEnabled.set(data);
let settingData =
await browser.privacy.network.networkPredictionEnabled.get({});
browser.test.sendMessage("privacyData", settingData);
});
}
await promiseStartupManager();
let testExtensions = [
ExtensionTestUtils.loadExtension({
background,
manifest: {
browser_specific_settings: {
gecko: {
id: OLD_ID,
},
},
permissions: ["privacy"],
},
useAddonManager: "temporary",
}),
ExtensionTestUtils.loadExtension({
background,
manifest: {
browser_specific_settings: {
gecko: {
id: NEW_ID,
},
},
permissions: ["privacy"],
},
useAddonManager: "temporary",
}),
];
for (let extension of testExtensions) {
await extension.startup();
}
// Set the value to true for the older extension.
testExtensions[0].sendMessage("set", { value: true });
let data = await testExtensions[0].awaitMessage("privacyData");
ok(data.value, "Value set to true for the older extension.");
// Set the value to false for the newest extension.
testExtensions[1].sendMessage("set", { value: false });
data = await testExtensions[1].awaitMessage("privacyData");
ok(!data.value, "Value set to false for the newest extension.");
// Verify the prefs have been set to match the "false" setting.
checkPrefs(false);
// Disable the newest extension.
let disabledPromise = awaitPrefChange(PREF_TO_WATCH);
let newAddon = await AddonManager.getAddonByID(NEW_ID);
await newAddon.disable();
await disabledPromise;
// Verify the prefs have been set to match the "true" setting.
checkPrefs(true);
// Disable the older extension.
disabledPromise = awaitPrefChange(PREF_TO_WATCH);
let oldAddon = await AddonManager.getAddonByID(OLD_ID);
await oldAddon.disable();
await disabledPromise;
// Verify the prefs have reverted back to their initial values.
for (let pref in PREFS) {
equal(Preferences.get(pref), PREFS[pref], `${pref} reset correctly.`);
}
// Re-enable the newest extension.
let enabledPromise = awaitEvent("ready");
await newAddon.enable();
await enabledPromise;
// Verify the prefs have been set to match the "false" setting.
checkPrefs(false);
// Re-enable the older extension.
enabledPromise = awaitEvent("ready");
await oldAddon.enable();
await enabledPromise;
// Verify the prefs have remained set to match the "false" setting.
checkPrefs(false);
for (let extension of testExtensions) {
await extension.unload();
}
await promiseShutdownManager();
});
|
