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
|
"use strict";
// Make sure that we won't trigger events for a private window.
add_task(async function test_no_show_hide_for_private_window() {
function background() {
let events = [];
browser.menus.onShown.addListener(data => events.push(data));
browser.menus.onHidden.addListener(() => events.push("onHidden"));
browser.test.onMessage.addListener(async (name, data) => {
if (name == "check-events") {
browser.test.sendMessage("events", events);
events = [];
}
if (name == "create-menu") {
let id = await new Promise(resolve => {
let mid = browser.menus.create(data, () => resolve(mid));
});
browser.test.sendMessage("menu-id", id);
}
});
}
let pb_extension = ExtensionTestUtils.loadExtension({
background,
manifest: {
browser_specific_settings: {
gecko: { id: "@private-allowed" },
},
permissions: ["menus", "tabs"],
},
incognitoOverride: "spanning",
});
let extension = ExtensionTestUtils.loadExtension({
background,
manifest: {
browser_specific_settings: {
gecko: { id: "@not-allowed" },
},
permissions: ["menus", "tabs"],
},
});
async function testEvents(ext, expected) {
ext.sendMessage("check-events");
let events = await ext.awaitMessage("events");
Assert.deepEqual(
expected,
events,
`expected events received for ${ext.id}.`
);
}
await pb_extension.startup();
await extension.startup();
extension.sendMessage("create-menu", {
title: "not_allowed",
contexts: ["all", "tools_menu"],
});
let id1 = await extension.awaitMessage("menu-id");
let extMenuId = `${makeWidgetId(extension.id)}-menuitem-${id1}`;
pb_extension.sendMessage("create-menu", {
title: "spanning_allowed",
contexts: ["all", "tools_menu"],
});
let id2 = await pb_extension.awaitMessage("menu-id");
let pb_extMenuId = `${makeWidgetId(pb_extension.id)}-menuitem-${id2}`;
// Expected menu events
let baseShownEvent = {
contexts: ["page", "all"],
viewType: "tab",
frameId: 0,
editable: false,
};
let publicShown = { menuIds: [id1], ...baseShownEvent };
let privateShown = { menuIds: [id2], ...baseShownEvent };
baseShownEvent = {
contexts: ["tools_menu"],
viewType: undefined,
editable: false,
};
let toolsShown = { menuIds: [id1], ...baseShownEvent };
let privateToolsShown = { menuIds: [id2], ...baseShownEvent };
// Run tests in non-private window
let tab = await BrowserTestUtils.openNewForegroundTab(
gBrowser,
"about:robots"
);
// Open and close a menu on the public window.
await openContextMenu("body");
// We naturally expect both extensions here.
ok(document.getElementById(extMenuId), `menu exists ${extMenuId}`);
ok(document.getElementById(pb_extMenuId), `menu exists ${pb_extMenuId}`);
await closeContextMenu();
await testEvents(extension, [publicShown, "onHidden"]);
await testEvents(pb_extension, [privateShown, "onHidden"]);
await openToolsMenu();
ok(document.getElementById(extMenuId), `menu exists ${extMenuId}`);
ok(document.getElementById(pb_extMenuId), `menu exists ${pb_extMenuId}`);
await closeToolsMenu();
await testEvents(extension, [toolsShown, "onHidden"]);
await testEvents(pb_extension, [privateToolsShown, "onHidden"]);
// Run tests on private window
let privateWindow = await BrowserTestUtils.openNewBrowserWindow({
private: true,
});
// Open and close a menu on the private window.
let menu = await openContextMenu("body div", privateWindow);
// We should not see the "not_allowed" extension here.
ok(
!privateWindow.document.getElementById(extMenuId),
`menu does not exist ${extMenuId} in private window`
);
ok(
privateWindow.document.getElementById(pb_extMenuId),
`menu exists ${pb_extMenuId} in private window`
);
await closeContextMenu(menu);
await testEvents(extension, []);
await testEvents(pb_extension, [privateShown, "onHidden"]);
await openToolsMenu(privateWindow);
// We should not see the "not_allowed" extension here.
ok(
!privateWindow.document.getElementById(extMenuId),
`menu does not exist ${extMenuId} in private window`
);
ok(
privateWindow.document.getElementById(pb_extMenuId),
`menu exists ${pb_extMenuId} in private window`
);
await closeToolsMenu(undefined, privateWindow);
await testEvents(extension, []);
await testEvents(pb_extension, [privateToolsShown, "onHidden"]);
await extension.unload();
await pb_extension.unload();
BrowserTestUtils.removeTab(tab);
await BrowserTestUtils.closeWindow(privateWindow);
});
|
